From ad735fb1dc2500d14ced95b5c46e76f90c8e38e6 Mon Sep 17 00:00:00 2001
From: Pieter Donker <donker@astron.nl>
Date: Mon, 22 Dec 2008 09:40:49 +0000
Subject: [PATCH] Bug 335 :further development of TBBDriver
---
MAC/APL/PIC/TBBDriver/src/AllocCmd.h | 2 +-
MAC/APL/PIC/TBBDriver/src/ArpCmd.cc | 2 +-
MAC/APL/PIC/TBBDriver/src/ArpModeCmd.cc | 2 +-
MAC/APL/PIC/TBBDriver/src/BoardCmdHandler.cc | 8 +-
MAC/APL/PIC/TBBDriver/src/ClearCmd.cc | 2 +-
MAC/APL/PIC/TBBDriver/src/ConfigCmd.cc | 8 +-
MAC/APL/PIC/TBBDriver/src/DriverSettings.cc | 8 +-
MAC/APL/PIC/TBBDriver/src/DriverSettings.h | 21 +-
MAC/APL/PIC/TBBDriver/src/FreeCmd.cc | 2 +-
MAC/APL/PIC/TBBDriver/src/FreeCmd.h | 2 +-
MAC/APL/PIC/TBBDriver/src/ImageInfoCmd.cc | 4 +-
MAC/APL/PIC/TBBDriver/src/RecordCmd.cc | 2 +-
MAC/APL/PIC/TBBDriver/src/RecordCmd.h | 2 +-
MAC/APL/PIC/TBBDriver/src/ResetCmd.cc | 6 +-
MAC/APL/PIC/TBBDriver/src/SizeCmd.cc | 2 +-
MAC/APL/PIC/TBBDriver/src/StatusCmd.cc | 2 +-
MAC/APL/PIC/TBBDriver/src/StopCepCmd.cc | 2 +-
MAC/APL/PIC/TBBDriver/src/StopCmd.cc | 2 +-
MAC/APL/PIC/TBBDriver/src/StopCmd.h | 2 +-
MAC/APL/PIC/TBBDriver/src/TBBDriver.cc | 2229 ++++----
MAC/APL/PIC/TBBDriver/src/TempLimitCmd.cc | 2 +-
MAC/APL/PIC/TBBDriver/src/TrigCoefCmd.cc | 2 +-
MAC/APL/PIC/TBBDriver/src/TrigGenCmd.cc | 2 +-
MAC/APL/PIC/TBBDriver/src/TrigGenCmd.h | 2 +-
MAC/APL/PIC/TBBDriver/src/TrigReleaseCmd.h | 4 +-
MAC/APL/PIC/TBBDriver/src/TrigSetupCmd.cc | 2 +-
MAC/APL/PIC/TBBDriver/src/VersionCmd.cc | 2 +-
MAC/APL/PIC/TBBDriver/src/WritefCmd.cc | 14 +-
MAC/APL/PIC/TBBDriver/src/tbbctl.cc | 4912 +++++++++---------
MAC/APL/PIC/TBBDriver/src/tbbctl.h | 6 +-
MAC/APL/PIC/TBBDriver/test/TBBTest.cc | 16 +-
31 files changed, 3651 insertions(+), 3623 deletions(-)
diff --git a/MAC/APL/PIC/TBBDriver/src/AllocCmd.h b/MAC/APL/PIC/TBBDriver/src/AllocCmd.h
index 37c67f5a686..d2d0bf72668 100644
--- a/MAC/APL/PIC/TBBDriver/src/AllocCmd.h
+++ b/MAC/APL/PIC/TBBDriver/src/AllocCmd.h
@@ -65,7 +65,7 @@ namespace LOFAR {
int32 itsStage;
//uint32 itsBoardMask; // mask indicates the boards to communicate with
uint32 itsRcuStatus;
- uint32 itsChannelMask[MAX_N_TBBBOARDS];
+ uint32 itsChannelMask[MAX_N_TBBOARDS];
TPAllocEvent *itsTPE;
TPAllocAckEvent *itsTPackE;
diff --git a/MAC/APL/PIC/TBBDriver/src/ArpCmd.cc b/MAC/APL/PIC/TBBDriver/src/ArpCmd.cc
index d998c0af47a..12efc1ff5e1 100644
--- a/MAC/APL/PIC/TBBDriver/src/ArpCmd.cc
+++ b/MAC/APL/PIC/TBBDriver/src/ArpCmd.cc
@@ -41,7 +41,7 @@ ArpCmd::ArpCmd()
itsTBBE = 0;
itsTBBackE = new TBBArpAckEvent();
- for(int boardnr = 0;boardnr < MAX_N_TBBBOARDS;boardnr++) {
+ for(int boardnr = 0;boardnr < MAX_N_TBBOARDS;boardnr++) {
itsTBBackE->status_mask[boardnr] = 0;
}
diff --git a/MAC/APL/PIC/TBBDriver/src/ArpModeCmd.cc b/MAC/APL/PIC/TBBDriver/src/ArpModeCmd.cc
index 529cc113687..611ec2a8796 100644
--- a/MAC/APL/PIC/TBBDriver/src/ArpModeCmd.cc
+++ b/MAC/APL/PIC/TBBDriver/src/ArpModeCmd.cc
@@ -41,7 +41,7 @@ ArpModeCmd::ArpModeCmd()
itsTBBE = 0;
itsTBBackE = new TBBArpModeAckEvent();
- for(int boardnr = 0;boardnr < MAX_N_TBBBOARDS;boardnr++) {
+ for(int boardnr = 0;boardnr < MAX_N_TBBOARDS;boardnr++) {
itsTBBackE->status_mask[boardnr] = 0;
}
diff --git a/MAC/APL/PIC/TBBDriver/src/BoardCmdHandler.cc b/MAC/APL/PIC/TBBDriver/src/BoardCmdHandler.cc
index 3d3c34538ee..7987d1c1059 100644
--- a/MAC/APL/PIC/TBBDriver/src/BoardCmdHandler.cc
+++ b/MAC/APL/PIC/TBBDriver/src/BoardCmdHandler.cc
@@ -155,8 +155,8 @@ GCFEvent::TResult BoardCmdHandler::waitack_state(GCFEvent& event, GCFPortInterfa
TS->setBoardState(itsCmd->getBoardNr(),boardError);
}
itsCmd->saveTpAckEvent(event); // max retries or done, save zero's
- if (itsCmd->getSleepTime() > 0) {
- itsSleepTimer->setTimer((long)itsCmd->getSleepTime());
+ if (itsCmd->getSleepTime() > 0.0) {
+ itsSleepTimer->setTimer(itsCmd->getSleepTime());
itsCmd->setSleepTime(0.0);
} else {
TRAN(BoardCmdHandler::send_state);
@@ -178,8 +178,8 @@ GCFEvent::TResult BoardCmdHandler::waitack_state(GCFEvent& event, GCFPortInterfa
if (itsCmd->isValid(event)) {
port.cancelAllTimers();
itsCmd->saveTpAckEvent(event);
- if (itsCmd->getSleepTime()) {
- itsSleepTimer->setTimer((long)itsCmd->getSleepTime());
+ if (itsCmd->getSleepTime() > 0.0) {
+ itsSleepTimer->setTimer(itsCmd->getSleepTime());
itsCmd->setSleepTime(0);
} else {
TRAN(BoardCmdHandler::send_state);
diff --git a/MAC/APL/PIC/TBBDriver/src/ClearCmd.cc b/MAC/APL/PIC/TBBDriver/src/ClearCmd.cc
index 5e6e612662e..b18eeab3758 100644
--- a/MAC/APL/PIC/TBBDriver/src/ClearCmd.cc
+++ b/MAC/APL/PIC/TBBDriver/src/ClearCmd.cc
@@ -41,7 +41,7 @@ ClearCmd::ClearCmd()
itsTBBE = 0;
itsTBBackE = new TBBClearAckEvent();
- for(int boardnr = 0;boardnr < MAX_N_TBBBOARDS;boardnr++) {
+ for(int boardnr = 0;boardnr < MAX_N_TBBOARDS;boardnr++) {
itsTBBackE->status_mask[boardnr] = 0;
}
setWaitAck(true);
diff --git a/MAC/APL/PIC/TBBDriver/src/ConfigCmd.cc b/MAC/APL/PIC/TBBDriver/src/ConfigCmd.cc
index 551fa2831a8..a99fc4a48b4 100644
--- a/MAC/APL/PIC/TBBDriver/src/ConfigCmd.cc
+++ b/MAC/APL/PIC/TBBDriver/src/ConfigCmd.cc
@@ -41,7 +41,7 @@ ConfigCmd::ConfigCmd()
itsTBBE = 0;
itsTBBackE = new TBBConfigAckEvent();
- for(int boardnr = 0;boardnr < MAX_N_TBBBOARDS;boardnr++) {
+ for(int boardnr = 0;boardnr < MAX_N_TBBOARDS;boardnr++) {
itsTBBackE->status_mask[boardnr] = 0;
}
setWaitAck(true);
@@ -104,7 +104,8 @@ void ConfigCmd::saveTpAckEvent(GCFEvent& event)
itsTBBackE->status_mask[getBoardNr()] |= TBB_COMM_ERROR;
} else {
itsTPackE = new TPConfigAckEvent(event);
-
+ TS->setImageNr(getBoardNr(), itsTPE->imagenr);
+ TS->setFreeToReset(getBoardNr(), false);
if ((itsTPackE->status >= 0xF0) && (itsTPackE->status <= 0xF6))
itsTBBackE->status_mask[getBoardNr()] |= (1 << (16 + (itsTPackE->status & 0x0F)));
@@ -112,6 +113,9 @@ void ConfigCmd::saveTpAckEvent(GCFEvent& event)
delete itsTPackE;
}
nextBoardNr();
+ if (isDone()) {
+ setSleepTime(15.0);
+ }
}
// ----------------------------------------------------------------------------
diff --git a/MAC/APL/PIC/TBBDriver/src/DriverSettings.cc b/MAC/APL/PIC/TBBDriver/src/DriverSettings.cc
index 084ef485fab..bbc1a45169a 100644
--- a/MAC/APL/PIC/TBBDriver/src/DriverSettings.cc
+++ b/MAC/APL/PIC/TBBDriver/src/DriverSettings.cc
@@ -100,7 +100,7 @@ void TbbSettings::getTbbSettings()
}
// setMaxBoards() must be set 2e
- setMaxBoards(MAX_N_TBBBOARDS);
+ setMaxBoards(MAX_N_TBBOARDS);
try { itsSaveTriggersToFile = globalParameterSet()->getInt32("TBBDriver.SAVE_TRIGGERS_TO_FILE"); }
catch (...) { LOG_INFO_STR(formatString("TBBDriver.SAVE_TRIGGERS_TO_FILE not found")); }
@@ -219,9 +219,11 @@ void TbbSettings::setMaxBoards (int32 maxboards)
itsBoardInfo = new BoardInfo[itsMaxBoards];
for (int nr = 0;nr < itsMaxBoards; nr++) {
- itsBoardInfo[nr].boardState = boardReset;
+ itsBoardInfo[nr].boardState = setImage1;
itsBoardInfo[nr].memorySize = 0;
- itsBoardInfo[nr].srcIp = "";
+ itsBoardInfo[nr].imageNr = 0;
+ itsBoardInfo[nr].freeToReset = true;
+ itsBoardInfo[nr].srcIp = "";
itsBoardInfo[nr].dstIp = "";
itsBoardInfo[nr].srcMac = "";
itsBoardInfo[nr].dstMac = "";
diff --git a/MAC/APL/PIC/TBBDriver/src/DriverSettings.h b/MAC/APL/PIC/TBBDriver/src/DriverSettings.h
index 45f5e9d3809..4ae137dca77 100644
--- a/MAC/APL/PIC/TBBDriver/src/DriverSettings.h
+++ b/MAC/APL/PIC/TBBDriver/src/DriverSettings.h
@@ -26,8 +26,6 @@
#include <APL/TBB_Protocol/TBB_Protocol.ph>
#include "TP_Protocol.ph"
#include <GCF/TM/GCF_Control.h>
-//#include <GCF/TM/GCF_ETHRawPort.h>
-//#include <GCF/TM/GCF_DevicePort.h>
#include <Common/LofarTypes.h>
@@ -35,10 +33,10 @@
namespace LOFAR {
namespace TBB {
-static const int DRIVER_VERSION = 200; // 2.00
+static const int DRIVER_VERSION = 201; // 2.00
+
+enum BoardStateT {noBoard, setImage1, image1Set, clearBoard, boardCleared, freeBoard, boardFreed, boardReady, boardError};
-//enum BoardStateT {noBoard, newBoard, boardReset, boardCleared, boardFreed, boardReady, boardError};
-enum BoardStateT {noBoard, resetBoard, boardReset, clearBoard, boardCleared, freeBoard, boardFreed, boardReady, boardError};
// info for all channels
struct ChannelInfo
{
@@ -68,6 +66,8 @@ struct BoardInfo
GCFPortInterface* port;
BoardStateT boardState;
uint32 memorySize;
+ uint32 imageNr;
+ bool freeToReset;
string srcIp;
string dstIp;
string srcMac;
@@ -166,6 +166,11 @@ public:
uint32 getMemorySize(int32 boardnr);
void setMemorySize(int32 boardnr,uint32 pages);
+ uint32 getImageNr(int32 boardnr);
+ void setImageNr(int32 boardnr,uint32 image);
+ bool getFreeToReset(int32 boardnr);
+ void setFreeToReset(int32 boardnr, bool reset);
+
friend class TBBDriver;
protected: // note TBBDriver must be able to set them
@@ -282,7 +287,11 @@ inline void TbbSettings::setTriggerMode(int16 triggermode){ itsTriggerMode = tri
//---- inline functions for board information ------------
inline uint32 TbbSettings::getMemorySize(int32 boardnr) { return (itsBoardInfo[boardnr].memorySize); }
inline void TbbSettings::setMemorySize(int32 boardnr,uint32 pages) { itsBoardInfo[boardnr].memorySize = pages; }
-
+inline uint32 TbbSettings::getImageNr(int32 boardnr) { return (itsBoardInfo[boardnr].imageNr); }
+inline void TbbSettings::setImageNr(int32 boardnr,uint32 image) { itsBoardInfo[boardnr].imageNr = image; }
+inline bool TbbSettings::getFreeToReset(int32 boardnr) { return (itsBoardInfo[boardnr].freeToReset); }
+inline void TbbSettings::setFreeToReset(int32 boardnr, bool reset) { itsBoardInfo[boardnr].freeToReset = reset; }
+
} // namespace TBB
} // namespace LOFAR
diff --git a/MAC/APL/PIC/TBBDriver/src/FreeCmd.cc b/MAC/APL/PIC/TBBDriver/src/FreeCmd.cc
index fe4faa17005..8671c53f26a 100644
--- a/MAC/APL/PIC/TBBDriver/src/FreeCmd.cc
+++ b/MAC/APL/PIC/TBBDriver/src/FreeCmd.cc
@@ -41,7 +41,7 @@ FreeCmd::FreeCmd():
itsTBBE = 0;
itsTBBackE = new TBBFreeAckEvent();
- for(int boardnr = 0;boardnr < MAX_N_TBBBOARDS;boardnr++) {
+ for(int boardnr = 0;boardnr < MAX_N_TBBOARDS;boardnr++) {
itsTBBackE->status_mask[boardnr] = 0;
itsChannelMask[boardnr] = 0;
}
diff --git a/MAC/APL/PIC/TBBDriver/src/FreeCmd.h b/MAC/APL/PIC/TBBDriver/src/FreeCmd.h
index 97866072548..a19f3b32568 100644
--- a/MAC/APL/PIC/TBBDriver/src/FreeCmd.h
+++ b/MAC/APL/PIC/TBBDriver/src/FreeCmd.h
@@ -61,7 +61,7 @@ namespace LOFAR {
TbbSettings *TS;
int32 itsBoardNr;
- uint32 itsChannelMask[MAX_N_TBBBOARDS];
+ uint32 itsChannelMask[MAX_N_TBBOARDS];
bool itsBoardFreeAll;
uint32 itsRcuStatus;
diff --git a/MAC/APL/PIC/TBBDriver/src/ImageInfoCmd.cc b/MAC/APL/PIC/TBBDriver/src/ImageInfoCmd.cc
index 505e9d5debf..8eed62b7c4f 100644
--- a/MAC/APL/PIC/TBBDriver/src/ImageInfoCmd.cc
+++ b/MAC/APL/PIC/TBBDriver/src/ImageInfoCmd.cc
@@ -82,15 +82,15 @@ void ImageInfoCmd::saveTbbEvent(GCFEvent& event)
itsTBBE = new TBBImageInfoEvent(event);
setBoardNr(itsTBBE->board);
- itsTBBackE->board = itsTBBE->board;
+ itsTBBackE->board = getBoardNr();
itsTBBackE->status_mask = 0;
+ itsTBBackE->active_image = TS->getImageNr(getBoardNr());
itsImage = 0;
// initialize TP send frame
itsTPE->opcode = TPREADF;
itsTPE->status = 0;
-
delete itsTBBE;
}
diff --git a/MAC/APL/PIC/TBBDriver/src/RecordCmd.cc b/MAC/APL/PIC/TBBDriver/src/RecordCmd.cc
index 50302876dfa..86c12088e67 100644
--- a/MAC/APL/PIC/TBBDriver/src/RecordCmd.cc
+++ b/MAC/APL/PIC/TBBDriver/src/RecordCmd.cc
@@ -41,7 +41,7 @@ RecordCmd::RecordCmd():
itsTBBE = 0;
itsTBBackE = new TBBRecordAckEvent();
- for(int boardnr = 0;boardnr < MAX_N_TBBBOARDS;boardnr++) {
+ for(int boardnr = 0;boardnr < MAX_N_TBBOARDS;boardnr++) {
itsTBBackE->status_mask[boardnr] = 0;
itsChannelMask[boardnr] = 0;
}
diff --git a/MAC/APL/PIC/TBBDriver/src/RecordCmd.h b/MAC/APL/PIC/TBBDriver/src/RecordCmd.h
index 9c01bbc2b9e..5d7a497a85e 100644
--- a/MAC/APL/PIC/TBBDriver/src/RecordCmd.h
+++ b/MAC/APL/PIC/TBBDriver/src/RecordCmd.h
@@ -60,7 +60,7 @@ namespace LOFAR {
private:
TbbSettings *TS;
- uint32 itsChannelMask[MAX_N_TBBBOARDS];
+ uint32 itsChannelMask[MAX_N_TBBOARDS];
uint32 itsRcuStatus;
TPRecordEvent *itsTPE;
diff --git a/MAC/APL/PIC/TBBDriver/src/ResetCmd.cc b/MAC/APL/PIC/TBBDriver/src/ResetCmd.cc
index ea57e45d08c..9852e3de246 100644
--- a/MAC/APL/PIC/TBBDriver/src/ResetCmd.cc
+++ b/MAC/APL/PIC/TBBDriver/src/ResetCmd.cc
@@ -42,7 +42,7 @@ ResetCmd::ResetCmd():
itsTBBE = 0;
itsTBBackE = new TBBResetAckEvent();
- for(int boardnr = 0; boardnr < MAX_N_TBBBOARDS; boardnr++) {
+ for(int boardnr = 0; boardnr < MAX_N_TBBOARDS; boardnr++) {
itsTBBackE->status_mask[boardnr] = 0;
}
setWaitAck(true);
@@ -115,7 +115,7 @@ void ResetCmd::saveTpAckEvent(GCFEvent& event)
} else {
itsTPackE = new TPResetAckEvent(event);
if (itsTPackE->status == 0) {
- TS->setBoardState(getBoardNr(),boardReset);
+ TS->setBoardState(getBoardNr(),setImage1);
} else {
TS->setBoardState(getBoardNr(),boardError);
}
@@ -134,7 +134,7 @@ void ResetCmd::saveTpAckEvent(GCFEvent& event)
if (itsBoardNr < TS->maxBoards()) {
setBoardNr(itsBoardNr);
} else {
- setSleepTime(3.0);
+ setSleepTime(20.0);
setDone(true);
}
}
diff --git a/MAC/APL/PIC/TBBDriver/src/SizeCmd.cc b/MAC/APL/PIC/TBBDriver/src/SizeCmd.cc
index 86d1a54b5ab..914fb4ff2e0 100644
--- a/MAC/APL/PIC/TBBDriver/src/SizeCmd.cc
+++ b/MAC/APL/PIC/TBBDriver/src/SizeCmd.cc
@@ -40,7 +40,7 @@ SizeCmd::SizeCmd()
itsTBBE = 0;
itsTBBackE = new TBBSizeAckEvent();
- for(int boardnr = 0;boardnr < MAX_N_TBBBOARDS;boardnr++) {
+ for(int boardnr = 0;boardnr < MAX_N_TBBOARDS;boardnr++) {
itsTBBackE->status_mask[boardnr] = 0;
itsTBBackE->npages[boardnr] = 0;
}
diff --git a/MAC/APL/PIC/TBBDriver/src/StatusCmd.cc b/MAC/APL/PIC/TBBDriver/src/StatusCmd.cc
index cc9f2581492..13ae1b4c93c 100644
--- a/MAC/APL/PIC/TBBDriver/src/StatusCmd.cc
+++ b/MAC/APL/PIC/TBBDriver/src/StatusCmd.cc
@@ -39,7 +39,7 @@ StatusCmd::StatusCmd()
itsTBBE = 0;
itsTBBackE = new TBBStatusAckEvent();
- for(int boardnr = 0;boardnr < MAX_N_TBBBOARDS;boardnr++) {
+ for(int boardnr = 0;boardnr < MAX_N_TBBOARDS;boardnr++) {
itsTBBackE->status_mask[boardnr] = 0;
itsTBBackE->V12[boardnr] = 0;
itsTBBackE->V25[boardnr] = 0;
diff --git a/MAC/APL/PIC/TBBDriver/src/StopCepCmd.cc b/MAC/APL/PIC/TBBDriver/src/StopCepCmd.cc
index bb26313267d..644d29054af 100644
--- a/MAC/APL/PIC/TBBDriver/src/StopCepCmd.cc
+++ b/MAC/APL/PIC/TBBDriver/src/StopCepCmd.cc
@@ -41,7 +41,7 @@ StopCepCmd::StopCepCmd()
itsTBBE = 0;
itsTBBackE = new TBBStopCepAckEvent();
- for(int boardnr = 0;boardnr < MAX_N_TBBBOARDS;boardnr++) {
+ for(int boardnr = 0;boardnr < MAX_N_TBBOARDS;boardnr++) {
itsTBBackE->status_mask[boardnr] = 0;
}
diff --git a/MAC/APL/PIC/TBBDriver/src/StopCmd.cc b/MAC/APL/PIC/TBBDriver/src/StopCmd.cc
index 516f49cb1f2..44e4b8f1daa 100644
--- a/MAC/APL/PIC/TBBDriver/src/StopCmd.cc
+++ b/MAC/APL/PIC/TBBDriver/src/StopCmd.cc
@@ -41,7 +41,7 @@ StopCmd::StopCmd():
itsTBBE = 0;
itsTBBackE = new TBBStopAckEvent();
- for(int boardnr = 0;boardnr < MAX_N_TBBBOARDS;boardnr++) {
+ for(int boardnr = 0;boardnr < MAX_N_TBBOARDS;boardnr++) {
itsTBBackE->status_mask[boardnr] = 0;
itsChannelMask[boardnr] = 0;
}
diff --git a/MAC/APL/PIC/TBBDriver/src/StopCmd.h b/MAC/APL/PIC/TBBDriver/src/StopCmd.h
index 157e0f8d298..154adada056 100644
--- a/MAC/APL/PIC/TBBDriver/src/StopCmd.h
+++ b/MAC/APL/PIC/TBBDriver/src/StopCmd.h
@@ -60,7 +60,7 @@ namespace LOFAR {
private:
TbbSettings *TS;
- uint32 itsChannelMask[MAX_N_TBBBOARDS];
+ uint32 itsChannelMask[MAX_N_TBBOARDS];
uint32 itsRcuStatus;
TPStopEvent *itsTPE;
diff --git a/MAC/APL/PIC/TBBDriver/src/TBBDriver.cc b/MAC/APL/PIC/TBBDriver/src/TBBDriver.cc
index 3ebf78e2210..b9cf8e05c0c 100644
--- a/MAC/APL/PIC/TBBDriver/src/TBBDriver.cc
+++ b/MAC/APL/PIC/TBBDriver/src/TBBDriver.cc
@@ -69,14 +69,14 @@
#include "TempLimitCmd.h"
-#define ETHERTYPE_TP 0x7BB0 // letters of TBB
+#define ETHERTYPE_TP 0x7BB0 // letters of TBB
using namespace LOFAR;
using namespace ACC::APS;
using namespace TBB;
static bool itsDaemonize = false;
-static int32 itsInstancenr = -1;
+static int32 itsInstancenr = -1;
static const double ALIVECHECKTIME = 60.0;
@@ -86,591 +86,596 @@ static const double ALIVECHECKTIME = 60.0;
//
void parseOptions(int argc, char** argv)
{
- static struct option long_options[] = {
- { "instance", required_argument, 0, 'I' },
- { "daemon", no_argument, 0, 'd' },
- { 0, 0, 0, 0 }
- };
+ static struct option long_options[] = {
+ { "instance", required_argument, 0, 'I' },
+ { "daemon", no_argument, 0, 'd' },
+ { 0, 0, 0, 0 }
+ };
- optind = 0; // reset option parsing
- for(;;) {
- int option_index = 0;
- int c = getopt_long(argc, argv, "dI:", long_options, &option_index);
+ optind = 0; // reset option parsing
+ for(;;) {
+ int option_index = 0;
+ int c = getopt_long(argc, argv, "dI:", long_options, &option_index);
- if (c == -1) {
- break;
- }
+ if (c == -1) {
+ break;
+ }
- switch (c) {
- case 'I': { // --instance
- itsInstancenr = atoi(optarg);
- } break;
-
- case 'd': { // --daemon
- itsDaemonize = true;
- } break;
-
- default: {
- LOG_FATAL_STR("Unknown option " << c);
- ASSERT(false);
- }
- }
- }
+ switch (c) {
+ case 'I': { // --instance
+ itsInstancenr = atoi(optarg);
+ } break;
+
+ case 'd': { // --daemon
+ itsDaemonize = true;
+ } break;
+
+ default: {
+ LOG_FATAL_STR("Unknown option " << c);
+ ASSERT(false);
+ }
+ }
+ }
}
-//-----------------------------------------------------------------------------
+//-----------------------------------------------------------------------------
TBBDriver::TBBDriver(string name)
: GCFTask((State)&TBBDriver::init_state, name)
{
- // use TS->getXXX() tot get settings of the driver
- TS = TbbSettings::instance();
-
- // get settings adopted from config file
+ // use TS->getXXX() tot get settings of the driver
+ TS = TbbSettings::instance();
+
+ // get settings adopted from config file
TS->getTbbSettings();
- cmd = 0;
- //itsNewBoards = 0;
- itsAliveCheck = false;
- itsResetCount = 0;
+ cmd = 0;
+ //itsNewBoards = 0;
+ itsAliveCheck = false;
+ itsResetCount = 0;
// tell broker we are here
LOG_DEBUG_STR("Registering protocols");
- registerProtocol (TBB_PROTOCOL, TBB_PROTOCOL_STRINGS);
- registerProtocol (TP_PROTOCOL, TP_PROTOCOL_STRINGS);
-
+ registerProtocol (TBB_PROTOCOL, TBB_PROTOCOL_STRINGS);
+ registerProtocol (TP_PROTOCOL, TP_PROTOCOL_STRINGS);
+
// open client port
LOG_DEBUG_STR("Opening listener for clients");
-
- string acceptorID;
+
+ string acceptorID;
if (itsInstancenr >= 0) {
- acceptorID = formatString("(%d)", itsInstancenr);
+ acceptorID = formatString("(%d)", itsInstancenr);
}
-
+
itsAcceptor.init(*this, MAC_SVCMASK_TBBDRIVER + acceptorID, GCFPortInterface::MSPP, TBB_PROTOCOL);
// open port with TBB board
LOG_DEBUG_STR("Connecting to TBB boards");
- itsBoard = new GCFETHRawPort[TS->maxBoards()];
+ itsBoard = new GCFETHRawPort[TS->maxBoards()];
ASSERT(itsBoard);
-
+
char boardname[64];
- for (int boardnr = 0; boardnr < TS->maxBoards(); boardnr++) {
- snprintf(boardname, 64, "board%d", boardnr);
+ for (int boardnr = 0; boardnr < TS->maxBoards(); boardnr++) {
+ snprintf(boardname, 64, "board%d", boardnr);
- LOG_DEBUG_STR("initializing board " << boardname << ":" << TS->getSrcMac(boardnr).c_str());
- itsBoard[boardnr].init(*this, boardname, GCFPortInterface::SAP, TP_PROTOCOL,true /*raw*/);
-
- LOG_DEBUG_STR("setAddr " << boardname << ":" << TS->getSrcMac(boardnr).c_str());
- itsBoard[boardnr].setAddr(TS->getIfName().c_str(), TS->getSrcMac(boardnr).c_str());
-
- // set ethertype to 0x7BB0 so Ethereal can decode TBB messages
- itsBoard[boardnr].setEtherType(ETHERTYPE_TP);
- }
-
- for (int bn = 0; bn < TS->maxBoards();bn++) {
- TS->setBoardPorts(bn,&itsBoard[bn]);
- }
-
- itsAliveTimer = new GCFTimerPort(*this, "AliveTimer");
- itsSetupTimer = new GCFTimerPort(*this, "SetupTimer");
- itsCmdTimer = new GCFTimerPort(*this, "CmdTimer");
- itsSaveTimer = new GCFTimerPort(*this, "SaveTimer");
-
- // create cmd & msg handler
- LOG_DEBUG_STR("initializing handlers");
- cmdhandler = new BoardCmdHandler(itsCmdTimer);
- msghandler = new MsgHandler();
-
- itsResetCount = new int32[TS->maxBoards()];
- memset(itsResetCount,0,sizeof(int32)*TS->maxBoards());
-
- // set Tbb queue
- LOG_DEBUG_STR("initializing TbbQueue");
- itsTbbQueue = new deque<TbbEvent*>(100);
- itsTbbQueue->clear();
-
- itsAlive = new TPAliveEvent();
- itsAlive->opcode = TPALIVE;
- itsAlive->status = 0;
+ LOG_DEBUG_STR("initializing board " << boardname << ":" << TS->getSrcMac(boardnr).c_str());
+ itsBoard[boardnr].init(*this, boardname, GCFPortInterface::SAP, TP_PROTOCOL,true /*raw*/);
+
+ LOG_DEBUG_STR("setAddr " << boardname << ":" << TS->getSrcMac(boardnr).c_str());
+ itsBoard[boardnr].setAddr(TS->getIfName().c_str(), TS->getSrcMac(boardnr).c_str());
+
+ // set ethertype to 0x7BB0 so Ethereal can decode TBB messages
+ itsBoard[boardnr].setEtherType(ETHERTYPE_TP);
+ }
+
+ for (int bn = 0; bn < TS->maxBoards();bn++) {
+ TS->setBoardPorts(bn,&itsBoard[bn]);
+ }
+
+ itsAliveTimer = new GCFTimerPort(*this, "AliveTimer");
+ itsSetupTimer = new GCFTimerPort(*this, "SetupTimer");
+ itsCmdTimer = new GCFTimerPort(*this, "CmdTimer");
+ itsSaveTimer = new GCFTimerPort(*this, "SaveTimer");
+
+ // create cmd & msg handler
+ LOG_DEBUG_STR("initializing handlers");
+ cmdhandler = new BoardCmdHandler(itsCmdTimer);
+ msghandler = new MsgHandler();
+
+ itsResetCount = new int32[TS->maxBoards()];
+ memset(itsResetCount,0,sizeof(int32)*TS->maxBoards());
+
+ // set Tbb queue
+ LOG_DEBUG_STR("initializing TbbQueue");
+ itsTbbQueue = new deque<TbbEvent*>(100);
+ itsTbbQueue->clear();
+
+ itsAlive = new TPAliveEvent();
+ itsAlive->opcode = TPALIVE;
+ itsAlive->status = 0;
}
//-----------------------------------------------------------------------------
TBBDriver::~TBBDriver()
{
- delete [] itsBoard;
- delete itsAliveTimer;
- delete itsSetupTimer;
- delete cmdhandler;
- delete msghandler;
- delete [] itsResetCount;
- delete itsTbbQueue;
- delete itsAlive;
- if (cmd) delete cmd;
+ delete [] itsBoard;
+ delete itsAliveTimer;
+ delete itsSetupTimer;
+ delete cmdhandler;
+ delete msghandler;
+ delete [] itsResetCount;
+ delete itsTbbQueue;
+ delete itsAlive;
+ if (cmd) delete cmd;
}
//-----------------------------------------------------------------------------
GCFEvent::TResult TBBDriver::init_state(GCFEvent& event, GCFPortInterface& port)
{
- GCFEvent::TResult status = GCFEvent::HANDLED;
- LOG_DEBUG_STR ("init_state:" << eventName(event) << "@" << port.getName());
-
- switch(event.signal) {
- case F_INIT: {
- if (itsAcceptor.isConnected())
- itsAcceptor.close();
- } break;
-
- case F_EXIT: {
- } break;
+ GCFEvent::TResult status = GCFEvent::HANDLED;
+ LOG_DEBUG_STR ("init_state:" << eventName(event) << "@" << port.getName());
+
+ switch(event.signal) {
+ case F_INIT: {
+ if (itsAcceptor.isConnected())
+ itsAcceptor.close();
+ } break;
+
+ case F_EXIT: {
+ } break;
- case F_ENTRY: {
- openBoards();
- } break;
-
- case F_CONNECTED: {
+ case F_ENTRY: {
+ openBoards();
+ } break;
+
+ case F_CONNECTED: {
LOG_DEBUG_STR("CONNECTED: port " << port.getName());
-
- if (isEnabled() && !itsAcceptor.isConnected()) {
- itsAcceptor.open();
- }
- if (itsAcceptor.isConnected()) {
- TRAN(TBBDriver::idle_state);
+
+ if (isEnabled() && !itsAcceptor.isConnected()) {
+ itsAcceptor.open();
+ }
+ if (itsAcceptor.isConnected()) {
+ TRAN(TBBDriver::idle_state);
}
} break;
-
- case F_TIMER: {
- } break;
-
- case F_DATAIN: {
- } break;
-
- default: {
- status = GCFEvent::NOT_HANDLED;
- } break;
- }
- return(status);
+
+ case F_TIMER: {
+ } break;
+
+ case F_DATAIN: {
+ } break;
+
+ default: {
+ status = GCFEvent::NOT_HANDLED;
+ } break;
+ }
+ return(status);
}
//-----------------------------------------------------------------------------
GCFEvent::TResult TBBDriver::setup_state(GCFEvent& event, GCFPortInterface& port)
{
- GCFEvent::TResult status = GCFEvent::HANDLED;
- LOG_DEBUG_STR ("setup_state:" << eventName(event) << "@" << port.getName());
-
- bool setupDone;
- static int* retries;
- static int* waitTimer;
-
- switch(event.signal) {
- case F_INIT: {
- } break;
-
- case F_EXIT: {
- if (retries) delete [] retries;
- if (waitTimer) delete [] waitTimer;
- } break;
+ GCFEvent::TResult status = GCFEvent::HANDLED;
+ LOG_DEBUG_STR ("setup_state:" << eventName(event) << "@" << port.getName());
+
+ bool setupDone;
+ static int* retries;
+ static int* waitTimer;
+
+ switch(event.signal) {
+ case F_INIT: {
+ } break;
+
+ case F_EXIT: {
+ if (retries) delete [] retries;
+ if (waitTimer) delete [] waitTimer;
+ } break;
- case F_ENTRY: {
- itsSaveTimer->cancelAllTimers();
- itsAliveTimer->cancelAllTimers();
- retries = new int[TS->maxBoards()];
- waitTimer = new int[TS->maxBoards()];
+ case F_ENTRY: {
+ itsSaveTimer->cancelAllTimers();
+ itsAliveTimer->cancelAllTimers();
+ retries = new int[TS->maxBoards()];
+ waitTimer = new int[TS->maxBoards()];
- for (int board = 0; board < TS->maxBoards(); board++) {
- waitTimer[board] = 0;
- retries[board] = 0;
- }
- LOG_INFO_STR("setting up boards");
- itsSetupTimer->setTimer(0.0);
- } break;
-
- case F_CONNECTED: {
- } break;
-
- case F_DISCONNECTED: {
- LOG_DEBUG_STR("DISCONNECTED: port ''" << port.getName() << "'");
- port.close();
-
- if (&port == &itsAcceptor) {
- LOG_FATAL_STR("Failed to start listening for client connections.");
- exit(EXIT_FAILURE);
- } else {
- itsClientList.remove(&port);
- msghandler->removeTriggerClient(port);
- msghandler->removeHardwareClient(port);
- }
- } break;
-
- case F_ACCEPT_REQ: {
- GCFTCPPort* client = new GCFTCPPort();
- client->init(*this, "client", GCFPortInterface::SPP, TBB_PROTOCOL);
- itsAcceptor.accept(*client);
- itsClientList.push_back(client);
+ for (int board = 0; board < TS->maxBoards(); board++) {
+ waitTimer[board] = 0;
+ retries[board] = 0;
+ }
+ LOG_INFO_STR("setting up boards");
+ itsSetupTimer->setTimer(0.0);
+ } break;
+
+ case F_CONNECTED: {
+ } break;
+
+ case F_DISCONNECTED: {
+ LOG_DEBUG_STR("DISCONNECTED: port ''" << port.getName() << "'");
+ port.close();
+
+ if (&port == &itsAcceptor) {
+ LOG_FATAL_STR("Failed to start listening for client connections.");
+ exit(EXIT_FAILURE);
+ } else {
+ itsClientList.remove(&port);
+ msghandler->removeTriggerClient(port);
+ msghandler->removeHardwareClient(port);
+ }
+ } break;
+
+ case F_ACCEPT_REQ: {
+ GCFTCPPort* client = new GCFTCPPort();
+ client->init(*this, "client", GCFPortInterface::SPP, TBB_PROTOCOL);
+ itsAcceptor.accept(*client);
+ itsClientList.push_back(client);
- LOG_DEBUG_STR("NEW CLIENT CONNECTED: " << itsClientList.size() << " clients connected");
- } break;
-
- case F_TIMER: {
- if (&port == itsSetupTimer) {
- setupDone = true;
- for (int board = 0; board < TS->maxBoards(); board++) {
-
- if (waitTimer[board]) { waitTimer[board]--; }
- if (waitTimer[board]) {
- setupDone = false;
- continue;
- } // board still busy, next board
-
- if ((TS->getBoardState(board) == noBoard)
- || (TS->getBoardState(board) == boardReady)
- || (TS->getBoardState(board) == boardError)) {
- continue;
- }
-
- if (TS->getBoardState(board) == resetBoard) {
- TPResetEvent reset;
- reset.opcode = TPRESET;
- reset.status = 0;
- itsBoard[board].send(reset);
- itsBoard[board].setTimer(5.0);
- LOG_INFO_STR("RESET is send to port '" << itsBoard[board].getName() << "'");
- waitTimer[board] = 10;
- setupDone = false;
- continue;
- }
-
- if ((TS->getBoardState(board) == clearBoard) || (TS->getBoardState(board) == boardReset)) {
- TPClearEvent clear;
- clear.opcode = TPCLEAR;
- clear.status = 0;
- itsBoard[board].send(clear);
- itsBoard[board].setTimer(5.0);
- LOG_INFO_STR("CLEAR is send to port '" << itsBoard[board].getName() << "'");
- waitTimer[board] = 10;
- setupDone = false;
- continue;
- }
+ LOG_DEBUG_STR("NEW CLIENT CONNECTED: " << itsClientList.size() << " clients connected");
+ } break;
+
+ case F_TIMER: {
+ if (&port == itsSetupTimer) {
+ setupDone = true;
+ for (int board = 0; board < TS->maxBoards(); board++) {
+
+ if (waitTimer[board]) { waitTimer[board]--; }
+ if (waitTimer[board]) {
+ setupDone = false;
+ continue;
+ } // board still busy, next board
+
+ if ((TS->getBoardState(board) == noBoard)
+ || (TS->getBoardState(board) == boardReady)
+ || (TS->getBoardState(board) == boardError)) {
+ continue;
+ }
+
+ if (TS->getBoardState(board) == setImage1) {
+ TPConfigEvent config;
+ config.opcode = TPCONFIG;
+ config.status = 0;
+ config.imagenr = 1;
+ //config.imagenr = 0;
+ itsBoard[board].send(config);
+ itsBoard[board].setTimer(5.0);
+ LOG_INFO_STR("CONFIG 1 is send to port '" << itsBoard[board].getName() << "'");
+ waitTimer[board] = 10;
+ setupDone = false;
+ continue;
+ }
+
+ if (TS->getBoardState(board) == clearBoard) {
+ TPClearEvent clear;
+ clear.opcode = TPCLEAR;
+ clear.status = 0;
+ itsBoard[board].send(clear);
+ itsBoard[board].setTimer(5.0);
+ LOG_INFO_STR("CLEAR is send to port '" << itsBoard[board].getName() << "'");
+ waitTimer[board] = 5;
+ setupDone = false;
+ continue;
+ }
- if ((TS->getBoardState(board) == freeBoard) || (TS->getBoardState(board) == boardCleared)) {
- TPFreeEvent free;
- free.opcode = TPFREE;
- free.status = 0;
- free.channel = 0xFFFFFFFF; // send channel = -1 to free all inputs
- itsBoard[board].send(free);
- itsBoard[board].setTimer(5.0);
- LOG_INFO_STR("FREE -1 is send to port '" << itsBoard[board].getName() << "'");
- waitTimer[board] = 10;
- setupDone = false;
- continue;
- }
-
- if (TS->getBoardState(board) == boardFreed) {
- TPAliveEvent alive;
- alive.opcode = TPALIVE;
- alive.status = 0;
- itsBoard[board].send(alive);
- itsBoard[board].setTimer(5.0);
- LOG_INFO_STR("ALIVE is send to port '" << itsBoard[board].getName() << "'");
- waitTimer[board] = 10;
- setupDone = false;
- continue;
- }
- }
-
- if (!setupDone) {
- itsSetupTimer->setTimer(1.0); // run this every second
- }
-
- } else { // no setup-timer event, must be a board time-out
- int board = TS->port2Board(&port); // get board nr
- if (TS->getBoardState(board) == resetBoard) {
- TS->resetActiveBoard(board);
- TS->setBoardState(board,boardReset);
- } else {
- waitTimer[board] = 0;
- retries[board]++;
- if (retries[board] >= TS->maxRetries()) {
- TS->resetActiveBoard(board);
- TS->setBoardState(board,boardError);
- }
- }
- }
-
- if (setupDone) {
- LOG_INFO_STR("setting up boards done");
- TS->clearBoardSetup();
- if (TS->saveTriggersToFile()) { itsSaveTimer->setTimer(2.0, 2.0); }
- itsAliveTimer->setTimer(ALIVECHECKTIME);
- TRAN(TBBDriver::idle_state);
- }
- } break;
-
- case F_DATAIN: {
- status = RawEvent::dispatch(*this, port);
- } break;
-
- case TP_RESET_ACK: {
- int board = TS->port2Board(&port); // get board nr
- itsBoard[board].cancelAllTimers();
- TS->setBoardState(board,boardReset);
- waitTimer[board] = 4;
- } break;
-
- case TP_CLEAR_ACK: {
- int board = TS->port2Board(&port); // get board nr
- itsBoard[board].cancelAllTimers();
- TS->setBoardState(board,boardCleared);
- waitTimer[board] = 3;
- } break;
-
- case TP_FREE_ACK: {
- int board = TS->port2Board(&port); // get board nr
- itsBoard[board].cancelAllTimers();
- TS->setBoardState(board,boardFreed);
- waitTimer[board] = 3;
+ if ((TS->getBoardState(board) == freeBoard)
+ || (TS->getBoardState(board) == boardCleared)
+ || (TS->getBoardState(board) == image1Set)) {
+ TPFreeEvent free;
+ free.opcode = TPFREE;
+ free.status = 0;
+ free.channel = 0xFFFFFFFF; // send channel = -1 to free all inputs
+ itsBoard[board].send(free);
+ itsBoard[board].setTimer(5.0);
+ LOG_INFO_STR("FREE -1 is send to port '" << itsBoard[board].getName() << "'");
+ waitTimer[board] = 5;
+ setupDone = false;
+ continue;
+ }
+
+ if (TS->getBoardState(board) == boardFreed) {
+ TPAliveEvent alive;
+ alive.opcode = TPALIVE;
+ alive.status = 0;
+ itsBoard[board].send(alive);
+ itsBoard[board].setTimer(1.0);
+ LOG_INFO_STR("ALIVE is send to port '" << itsBoard[board].getName() << "'");
+ waitTimer[board] = 1;
+ setupDone = false;
+ continue;
+ }
+ }
+
+ if (!setupDone) {
+ itsSetupTimer->setTimer(1.0); // run this every second
+ }
+
+ } else { // no setup-timer event, must be a board time-out
+ int board = TS->port2Board(&port); // get board nr
+ if (TS->getBoardState(board) == setImage1) {
+ TS->resetActiveBoard(board);
+ //TS->setBoardState(board,image1Set);
+ } else {
+ waitTimer[board] = 0;
+ retries[board]++;
+ if (retries[board] >= TS->maxRetries()) {
+ TS->resetActiveBoard(board);
+ TS->setBoardState(board,boardError);
+ }
+ }
+ }
+
+ if (setupDone) {
+ LOG_INFO_STR("setting up boards done");
+ TS->clearBoardSetup();
+ if (TS->saveTriggersToFile()) { itsSaveTimer->setTimer(2.0, 2.0); }
+ itsAliveTimer->setTimer(ALIVECHECKTIME);
+ TRAN(TBBDriver::idle_state);
+ }
+ } break;
+
+ case F_DATAIN: {
+ status = RawEvent::dispatch(*this, port);
+ } break;
+
+ case TP_CONFIG_ACK: {
+ int board = TS->port2Board(&port); // get board nr
+ itsBoard[board].cancelAllTimers();
+ TS->setBoardState(board,image1Set);
+ TS->setImageNr(board, 1);
+ waitTimer[board] = 15;
+ } break;
+
+ case TP_CLEAR_ACK: {
+ int board = TS->port2Board(&port); // get board nr
+ itsBoard[board].cancelAllTimers();
+ TS->setBoardState(board,boardCleared);
+ waitTimer[board] = 2;
+ } break;
+
+ case TP_FREE_ACK: {
+ int board = TS->port2Board(&port); // get board nr
+ itsBoard[board].cancelAllTimers();
+ TS->setBoardState(board,boardFreed);
+ waitTimer[board] = 2;
} break;
case TP_ALIVE_ACK: {
- int board = TS->port2Board(&port); // get board nr
- itsBoard[board].cancelAllTimers();
- TS->setBoardState(board,boardReady);
- LOG_INFO_STR("'" << itsBoard[board].getName() << "' is Ready");
- waitTimer[board] = 0;
- } break;
-
- case TP_TRIGGER: {
- for (int boardnr = 0; boardnr < TS->maxBoards(); boardnr++) {
- if (&port == &TS->boardPort(boardnr)) {
- msghandler->sendTrigger(event,boardnr);
- break;
- }
- }
- } break;
-
- case TBB_GET_CONFIG:
- case TBB_RCU_INFO:
- case TBB_SUBSCRIBE:
- case TBB_UNSUBSCRIBE:
- case TBB_ALLOC:
- case TBB_FREE:
- case TBB_RECORD:
- case TBB_STOP:
- case TBB_TRIG_RELEASE:
- case TBB_TRIG_GENERATE:
- case TBB_TRIG_SETUP:
- case TBB_TRIG_COEF:
- case TBB_TRIG_SETTINGS:
- case TBB_TRIG_INFO:
- case TBB_READ:
- case TBB_MODE:
- case TBB_PAGEPERIOD:
- case TBB_VERSION:
- case TBB_SIZE:
- case TBB_STATUS:
- case TBB_CLEAR:
- case TBB_RESET:
- case TBB_CONFIG:
- case TBB_ERASE_IMAGE:
- case TBB_READ_IMAGE:
- case TBB_WRITE_IMAGE:
- case TBB_IMAGE_INFO:
- case TBB_READX:
- case TBB_READW:
- case TBB_WRITEW:
- case TBB_READR:
- case TBB_WRITER:
- case TBB_ARP:
- case TBB_ARP_MODE:
- case TBB_STOP_CEP:
- case TBB_TEMP_LIMIT: {
- TBBDriverBusyAckEvent ack;
- port.send(ack);
- } break;
-
- default: {
- status = GCFEvent::NOT_HANDLED;
- } break;
- }
-
- return(status);
-}
+ int board = TS->port2Board(&port); // get board nr
+ itsBoard[board].cancelAllTimers();
+ TS->setBoardState(board,boardReady);
+ LOG_INFO_STR("'" << itsBoard[board].getName() << "' is Ready");
+ waitTimer[board] = 0;
+ } break;
+
+ case TP_TRIGGER: {
+ for (int boardnr = 0; boardnr < TS->maxBoards(); boardnr++) {
+ if (&port == &TS->boardPort(boardnr)) {
+ msghandler->sendTrigger(event,boardnr);
+ break;
+ }
+ }
+ } break;
+
+ case TBB_GET_CONFIG:
+ case TBB_RCU_INFO:
+ case TBB_SUBSCRIBE:
+ case TBB_UNSUBSCRIBE:
+ case TBB_ALLOC:
+ case TBB_FREE:
+ case TBB_RECORD:
+ case TBB_STOP:
+ case TBB_TRIG_RELEASE:
+ case TBB_TRIG_GENERATE:
+ case TBB_TRIG_SETUP:
+ case TBB_TRIG_COEF:
+ case TBB_TRIG_SETTINGS:
+ case TBB_TRIG_INFO:
+ case TBB_READ:
+ case TBB_MODE:
+ case TBB_PAGEPERIOD:
+ case TBB_VERSION:
+ case TBB_SIZE:
+ case TBB_STATUS:
+ case TBB_CLEAR:
+ case TBB_RESET:
+ case TBB_CONFIG:
+ case TBB_ERASE_IMAGE:
+ case TBB_READ_IMAGE:
+ case TBB_WRITE_IMAGE:
+ case TBB_IMAGE_INFO:
+ case TBB_READX:
+ case TBB_READW:
+ case TBB_WRITEW:
+ case TBB_READR:
+ case TBB_WRITER:
+ case TBB_ARP:
+ case TBB_ARP_MODE:
+ case TBB_STOP_CEP:
+ case TBB_TEMP_LIMIT: {
+ TBBDriverBusyAckEvent ack;
+ port.send(ack);
+ } break;
+
+ default: {
+ status = GCFEvent::NOT_HANDLED;
+ } break;
+ }
+
+ return(status);
+}
//-----------------------------------------------------------------------------
// idle(event, port)
//
GCFEvent::TResult TBBDriver::idle_state(GCFEvent& event, GCFPortInterface& port)
{
- GCFEvent::TResult status = GCFEvent::HANDLED;
- LOG_DEBUG_STR("idle:" << eventName(event) << "@" << port.getName());
-
- switch(event.signal) {
- case F_INIT: {
- } break;
+ GCFEvent::TResult status = GCFEvent::HANDLED;
+ LOG_DEBUG_STR("idle:" << eventName(event) << "@" << port.getName());
+
+ switch(event.signal) {
+ case F_INIT: {
+ } break;
case F_EXIT: {
- } break;
+ } break;
- case F_ENTRY: {
- LOG_DEBUG_STR("Entering Idle State");
- // if no tbb boards start check-alive
- if (TS->activeBoardsMask() == 0) {
- itsAliveTimer->setTimer(0.0);
- break;
- }
-
- // if board setup needed
- if (TS->boardSetupNeeded()) {
- LOG_DEBUG_STR("need boards setup");
- TRAN(TBBDriver::setup_state);
- break;
- }
-
- if (itsClientList.empty()) {
- itsTbbQueue->clear();
- LOG_DEBUG_STR("Client list is empty, the queue is cleared");
- }
-
- // look if there is an Tbb command in queue
- if (!itsTbbQueue->empty()) {
- LOG_DEBUG_STR("The queue is NOT empty");
-
- uint8* bufptr = new uint8[sizeof(GCFEvent) + itsTbbQueue->front()->length];
-
- GCFEvent* e = new (bufptr) GCFEvent;
- memcpy(e, &(itsTbbQueue->front()->event), itsTbbQueue->front()->length);
-
-
- LOG_DEBUG_STR("queue:" << eventName(*e));
-
- if (SetTbbCommand(e->signal)) {
- status = cmdhandler->dispatch(*e,*itsTbbQueue->front()->port);
- // delete e;
+ case F_ENTRY: {
+ LOG_DEBUG_STR("Entering Idle State");
+ // if no tbb boards start check-alive
+ if (TS->activeBoardsMask() == 0) {
+ itsAliveTimer->setTimer(0.0);
+ break;
+ }
+
+ // if board setup needed
+ if (TS->boardSetupNeeded()) {
+ LOG_DEBUG_STR("need boards setup");
+ TRAN(TBBDriver::setup_state);
+ break;
+ }
+
+ if (itsClientList.empty()) {
+ itsTbbQueue->clear();
+ LOG_DEBUG_STR("Client list is empty, the queue is cleared");
+ }
+
+ // look if there is an Tbb command in queue
+ if (!itsTbbQueue->empty()) {
+ LOG_DEBUG_STR("The queue is NOT empty");
+
+ uint8* bufptr = new uint8[sizeof(GCFEvent) + itsTbbQueue->front()->length];
+
+ GCFEvent* e = new (bufptr) GCFEvent;
+ memcpy(e, &(itsTbbQueue->front()->event), itsTbbQueue->front()->length);
+
+
+ LOG_DEBUG_STR("queue:" << eventName(*e));
+
+ if (SetTbbCommand(e->signal)) {
+ status = cmdhandler->dispatch(*e,*itsTbbQueue->front()->port);
+ // delete e;
- TbbEvent* tmp = itsTbbQueue->front();
- itsTbbQueue->pop_front();
- delete tmp;
+ TbbEvent* tmp = itsTbbQueue->front();
+ itsTbbQueue->pop_front();
+ delete tmp;
- TRAN(TBBDriver::busy_state);
- } else {
- sendInfo(*e, *itsTbbQueue->front()->port);
-
- TbbEvent* tmp = itsTbbQueue->front();
- itsTbbQueue->pop_front();
- delete tmp;
- }
- }
- } break;
+ TRAN(TBBDriver::busy_state);
+ } else {
+ sendInfo(*e, *itsTbbQueue->front()->port);
+
+ TbbEvent* tmp = itsTbbQueue->front();
+ itsTbbQueue->pop_front();
+ delete tmp;
+ }
+ }
+ } break;
- case F_CONNECTED: {
- LOG_DEBUG_STR("CONNECTED: port '" << port.getName() << "'");
- } break;
-
- case F_DISCONNECTED: {
- LOG_DEBUG_STR("DISCONNECTED: port ''" << port.getName() << "'");
+ case F_CONNECTED: {
+ LOG_DEBUG_STR("CONNECTED: port '" << port.getName() << "'");
+ } break;
+
+ case F_DISCONNECTED: {
+ LOG_DEBUG_STR("DISCONNECTED: port ''" << port.getName() << "'");
port.close();
-
- if (&port == &itsAcceptor) {
+
+ if (&port == &itsAcceptor) {
LOG_FATAL_STR("Failed to start listening for client connections.");
exit(EXIT_FAILURE);
} else {
- itsClientList.remove(&port);
- msghandler->removeTriggerClient(port);
- msghandler->removeHardwareClient(port);
+ itsClientList.remove(&port);
+ msghandler->removeTriggerClient(port);
+ msghandler->removeHardwareClient(port);
}
- } break;
-
- case F_ACCEPT_REQ: {
- GCFTCPPort* client = new GCFTCPPort();
- client->init(*this, "client", GCFPortInterface::SPP, TBB_PROTOCOL);
+ } break;
+
+ case F_ACCEPT_REQ: {
+ GCFTCPPort* client = new GCFTCPPort();
+ client->init(*this, "client", GCFPortInterface::SPP, TBB_PROTOCOL);
itsAcceptor.accept(*client);
itsClientList.push_back(client);
- LOG_DEBUG_STR("NEW CLIENT CONNECTED: " << itsClientList.size() << " clients connected");
- } break;
-
- case F_DATAIN: {
- status = RawEvent::dispatch(*this, port);
- } break;
-
- case F_TIMER: {
- if (&port == itsSaveTimer) {
- msghandler->saveTriggerMessage();
- break;
- }
-
- if (&port == itsAliveTimer) {
- CheckAlive(event, port);
- }
- // if new boards detected set them up
- if (itsAliveCheck == false && TS->boardSetupNeeded()) {
- LOG_DEBUG_STR("need boards setup");
- TRAN(TBBDriver::setup_state);
- }
- } break;
-
- case TP_ALIVE_ACK: {
- LOG_DEBUG_STR("TP_ALIVE_ACK received");
- if (itsAliveCheck) { CheckAlive(event, port); }
- } break;
-
- case TBB_SUBSCRIBE: {
- TBBSubscribeEvent subscribe(event);
- if (subscribe.triggers) { msghandler->addTriggerClient(port); }
- if (subscribe.hardware) { msghandler->addHardwareClient(port); }
-
- TBBSubscribeAckEvent subscribeack;
- port.send(subscribeack);
- } break;
-
- case TBB_UNSUBSCRIBE: {
- msghandler->removeTriggerClient(port);
- msghandler->removeHardwareClient(port);
- TBBUnsubscribeAckEvent unsubscribeack;
- port.send(unsubscribeack);
- } break;
-
- case TP_TRIGGER: {
- for (int boardnr = 0; boardnr < TS->maxBoards(); boardnr++) {
- if (&port == &TS->boardPort(boardnr)) {
- msghandler->sendTrigger(event,boardnr);
- break;
- }
- }
- } break;
+ LOG_DEBUG_STR("NEW CLIENT CONNECTED: " << itsClientList.size() << " clients connected");
+ } break;
+
+ case F_DATAIN: {
+ status = RawEvent::dispatch(*this, port);
+ } break;
+
+ case F_TIMER: {
+ if (&port == itsSaveTimer) {
+ msghandler->saveTriggerMessage();
+ break;
+ }
+
+ if (&port == itsAliveTimer) {
+ CheckAlive(event, port);
+ }
+ // if new boards detected set them up
+ if (itsAliveCheck == false && TS->boardSetupNeeded()) {
+ LOG_DEBUG_STR("need boards setup");
+ TRAN(TBBDriver::setup_state);
+ }
+ } break;
+
+ case TP_ALIVE_ACK: {
+ LOG_DEBUG_STR("TP_ALIVE_ACK received");
+ if (itsAliveCheck) { CheckAlive(event, port); }
+ } break;
+
+ case TBB_SUBSCRIBE: {
+ TBBSubscribeEvent subscribe(event);
+ if (subscribe.triggers) { msghandler->addTriggerClient(port); }
+ if (subscribe.hardware) { msghandler->addHardwareClient(port); }
+
+ TBBSubscribeAckEvent subscribeack;
+ port.send(subscribeack);
+ } break;
+
+ case TBB_UNSUBSCRIBE: {
+ msghandler->removeTriggerClient(port);
+ msghandler->removeHardwareClient(port);
+ TBBUnsubscribeAckEvent unsubscribeack;
+ port.send(unsubscribeack);
+ } break;
+
+ case TP_TRIGGER: {
+ for (int boardnr = 0; boardnr < TS->maxBoards(); boardnr++) {
+ if (&port == &TS->boardPort(boardnr)) {
+ msghandler->sendTrigger(event,boardnr);
+ break;
+ }
+ }
+ } break;
- case TP_ERROR: {
- msghandler->sendError(event);
- } break;
-
- case TBB_GET_CONFIG:
- case TBB_RCU_INFO:
- case TBB_TRIG_SETTINGS: {
- sendInfo(event, port);
- } break;
-
- default: {
- // look if the event is a Tbb event
- if (SetTbbCommand(event.signal)) {
- if (TS->activeBoardsMask() != 0) {
- itsAliveTimer->cancelAllTimers();
- itsAliveTimer->setTimer(ALIVECHECKTIME);
- itsAliveCheck = false;
- status = cmdhandler->dispatch(event,port);
- TRAN(TBBDriver::busy_state);
- } else {
- TBBDriverBusyAckEvent ack;
- port.send(ack);
- }
- } else {
- // if not a Tbb event, return not-handled
- status = GCFEvent::NOT_HANDLED;
- }
- } break;
- }
-
- return(status);
+ case TP_ERROR: {
+ msghandler->sendError(event);
+ } break;
+
+ case TBB_GET_CONFIG:
+ case TBB_RCU_INFO:
+ case TBB_TRIG_SETTINGS: {
+ sendInfo(event, port);
+ } break;
+
+ default: {
+ // look if the event is a Tbb event
+ if (SetTbbCommand(event.signal)) {
+ if (TS->activeBoardsMask() != 0) {
+ itsAliveTimer->cancelAllTimers();
+ itsAliveTimer->setTimer(ALIVECHECKTIME);
+ itsAliveCheck = false;
+ status = cmdhandler->dispatch(event,port);
+ TRAN(TBBDriver::busy_state);
+ } else {
+ TBBDriverBusyAckEvent ack;
+ port.send(ack);
+ }
+ } else {
+ // if not a Tbb event, return not-handled
+ status = GCFEvent::NOT_HANDLED;
+ }
+ } break;
+ }
+
+ return(status);
}
//-----------------------------------------------------------------------------
@@ -678,201 +683,206 @@ GCFEvent::TResult TBBDriver::idle_state(GCFEvent& event, GCFPortInterface& port)
//
GCFEvent::TResult TBBDriver::busy_state(GCFEvent& event, GCFPortInterface& port)
{
- GCFEvent::TResult status = GCFEvent::HANDLED;
- LOG_DEBUG_STR ("busy_state:" << eventName(event) << "@" << port.getName());
-
- switch(event.signal) {
- case F_INIT: {
- } break;
-
- case F_EXIT: {
- if (cmd) delete cmd;
- itsAliveTimer->setTimer(1.0);
- itsAliveCheck = false;
- } break;
-
- case F_ENTRY: {
- if (cmdhandler->tpCmdDone()) {
- TRAN(TBBDriver::idle_state);
- }
- } break;
-
- case F_ACCEPT_REQ: {
- GCFTCPPort* client = new GCFTCPPort();
- client->init(*this, "client", GCFPortInterface::SPP, TBB_PROTOCOL);
- itsAcceptor.accept(*client);
- } break;
-
- case F_CONNECTED: {
- LOG_DEBUG_STR("CONNECTED: port '" << port.getName() << "'");
- } break;
-
- case F_DISCONNECTED: {
- LOG_DEBUG_STR("DISCONNECTED: port '" << port.getName() << "'");
- port.close();
-
- if (&port == &itsAcceptor) {
- LOG_FATAL_STR("Failed to start listening for client connections.");
- exit(EXIT_FAILURE);
- } else {
- itsClientList.remove(&port);
- msghandler->removeTriggerClient(port);
- msghandler->removeHardwareClient(port);
- }
-
- TRAN(TBBDriver::idle_state);
- } break;
-
- case F_TIMER: {
- if (&port == itsSaveTimer) {
- msghandler->saveTriggerMessage();
- break;
- }
-
- if (&port == itsAliveTimer) {
- if (itsAliveCheck) {
- CheckAlive(event, port);// if true, then all boards are checked
- } else {
- itsAliveTimer->setTimer(ALIVECHECKTIME);
- }
- } else {
- status = cmdhandler->dispatch(event,port); // dispatch time-out event
- }
- } break;
-
- case F_DATAIN: {
- status = RawEvent::dispatch(*this, port);
- } break;
-
- case TP_ALIVE_ACK: {
- LOG_DEBUG_STR("TP_ALIVE_ACK received");
- if (itsAliveCheck) { CheckAlive(event, port); }
- } break;
-
- case TBB_SUBSCRIBE: {
- TBBSubscribeEvent subscribe(event);
- if (subscribe.triggers) { msghandler->addTriggerClient(port); }
- if (subscribe.hardware) { msghandler->addHardwareClient(port); }
-
- TBBSubscribeAckEvent subscribeack;
- port.send(subscribeack);
- } break;
-
- case TBB_UNSUBSCRIBE: {
- msghandler->removeTriggerClient(port);
- msghandler->removeHardwareClient(port);
- TRAN(TBBDriver::idle_state);
- } break;
-
- case TP_TRIGGER: {
- for (int boardnr = 0; boardnr < TS->maxBoards(); boardnr++) {
- if (&port == &TS->boardPort(boardnr)) {
- msghandler->sendTrigger(event,boardnr);
- break;
- }
- }
- } break;
+ GCFEvent::TResult status = GCFEvent::HANDLED;
+ LOG_DEBUG_STR ("busy_state:" << eventName(event) << "@" << port.getName());
+
+ switch(event.signal) {
+ case F_INIT: {
+ } break;
+
+ case F_EXIT: {
+ if (cmd) delete cmd;
+ itsAliveTimer->setTimer(1.0);
+ itsAliveCheck = false;
+ } break;
+
+ case F_ENTRY: {
+ if (cmdhandler->tpCmdDone()) {
+ TRAN(TBBDriver::idle_state);
+ }
+ } break;
+
+ case F_ACCEPT_REQ: {
+ GCFTCPPort* client = new GCFTCPPort();
+ client->init(*this, "client", GCFPortInterface::SPP, TBB_PROTOCOL);
+ itsAcceptor.accept(*client);
+ } break;
+
+ case F_CONNECTED: {
+ LOG_DEBUG_STR("CONNECTED: port '" << port.getName() << "'");
+ } break;
+
+ case F_DISCONNECTED: {
+ LOG_DEBUG_STR("DISCONNECTED: port '" << port.getName() << "'");
+ port.close();
+
+ if (&port == &itsAcceptor) {
+ LOG_FATAL_STR("Failed to start listening for client connections.");
+ exit(EXIT_FAILURE);
+ } else {
+ itsClientList.remove(&port);
+ msghandler->removeTriggerClient(port);
+ msghandler->removeHardwareClient(port);
+ }
+
+ TRAN(TBBDriver::idle_state);
+ } break;
+
+ case F_TIMER: {
+ if (&port == itsSaveTimer) {
+ msghandler->saveTriggerMessage();
+ break;
+ }
+
+ if (&port == itsAliveTimer) {
+ if (itsAliveCheck) {
+ CheckAlive(event, port);// if true, then all boards are checked
+ } else {
+ itsAliveTimer->setTimer(ALIVECHECKTIME);
+ }
+ } else {
+ status = cmdhandler->dispatch(event,port); // dispatch time-out event
+ }
+ } break;
+
+ case F_DATAIN: {
+ status = RawEvent::dispatch(*this, port);
+ } break;
+
+ case TP_ALIVE_ACK: {
+ LOG_DEBUG_STR("TP_ALIVE_ACK received");
+ if (itsAliveCheck) { CheckAlive(event, port); }
+ } break;
+
+ case TBB_SUBSCRIBE: {
+ TBBSubscribeEvent subscribe(event);
+ if (subscribe.triggers) { msghandler->addTriggerClient(port); }
+ if (subscribe.hardware) { msghandler->addHardwareClient(port); }
+
+ TBBSubscribeAckEvent subscribeack;
+ port.send(subscribeack);
+ } break;
+
+ case TBB_UNSUBSCRIBE: {
+ msghandler->removeTriggerClient(port);
+ msghandler->removeHardwareClient(port);
+ if (cmdhandler->tpCmdDone()) {
+ TRAN(TBBDriver::idle_state);
+ }
+ } break;
+
+ case TP_TRIGGER: {
+ for (int boardnr = 0; boardnr < TS->maxBoards(); boardnr++) {
+ if (&port == &TS->boardPort(boardnr)) {
+ msghandler->sendTrigger(event,boardnr);
+ break;
+ }
+ }
+ } break;
- case TP_ERROR: {
- msghandler->sendError(event);
- } break;
-
- case TP_ALLOC_ACK:
- case TP_FREE_ACK:
- case TP_RECORD_ACK:
- case TP_STOP_ACK:
- case TP_TRIG_RELEASE_ACK:
- case TP_TRIG_GENERATE_ACK:
- case TP_TRIG_SETUP_ACK:
- case TP_TRIG_COEF_ACK:
- case TP_TRIG_INFO_ACK:
- case TP_READ_ACK:
- case TP_UDP_ACK:
- case TP_PAGEPERIOD_ACK:
- case TP_VERSION_ACK:
- case TP_STATUS_ACK:
- case TP_CLEAR_ACK:
- case TP_SIZE_ACK:
- case TP_RESET_ACK:
- case TP_CONFIG_ACK:
- case TP_ERASEF_ACK:
- case TP_READF_ACK:
- case TP_WRITEF_ACK:
- case TP_READW_ACK:
- case TP_WRITEW_ACK:
- case TP_READR_ACK:
- case TP_WRITER_ACK:
- case TP_READX_ACK:
- case TP_ARP_ACK:
- case TP_ARP_MODE_ACK:
- case TP_STOP_CEP_ACK:
- case TP_TEMP_LIMIT_ACK:
- {
- status = cmdhandler->dispatch(event,port); // dispatch ack from boards
- if (cmdhandler->tpCmdDone()) {
- TRAN(TBBDriver::idle_state);
- }
- } break;
-
- case TBB_GET_CONFIG:
- case TBB_RCU_INFO:
- case TBB_ALLOC:
- case TBB_FREE:
- case TBB_RECORD:
- case TBB_STOP:
- case TBB_TRIG_RELEASE:
- case TBB_TRIG_GENERATE:
- case TBB_TRIG_SETUP:
- case TBB_TRIG_COEF:
- case TBB_TRIG_SETTINGS:
- case TBB_TRIG_INFO:
- case TBB_READ:
- case TBB_MODE:
- case TBB_PAGEPERIOD:
- case TBB_VERSION:
- case TBB_SIZE:
- case TBB_STATUS:
- case TBB_CLEAR:
- case TBB_RESET:
- case TBB_CONFIG:
- case TBB_ERASE_IMAGE:
- case TBB_READ_IMAGE:
- case TBB_WRITE_IMAGE:
- case TBB_IMAGE_INFO:
- case TBB_READX:
- case TBB_READW:
- case TBB_WRITEW:
- case TBB_READR:
- case TBB_WRITER:
- case TBB_ARP:
- case TBB_ARP_MODE:
- case TBB_STOP_CEP:
- case TBB_TEMP_LIMIT: {
- // put event on the queue
- LOG_DEBUG_STR("Put event on queue");
-
- uint8* bufptr = new uint8[sizeof(GCFPortInterface*)
- + sizeof(uint32)
- + sizeof(GCFEvent)
- + event.length];
- TbbEvent* tbbevent = new (bufptr) TbbEvent;
-
- memcpy(&(tbbevent->event), &event, (sizeof(GCFEvent) + event.length));
- tbbevent->length = sizeof(GCFEvent) + event.length;
- tbbevent->port = &port;
-
- itsTbbQueue->push_back(tbbevent);
- } break;
-
- default: {
- LOG_DEBUG_STR("DEFAULT");
-
- status = GCFEvent::NOT_HANDLED;
- } break;
- }
-
-
- return(status);
+ case TP_ERROR: {
+ msghandler->sendError(event);
+ } break;
+
+ case TP_ALLOC_ACK:
+ case TP_FREE_ACK:
+ case TP_RECORD_ACK:
+ case TP_STOP_ACK:
+ case TP_TRIG_RELEASE_ACK:
+ case TP_TRIG_GENERATE_ACK:
+ case TP_TRIG_SETUP_ACK:
+ case TP_TRIG_COEF_ACK:
+ case TP_TRIG_INFO_ACK:
+ case TP_READ_ACK:
+ case TP_UDP_ACK:
+ case TP_PAGEPERIOD_ACK:
+ case TP_VERSION_ACK:
+ case TP_STATUS_ACK:
+ case TP_CLEAR_ACK:
+ case TP_SIZE_ACK:
+ case TP_RESET_ACK:
+ case TP_CONFIG_ACK:
+ case TP_ERASEF_ACK:
+ case TP_READF_ACK:
+ case TP_WRITEF_ACK:
+ case TP_READW_ACK:
+ case TP_WRITEW_ACK:
+ case TP_READR_ACK:
+ case TP_WRITER_ACK:
+ case TP_READX_ACK:
+ case TP_ARP_ACK:
+ case TP_ARP_MODE_ACK:
+ case TP_STOP_CEP_ACK:
+ case TP_TEMP_LIMIT_ACK:
+ {
+ status = cmdhandler->dispatch(event,port); // dispatch ack from boards
+ if (cmdhandler->tpCmdDone()) {
+ TRAN(TBBDriver::idle_state);
+ }
+ } break;
+
+ case TBB_GET_CONFIG:
+ case TBB_RCU_INFO:
+ case TBB_ALLOC:
+ case TBB_FREE:
+ case TBB_RECORD:
+ case TBB_STOP:
+ case TBB_TRIG_RELEASE:
+ case TBB_TRIG_GENERATE:
+ case TBB_TRIG_SETUP:
+ case TBB_TRIG_COEF:
+ case TBB_TRIG_SETTINGS:
+ case TBB_TRIG_INFO:
+ case TBB_READ:
+ case TBB_MODE:
+ case TBB_PAGEPERIOD:
+ case TBB_VERSION:
+ case TBB_SIZE:
+ case TBB_STATUS:
+ case TBB_CLEAR:
+ case TBB_RESET:
+ case TBB_CONFIG:
+ case TBB_ERASE_IMAGE:
+ case TBB_READ_IMAGE:
+ case TBB_WRITE_IMAGE:
+ case TBB_IMAGE_INFO:
+ case TBB_READX:
+ case TBB_READW:
+ case TBB_WRITEW:
+ case TBB_READR:
+ case TBB_WRITER:
+ case TBB_ARP:
+ case TBB_ARP_MODE:
+ case TBB_STOP_CEP:
+ case TBB_TEMP_LIMIT: {
+ // put event on the queue
+ LOG_DEBUG_STR("Put event on queue");
+
+ uint8* bufptr = new uint8[sizeof(GCFPortInterface*)
+ + sizeof(uint32)
+ + sizeof(GCFEvent)
+ + event.length];
+ TbbEvent* tbbevent = new (bufptr) TbbEvent;
+
+ memcpy(&(tbbevent->event), &event, (sizeof(GCFEvent) + event.length));
+ tbbevent->length = sizeof(GCFEvent) + event.length;
+ tbbevent->port = &port;
+
+ itsTbbQueue->push_back(tbbevent);
+ if (cmdhandler->tpCmdDone()) {
+ TRAN(TBBDriver::idle_state);
+ }
+ } break;
+
+ default: {
+ LOG_DEBUG_STR("DEFAULT");
+
+ status = GCFEvent::NOT_HANDLED;
+ } break;
+ }
+
+
+ return(status);
}
//-----------------------------------------------------------------------------
@@ -880,11 +890,11 @@ GCFEvent::TResult TBBDriver::busy_state(GCFEvent& event, GCFPortInterface& port)
//
void TBBDriver::openBoards()
{
- LOG_DEBUG_STR("opening boards");
- for (int boardnr = 0; boardnr < TS->maxBoards(); boardnr++) {
- if (itsBoard[boardnr].isConnected())
- itsBoard[boardnr].close();
- itsBoard[boardnr].open();
+ LOG_DEBUG_STR("opening boards");
+ for (int boardnr = 0; boardnr < TS->maxBoards(); boardnr++) {
+ if (itsBoard[boardnr].isConnected())
+ itsBoard[boardnr].close();
+ itsBoard[boardnr].open();
}
}
@@ -894,8 +904,8 @@ void TBBDriver::openBoards()
bool TBBDriver::isEnabled()
{
bool enabled = true;
- for (int boardnr = 0; boardnr < TS->maxBoards(); boardnr++)
- {
+ for (int boardnr = 0; boardnr < TS->maxBoards(); boardnr++)
+ {
if (!itsBoard[boardnr].isConnected())
{
enabled = false;
@@ -908,376 +918,387 @@ bool TBBDriver::isEnabled()
//-----------------------------------------------------------------------------
bool TBBDriver::CheckAlive(GCFEvent& event, GCFPortInterface& port)
{
- //bool done = false;
- int32 boardnr;
- static uint32 activeboards;
- static uint32 sendmask;
-
-
- //itsAliveTimer->cancelAllTimers();
- if (!itsAliveCheck) {
- itsAliveCheck = true;
- //itsNewBoards = 0;
- boardnr = 0;
- sendmask = 0;
- activeboards = 0;
-
- itsAliveTimer->cancelAllTimers();
- // mask all boards to check
- for(int nr = 0; nr < TS->maxBoards(); nr++) {
- itsBoard[nr].send(*itsAlive);
- sendmask |= (1 << nr);
- }
- // 1 timer for al events
- itsAliveTimer->setTimer(2.0);
- } else {
-
- if (event.signal == TP_ALIVE_ACK) {
- boardnr = TS->port2Board(&port);
- if (boardnr != -1) {
- activeboards |= (1 << boardnr);
-
- TPAliveAckEvent ack(event);
-
- if (ack.resetflag == 0) {
- //itsNewBoards |= (1 << boardnr); // board is reset, setup is needed
- itsResetCount[boardnr]++;
- TS->clearRcuSettings(boardnr);
- TS->setBoardState(boardnr,clearBoard);
- LOG_INFO_STR("=BOARD-RESET=, TBB board " << boardnr << " has been reset " << itsResetCount[boardnr] << " times");
- }
-
- if ((TS->activeBoardsMask() & (1 << boardnr)) == 0) {
- //itsNewBoards |= (1 << boardnr); // new board, setup is needed
- TS->setBoardState(boardnr,resetBoard);
- //TS->setBoardState(boardnr,clearBoard);
- LOG_INFO_STR("=NEW_BOARD=, TBB board " << boardnr << " is new");
- }
- }
- }
-
- if ((event.signal == F_TIMER) || (activeboards == sendmask )) {
- if (activeboards == sendmask) {
- itsAliveTimer->cancelAllTimers();
- }
-
- for (int board = 0; board < TS->maxBoards(); board++) {
- if (~activeboards & (1 << board)) { // look for not active boards
- TS->setBoardState(board, noBoard);
- }
- }
-
- if (activeboards != TS->activeBoardsMask()) {
- TS->setActiveBoardsMask(activeboards);
-
- //itsActiveBoardsChange = true;
- char boardstr[40];
- char instr[5];
- strcpy(boardstr,"");
- for (int i = 0; i < TS->maxBoards(); i++) {
- if (activeboards & (1 << i)) {
- sprintf(instr," %d",i);
- strcat(boardstr,instr);
- } else {
- strcat(boardstr," .");
- }
- }
- msghandler->sendBoardChange(TS->activeBoardsMask());
- LOG_INFO_STR("Available TBB boards changed:" << boardstr);
- }
-
- LOG_DEBUG_STR("Active TBB boards check");
- if (TS->activeBoardsMask() == 0) {
- itsAliveTimer->setTimer(5.0);
- } else {
- itsAliveTimer->setTimer(ALIVECHECKTIME);
- }
- itsAliveCheck = false;
- //done = true;
- }
- }
- return(!itsAliveCheck);
+ //bool done = false;
+ int32 boardnr;
+ static uint32 activeboards;
+ static uint32 sendmask;
+
+
+ //itsAliveTimer->cancelAllTimers();
+ if (!itsAliveCheck) {
+ itsAliveCheck = true;
+ //itsNewBoards = 0;
+ boardnr = 0;
+ sendmask = 0;
+ activeboards = 0;
+
+ itsAliveTimer->cancelAllTimers();
+ // mask all boards to check
+ for(int nr = 0; nr < TS->maxBoards(); nr++) {
+ itsBoard[nr].send(*itsAlive);
+ sendmask |= (1 << nr);
+ }
+ // 1 timer for al events
+ itsAliveTimer->setTimer(2.0);
+ } else {
+
+ if (event.signal == TP_ALIVE_ACK) {
+ boardnr = TS->port2Board(&port);
+ if (boardnr != -1) {
+ activeboards |= (1 << boardnr);
+ LOG_INFO_STR("TP_ALIVE_ACK " << activeboards << " <== activeboards mask");
+
+ TPAliveAckEvent ack(event);
+ // board is reset
+ if (ack.resetflag == 0) {
+ TS->clearRcuSettings(boardnr);
+ if (TS->getFreeToReset(boardnr)) {
+ TS->setImageNr(boardnr, 0);
+ TS->setBoardState(boardnr,setImage1);
+ } else {
+ // new image loaded
+ TS->setFreeToReset(boardnr, true);
+ TS->setBoardState(boardnr,clearBoard);
+ }
+ itsResetCount[boardnr]++;
+ LOG_INFO_STR("=BOARD-RESET=, TBB board " << boardnr << " has been reset " << itsResetCount[boardnr] << " times");
+ } else if ((TS->activeBoardsMask() & (1 << boardnr)) == 0) { // new board
+ TS->clearRcuSettings(boardnr);
+ if (TS->getFreeToReset(boardnr)) {
+ TS->setImageNr(boardnr, 0);
+ TS->setBoardState(boardnr,setImage1);
+ } else {
+ // new image loaded
+ TS->setFreeToReset(boardnr, true);
+ TS->setBoardState(boardnr,clearBoard);
+ }
+ LOG_INFO_STR("=NEW_BOARD=, TBB board " << boardnr << " is new");
+ }
+ }
+ }
+
+ if ((event.signal == F_TIMER) || (activeboards == sendmask )) {
+ if (activeboards == sendmask) {
+ itsAliveTimer->cancelAllTimers();
+ }
+
+ for (int board = 0; board < TS->maxBoards(); board++) {
+ if (~activeboards & (1 << board)) { // look for not active boards
+ TS->setBoardState(board, noBoard);
+ }
+ }
+
+ if (activeboards != TS->activeBoardsMask()) {
+ TS->setActiveBoardsMask(activeboards);
+
+ //itsActiveBoardsChange = true;
+ char boardstr[40];
+ char instr[5];
+ strcpy(boardstr,"");
+ for (int i = 0; i < TS->maxBoards(); i++) {
+ if (activeboards & (1 << i)) {
+ sprintf(instr," %d",i);
+ strcat(boardstr,instr);
+ } else {
+ strcat(boardstr," .");
+ }
+ }
+ msghandler->sendBoardChange(TS->activeBoardsMask());
+ LOG_INFO_STR("Available TBB boards changed:" << boardstr);
+ }
+
+ LOG_DEBUG_STR("Active TBB boards check");
+ if (TS->activeBoardsMask() == 0) {
+ itsAliveTimer->setTimer(5.0);
+ } else {
+ itsAliveTimer->setTimer(ALIVECHECKTIME);
+ }
+ itsAliveCheck = false;
+ //done = true;
+ }
+ }
+ return(!itsAliveCheck);
}
//-----------------------------------------------------------------------------
bool TBBDriver::sendInfo(GCFEvent& event, GCFPortInterface& port)
{
- bool valid = true;
-
- switch (event.signal) {
+ bool valid = true;
+
+ switch (event.signal) {
- case TBB_GET_CONFIG: {
- if (TS->activeBoardsMask() != 0) {
- TBBGetConfigAckEvent ack;
- ack.max_boards = TS->maxBoards();
- ack.active_boards_mask = TS->activeBoardsMask();
- port.send(ack);
- } else {
- TBBDriverBusyAckEvent ack;
- port.send(ack);
- }
- } break;
-
- case TBB_RCU_INFO: {
- if (TS->activeBoardsMask() != 0) {
- TBBRcuInfoAckEvent ack;
- int rcu;
- for (int32 ch = 0; ch < TS->maxChannels(); ch++) {
- rcu = TS->getChRcuNr(ch);
- //LOG_INFO(formatString("info for ch %d rcu.%d", ch, rcu));
- ack.rcu_status[rcu] = (uint16)TS->getChStatus(ch);
- ack.rcu_state[rcu] = TS->getChState(ch);
- ack.rcu_start_addr[rcu] = TS->getChStartAddr(ch);
- ack.rcu_pages[rcu] = TS->getChPageSize(ch);
- ack.rcu_on_board[rcu] = (uint8)TS->getChBoardNr(ch);
- ack.rcu_on_input[rcu] = (uint8)TS->getChInputNr(ch);
-
- //LOG_DEBUG_STR(formatString("Channel %d ,Rcu %d = status[0x%04X] state[%c] addr[%u] pages[%u]"
- // ,ch,TS->getChRcuNr(ch), TS->getChStatus(ch), TS->getChState(ch),TS->getChStartAddr(ch),TS->getChPageSize(ch)));
- }
- port.send(ack);
- } else {
- TBBDriverBusyAckEvent ack;
- port.send(ack);
- }
- } break;
-
- case TBB_TRIG_SETTINGS: {
- if (TS->activeBoardsMask() != 0) {
- TBBTrigSettingsAckEvent ack;
- int rcu;
- for (int32 ch = 0; ch < TS->maxChannels(); ch++) {
- rcu = TS->getChRcuNr(ch);
-
- ack.setup[rcu].level = TS->getChTriggerLevel(ch);
- ack.setup[rcu].start_mode = TS->getChTriggerStartMode(ch);
- ack.setup[rcu].stop_mode = TS->getChTriggerStopMode(ch);
- ack.setup[rcu].filter_select = TS->getChFilterSelect(ch);
- ack.setup[rcu].window = TS->getChDetectWindow(ch);
- ack.setup[rcu].operating_mode = TS->getChOperatingMode(ch);
- ack.coefficients[rcu].c0 = TS->getChFilterCoefficient(ch,0);
- ack.coefficients[rcu].c1 = TS->getChFilterCoefficient(ch,1);
- ack.coefficients[rcu].c2 = TS->getChFilterCoefficient(ch,2);
- ack.coefficients[rcu].c3 = TS->getChFilterCoefficient(ch,3);
- }
- port.send(ack);
- } else {
- TBBDriverBusyAckEvent ack;
- port.send(ack);
- }
- } break;
-
- default: {
- valid = false;
- } break;
- }
- return (valid);
+ case TBB_GET_CONFIG: {
+ if (TS->activeBoardsMask() != 0) {
+ TBBGetConfigAckEvent ack;
+ ack.max_boards = TS->maxBoards();
+ ack.active_boards_mask = TS->activeBoardsMask();
+ port.send(ack);
+ } else {
+ TBBDriverBusyAckEvent ack;
+ port.send(ack);
+ }
+ } break;
+
+ case TBB_RCU_INFO: {
+ if (TS->activeBoardsMask() != 0) {
+ TBBRcuInfoAckEvent ack;
+ int rcu;
+ for (int32 ch = 0; ch < TS->maxChannels(); ch++) {
+ rcu = TS->getChRcuNr(ch);
+ //LOG_INFO(formatString("info for ch %d rcu.%d", ch, rcu));
+ ack.rcu_status[rcu] = (uint16)TS->getChStatus(ch);
+ ack.rcu_state[rcu] = TS->getChState(ch);
+ ack.rcu_start_addr[rcu] = TS->getChStartAddr(ch);
+ ack.rcu_pages[rcu] = TS->getChPageSize(ch);
+ ack.rcu_on_board[rcu] = (uint8)TS->getChBoardNr(ch);
+ ack.rcu_on_input[rcu] = (uint8)TS->getChInputNr(ch);
+
+ //LOG_DEBUG_STR(formatString("Channel %d ,Rcu %d = status[0x%04X] state[%c] addr[%u] pages[%u]"
+ // ,ch,TS->getChRcuNr(ch), TS->getChStatus(ch), TS->getChState(ch),TS->getChStartAddr(ch),TS->getChPageSize(ch)));
+ }
+ port.send(ack);
+ } else {
+ TBBDriverBusyAckEvent ack;
+ port.send(ack);
+ }
+ } break;
+
+ case TBB_TRIG_SETTINGS: {
+ if (TS->activeBoardsMask() != 0) {
+ TBBTrigSettingsAckEvent ack;
+ int rcu;
+ for (int32 ch = 0; ch < TS->maxChannels(); ch++) {
+ rcu = TS->getChRcuNr(ch);
+
+ ack.setup[rcu].level = TS->getChTriggerLevel(ch);
+ ack.setup[rcu].start_mode = TS->getChTriggerStartMode(ch);
+ ack.setup[rcu].stop_mode = TS->getChTriggerStopMode(ch);
+ ack.setup[rcu].filter_select = TS->getChFilterSelect(ch);
+ ack.setup[rcu].window = TS->getChDetectWindow(ch);
+ ack.setup[rcu].operating_mode = TS->getChOperatingMode(ch);
+ ack.coefficients[rcu].c0 = TS->getChFilterCoefficient(ch,0);
+ ack.coefficients[rcu].c1 = TS->getChFilterCoefficient(ch,1);
+ ack.coefficients[rcu].c2 = TS->getChFilterCoefficient(ch,2);
+ ack.coefficients[rcu].c3 = TS->getChFilterCoefficient(ch,3);
+ }
+ port.send(ack);
+ } else {
+ TBBDriverBusyAckEvent ack;
+ port.send(ack);
+ }
+ } break;
+
+ default: {
+ valid = false;
+ } break;
+ }
+ return (valid);
}
//-----------------------------------------------------------------------------
bool TBBDriver::SetTbbCommand(unsigned short signal)
{
- if (cmd) {
- //cmdhandler->setTpCmd(0);
- delete cmd;
- }
- switch(signal)
- {
- case TBB_ALLOC: {
- AllocCmd *cmd;
- cmd = new AllocCmd();
- cmdhandler->setTpCmd(cmd);
- } break;
-
- case TBB_FREE: {
- FreeCmd *cmd;
- cmd = new FreeCmd();
- cmdhandler->setTpCmd(cmd);
- } break;
-
- case TBB_RECORD: {
- RecordCmd *cmd;
- cmd = new RecordCmd();
- cmdhandler->setTpCmd(cmd);
- } break;
-
- case TBB_STOP: {
- StopCmd *cmd;
- cmd = new StopCmd();
- cmdhandler->setTpCmd(cmd);
- } break;
-
- case TBB_TRIG_RELEASE: {
- TrigReleaseCmd *cmd;
- cmd = new TrigReleaseCmd();
- cmdhandler->setTpCmd(cmd);
- } break;
-
- case TBB_TRIG_GENERATE: {
- TrigGenCmd *cmd;
- cmd = new TrigGenCmd();
- cmdhandler->setTpCmd(cmd);
- } break;
-
- case TBB_TRIG_SETUP: {
- TrigSetupCmd *cmd;
- cmd = new TrigSetupCmd();
- cmdhandler->setTpCmd(cmd);
- } break;
-
- case TBB_TRIG_COEF: {
- TrigCoefCmd *cmd;
- cmd = new TrigCoefCmd();
- cmdhandler->setTpCmd(cmd);
- } break;
-
- case TBB_TRIG_INFO: {
- TrigInfoCmd *cmd;
- cmd = new TrigInfoCmd();
- cmdhandler->setTpCmd(cmd);
- } break;
-
- case TBB_READ: {
- ReadCmd *cmd;
- cmd = new ReadCmd();
- cmdhandler->setTpCmd(cmd);
- } break;
-
- case TBB_MODE: {
- UdpCmd *cmd;
- cmd = new UdpCmd();
- cmdhandler->setTpCmd(cmd);
- } break;
-
- case TBB_PAGEPERIOD: {
- PageperiodCmd *cmd;
- cmd = new PageperiodCmd();
- cmdhandler->setTpCmd(cmd);
- } break;
-
- case TBB_VERSION: {
- VersionCmd *cmd;
- cmd = new VersionCmd();
- cmdhandler->setTpCmd(cmd);
- } break;
-
- case TBB_SIZE: {
- SizeCmd *cmd;
- cmd = new SizeCmd();
- cmdhandler->setTpCmd(cmd);
- } break;
-
- case TBB_STATUS: {
- StatusCmd *cmd;
- cmd = new StatusCmd();
- cmdhandler->setTpCmd(cmd);
- } break;
-
- case TBB_CLEAR: {
- ClearCmd *cmd;
- cmd = new ClearCmd();
- cmdhandler->setTpCmd(cmd);
- } break;
-
- case TBB_RESET: {
- ResetCmd *cmd;
- cmd = new ResetCmd();
- cmdhandler->setTpCmd(cmd);
- } break;
-
- case TBB_CONFIG: {
- ConfigCmd *cmd;
- cmd = new ConfigCmd();
- cmdhandler->setTpCmd(cmd);
- } break;
-
- case TBB_ERASE_IMAGE: {
- ErasefCmd *cmd;
- cmd = new ErasefCmd();
- cmdhandler->setTpCmd(cmd);
- } break;
-
- case TBB_READ_IMAGE: {
- ReadfCmd *cmd;
- cmd = new ReadfCmd();
- cmdhandler->setTpCmd(cmd);
- } break;
-
- case TBB_WRITE_IMAGE:
- {
- WritefCmd *cmd;
- cmd = new WritefCmd();
- cmdhandler->setTpCmd(cmd);
- } break;
-
- case TBB_IMAGE_INFO:
- {
- ImageInfoCmd *cmd;
- cmd = new ImageInfoCmd();
- cmdhandler->setTpCmd(cmd);
- } break;
-
- case TBB_READW: {
- ReadwCmd *cmd;
- cmd = new ReadwCmd();
- cmdhandler->setTpCmd(cmd);
- } break;
-
- case TBB_WRITEW: {
- WritewCmd *cmd;
- cmd = new WritewCmd();
- cmdhandler->setTpCmd(cmd);
- } break;
-
- case TBB_READR: {
- ReadrCmd *cmd;
- cmd = new ReadrCmd();
- cmdhandler->setTpCmd(cmd);
- } break;
-
- case TBB_WRITER: {
- WriterCmd *cmd;
- cmd = new WriterCmd();
- cmdhandler->setTpCmd(cmd);
- } break;
-
- case TBB_READX: {
- ReadxCmd *cmd;
- cmd = new ReadxCmd();
- cmdhandler->setTpCmd(cmd);
- } break;
-
- case TBB_ARP: {
- ArpCmd *cmd;
- cmd = new ArpCmd();
- cmdhandler->setTpCmd(cmd);
- } break;
-
- case TBB_ARP_MODE: {
- ArpModeCmd *cmd;
- cmd = new ArpModeCmd();
- cmdhandler->setTpCmd(cmd);
- } break;
-
- case TBB_STOP_CEP: {
- StopCepCmd *cmd;
- cmd = new StopCepCmd();
- cmdhandler->setTpCmd(cmd);
- } break;
-
- case TBB_TEMP_LIMIT: {
- TempLimitCmd *cmd;
- cmd = new TempLimitCmd();
- cmdhandler->setTpCmd(cmd);
- } break;
-
- default: {
- return (false);
- } break;
- }
-
- itsAcceptor.cancelAllTimers();
- return (true);
+ if (cmd) {
+ //cmdhandler->setTpCmd(0);
+ delete cmd;
+ }
+ switch(signal)
+ {
+ case TBB_ALLOC: {
+ AllocCmd *cmd;
+ cmd = new AllocCmd();
+ cmdhandler->setTpCmd(cmd);
+ } break;
+
+ case TBB_FREE: {
+ FreeCmd *cmd;
+ cmd = new FreeCmd();
+ cmdhandler->setTpCmd(cmd);
+ } break;
+
+ case TBB_RECORD: {
+ RecordCmd *cmd;
+ cmd = new RecordCmd();
+ cmdhandler->setTpCmd(cmd);
+ } break;
+
+ case TBB_STOP: {
+ StopCmd *cmd;
+ cmd = new StopCmd();
+ cmdhandler->setTpCmd(cmd);
+ } break;
+
+ case TBB_TRIG_RELEASE: {
+ TrigReleaseCmd *cmd;
+ cmd = new TrigReleaseCmd();
+ cmdhandler->setTpCmd(cmd);
+ } break;
+
+ case TBB_TRIG_GENERATE: {
+ TrigGenCmd *cmd;
+ cmd = new TrigGenCmd();
+ cmdhandler->setTpCmd(cmd);
+ } break;
+
+ case TBB_TRIG_SETUP: {
+ TrigSetupCmd *cmd;
+ cmd = new TrigSetupCmd();
+ cmdhandler->setTpCmd(cmd);
+ } break;
+
+ case TBB_TRIG_COEF: {
+ TrigCoefCmd *cmd;
+ cmd = new TrigCoefCmd();
+ cmdhandler->setTpCmd(cmd);
+ } break;
+
+ case TBB_TRIG_INFO: {
+ TrigInfoCmd *cmd;
+ cmd = new TrigInfoCmd();
+ cmdhandler->setTpCmd(cmd);
+ } break;
+
+ case TBB_READ: {
+ ReadCmd *cmd;
+ cmd = new ReadCmd();
+ cmdhandler->setTpCmd(cmd);
+ } break;
+
+ case TBB_MODE: {
+ UdpCmd *cmd;
+ cmd = new UdpCmd();
+ cmdhandler->setTpCmd(cmd);
+ } break;
+
+ case TBB_PAGEPERIOD: {
+ PageperiodCmd *cmd;
+ cmd = new PageperiodCmd();
+ cmdhandler->setTpCmd(cmd);
+ } break;
+
+ case TBB_VERSION: {
+ VersionCmd *cmd;
+ cmd = new VersionCmd();
+ cmdhandler->setTpCmd(cmd);
+ } break;
+
+ case TBB_SIZE: {
+ SizeCmd *cmd;
+ cmd = new SizeCmd();
+ cmdhandler->setTpCmd(cmd);
+ } break;
+
+ case TBB_STATUS: {
+ StatusCmd *cmd;
+ cmd = new StatusCmd();
+ cmdhandler->setTpCmd(cmd);
+ } break;
+
+ case TBB_CLEAR: {
+ ClearCmd *cmd;
+ cmd = new ClearCmd();
+ cmdhandler->setTpCmd(cmd);
+ } break;
+
+ case TBB_RESET: {
+ ResetCmd *cmd;
+ cmd = new ResetCmd();
+ cmdhandler->setTpCmd(cmd);
+ } break;
+
+ case TBB_CONFIG: {
+ ConfigCmd *cmd;
+ cmd = new ConfigCmd();
+ cmdhandler->setTpCmd(cmd);
+ } break;
+
+ case TBB_ERASE_IMAGE: {
+ ErasefCmd *cmd;
+ cmd = new ErasefCmd();
+ cmdhandler->setTpCmd(cmd);
+ } break;
+
+ case TBB_READ_IMAGE: {
+ ReadfCmd *cmd;
+ cmd = new ReadfCmd();
+ cmdhandler->setTpCmd(cmd);
+ } break;
+
+ case TBB_WRITE_IMAGE:
+ {
+ WritefCmd *cmd;
+ cmd = new WritefCmd();
+ cmdhandler->setTpCmd(cmd);
+ } break;
+
+ case TBB_IMAGE_INFO:
+ {
+ ImageInfoCmd *cmd;
+ cmd = new ImageInfoCmd();
+ cmdhandler->setTpCmd(cmd);
+ } break;
+
+ case TBB_READW: {
+ ReadwCmd *cmd;
+ cmd = new ReadwCmd();
+ cmdhandler->setTpCmd(cmd);
+ } break;
+
+ case TBB_WRITEW: {
+ WritewCmd *cmd;
+ cmd = new WritewCmd();
+ cmdhandler->setTpCmd(cmd);
+ } break;
+
+ case TBB_READR: {
+ ReadrCmd *cmd;
+ cmd = new ReadrCmd();
+ cmdhandler->setTpCmd(cmd);
+ } break;
+
+ case TBB_WRITER: {
+ WriterCmd *cmd;
+ cmd = new WriterCmd();
+ cmdhandler->setTpCmd(cmd);
+ } break;
+
+ case TBB_READX: {
+ ReadxCmd *cmd;
+ cmd = new ReadxCmd();
+ cmdhandler->setTpCmd(cmd);
+ } break;
+
+ case TBB_ARP: {
+ ArpCmd *cmd;
+ cmd = new ArpCmd();
+ cmdhandler->setTpCmd(cmd);
+ } break;
+
+ case TBB_ARP_MODE: {
+ ArpModeCmd *cmd;
+ cmd = new ArpModeCmd();
+ cmdhandler->setTpCmd(cmd);
+ } break;
+
+ case TBB_STOP_CEP: {
+ StopCepCmd *cmd;
+ cmd = new StopCepCmd();
+ cmdhandler->setTpCmd(cmd);
+ } break;
+
+ case TBB_TEMP_LIMIT: {
+ TempLimitCmd *cmd;
+ cmd = new TempLimitCmd();
+ cmdhandler->setTpCmd(cmd);
+ } break;
+
+ default: {
+ return (false);
+ } break;
+ }
+
+ itsAcceptor.cancelAllTimers();
+ return (true);
}
//} // end namespace TBB
@@ -1302,48 +1323,38 @@ int main(int argc, char** argv)
// daemonize if required
if (itsDaemonize) {
- LOG_DEBUG_STR("background this process");
- if (daemonize(false) == 0) {
- //cerr << "Failed to background this process: " << strerror(errno) << endl;
- exit(EXIT_FAILURE);
- }
- }
-
- LOG_DEBUG_STR("Reading configuration files");
- try {
- LOFAR::ConfigLocator cl;
- LOFAR::ACC::APS::globalParameterSet()->adoptFile(cl.locate("TBBDriver.conf"));
- }
- catch (LOFAR::Exception e) {
- LOG_ERROR_STR("Failed to load configuration files: " << e.text());
- exit(EXIT_FAILURE);
- }
+ LOG_DEBUG_STR("background this process");
+ if (daemonize(false) == 0) {
+ //cerr << "Failed to background this process: " << strerror(errno) << endl;
+ exit(EXIT_FAILURE);
+ }
+ }
+
+ LOG_DEBUG_STR("Reading configuration files");
+ try {
+ LOFAR::ConfigLocator cl;
+ LOFAR::ACC::APS::globalParameterSet()->adoptFile(cl.locate("TBBDriver.conf"));
+ LOFAR::ACC::APS::globalParameterSet()->adoptFile(cl.locate("RemoteStation.conf"));
+ }
+ catch (LOFAR::Exception e) {
+ LOG_ERROR_STR("Failed to load configuration files: " << e.text());
+ exit(EXIT_FAILURE);
+ }
- LOFAR::TBB::TBBDriver tbb("TBBDriver");
+ LOFAR::TBB::TBBDriver tbb("TBBDriver");
- tbb.start(); // make initialsition
+ tbb.start(); // make initialsition
try {
- LOFAR::GCF::TM::GCFTask::run();
- }
- catch (LOFAR::Exception e) {
- LOG_ERROR_STR("Exception: " << e.text());
- exit(EXIT_FAILURE);
- }
+ LOFAR::GCF::TM::GCFTask::run();
+ }
+ catch (LOFAR::Exception e) {
+ LOG_ERROR_STR("Exception: " << e.text());
+ exit(EXIT_FAILURE);
+ }
LOG_INFO("Normal termination of program");
return(0);
}
-// Remove lines or remove comments for copy constructor and assignment.
-///TBBDriver::TBBDriver (const TBBDriver& that)
-///{}
-///TBBDriver& TBBDriver::operator= (const TBBDriver& that)
-///{
-/// if (this != &that) {
-/// ... copy members ...
-/// }
-/// return *this;
-///}
-
diff --git a/MAC/APL/PIC/TBBDriver/src/TempLimitCmd.cc b/MAC/APL/PIC/TBBDriver/src/TempLimitCmd.cc
index 002c44d2a3d..607033bce7e 100644
--- a/MAC/APL/PIC/TBBDriver/src/TempLimitCmd.cc
+++ b/MAC/APL/PIC/TBBDriver/src/TempLimitCmd.cc
@@ -41,7 +41,7 @@ TempLimitCmd::TempLimitCmd()
itsTBBE = 0;
itsTBBackE = new TBBTempLimitAckEvent();
- for(int boardnr = 0;boardnr < MAX_N_TBBBOARDS;boardnr++) {
+ for(int boardnr = 0;boardnr < MAX_N_TBBOARDS;boardnr++) {
itsTBBackE->status_mask[boardnr] = 0;
}
diff --git a/MAC/APL/PIC/TBBDriver/src/TrigCoefCmd.cc b/MAC/APL/PIC/TBBDriver/src/TrigCoefCmd.cc
index b7c6c619e2d..a8a3457b83c 100644
--- a/MAC/APL/PIC/TBBDriver/src/TrigCoefCmd.cc
+++ b/MAC/APL/PIC/TBBDriver/src/TrigCoefCmd.cc
@@ -41,7 +41,7 @@ TrigCoefCmd::TrigCoefCmd()
itsTBBE = 0;
itsTBBackE = new TBBTrigCoefAckEvent();
- for(int boardnr = 0;boardnr < MAX_N_TBBBOARDS;boardnr++) {
+ for(int boardnr = 0;boardnr < MAX_N_TBBOARDS;boardnr++) {
itsTBBackE->status_mask[boardnr] = 0;
}
setWaitAck(true);
diff --git a/MAC/APL/PIC/TBBDriver/src/TrigGenCmd.cc b/MAC/APL/PIC/TBBDriver/src/TrigGenCmd.cc
index dc57452c46b..da0599c9e45 100644
--- a/MAC/APL/PIC/TBBDriver/src/TrigGenCmd.cc
+++ b/MAC/APL/PIC/TBBDriver/src/TrigGenCmd.cc
@@ -42,7 +42,7 @@ TrigGenCmd::TrigGenCmd():
itsTBBE = 0;
itsTBBackE = new TBBTrigGenerateAckEvent();
- for(int boardnr = 0;boardnr < MAX_N_TBBBOARDS;boardnr++) {
+ for(int boardnr = 0;boardnr < MAX_N_TBBOARDS;boardnr++) {
itsTBBackE->status_mask[boardnr] = 0;
itsChannelMask[boardnr] = 0;
}
diff --git a/MAC/APL/PIC/TBBDriver/src/TrigGenCmd.h b/MAC/APL/PIC/TBBDriver/src/TrigGenCmd.h
index b51661207fb..6ff7fdde119 100644
--- a/MAC/APL/PIC/TBBDriver/src/TrigGenCmd.h
+++ b/MAC/APL/PIC/TBBDriver/src/TrigGenCmd.h
@@ -67,7 +67,7 @@ namespace LOFAR {
int32 itsStage;
// variables holding data from tp cmd
- uint32 itsChannelMask[MAX_N_TBBBOARDS];
+ uint32 itsChannelMask[MAX_N_TBBOARDS];
};
} // end TBB namespace
} // end LOFAR namespace
diff --git a/MAC/APL/PIC/TBBDriver/src/TrigReleaseCmd.h b/MAC/APL/PIC/TBBDriver/src/TrigReleaseCmd.h
index 6d6a2121f5d..80455a4f11a 100644
--- a/MAC/APL/PIC/TBBDriver/src/TrigReleaseCmd.h
+++ b/MAC/APL/PIC/TBBDriver/src/TrigReleaseCmd.h
@@ -61,8 +61,8 @@ namespace LOFAR {
TbbSettings *TS;
int32 itsStage;
- uint32 itsChannelStopMask[MAX_N_TBBBOARDS];
- uint32 itsChannelStartMask[MAX_N_TBBBOARDS];
+ uint32 itsChannelStopMask[MAX_N_TBBOARDS];
+ uint32 itsChannelStartMask[MAX_N_TBBOARDS];
TPTrigReleaseEvent *itsTPE;
TPTrigReleaseAckEvent *itsTPackE;
diff --git a/MAC/APL/PIC/TBBDriver/src/TrigSetupCmd.cc b/MAC/APL/PIC/TBBDriver/src/TrigSetupCmd.cc
index 4432ecf6fb3..f479fc66030 100644
--- a/MAC/APL/PIC/TBBDriver/src/TrigSetupCmd.cc
+++ b/MAC/APL/PIC/TBBDriver/src/TrigSetupCmd.cc
@@ -41,7 +41,7 @@ TrigSetupCmd::TrigSetupCmd()
itsTBBE = 0;
itsTBBackE = new TBBTrigSetupAckEvent();
- for(int boardnr = 0;boardnr < MAX_N_TBBBOARDS;boardnr++) {
+ for(int boardnr = 0;boardnr < MAX_N_TBBOARDS;boardnr++) {
itsTBBackE->status_mask[boardnr] = 0;
}
setWaitAck(true);
diff --git a/MAC/APL/PIC/TBBDriver/src/VersionCmd.cc b/MAC/APL/PIC/TBBDriver/src/VersionCmd.cc
index 103e3cae6b6..42ea530000a 100644
--- a/MAC/APL/PIC/TBBDriver/src/VersionCmd.cc
+++ b/MAC/APL/PIC/TBBDriver/src/VersionCmd.cc
@@ -41,7 +41,7 @@ VersionCmd::VersionCmd()
itsTBBE = 0;
itsTBBackE = new TBBVersionAckEvent();
- for(int boardnr = 0;boardnr < MAX_N_TBBBOARDS;boardnr++) {
+ for(int boardnr = 0;boardnr < MAX_N_TBBOARDS;boardnr++) {
itsTBBackE->status_mask[boardnr] = 0;
itsTBBackE->boardid[boardnr] = 0;
itsTBBackE->swversion[boardnr] = 0;
diff --git a/MAC/APL/PIC/TBBDriver/src/WritefCmd.cc b/MAC/APL/PIC/TBBDriver/src/WritefCmd.cc
index df1a2a03a9b..7a22caa70de 100644
--- a/MAC/APL/PIC/TBBDriver/src/WritefCmd.cc
+++ b/MAC/APL/PIC/TBBDriver/src/WritefCmd.cc
@@ -136,7 +136,7 @@ void WritefCmd::sendTpEvent()
erasefEvent->status = 0;
erasefEvent->addr = static_cast<uint32>(itsSector * FL_SECTOR_SIZE);
TS->boardPort(getBoardNr()).send(*erasefEvent);
- TS->boardPort(getBoardNr()).setTimer((long)1); // erase time sector is 500 mSec
+ TS->boardPort(getBoardNr()).setTimer(1.0); // erase time sector is 500 mSec
delete erasefEvent;
} break;
@@ -152,9 +152,8 @@ void WritefCmd::sendTpEvent()
itsTPE->data[tp_an] |= (itsImageData[itsDataPtr] << 16); itsDataPtr++;
itsTPE->data[tp_an] |= (itsImageData[itsDataPtr] << 24); itsDataPtr++;
}
-
TS->boardPort(getBoardNr()).send(*itsTPE);
- TS->boardPort(getBoardNr()).setTimer((long)1);
+ TS->boardPort(getBoardNr()).setTimer(1.0);
} break;
// stage 3, verify flash
@@ -164,7 +163,7 @@ void WritefCmd::sendTpEvent()
readfEvent->status = 0;
readfEvent->addr = static_cast<uint32>(itsBlock * FL_BLOCK_SIZE);
TS->boardPort(getBoardNr()).send(*readfEvent);
- TS->boardPort(getBoardNr()).setTimer(TS->timeout());
+ TS->boardPort(getBoardNr()).setTimer(1.0);
delete readfEvent;
} break;
@@ -204,7 +203,7 @@ void WritefCmd::sendTpEvent()
memcpy(&itsTPE->data[2],info,sizeof(info));
TS->boardPort(getBoardNr()).send(*itsTPE);
- TS->boardPort(getBoardNr()).setTimer(TS->timeout());
+ TS->boardPort(getBoardNr()).setTimer(1.0);
LOG_DEBUG_STR("Writing image info");
LOG_DEBUG_STR(formatString("%u %u",itsTPE->data[0],itsTPE->data[1]));
} break;
@@ -216,7 +215,7 @@ void WritefCmd::sendTpEvent()
itsBlock = (itsImage * FL_BLOCKS_IN_IMAGE) + (FL_BLOCKS_IN_IMAGE - 1);
readfEvent->addr = static_cast<uint32>(itsBlock * FL_BLOCK_SIZE);
TS->boardPort(getBoardNr()).send(*readfEvent);
- TS->boardPort(getBoardNr()).setTimer(TS->timeout());
+ TS->boardPort(getBoardNr()).setTimer(1.0);
LOG_DEBUG_STR("Verifying image info");
delete readfEvent;
} break;
@@ -240,6 +239,7 @@ void WritefCmd::saveTpAckEvent(GCFEvent& event)
TPErasefAckEvent *erasefAckEvent = new TPErasefAckEvent(event);
if (erasefAckEvent->status == 0) {
+ setSleepTime(0.50);
itsSector++;
if (itsSector == ((itsImage + 1) * FL_SECTORS_IN_IMAGE)) {
itsStage = write_flash;
@@ -256,6 +256,7 @@ void WritefCmd::saveTpAckEvent(GCFEvent& event)
itsTPackE = new TPWritefAckEvent(event);
if (itsTPackE->status == 0) {
+ setSleepTime(0.002);
itsStage = verify_flash;
} else {
itsTBBackE->status_mask |= TBB_FLASH_ERROR;
@@ -303,6 +304,7 @@ void WritefCmd::saveTpAckEvent(GCFEvent& event)
itsTPackE = new TPWritefAckEvent(event);
if (itsTPackE->status == 0) {
+ setSleepTime(0.002);
itsStage = verify_info;
} else {
itsTBBackE->status_mask |= TBB_FLASH_ERROR;
diff --git a/MAC/APL/PIC/TBBDriver/src/tbbctl.cc b/MAC/APL/PIC/TBBDriver/src/tbbctl.cc
index 6506b5dde3d..14bbc613ea6 100644
--- a/MAC/APL/PIC/TBBDriver/src/tbbctl.cc
+++ b/MAC/APL/PIC/TBBDriver/src/tbbctl.cc
@@ -61,760 +61,760 @@ static const long DELAY = 5;
//---- ALLOC ----------------------------------------------------------------
AllocCmd::AllocCmd(GCFPortInterface& port) : Command(port)
{
- cout << endl;
- cout << "== TBB ================================================== allocate memory ====" << endl;
- cout << endl;
+ cout << endl;
+ cout << "== TBB ================================================== allocate memory ====" << endl;
+ cout << endl;
}
//-----------------------------------------------------------------------------
void AllocCmd::send()
{
- TBBAllocEvent event;
-
- if (isSelectionDone()) event.rcu_mask = getRcuMask(); // if select cmd is used
-
- itsPort.send(event);
- itsPort.setTimer(DELAY);
+ TBBAllocEvent event;
+
+ if (isSelectionDone()) event.rcu_mask = getRcuMask(); // if select cmd is used
+
+ itsPort.send(event);
+ itsPort.setTimer(DELAY);
}
//-----------------------------------------------------------------------------
GCFEvent::TResult AllocCmd::ack(GCFEvent& e)
{
- TBBAllocAckEvent ack(e);
- cout << "TBB Info" << endl;
- cout << "--- -------------------------------------------------------" << endl;
- int32 bnr = 0;
- int32 oldbnr = -1;
- for (int cnr=0; cnr < getMaxSelections(); cnr++) {
- bnr = static_cast<int32>(cnr / 16);
-
- if (bnr != oldbnr) {
- if ((ack.status_mask[bnr] & TBB_SUCCESS) || (ack.status_mask[bnr] & TBB_RCU_COMM_ERROR)) {
- cout << formatString(" %2d memory allocated for selected rcu's", bnr) << endl;
- } else {
- cout << formatString(" %2d %s", bnr, getDriverErrorStr(ack.status_mask[bnr]).c_str()) << endl;
- }
- }
-
- if (isSelected(cnr) && !(ack.status_mask[bnr] & TBB_NO_BOARD) ) {
- if (ack.rcu_mask.test(cnr)) {
- if (ack.status_mask[bnr] & TBB_SUCCESS) {
- cout << formatString(" ERROR, Rcu-%d NOT in correct state",cnr) << endl;
- } else {
- cout << formatString(" ERROR, Rcu-%d %s",cnr,getDriverErrorStr(ack.status_mask[bnr] & 0xFFFF0000).c_str()) << endl;
- }
- }
- }
- oldbnr = bnr;
- }
-
- setCmdDone(true);
-
- return(GCFEvent::HANDLED);
+ TBBAllocAckEvent ack(e);
+ cout << "TBB Info" << endl;
+ cout << "--- -------------------------------------------------------" << endl;
+ int32 bnr = 0;
+ int32 oldbnr = -1;
+ for (int cnr=0; cnr < getMaxSelections(); cnr++) {
+ bnr = static_cast<int32>(cnr / 16);
+
+ if (bnr != oldbnr) {
+ if ((ack.status_mask[bnr] & TBB_SUCCESS) || (ack.status_mask[bnr] & TBB_RCU_COMM_ERROR)) {
+ cout << formatString(" %2d memory allocated for selected rcu's", bnr) << endl;
+ } else {
+ cout << formatString(" %2d %s", bnr, getDriverErrorStr(ack.status_mask[bnr]).c_str()) << endl;
+ }
+ }
+
+ if (isSelected(cnr) && !(ack.status_mask[bnr] & TBB_NO_BOARD) ) {
+ if (ack.rcu_mask.test(cnr)) {
+ if (ack.status_mask[bnr] & TBB_SUCCESS) {
+ cout << formatString(" ERROR, Rcu-%d NOT in correct state",cnr) << endl;
+ } else {
+ cout << formatString(" ERROR, Rcu-%d %s",cnr,getDriverErrorStr(ack.status_mask[bnr] & 0xFFFF0000).c_str()) << endl;
+ }
+ }
+ }
+ oldbnr = bnr;
+ }
+
+ setCmdDone(true);
+
+ return(GCFEvent::HANDLED);
}
//---- CHANNELINFO --------------------------------------------------------------
ChannelInfoCmd::ChannelInfoCmd(GCFPortInterface& port) : Command(port)
{
- cout << endl;
- cout << "== TBB ===================================================== rcu info =======" << endl;
- cout << endl;
+ cout << endl;
+ cout << "== TBB ===================================================== rcu info =======" << endl;
+ cout << endl;
}
//-----------------------------------------------------------------------------
void ChannelInfoCmd::send()
{
- TBBRcuInfoEvent event;
- itsPort.send(event);
- itsPort.setTimer(DELAY);
+ TBBRcuInfoEvent event;
+ itsPort.send(event);
+ itsPort.setTimer(DELAY);
}
//-----------------------------------------------------------------------------
GCFEvent::TResult ChannelInfoCmd::ack(GCFEvent& e)
{
- TBBRcuInfoAckEvent ack(e);
-
- int32 bnr = 0;
- int32 oldbnr = -1;
- for (int rcu=0; rcu < getMaxSelections(); rcu++) {
- bnr = static_cast<int32>(rcu / 16);
- if (ack.rcu_state[rcu] != 'F') {
- if (isSelected(rcu) ) {
- if (bnr != oldbnr) {
- cout << "Rcu Board Input State Start-address Size[pages]" << endl;
- cout << "--- ----- ----- ----- ------------- -----------" << endl;
- }
- cout << formatString(" %2d %2d %2d %c 0x%08X %11u %s",
- rcu, ack.rcu_on_board[rcu], ack.rcu_on_input[rcu],
- (char)ack.rcu_state[rcu], ack.rcu_start_addr[rcu], ack.rcu_pages[rcu],
- getBoardErrorStr(ack.rcu_status[rcu]).c_str()) << endl;
- }
- }
- oldbnr = bnr;
- }
- cout << endl;
- cout << " *State: F = Free, A = Allocated, R = Recording, S = Stopped, E = Error" << endl;
- cout << " *Only NOT Free rcu's are listed " << endl;
-
- setCmdDone(true);
-
- return(GCFEvent::HANDLED);
+ TBBRcuInfoAckEvent ack(e);
+
+ int32 bnr = 0;
+ int32 oldbnr = -1;
+ for (int rcu=0; rcu < getMaxSelections(); rcu++) {
+ bnr = static_cast<int32>(rcu / 16);
+ if (ack.rcu_state[rcu] != 'F') {
+ if (isSelected(rcu) ) {
+ if (bnr != oldbnr) {
+ cout << "Rcu Board Input State Start-address Size[pages]" << endl;
+ cout << "--- ----- ----- ----- ------------- -----------" << endl;
+ }
+ cout << formatString(" %2d %2d %2d %c 0x%08X %11u %s",
+ rcu, ack.rcu_on_board[rcu], ack.rcu_on_input[rcu],
+ (char)ack.rcu_state[rcu], ack.rcu_start_addr[rcu], ack.rcu_pages[rcu],
+ getBoardErrorStr(ack.rcu_status[rcu]).c_str()) << endl;
+ }
+ }
+ oldbnr = bnr;
+ }
+ cout << endl;
+ cout << " *State: F = Free, A = Allocated, R = Recording, S = Stopped, E = Error" << endl;
+ cout << " *Only NOT Free rcu's are listed " << endl;
+
+ setCmdDone(true);
+
+ return(GCFEvent::HANDLED);
}
//---- FREE ----------------------------------------------------------------
FreeCmd::FreeCmd(GCFPortInterface& port) : Command(port)
{
- cout << endl;
- cout << "== TBB =================== discard buffer allocation and disable rcu's ====" << endl;
- cout << endl;
+ cout << endl;
+ cout << "== TBB =================== discard buffer allocation and disable rcu's ====" << endl;
+ cout << endl;
}
//-----------------------------------------------------------------------------
void FreeCmd::send()
{
- TBBFreeEvent event;
-
- if (isSelectionDone()) event.rcu_mask = getRcuMask(); // if select cmd is used
-
- itsPort.send(event);
- itsPort.setTimer(DELAY);
+ TBBFreeEvent event;
+
+ if (isSelectionDone()) event.rcu_mask = getRcuMask(); // if select cmd is used
+
+ itsPort.send(event);
+ itsPort.setTimer(DELAY);
}
//-----------------------------------------------------------------------------
GCFEvent::TResult FreeCmd::ack(GCFEvent& e)
{
- TBBFreeAckEvent ack(e);
- cout << "TBB Info" << endl;
- cout << "--- -------------------------------------------------------" << endl;
- int32 bnr = 0;
- int32 oldbnr = -1;
- for (int cnr=0; cnr < getMaxSelections(); cnr++) {
- bnr = static_cast<int32>(cnr / 16);
-
- if (bnr != oldbnr) {
- if (ack.status_mask[bnr] & TBB_SUCCESS) {
- cout << formatString(" %2d buffer dischard and channel disabled for selected rcu's", bnr) << endl;
- } else {
- cout << formatString(" %2d %s", bnr, getDriverErrorStr(ack.status_mask[bnr]).c_str()) << endl;
- }
- }
- if (isSelected(cnr) && !(ack.status_mask[bnr] & TBB_NO_BOARD) ) {
- if (ack.rcu_mask.test(cnr)) {
- if (ack.status_mask[bnr] & TBB_SUCCESS) {
- cout << formatString(" ERROR, Rcu-%d NOT in correct state",cnr) << endl;
- } else {
- cout << formatString(" ERROR, Rcu-%d %s",cnr,getDriverErrorStr(ack.status_mask[bnr]).c_str()) << endl;
- }
- }
- }
- oldbnr = bnr;
- }
-
- setCmdDone(true);
-
- return(GCFEvent::HANDLED);
+ TBBFreeAckEvent ack(e);
+ cout << "TBB Info" << endl;
+ cout << "--- -------------------------------------------------------" << endl;
+ int32 bnr = 0;
+ int32 oldbnr = -1;
+ for (int cnr=0; cnr < getMaxSelections(); cnr++) {
+ bnr = static_cast<int32>(cnr / 16);
+
+ if (bnr != oldbnr) {
+ if (ack.status_mask[bnr] & TBB_SUCCESS) {
+ cout << formatString(" %2d buffer dischard and channel disabled for selected rcu's", bnr) << endl;
+ } else {
+ cout << formatString(" %2d %s", bnr, getDriverErrorStr(ack.status_mask[bnr]).c_str()) << endl;
+ }
+ }
+ if (isSelected(cnr) && !(ack.status_mask[bnr] & TBB_NO_BOARD) ) {
+ if (ack.rcu_mask.test(cnr)) {
+ if (ack.status_mask[bnr] & TBB_SUCCESS) {
+ cout << formatString(" ERROR, Rcu-%d NOT in correct state",cnr) << endl;
+ } else {
+ cout << formatString(" ERROR, Rcu-%d %s",cnr,getDriverErrorStr(ack.status_mask[bnr]).c_str()) << endl;
+ }
+ }
+ }
+ oldbnr = bnr;
+ }
+
+ setCmdDone(true);
+
+ return(GCFEvent::HANDLED);
}
//---- RECORD ----------------------------------------------------------------
RecordCmd::RecordCmd(GCFPortInterface& port) : Command(port)
{
- cout << endl;
- cout << "== TBB ============================= start recording on selected rcu's ====" << endl;
- cout << endl;
+ cout << endl;
+ cout << "== TBB ============================= start recording on selected rcu's ====" << endl;
+ cout << endl;
}
//-----------------------------------------------------------------------------
void RecordCmd::send()
{
- TBBRecordEvent event;
-
- if (isSelectionDone()) event.rcu_mask = getRcuMask(); // if select cmd is used
-
- itsPort.send(event);
- itsPort.setTimer(DELAY);
+ TBBRecordEvent event;
+
+ if (isSelectionDone()) event.rcu_mask = getRcuMask(); // if select cmd is used
+
+ itsPort.send(event);
+ itsPort.setTimer(DELAY);
}
//-----------------------------------------------------------------------------
GCFEvent::TResult RecordCmd::ack(GCFEvent& e)
{
- TBBRecordAckEvent ack(e);
- cout << "TBB Info" << endl;
- cout << "--- -------------------------------------------------------" << endl;
- int32 bnr = 0;
- int32 oldbnr = -1;
- for (int cnr=0; cnr < getMaxSelections(); cnr++) {
- bnr = static_cast<int32>(cnr / 16);
-
- if (bnr != oldbnr) {
- if (ack.status_mask[bnr] & TBB_SUCCESS) {
- cout << formatString(" %2d recording started for selected rcu's", bnr) << endl;
- } else {
- cout << formatString(" %2d %s", bnr, getDriverErrorStr(ack.status_mask[bnr]).c_str()) << endl;
- }
- }
-
- if (isSelected(cnr) && !(ack.status_mask[bnr] & TBB_NO_BOARD) ) {
- if (ack.rcu_mask.test(cnr)) {
- if (ack.status_mask[bnr] & TBB_SUCCESS) {
- //cout << formatString(" ERROR, Rcu-%d NOT in correct state",cnr) << endl;
- //cout << endl;
- } else {
- cout << formatString(" ERROR, Rcu-%d %s",cnr,getDriverErrorStr(ack.status_mask[bnr]).c_str()) << endl;
- }
- }
- }
- oldbnr = bnr;
- }
-
-
- setCmdDone(true);
-
- return(GCFEvent::HANDLED);
+ TBBRecordAckEvent ack(e);
+ cout << "TBB Info" << endl;
+ cout << "--- -------------------------------------------------------" << endl;
+ int32 bnr = 0;
+ int32 oldbnr = -1;
+ for (int cnr=0; cnr < getMaxSelections(); cnr++) {
+ bnr = static_cast<int32>(cnr / 16);
+
+ if (bnr != oldbnr) {
+ if (ack.status_mask[bnr] & TBB_SUCCESS) {
+ cout << formatString(" %2d recording started for selected rcu's", bnr) << endl;
+ } else {
+ cout << formatString(" %2d %s", bnr, getDriverErrorStr(ack.status_mask[bnr]).c_str()) << endl;
+ }
+ }
+
+ if (isSelected(cnr) && !(ack.status_mask[bnr] & TBB_NO_BOARD) ) {
+ if (ack.rcu_mask.test(cnr)) {
+ if (ack.status_mask[bnr] & TBB_SUCCESS) {
+ //cout << formatString(" ERROR, Rcu-%d NOT in correct state",cnr) << endl;
+ //cout << endl;
+ } else {
+ cout << formatString(" ERROR, Rcu-%d %s",cnr,getDriverErrorStr(ack.status_mask[bnr]).c_str()) << endl;
+ }
+ }
+ }
+ oldbnr = bnr;
+ }
+
+
+ setCmdDone(true);
+
+ return(GCFEvent::HANDLED);
}
//---- STOP -------------------------------------------------------------------
StopCmd::StopCmd(GCFPortInterface& port) : Command(port)
{
- cout << endl;
- cout << "== TBB ============================== stop recording on selected rcu's ====" << endl;
- cout << endl;
+ cout << endl;
+ cout << "== TBB ============================== stop recording on selected rcu's ====" << endl;
+ cout << endl;
}
//-----------------------------------------------------------------------------
void StopCmd::send()
{
- TBBStopEvent event;
- if (isSelectionDone()) event.rcu_mask = getRcuMask(); // if select cmd is used
-
- itsPort.send(event);
- itsPort.setTimer(DELAY);
+ TBBStopEvent event;
+ if (isSelectionDone()) event.rcu_mask = getRcuMask(); // if select cmd is used
+
+ itsPort.send(event);
+ itsPort.setTimer(DELAY);
}
//-----------------------------------------------------------------------------
GCFEvent::TResult StopCmd::ack(GCFEvent& e)
{
- TBBStopAckEvent ack(e);
- cout << "TBB Info" << endl;
- cout << "--- -------------------------------------------------------" << endl;
- int32 bnr = 0;
- int32 oldbnr = -1;
- for (int cnr=0; cnr < getMaxSelections(); cnr++) {
- bnr = static_cast<int32>(cnr / 16);
-
- if (bnr != oldbnr) {
- if (ack.status_mask[bnr] & TBB_SUCCESS) {
- cout << formatString(" %2d recording stopped for selected rcu's", bnr) << endl;
- } else {
- cout << formatString(" %2d %s", bnr, getDriverErrorStr(ack.status_mask[bnr]).c_str()) << endl;
- }
- }
-
- if (isSelected(cnr) && !(ack.status_mask[bnr] & TBB_NO_BOARD) ) {
- if (ack.rcu_mask.test(cnr)) {
- if (!(ack.status_mask[bnr] & TBB_SUCCESS)) {
- cout << formatString(" ERROR, Rcu-%d %s",cnr,getDriverErrorStr(ack.status_mask[bnr]).c_str()) << endl;
- }
- }
- }
- oldbnr = bnr;
- }
-
-
- setCmdDone(true);
-
- return(GCFEvent::HANDLED);
+ TBBStopAckEvent ack(e);
+ cout << "TBB Info" << endl;
+ cout << "--- -------------------------------------------------------" << endl;
+ int32 bnr = 0;
+ int32 oldbnr = -1;
+ for (int cnr=0; cnr < getMaxSelections(); cnr++) {
+ bnr = static_cast<int32>(cnr / 16);
+
+ if (bnr != oldbnr) {
+ if (ack.status_mask[bnr] & TBB_SUCCESS) {
+ cout << formatString(" %2d recording stopped for selected rcu's", bnr) << endl;
+ } else {
+ cout << formatString(" %2d %s", bnr, getDriverErrorStr(ack.status_mask[bnr]).c_str()) << endl;
+ }
+ }
+
+ if (isSelected(cnr) && !(ack.status_mask[bnr] & TBB_NO_BOARD) ) {
+ if (ack.rcu_mask.test(cnr)) {
+ if (!(ack.status_mask[bnr] & TBB_SUCCESS)) {
+ cout << formatString(" ERROR, Rcu-%d %s",cnr,getDriverErrorStr(ack.status_mask[bnr]).c_str()) << endl;
+ }
+ }
+ }
+ oldbnr = bnr;
+ }
+
+
+ setCmdDone(true);
+
+ return(GCFEvent::HANDLED);
}
//---- TRIGGERSETTINGS --------------------------------------------------------
TriggerSettingsCmd::TriggerSettingsCmd(GCFPortInterface& port) : Command(port)
{
- cout << endl;
- cout << "== TBB ===================================================== rcu info =======" << endl;
- cout << endl;
+ cout << endl;
+ cout << "== TBB ===================================================== rcu info =======" << endl;
+ cout << endl;
}
//-----------------------------------------------------------------------------
void TriggerSettingsCmd::send()
{
- TBBTrigSettingsEvent event;
- itsPort.send(event);
- itsPort.setTimer(DELAY);
+ TBBTrigSettingsEvent event;
+ itsPort.send(event);
+ itsPort.setTimer(DELAY);
}
//-----------------------------------------------------------------------------
GCFEvent::TResult TriggerSettingsCmd::ack(GCFEvent& e)
{
- TBBTrigSettingsAckEvent ack(e);
-
- int32 bnr = 0;
- int32 oldbnr = -1;
- for (int rcu=0; rcu < getMaxSelections(); rcu++) {
- bnr = static_cast<int32>(rcu / 16);
- if (isSelected(rcu) ) {
- if (bnr != oldbnr) {
- cout << "Rcu Board level start stop filter window c0 c1 c2 c3" << endl;
- cout << "--- ----- ------ ------ ------ ------ ------ ------ ------ ------ ------" << endl;
- }
- cout << formatString("%3d %5d %6d %6d %6d %6d %6d %6d %6d %6d %6d",
- rcu, bnr, ack.setup[rcu].level, ack.setup[rcu].start_mode, ack.setup[rcu].stop_mode,
- ack.setup[rcu].filter_select, ack.setup[rcu].window, ack.coefficients[rcu].c0,
- ack.coefficients[rcu].c1, ack.coefficients[rcu].c2, ack.coefficients[rcu].c3) << endl;
- }
- oldbnr = bnr;
- }
- cout << endl;
-
- setCmdDone(true);
- return(GCFEvent::HANDLED);
+ TBBTrigSettingsAckEvent ack(e);
+
+ int32 bnr = 0;
+ int32 oldbnr = -1;
+ for (int rcu=0; rcu < getMaxSelections(); rcu++) {
+ bnr = static_cast<int32>(rcu / 16);
+ if (isSelected(rcu) ) {
+ if (bnr != oldbnr) {
+ cout << "Rcu Board level start stop filter window c0 c1 c2 c3" << endl;
+ cout << "--- ----- ------ ------ ------ ------ ------ ------ ------ ------ ------" << endl;
+ }
+ cout << formatString("%3d %5d %6d %6d %6d %6d %6d %6d %6d %6d %6d",
+ rcu, bnr, ack.setup[rcu].level, ack.setup[rcu].start_mode, ack.setup[rcu].stop_mode,
+ ack.setup[rcu].filter_select, ack.setup[rcu].window, ack.coefficients[rcu].c0,
+ ack.coefficients[rcu].c1, ack.coefficients[rcu].c2, ack.coefficients[rcu].c3) << endl;
+ }
+ oldbnr = bnr;
+ }
+ cout << endl;
+
+ setCmdDone(true);
+ return(GCFEvent::HANDLED);
}
//---- TRIGRELEASE ------------------------------------------------------------
TrigReleaseCmd::TrigReleaseCmd(GCFPortInterface& port) : Command(port)
{
- cout << endl;
- cout << "== TBB ============================ release trigger for selected rcu's ====" << endl;
- cout << endl;
+ cout << endl;
+ cout << "== TBB ============================ release trigger for selected rcu's ====" << endl;
+ cout << endl;
}
//-----------------------------------------------------------------------------
void TrigReleaseCmd::send()
{
- TBBTrigReleaseEvent event;
- if (isSelectionDone()) {
- event.rcu_stop_mask = getRcuMask();
- event.rcu_start_mask = getRcuMask();
- }
- itsPort.send(event);
- itsPort.setTimer(DELAY);
+ TBBTrigReleaseEvent event;
+ if (isSelectionDone()) {
+ event.rcu_stop_mask = getRcuMask();
+ event.rcu_start_mask = getRcuMask();
+ }
+ itsPort.send(event);
+ itsPort.setTimer(DELAY);
}
//-----------------------------------------------------------------------------
GCFEvent::TResult TrigReleaseCmd::ack(GCFEvent& e)
{
- TBBTrigReleaseAckEvent ack(e);
- cout << "TBB Info" << endl;
- cout << "--- -------------------------------------------------------" << endl;
- int32 bnr = 0;
- int32 oldbnr = -1;
- for (int cnr=0; cnr < getMaxSelections(); cnr++) {
- bnr = static_cast<int32>(cnr / 16);
-
- if (bnr != oldbnr) {
- //cout << formatString("status[%d]%08x",bnr, ack.status_mask[bnr]);
- if (ack.status_mask[bnr] & TBB_SUCCESS) {
- cout << formatString(" %2d trigger detection released for selected rcu's",bnr ) << endl;
- } else {
- cout << formatString(" %2d %s",bnr, getDriverErrorStr(ack.status_mask[bnr]).c_str()) << endl;
- }
- }
- oldbnr = bnr;
- }
-
- setCmdDone(true);
- return(GCFEvent::HANDLED);
+ TBBTrigReleaseAckEvent ack(e);
+ cout << "TBB Info" << endl;
+ cout << "--- -------------------------------------------------------" << endl;
+ int32 bnr = 0;
+ int32 oldbnr = -1;
+ for (int cnr=0; cnr < getMaxSelections(); cnr++) {
+ bnr = static_cast<int32>(cnr / 16);
+
+ if (bnr != oldbnr) {
+ //cout << formatString("status[%d]%08x",bnr, ack.status_mask[bnr]);
+ if (ack.status_mask[bnr] & TBB_SUCCESS) {
+ cout << formatString(" %2d trigger detection released for selected rcu's",bnr ) << endl;
+ } else {
+ cout << formatString(" %2d %s",bnr, getDriverErrorStr(ack.status_mask[bnr]).c_str()) << endl;
+ }
+ }
+ oldbnr = bnr;
+ }
+
+ setCmdDone(true);
+ return(GCFEvent::HANDLED);
}
//---- TRIGGENERATE -----------------------------------------------------------
TrigGenerateCmd::TrigGenerateCmd(GCFPortInterface& port) : Command(port)
{
- cout << endl;
- cout << "== TBB ============================ generate trigger on selected rcu's ====" << endl;
- cout << endl;
- cout << "RCU seq_nr time sample sum samples peak pwr_before pwr_after" << endl;
- cout << "--- --------- --------- ---------- ---------- --------- --------- --------- ---------" << endl;
+ cout << endl;
+ cout << "== TBB ============================ generate trigger on selected rcu's ====" << endl;
+ cout << endl;
+ cout << "RCU seq_nr time sample sum samples peak pwr_before pwr_after" << endl;
+ cout << "--- --------- --------- ---------- ---------- --------- --------- --------- ---------" << endl;
}
//-----------------------------------------------------------------------------
void TrigGenerateCmd::send()
{
- setCmdSendNext(false);
- TBBSubscribeEvent subscribe;
- subscribe.triggers = true;
- subscribe.hardware = true;
+ setCmdSendNext(false);
+ TBBSubscribeEvent subscribe;
+ subscribe.triggers = true;
+ subscribe.hardware = true;
itsPort.send(subscribe);
-
- TBBTrigGenerateEvent event;
- if (isSelectionDone()) {
- event.rcu_mask = getRcuMask();
- }
- itsPort.send(event);
- itsPort.setTimer(DELAY);
+
+ TBBTrigGenerateEvent event;
+ if (isSelectionDone()) {
+ event.rcu_mask = getRcuMask();
+ }
+ itsPort.send(event);
+ itsPort.setTimer(DELAY);
}
//-----------------------------------------------------------------------------
GCFEvent::TResult TrigGenerateCmd::ack(GCFEvent& e)
{
- if (e.signal == TBB_TRIG_GENERATE_ACK) {
- TBBTrigGenerateAckEvent ack(e);
- }
- if (e.signal == TBB_SUBSCRIBE_ACK) {
- }
- if (e.signal == TBB_TRIGGER) {
- TBBTriggerEvent trig(e);
- cout << formatString(" %2d %9u %9u %10u %10u %9u %9u %9u %9u",
- trig.rcu,
- trig.sequence_nr,
- trig.time,
- trig.sample_nr,
- trig.trigger_sum,
- trig.trigger_samples,
- trig.peak_value,
- trig.power_before,
- trig.power_after
- ) << endl;
- }
- //setCmdDone(true);
- return(GCFEvent::HANDLED);
+ if (e.signal == TBB_TRIG_GENERATE_ACK) {
+ TBBTrigGenerateAckEvent ack(e);
+ }
+ if (e.signal == TBB_SUBSCRIBE_ACK) {
+ }
+ if (e.signal == TBB_TRIGGER) {
+ TBBTriggerEvent trig(e);
+ cout << formatString(" %2d %9u %9u %10u %10u %9u %9u %9u %9u",
+ trig.rcu,
+ trig.sequence_nr,
+ trig.time,
+ trig.sample_nr,
+ trig.trigger_sum,
+ trig.trigger_samples,
+ trig.peak_value,
+ trig.power_before,
+ trig.power_after
+ ) << endl;
+ }
+ //setCmdDone(true);
+ return(GCFEvent::HANDLED);
}
//---- TRIGSETUP --------------------------------------------------------------
TrigSetupCmd::TrigSetupCmd(GCFPortInterface& port) : Command(port),
- itsLevel(0), itsStartMode(0), itsStopMode(0),itsFilter(0), itsWindow(0), itsOperatingMode(0), itsTriggerMode(0)
+ itsLevel(0), itsStartMode(0), itsStopMode(0),itsFilter(0), itsWindow(0), itsOperatingMode(0), itsTriggerMode(0)
{
- cout << endl;
- cout << "== TBB ============================ trigger system setup for selected rcu's ====" << endl;
- cout << endl;
+ cout << endl;
+ cout << "== TBB ============================ trigger system setup for selected rcu's ====" << endl;
+ cout << endl;
}
//-----------------------------------------------------------------------------
void TrigSetupCmd::send()
{
- TBBTrigSetupEvent event;
- if (isSelectionDone()) {
- for (int cnr=0; cnr < getMaxSelections(); cnr++) {
- event.setup[cnr].level = itsLevel;
- event.setup[cnr].start_mode = itsStartMode;
- event.setup[cnr].stop_mode = itsStopMode;
- event.setup[cnr].filter_select = itsFilter;
- event.setup[cnr].window = itsWindow;
- event.setup[cnr].operating_mode = itsOperatingMode;
- event.trigger_mode = itsTriggerMode;
- }
- }
- itsPort.send(event);
- itsPort.setTimer(DELAY);
+ TBBTrigSetupEvent event;
+ if (isSelectionDone()) {
+ for (int cnr=0; cnr < getMaxSelections(); cnr++) {
+ event.setup[cnr].level = itsLevel;
+ event.setup[cnr].start_mode = itsStartMode;
+ event.setup[cnr].stop_mode = itsStopMode;
+ event.setup[cnr].filter_select = itsFilter;
+ event.setup[cnr].window = itsWindow;
+ event.setup[cnr].operating_mode = itsOperatingMode;
+ event.trigger_mode = itsTriggerMode;
+ }
+ }
+ itsPort.send(event);
+ itsPort.setTimer(DELAY);
}
//-----------------------------------------------------------------------------
GCFEvent::TResult TrigSetupCmd::ack(GCFEvent& e)
{
- if (e.signal == TBB_TRIG_SETUP_ACK) {
- TBBTrigSetupAckEvent ack(e);
- cout << "TBB Info" << endl;
- cout << "--- -------------------------------------------------------" << endl;
- int32 bnr = 0;
- int32 oldbnr = -1;
- for (int cnr=0; cnr < getMaxSelections(); cnr++) {
- bnr = static_cast<int32>(cnr / 16);
-
- if (bnr != oldbnr) {
- if (ack.status_mask[bnr] & TBB_SUCCESS) {
- cout << formatString(" %2d setup trigger system for all rcu's",bnr ) << endl;
- } else {
- cout << formatString(" %2d %s",bnr, getDriverErrorStr(ack.status_mask[bnr]).c_str()) << endl;
- }
- }
- oldbnr = bnr;
- }
- setCmdDone(true);
- }
- return(GCFEvent::HANDLED);
+ if (e.signal == TBB_TRIG_SETUP_ACK) {
+ TBBTrigSetupAckEvent ack(e);
+ cout << "TBB Info" << endl;
+ cout << "--- -------------------------------------------------------" << endl;
+ int32 bnr = 0;
+ int32 oldbnr = -1;
+ for (int cnr=0; cnr < getMaxSelections(); cnr++) {
+ bnr = static_cast<int32>(cnr / 16);
+
+ if (bnr != oldbnr) {
+ if (ack.status_mask[bnr] & TBB_SUCCESS) {
+ cout << formatString(" %2d setup trigger system for all rcu's",bnr ) << endl;
+ } else {
+ cout << formatString(" %2d %s",bnr, getDriverErrorStr(ack.status_mask[bnr]).c_str()) << endl;
+ }
+ }
+ oldbnr = bnr;
+ }
+ setCmdDone(true);
+ }
+ return(GCFEvent::HANDLED);
}
//---- TRIGCOEFFICIENTS -------------------------------------------------------
TrigCoefficientCmd::TrigCoefficientCmd(GCFPortInterface& port) : Command(port),
- itsC0(0), itsC1(0), itsC2(0), itsC3(0)
+ itsC0(0), itsC1(0), itsC2(0), itsC3(0)
{
- cout << endl;
- cout << "== TBB ============================ setup trigger coeffients for selected rcu's ====" << endl;
- cout << endl;
+ cout << endl;
+ cout << "== TBB ============================ setup trigger coeffients for selected rcu's ====" << endl;
+ cout << endl;
}
//-----------------------------------------------------------------------------
void TrigCoefficientCmd::send()
{
- TBBTrigCoefEvent event;
- if (isSelectionDone()) {
- for (int cnr=0; cnr < getMaxSelections(); cnr++) {
- event.coefficients[cnr].c0 = itsC0;
- event.coefficients[cnr].c1 = itsC1;
- event.coefficients[cnr].c2 = itsC2;
- event.coefficients[cnr].c3 = itsC3;
- }
- }
- itsPort.send(event);
- itsPort.setTimer(DELAY);
+ TBBTrigCoefEvent event;
+ if (isSelectionDone()) {
+ for (int cnr=0; cnr < getMaxSelections(); cnr++) {
+ event.coefficients[cnr].c0 = itsC0;
+ event.coefficients[cnr].c1 = itsC1;
+ event.coefficients[cnr].c2 = itsC2;
+ event.coefficients[cnr].c3 = itsC3;
+ }
+ }
+ itsPort.send(event);
+ itsPort.setTimer(DELAY);
}
//-----------------------------------------------------------------------------
GCFEvent::TResult TrigCoefficientCmd::ack(GCFEvent& e)
{
- TBBTrigCoefAckEvent ack(e);
- cout << "TBB Info" << endl;
- cout << "--- -------------------------------------------------------" << endl;
- int32 bnr = 0;
- int32 oldbnr = -1;
- for (int cnr=0; cnr < getMaxSelections(); cnr++) {
- bnr = static_cast<int32>(cnr / 16);
-
- if (bnr != oldbnr) {
- if (ack.status_mask[bnr] & TBB_SUCCESS) {
- cout << formatString(" %2d setup trigger system for all rcu's",bnr ) << endl;
- } else {
- cout << formatString(" %2d %s",bnr, getDriverErrorStr(ack.status_mask[bnr]).c_str()) << endl;
- }
- }
- oldbnr = bnr;
- }
- setCmdDone(true);
- return(GCFEvent::HANDLED);
+ TBBTrigCoefAckEvent ack(e);
+ cout << "TBB Info" << endl;
+ cout << "--- -------------------------------------------------------" << endl;
+ int32 bnr = 0;
+ int32 oldbnr = -1;
+ for (int cnr=0; cnr < getMaxSelections(); cnr++) {
+ bnr = static_cast<int32>(cnr / 16);
+
+ if (bnr != oldbnr) {
+ if (ack.status_mask[bnr] & TBB_SUCCESS) {
+ cout << formatString(" %2d setup trigger system for all rcu's",bnr ) << endl;
+ } else {
+ cout << formatString(" %2d %s",bnr, getDriverErrorStr(ack.status_mask[bnr]).c_str()) << endl;
+ }
+ }
+ oldbnr = bnr;
+ }
+ setCmdDone(true);
+ return(GCFEvent::HANDLED);
}
//---- TRIGINFO ---------------------------------------------------------------
TrigInfoCmd::TrigInfoCmd(GCFPortInterface& port) : Command(port)
{
- cout << endl;
- cout << "== TBB ============================ trigger info for selected rcu's ====" << endl;
- cout << endl;
+ cout << endl;
+ cout << "== TBB ============================ trigger info for selected rcu's ====" << endl;
+ cout << endl;
}
//-----------------------------------------------------------------------------
void TrigInfoCmd::send()
{
- TBBTrigInfoEvent event;
- if (isSelectionDone()) {
- event.rcu = getRcu();
- }
- itsPort.send(event);
- itsPort.setTimer(DELAY);
+ TBBTrigInfoEvent event;
+ if (isSelectionDone()) {
+ event.rcu = getRcu();
+ }
+ itsPort.send(event);
+ itsPort.setTimer(DELAY);
}
//-----------------------------------------------------------------------------
GCFEvent::TResult TrigInfoCmd::ack(GCFEvent& e)
{
- TBBTrigInfoAckEvent ack(e);
- cout << "RCU Info" << endl;
- cout << "--- -------------------------------------------------------" << endl;
- if (ack.status_mask & TBB_SUCCESS) {
- cout << formatString(" %2d sequence : %lu",getRcu(),ack.sequence_nr) << endl;
- cout << formatString(" time : %lu",ack.time) << endl;
- cout << formatString(" sample : %lu",ack.sample_nr) << endl;
- cout << formatString(" sum : %lu",ack.trigger_sum) << endl;
- cout << formatString(" samples : %lu",ack.trigger_samples) << endl;
- cout << formatString(" peak value : %lu",ack.peak_value) << endl;
- cout << formatString(" pwr before : %u",ack.power_before) << endl;
- cout << formatString(" pwr after : %u",ack.power_after) << endl;
- } else {
- cout << formatString(" %2d %s",getRcu(), getDriverErrorStr(ack.status_mask).c_str()) << endl;
- }
- setCmdDone(true);
- return(GCFEvent::HANDLED);
+ TBBTrigInfoAckEvent ack(e);
+ cout << "RCU Info" << endl;
+ cout << "--- -------------------------------------------------------" << endl;
+ if (ack.status_mask & TBB_SUCCESS) {
+ cout << formatString(" %2d sequence : %lu",getRcu(),ack.sequence_nr) << endl;
+ cout << formatString(" time : %lu",ack.time) << endl;
+ cout << formatString(" sample : %lu",ack.sample_nr) << endl;
+ cout << formatString(" sum : %lu",ack.trigger_sum) << endl;
+ cout << formatString(" samples : %lu",ack.trigger_samples) << endl;
+ cout << formatString(" peak value : %lu",ack.peak_value) << endl;
+ cout << formatString(" pwr before : %u",ack.power_before) << endl;
+ cout << formatString(" pwr after : %u",ack.power_after) << endl;
+ } else {
+ cout << formatString(" %2d %s",getRcu(), getDriverErrorStr(ack.status_mask).c_str()) << endl;
+ }
+ setCmdDone(true);
+ return(GCFEvent::HANDLED);
}
//---- LISTEN ---------------------------------------------------------------
ListenCmd::ListenCmd(GCFPortInterface& port) : Command(port),
- itsCmdStage(0)
+ itsCmdStage(0)
{
- cout << endl;
- cout << "== TBB ============================ listen for triggers on selected rcu's ====" << endl;
- cout << endl;
-
+ cout << endl;
+ cout << "== TBB ============================ listen for triggers on selected rcu's ====" << endl;
+ cout << endl;
+
}
//-----------------------------------------------------------------------------
void ListenCmd::send()
{
- switch (itsCmdStage) {
- case 0: {
- cout << "-stop all trigger systems" << endl;
- TBBTrigReleaseEvent release;
- release.rcu_stop_mask.set();
- release.rcu_start_mask.reset();
- itsPort.send(release);
- } break;
-
- case 1: {
- cout << "-stopped recording on all allocated rcu's" << endl;
- TBBStopEvent stop;
- stop.rcu_mask = getRcuMask();
- itsPort.send(stop);
- } break;
-
- case 2: {
- cout << "-restarted recording on all allocated rcu's" << endl;
- TBBRecordEvent record;
- record.rcu_mask = getRcuMask(); // if select cmd is used
- itsPort.send(record);
- } break;
-
- case 3: {
- TBBSubscribeEvent subscribe;
- subscribe.triggers = true;
- subscribe.hardware = true;
+ switch (itsCmdStage) {
+ case 0: {
+ cout << "-stop all trigger systems" << endl;
+ TBBTrigReleaseEvent release;
+ release.rcu_stop_mask.set();
+ release.rcu_start_mask.reset();
+ itsPort.send(release);
+ } break;
+
+ case 1: {
+ cout << "-stopped recording on all allocated rcu's" << endl;
+ TBBStopEvent stop;
+ stop.rcu_mask = getRcuMask();
+ itsPort.send(stop);
+ } break;
+
+ case 2: {
+ cout << "-restarted recording on all allocated rcu's" << endl;
+ TBBRecordEvent record;
+ record.rcu_mask = getRcuMask(); // if select cmd is used
+ itsPort.send(record);
+ } break;
+
+ case 3: {
+ TBBSubscribeEvent subscribe;
+ subscribe.triggers = true;
+ subscribe.hardware = true;
itsPort.send(subscribe);
- } break;
-
- case 4: {
- cout << "-released all trigger systems, and waiting (STOP WAITING WITH CTRL-C)" << endl;
- setCmdSendNext(false);
- TBBTrigReleaseEvent release;
- release.rcu_stop_mask.reset();
- release.rcu_start_mask = getRcuMask();
- itsPort.send(release);
- cout << endl;
- cout << "RCU seq_nr time sample sum samples peak pwr_before pwr_after" << endl;
- cout << "--- --------- ---------- ---------- ---------- --------- --------- --------- ---------" << endl;
- } break;
-
-
-
-
- default: {
- } break;
- }
- itsPort.setTimer(DELAY);
+ } break;
+
+ case 4: {
+ cout << "-released all trigger systems, and waiting (STOP WAITING WITH CTRL-C)" << endl;
+ setCmdSendNext(false);
+ TBBTrigReleaseEvent release;
+ release.rcu_stop_mask.reset();
+ release.rcu_start_mask = getRcuMask();
+ itsPort.send(release);
+ cout << endl;
+ cout << "RCU seq_nr time sample sum samples peak pwr_before pwr_after" << endl;
+ cout << "--- --------- ---------- ---------- ---------- --------- --------- --------- ---------" << endl;
+ } break;
+
+
+
+
+ default: {
+ } break;
+ }
+ itsPort.setTimer(DELAY);
}
//-----------------------------------------------------------------------------
GCFEvent::TResult ListenCmd::ack(GCFEvent& e)
{
- static int nummer;
- if (e.signal == TBB_STOP_ACK) {
- TBBTrigReleaseAckEvent ack(e);
- if (itsCmdStage == 1) { itsCmdStage = 2; }
- }
- if (e.signal == TBB_RECORD_ACK) {
- TBBTrigReleaseAckEvent ack(e);
- itsCmdStage = 3;
- }
- if (e.signal == TBB_SUBSCRIBE_ACK) {
- itsCmdStage = 4;
- nummer = 0;
- }
- if (e.signal == TBB_TRIG_RELEASE_ACK) {
- TBBTrigReleaseAckEvent ack(e);
- if (itsCmdStage == 0) itsCmdStage = 1;
- if (itsCmdStage == 4) itsCmdStage = 5;
- }
-
- if (e.signal == TBB_TRIGGER) {
-
- TBBTriggerEvent trig(e);
- nummer++;
- cout << formatString(" %2d %9u %9u %10u %10u %9u %9u %9u %9u (stopped) %6d",
- trig.rcu,
- trig.sequence_nr,
- trig.time,
- trig.sample_nr,
- trig.trigger_sum,
- trig.trigger_samples,
- trig.peak_value,
- trig.power_before,
- trig.power_after,
- nummer
- ) << endl;
-
- if (itsListenMode == TBB_LISTEN_ONE_SHOT) {
- TBBStopEvent event;
- event.rcu_mask.set(trig.rcu);
- itsPort.send(event);
- } else {
- TBBTrigReleaseEvent release;
- release.rcu_stop_mask.set(trig.rcu);
- release.rcu_start_mask.set(trig.rcu);
- itsPort.send(release);
- }
- }
- //setCmdDone(true);
- return(GCFEvent::HANDLED);
+ static int nummer;
+ if (e.signal == TBB_STOP_ACK) {
+ TBBTrigReleaseAckEvent ack(e);
+ if (itsCmdStage == 1) { itsCmdStage = 2; }
+ }
+ if (e.signal == TBB_RECORD_ACK) {
+ TBBTrigReleaseAckEvent ack(e);
+ itsCmdStage = 3;
+ }
+ if (e.signal == TBB_SUBSCRIBE_ACK) {
+ itsCmdStage = 4;
+ nummer = 0;
+ }
+ if (e.signal == TBB_TRIG_RELEASE_ACK) {
+ TBBTrigReleaseAckEvent ack(e);
+ if (itsCmdStage == 0) itsCmdStage = 1;
+ if (itsCmdStage == 4) itsCmdStage = 5;
+ }
+
+ if (e.signal == TBB_TRIGGER) {
+
+ TBBTriggerEvent trig(e);
+ nummer++;
+ cout << formatString(" %2d %9u %9u %10u %10u %9u %9u %9u %9u (stopped) %6d",
+ trig.rcu,
+ trig.sequence_nr,
+ trig.time,
+ trig.sample_nr,
+ trig.trigger_sum,
+ trig.trigger_samples,
+ trig.peak_value,
+ trig.power_before,
+ trig.power_after,
+ nummer
+ ) << endl;
+
+ if (itsListenMode == TBB_LISTEN_ONE_SHOT) {
+ TBBStopEvent event;
+ event.rcu_mask.set(trig.rcu);
+ itsPort.send(event);
+ } else {
+ TBBTrigReleaseEvent release;
+ release.rcu_stop_mask.set(trig.rcu);
+ release.rcu_start_mask.set(trig.rcu);
+ itsPort.send(release);
+ }
+ }
+ //setCmdDone(true);
+ return(GCFEvent::HANDLED);
}
//---- READ -------------------------------------------------------------------
ReadCmd::ReadCmd(GCFPortInterface& port) : Command(port),
- itsSecondsTime(0),itsSampleTime(0),itsPrePages(0),itsPostPages(0)
+ itsSecondsTime(0),itsSampleTime(0),itsPrePages(0),itsPostPages(0)
{
- cout << endl;
- cout << "== TBB ============== transfer data to CEP for all selected rcu ====" << endl;
- cout << endl;
+ cout << endl;
+ cout << "== TBB ============== transfer data to CEP for all selected rcu ====" << endl;
+ cout << endl;
}
//-----------------------------------------------------------------------------
void ReadCmd::send()
{
- TBBReadEvent event;
- event.rcu = (uint32)getRcu();
- event.secondstime = itsSecondsTime;
- event.sampletime = itsSampleTime;
- event.prepages = itsPrePages;
- event.postpages = itsPostPages;
- itsPort.send(event);
- itsPort.setTimer(DELAY);
+ TBBReadEvent event;
+ event.rcu = (uint32)getRcu();
+ event.secondstime = itsSecondsTime;
+ event.sampletime = itsSampleTime;
+ event.prepages = itsPrePages;
+ event.postpages = itsPostPages;
+ itsPort.send(event);
+ itsPort.setTimer(DELAY);
}
//-----------------------------------------------------------------------------
GCFEvent::TResult ReadCmd::ack(GCFEvent& e)
{
- TBBReadAckEvent ack(e);
- cout << "RCU Info" << endl;
- cout << "--- -------------------------------------------------------" << endl;
- for (int cnr=0; cnr < getMaxSelections(); cnr++) {
- if (isSelected(cnr) ) {
- if (ack.status_mask & TBB_SUCCESS) {
- cout << formatString(" %2d tranfering data to CEP",cnr ) << endl;
- } else {
- cout << formatString(" %2d %s",cnr, getDriverErrorStr(ack.status_mask).c_str()) << endl;
- }
- }
- }
-
- setCmdDone(true);
+ TBBReadAckEvent ack(e);
+ cout << "RCU Info" << endl;
+ cout << "--- -------------------------------------------------------" << endl;
+ for (int cnr=0; cnr < getMaxSelections(); cnr++) {
+ if (isSelected(cnr) ) {
+ if (ack.status_mask & TBB_SUCCESS) {
+ cout << formatString(" %2d tranfering data to CEP",cnr ) << endl;
+ } else {
+ cout << formatString(" %2d %s",cnr, getDriverErrorStr(ack.status_mask).c_str()) << endl;
+ }
+ }
+ }
+
+ setCmdDone(true);
- return(GCFEvent::HANDLED);
+ return(GCFEvent::HANDLED);
}
//---- MODE --------------------------------------------------------------------
ModeCmd::ModeCmd(GCFPortInterface& port) : Command(port)
- ,itsRecMode(0)
+ ,itsRecMode(0)
{
- cout << endl;
- cout << "== TBB ===================================== set mode command ===============" << endl;
- cout << endl;
+ cout << endl;
+ cout << "== TBB ===================================== set mode command ===============" << endl;
+ cout << endl;
}
//-----------------------------------------------------------------------------
void ModeCmd::send()
{
- TBBModeEvent event;
- event.rec_mode = itsRecMode;
- itsPort.send(event);
- itsPort.setTimer(DELAY);
+ TBBModeEvent event;
+ event.rec_mode = itsRecMode;
+ itsPort.send(event);
+ itsPort.setTimer(DELAY);
}
//-----------------------------------------------------------------------------
GCFEvent::TResult ModeCmd::ack(GCFEvent& e)
{
- TBBModeAckEvent ack(e);
- cout << "TBB Info" << endl;
- cout << "--- -------------------------------------------------------" << endl;
- for (int i = 0; i < MAX_N_TBBBOARDS; i++) {
- if (ack.status_mask[i] & TBB_SUCCESS) {
- cout << formatString(" %2d mode set and UDP/IP configured", i) << endl;
- } else {
- cout << formatString(" %2d %s",i, getDriverErrorStr(ack.status_mask[i]).c_str()) << endl;
- }
- }
-
- setCmdDone(true);
+ TBBModeAckEvent ack(e);
+ cout << "TBB Info" << endl;
+ cout << "--- -------------------------------------------------------" << endl;
+ for (int i = 0; i < MAX_N_TBBOARDS; i++) {
+ if (ack.status_mask[i] & TBB_SUCCESS) {
+ cout << formatString(" %2d mode set and UDP/IP configured", i) << endl;
+ } else {
+ cout << formatString(" %2d %s",i, getDriverErrorStr(ack.status_mask[i]).c_str()) << endl;
+ }
+ }
+
+ setCmdDone(true);
- return(GCFEvent::HANDLED);
+ return(GCFEvent::HANDLED);
}
//---- VERSION ----------------------------------------------------------------
VersionCmd::VersionCmd(GCFPortInterface& port) : Command(port)
{
- cout << endl;
- cout << "== TBB ====================================== ID and version information ====" << endl;
- cout << endl;
+ cout << endl;
+ cout << "== TBB ====================================== ID and version information ====" << endl;
+ cout << endl;
}
//-----------------------------------------------------------------------------
@@ -830,30 +830,28 @@ void VersionCmd::send()
GCFEvent::TResult VersionCmd::ack(GCFEvent& e)
{
TBBVersionAckEvent ack(e);
-
- cout << formatString("TBBDriver software version %3.2f",(ack.driverversion / 100.)) << endl;
- cout << endl;
- cout << "TBB ID Software Board TP0 MP0 MP1 MP2 MP3" << endl;
- cout << "--- -- -------- ------- ------- ------- ------- ------- -------" << endl;
- for (int bnr=0; bnr < getMaxSelections(); bnr++) {
- if (isSelected(bnr) ) {
- if (ack.status_mask[bnr] & TBB_SUCCESS) {
- cout << formatString(" %2u %2u V%5.1f V%4.1f V%4.1f V%4.1f V%4.1f V%4.1f V%4.1f",
- bnr,
- ack.boardid[bnr],
- (ack.swversion[bnr] / 10.),
- (ack.boardversion[bnr] / 10.),
- (ack.tpversion[bnr] / 10.),
- (ack.mp0version[bnr] / 10.),
- (ack.mp1version[bnr] / 10.),
- (ack.mp2version[bnr] / 10.),
- (ack.mp3version[bnr] / 10.)) << endl;
- } else {
- cout << formatString(" %2u %s",bnr, getDriverErrorStr(ack.status_mask[bnr]).c_str()) << endl;
- }
- }
- }
-
+
+ cout << formatString("TBBDriver software version %3.2f",(ack.driverversion / 100.)) << endl;
+ cout << endl;
+ cout << "TBB ID Software Board TP MP " << endl;
+ cout << "--- -- -------- ------- ------ ------- " << endl;
+ for (int bnr=0; bnr < getMaxSelections(); bnr++) {
+ if (isSelected(bnr) ) {
+ if (ack.status_mask[bnr] & TBB_SUCCESS) {
+ cout << formatString(" %2u %2u V%5.1f V%4.1f V%4.1f V%4.1f",
+ bnr,
+ ack.boardid[bnr],
+ (ack.swversion[bnr] / 10.),
+ (ack.boardversion[bnr] / 10.),
+ (ack.tpversion[bnr] / 10.),
+ (ack.mp0version[bnr] / 10.)) << endl;
+ } else {
+ cout << formatString(" %2u %s",bnr, getDriverErrorStr(ack.status_mask[bnr]).c_str()) << endl;
+ }
+
+ }
+ }
+
setCmdDone(true);
return(GCFEvent::HANDLED);
@@ -863,7 +861,7 @@ GCFEvent::TResult VersionCmd::ack(GCFEvent& e)
SizeCmd::SizeCmd(GCFPortInterface& port) : Command(port)
{
cout << endl;
- cout << "== TBB ==================================== installed memory information ====" << endl;
+ cout << "== TBB ==================================== installed memory information ====" << endl;
cout << endl;
}
@@ -880,21 +878,21 @@ void SizeCmd::send()
GCFEvent::TResult SizeCmd::ack(GCFEvent& e)
{
TBBSizeAckEvent ack(e);
- cout << "TBB pages Total memory " << endl;
- cout << "--- -------- ------------" << endl;
- for (int bnr=0; bnr < getMaxSelections(); bnr++) {
- if (isSelected(bnr) ) {
- if (ack.status_mask[bnr] & TBB_SUCCESS) {
- double gbyte = ((double)ack.npages[bnr] * 2048.) / (1024. * 1024. * 1024.);
- cout << formatString(" %2d %8d %6.3f GByte",bnr,ack.npages[bnr],gbyte) << endl;
- } else {
- cout << formatString(" %2d %s",bnr, getDriverErrorStr(ack.status_mask[bnr]).c_str()) << endl;
+ cout << "TBB pages Total memory " << endl;
+ cout << "--- -------- ------------" << endl;
+ for (int bnr=0; bnr < getMaxSelections(); bnr++) {
+ if (isSelected(bnr) ) {
+ if (ack.status_mask[bnr] & TBB_SUCCESS) {
+ double gbyte = ((double)ack.npages[bnr] * 2048.) / (1024. * 1024. * 1024.);
+ cout << formatString(" %2d %8d %6.3f GByte",bnr,ack.npages[bnr],gbyte) << endl;
+ } else {
+ cout << formatString(" %2d %s",bnr, getDriverErrorStr(ack.status_mask[bnr]).c_str()) << endl;
}
- }
- }
- cout << endl;
- cout << "1 page = 2048 Bytes" << endl;
-
+ }
+ }
+ cout << endl;
+ cout << "1 page = 2048 Bytes" << endl;
+
setCmdDone(true);
return(GCFEvent::HANDLED);
@@ -904,8 +902,8 @@ GCFEvent::TResult SizeCmd::ack(GCFEvent& e)
StatusCmd::StatusCmd(GCFPortInterface& port) : Command(port)
{
cout << endl;
- cout << "== TBB ============================= voltage and temperature information ====" << endl;
- cout << endl;
+ cout << "== TBB ============================= voltage and temperature information ====" << endl;
+ cout << endl;
}
//-----------------------------------------------------------------------------
@@ -922,29 +920,29 @@ GCFEvent::TResult StatusCmd::ack(GCFEvent& e)
{
TBBStatusAckEvent ack(e);
- cout << "TBB Voltage 1.2 Voltage 2.5 Voltage 3.3 Temp PCB Temp TP Temp MP0 Temp MP1 Temp MP2 Temp MP3" << endl;
- cout << "--- ----------- ----------- ----------- -------- -------- -------- -------- -------- --------" << endl;
- for (int bnr=0; bnr < getMaxSelections(); bnr++) {
- if (isSelected(bnr) ) {
- if (ack.status_mask[bnr] & TBB_SUCCESS) {
-
- cout << formatString(" %2d %4.2f V %4.2f V %4.2f V %3u 'C %3u 'C %3u 'C %3u 'C %3u 'C %3u 'C",
- bnr,
- ((double)ack.V12[bnr] * (2.5 / 192.)), // MAX6652 pin-2: 2.5 / 192 = 0.0130 / count
- ((double)ack.V25[bnr] * (3.3 / 192.)), // MAX6652 pin-3: 3.3 / 192 = 0.0172 / count
- ((double)ack.V33[bnr] * (5.0 / 192.)), // MAX6652 pin-1: 5.0 / 192 = 0.0625 / count
- ack.Tpcb[bnr],
- ack.Ttp[bnr],
- ack.Tmp0[bnr],
- ack.Tmp1[bnr],
- ack.Tmp2[bnr],
- ack.Tmp3[bnr] ) << endl;
- } else {
- cout << formatString(" %2d %s",bnr, getDriverErrorStr(ack.status_mask[bnr]).c_str()) << endl;
+ cout << "TBB Voltage 1.2 Voltage 2.5 Voltage 3.3 Temp PCB Temp TP Temp MP0 Temp MP1 Temp MP2 Temp MP3" << endl;
+ cout << "--- ----------- ----------- ----------- -------- -------- -------- -------- -------- --------" << endl;
+ for (int bnr=0; bnr < getMaxSelections(); bnr++) {
+ if (isSelected(bnr) ) {
+ if (ack.status_mask[bnr] & TBB_SUCCESS) {
+
+ cout << formatString(" %2d %4.2f V %4.2f V %4.2f V %3u 'C %3u 'C %3u 'C %3u 'C %3u 'C %3u 'C",
+ bnr,
+ ((double)ack.V12[bnr] * (2.5 / 192.)), // MAX6652 pin-2: 2.5 / 192 = 0.0130 / count
+ ((double)ack.V25[bnr] * (3.3 / 192.)), // MAX6652 pin-3: 3.3 / 192 = 0.0172 / count
+ ((double)ack.V33[bnr] * (5.0 / 192.)), // MAX6652 pin-1: 5.0 / 192 = 0.0625 / count
+ ack.Tpcb[bnr],
+ ack.Ttp[bnr],
+ ack.Tmp0[bnr],
+ ack.Tmp1[bnr],
+ ack.Tmp2[bnr],
+ ack.Tmp3[bnr] ) << endl;
+ } else {
+ cout << formatString(" %2d %s",bnr, getDriverErrorStr(ack.status_mask[bnr]).c_str()) << endl;
}
- }
- }
-
+ }
+ }
+
setCmdDone(true);
return(GCFEvent::HANDLED);
@@ -953,463 +951,464 @@ GCFEvent::TResult StatusCmd::ack(GCFEvent& e)
//---- CLEAR -------------------------------------------------------------------
ClearCmd::ClearCmd(GCFPortInterface& port) : Command(port)
{
- cout << endl;
- cout << "== TBB =============================================== clear in progress ====" << endl;
- cout << " wait 5 seconds" << endl;
- cout << endl;
+ cout << endl;
+ cout << "== TBB =============================================== clear in progress ====" << endl;
+ cout << " wait 5 seconds" << endl;
+ cout << endl;
}
//-----------------------------------------------------------------------------
void ClearCmd::send()
{
- TBBClearEvent event;
- event.boardmask = getBoardMask();
- itsPort.send(event);
- itsPort.setTimer((long)5);
+ TBBClearEvent event;
+ event.boardmask = getBoardMask();
+ itsPort.send(event);
+ itsPort.setTimer(5.0);
}
//-----------------------------------------------------------------------------
GCFEvent::TResult ClearCmd::ack(GCFEvent& e)
{
- TBBClearAckEvent ack(e);
- cout << "TBB Info" << endl;
- cout << "--- -------------------------------------------------------" << endl;
- for (int bnr=0; bnr < getMaxSelections(); bnr++) {
- if (isSelected(bnr) ) {
- if (ack.status_mask[bnr] & TBB_SUCCESS) {
- cout << formatString(" %2d board is cleared",bnr ) << endl;
- } else {
- cout << formatString(" %2d %s",bnr, getDriverErrorStr(ack.status_mask[bnr]).c_str()) << endl;
- }
- }
- }
-
- setCmdDone(true);
+ TBBClearAckEvent ack(e);
+ cout << "TBB Info" << endl;
+ cout << "--- -------------------------------------------------------" << endl;
+ for (int bnr=0; bnr < getMaxSelections(); bnr++) {
+ if (isSelected(bnr) ) {
+ if (ack.status_mask[bnr] & TBB_SUCCESS) {
+ cout << formatString(" %2d board is cleared",bnr ) << endl;
+ } else {
+ cout << formatString(" %2d %s",bnr, getDriverErrorStr(ack.status_mask[bnr]).c_str()) << endl;
+ }
+ }
+ }
+
+ setCmdDone(true);
- return(GCFEvent::HANDLED);
+ return(GCFEvent::HANDLED);
}
//---- RESET -------------------------------------------------------------------
ResetCmd::ResetCmd(GCFPortInterface& port) : Command(port)
{
- cout << endl;
- cout << "== TBB =============================================== reset in progress ====" << endl;
- cout << " reset can take 20 seconds" << endl;
- cout << endl;
+ cout << endl;
+ cout << "== TBB =============================================== reset in progress ====" << endl;
+ cout << " reset can take 20 seconds" << endl;
+ cout << endl;
}
//-----------------------------------------------------------------------------
void ResetCmd::send()
{
- TBBResetEvent event;
- event.boardmask = getBoardMask();
- itsPort.send(event);
- itsPort.setTimer(20.0);
+ TBBResetEvent event;
+ event.boardmask = getBoardMask();
+ itsPort.send(event);
+ itsPort.setTimer(60.0);
}
//-----------------------------------------------------------------------------
GCFEvent::TResult ResetCmd::ack(GCFEvent& e)
{
- TBBResetAckEvent ack(e);
- cout << "TBB Info" << endl;
- cout << "--- -------------------------------------------------------" << endl;
- for (int bnr=0; bnr < getMaxSelections(); bnr++) {
- if (isSelected(bnr) ) {
- if (ack.status_mask[bnr] & TBB_SUCCESS) {
- cout << formatString(" %2d board is reset",bnr ) << endl;
- } else {
- cout << formatString(" %2d %s",bnr, getDriverErrorStr(ack.status_mask[bnr]).c_str()) << endl;
- }
- }
- }
- cout << " setting up the boards can take 10 seconds" << endl;
-
- setCmdDone(true);
-
- return(GCFEvent::HANDLED);
+ TBBResetAckEvent ack(e);
+ cout << "TBB Info" << endl;
+ cout << "--- -------------------------------------------------------" << endl;
+ for (int bnr=0; bnr < getMaxSelections(); bnr++) {
+ if (isSelected(bnr) ) {
+ if (ack.status_mask[bnr] & TBB_SUCCESS) {
+ cout << formatString(" %2d board is reset",bnr ) << endl;
+ } else {
+ cout << formatString(" %2d %s",bnr, getDriverErrorStr(ack.status_mask[bnr]).c_str()) << endl;
+ }
+ }
+ }
+ cout << " setting up the boards can take 30 seconds" << endl;
+
+ setCmdDone(true);
+
+ return(GCFEvent::HANDLED);
}
//---- CONFIG -------------------------------------------------------------------
ConfigCmd::ConfigCmd(GCFPortInterface& port) : Command(port)
{
- cout << endl;
- cout << "== TBB ========================================= reconfigure TP and MP's ====" << endl;
- cout << " wait 5 seconds" << endl;
- cout << endl;
+ cout << endl;
+ cout << "== TBB ========================================= reconfigure TP and MP's ====" << endl;
+ cout << " wait 10 seconds" << endl;
+ cout << endl;
}
//-----------------------------------------------------------------------------
void ConfigCmd::send()
{
- TBBConfigEvent event;
- event.boardmask = getBoardMask();
- event.imagenr = itsImage;
- itsPort.send(event);
- itsPort.setTimer((long)5);
+ TBBConfigEvent event;
+ event.boardmask = getBoardMask();
+ event.imagenr = itsImage;
+ itsPort.send(event);
+ itsPort.setTimer(60.0);
}
//-----------------------------------------------------------------------------
GCFEvent::TResult ConfigCmd::ack(GCFEvent& e)
{
- TBBConfigAckEvent ack(e);
- cout << "TBB Info" << endl;
- cout << "--- -------------------------------------------------------" << endl;
- for (int bnr=0; bnr < getMaxSelections(); bnr++) {
- if (isSelected(bnr) ) {
- if (ack.status_mask[bnr] & TBB_SUCCESS) {
- cout << formatString(" %2d reconfigured TP and MP's",bnr ) << endl;
- } else {
- cout << formatString(" %2d %s",bnr, getDriverErrorStr(ack.status_mask[bnr]).c_str()) << endl;
- }
- }
- }
-
- setCmdDone(true);
+ TBBConfigAckEvent ack(e);
+ cout << "TBB Info" << endl;
+ cout << "--- -------------------------------------------------------" << endl;
+ for (int bnr=0; bnr < getMaxSelections(); bnr++) {
+ if (isSelected(bnr) ) {
+ if (ack.status_mask[bnr] & TBB_SUCCESS) {
+ cout << formatString(" %2d reconfigured TP and MP's",bnr ) << endl;
+ } else {
+ cout << formatString(" %2d %s",bnr, getDriverErrorStr(ack.status_mask[bnr]).c_str()) << endl;
+ }
+ }
+ }
+
+ setCmdDone(true);
- return(GCFEvent::HANDLED);
+ return(GCFEvent::HANDLED);
}
//---- ARP -------------------------------------------------------------------
ArpCmd::ArpCmd(GCFPortInterface& port) : Command(port)
{
- cout << endl;
- cout << "== TBB ========================================= sending ARP message to CEP ====" << endl;
- cout << endl;
+ cout << endl;
+ cout << "== TBB ========================================= sending ARP message to CEP ====" << endl;
+ cout << endl;
}
//-----------------------------------------------------------------------------
void ArpCmd::send()
{
- TBBArpEvent event;
- event.boardmask = getBoardMask();
- itsPort.send(event);
- itsPort.setTimer(DELAY);
+ TBBArpEvent event;
+ event.boardmask = getBoardMask();
+ itsPort.send(event);
+ itsPort.setTimer(DELAY);
}
//-----------------------------------------------------------------------------
GCFEvent::TResult ArpCmd::ack(GCFEvent& e)
{
- TBBArpAckEvent ack(e);
- cout << "TBB Info" << endl;
- cout << "--- -------------------------------------------------------" << endl;
- for (int bnr=0; bnr < getMaxSelections(); bnr++) {
- if (isSelected(bnr) ) {
- if (ack.status_mask[bnr] & TBB_SUCCESS) {
- cout << formatString(" %2d send 1 arp message",bnr ) << endl;
- } else {
- cout << formatString(" %2d %s",bnr, getDriverErrorStr(ack.status_mask[bnr]).c_str()) << endl;
- }
- }
- }
-
- setCmdDone(true);
+ TBBArpAckEvent ack(e);
+ cout << "TBB Info" << endl;
+ cout << "--- -------------------------------------------------------" << endl;
+ for (int bnr=0; bnr < getMaxSelections(); bnr++) {
+ if (isSelected(bnr) ) {
+ if (ack.status_mask[bnr] & TBB_SUCCESS) {
+ cout << formatString(" %2d send 1 arp message",bnr ) << endl;
+ } else {
+ cout << formatString(" %2d %s",bnr, getDriverErrorStr(ack.status_mask[bnr]).c_str()) << endl;
+ }
+ }
+ }
+
+ setCmdDone(true);
- return(GCFEvent::HANDLED);
+ return(GCFEvent::HANDLED);
}
//---- ARPMODE -------------------------------------------------------------------
ArpModeCmd::ArpModeCmd(GCFPortInterface& port) : Command(port)
,itsMode(0)
{
- cout << endl;
- cout << "== TBB ========================================= set CEP ARP mode ====" << endl;
- cout << endl;
+ cout << endl;
+ cout << "== TBB ========================================= set CEP ARP mode ====" << endl;
+ cout << endl;
}
//-----------------------------------------------------------------------------
void ArpModeCmd::send()
{
- TBBArpModeEvent event;
- event.boardmask = getBoardMask();
- event.mode = itsMode;
- itsPort.send(event);
- itsPort.setTimer(DELAY);
+ TBBArpModeEvent event;
+ event.boardmask = getBoardMask();
+ event.mode = itsMode;
+ itsPort.send(event);
+ itsPort.setTimer(DELAY);
}
//-----------------------------------------------------------------------------
GCFEvent::TResult ArpModeCmd::ack(GCFEvent& e)
{
- TBBArpModeAckEvent ack(e);
- cout << "TBB Info" << endl;
- cout << "--- -------------------------------------------------------" << endl;
- for (int bnr=0; bnr < getMaxSelections(); bnr++) {
- if (isSelected(bnr) ) {
- if (ack.status_mask[bnr] & TBB_SUCCESS) {
- cout << formatString(" %2d arp mode set to %d",bnr, itsMode ) << endl;
- } else {
- cout << formatString(" %2d %s",bnr, getDriverErrorStr(ack.status_mask[bnr]).c_str()) << endl;
- }
- }
- }
-
- setCmdDone(true);
+ TBBArpModeAckEvent ack(e);
+ cout << "TBB Info" << endl;
+ cout << "--- -------------------------------------------------------" << endl;
+ for (int bnr=0; bnr < getMaxSelections(); bnr++) {
+ if (isSelected(bnr) ) {
+ if (ack.status_mask[bnr] & TBB_SUCCESS) {
+ cout << formatString(" %2d arp mode set to %d",bnr, itsMode ) << endl;
+ } else {
+ cout << formatString(" %2d %s",bnr, getDriverErrorStr(ack.status_mask[bnr]).c_str()) << endl;
+ }
+ }
+ }
+
+ setCmdDone(true);
- return(GCFEvent::HANDLED);
+ return(GCFEvent::HANDLED);
}
//---- STOPCEP -------------------------------------------------------------------
StopCepCmd::StopCepCmd(GCFPortInterface& port) : Command(port)
{
- cout << endl;
- cout << "== TBB ========================================= stop sending messages to CEP ====" << endl;
- cout << endl;
+ cout << endl;
+ cout << "== TBB ========================================= stop sending messages to CEP ====" << endl;
+ cout << endl;
}
//-----------------------------------------------------------------------------
void StopCepCmd::send()
{
- TBBStopCepEvent event;
- event.boardmask = getBoardMask();
- itsPort.send(event);
- itsPort.setTimer(DELAY);
+ TBBStopCepEvent event;
+ event.boardmask = getBoardMask();
+ itsPort.send(event);
+ itsPort.setTimer(DELAY);
}
//-----------------------------------------------------------------------------
GCFEvent::TResult StopCepCmd::ack(GCFEvent& e)
{
- TBBStopCepAckEvent ack(e);
- cout << "TBB Info" << endl;
- cout << "--- -------------------------------------------------------" << endl;
- for (int bnr=0; bnr < getMaxSelections(); bnr++) {
- if (isSelected(bnr) ) {
- if (ack.status_mask[bnr] & TBB_SUCCESS) {
- cout << formatString(" %2d CEP messages stopped",bnr ) << endl;
- } else {
- cout << formatString(" %2d %s",bnr, getDriverErrorStr(ack.status_mask[bnr]).c_str()) << endl;
- }
- }
- }
-
- setCmdDone(true);
+ TBBStopCepAckEvent ack(e);
+ cout << "TBB Info" << endl;
+ cout << "--- -------------------------------------------------------" << endl;
+ for (int bnr=0; bnr < getMaxSelections(); bnr++) {
+ if (isSelected(bnr) ) {
+ if (ack.status_mask[bnr] & TBB_SUCCESS) {
+ cout << formatString(" %2d CEP messages stopped",bnr ) << endl;
+ } else {
+ cout << formatString(" %2d %s",bnr, getDriverErrorStr(ack.status_mask[bnr]).c_str()) << endl;
+ }
+ }
+ }
+
+ setCmdDone(true);
- return(GCFEvent::HANDLED);
+ return(GCFEvent::HANDLED);
}
//---- TEMPLIMIT -------------------------------------------------------------------
TempLimitCmd::TempLimitCmd(GCFPortInterface& port) : Command(port)
, itsLimitHigh(0),itsLimitLow(0)
{
- cout << endl;
- cout << "== TBB ========================================= set temperature limits ====" << endl;
- cout << endl;
+ cout << endl;
+ cout << "== TBB ========================================= set temperature limits ====" << endl;
+ cout << endl;
}
//-----------------------------------------------------------------------------
void TempLimitCmd::send()
{
- TBBTempLimitEvent event;
- event.boardmask = getBoardMask();
- event.high = itsLimitHigh;
- event.low = itsLimitLow;
- itsPort.send(event);
- itsPort.setTimer(DELAY);
+ TBBTempLimitEvent event;
+ event.boardmask = getBoardMask();
+ event.high = itsLimitHigh;
+ event.low = itsLimitLow;
+ itsPort.send(event);
+ itsPort.setTimer(DELAY);
}
//-----------------------------------------------------------------------------
GCFEvent::TResult TempLimitCmd::ack(GCFEvent& e)
{
- TBBTempLimitAckEvent ack(e);
- cout << "TBB Info" << endl;
- cout << "--- -------------------------------------------------------" << endl;
- for (int bnr=0; bnr < getMaxSelections(); bnr++) {
- if (isSelected(bnr) ) {
- if (ack.status_mask[bnr] & TBB_SUCCESS) {
- cout << formatString(" %2d Temp limit set %d .. %d ",bnr, itsLimitLow, itsLimitHigh ) << endl;
- } else {
- cout << formatString(" %2d %s",bnr, getDriverErrorStr(ack.status_mask[bnr]).c_str()) << endl;
- }
- }
- }
-
- setCmdDone(true);
+ TBBTempLimitAckEvent ack(e);
+ cout << "TBB Info" << endl;
+ cout << "--- -------------------------------------------------------" << endl;
+ for (int bnr=0; bnr < getMaxSelections(); bnr++) {
+ if (isSelected(bnr) ) {
+ if (ack.status_mask[bnr] & TBB_SUCCESS) {
+ cout << formatString(" %2d Temp limit set %d .. %d ",bnr, itsLimitLow, itsLimitHigh ) << endl;
+ } else {
+ cout << formatString(" %2d %s",bnr, getDriverErrorStr(ack.status_mask[bnr]).c_str()) << endl;
+ }
+ }
+ }
+
+ setCmdDone(true);
- return(GCFEvent::HANDLED);
+ return(GCFEvent::HANDLED);
}
//---- ERASE IMAGE --------------------------------------------------------------
ErasefCmd::ErasefCmd(GCFPortInterface& port) : Command(port)
- ,itsPage(0)
+ ,itsPage(0)
{
- cout << endl;
- cout << "== TBB ===================================================== erase flash ====" << endl;
- cout << endl;
- cout << "TBB Info" << endl;
- cout << "--- -------------------------------------------------------" << endl;
+ cout << endl;
+ cout << "== TBB ===================================================== erase flash ====" << endl;
+ cout << endl;
+ cout << "TBB Info" << endl;
+ cout << "--- -------------------------------------------------------" << endl;
}
//-----------------------------------------------------------------------------
void ErasefCmd::send()
{
- TBBEraseImageEvent event;
- event.board = getBoard();
- event.image = itsPage;
- cout << formatString(" %2d erasing flash memory of image %d", getBoard(), itsPage) << endl;
- cout << endl;
- cout << " erasing will take about 8 seconds" << endl;
- itsPort.send(event);
- itsPort.setTimer((long)16);
+ TBBEraseImageEvent event;
+ event.board = getBoard();
+ event.image = itsPage;
+ cout << formatString(" %2d erasing flash memory of image %d", getBoard(), itsPage) << endl;
+ cout << endl;
+ cout << " erasing will take about 8 seconds" << endl;
+ itsPort.send(event);
+ itsPort.setTimer(16.0);
}
//-----------------------------------------------------------------------------
GCFEvent::TResult ErasefCmd::ack(GCFEvent& e)
{
- TBBEraseImageAckEvent ack(e);
-
- if (ack.status_mask & TBB_SUCCESS) {
- cout << formatString(" %2d image is erased",getBoard()) << endl;
- } else {
- cout << formatString(" %2d %s",getBoard(), getDriverErrorStr(ack.status_mask).c_str()) << endl;
- }
-
- setCmdDone(true);
+ TBBEraseImageAckEvent ack(e);
+
+ if (ack.status_mask & TBB_SUCCESS) {
+ cout << formatString(" %2d image is erased",getBoard()) << endl;
+ } else {
+ cout << formatString(" %2d %s",getBoard(), getDriverErrorStr(ack.status_mask).c_str()) << endl;
+ }
+
+ setCmdDone(true);
- return(GCFEvent::HANDLED);
+ return(GCFEvent::HANDLED);
}
//---- READ IMAGE --------------------------------------------------------------
ReadfCmd::ReadfCmd(GCFPortInterface& port) : Command(port)
- ,itsPage(0)
+ ,itsPage(0)
{
- //memset(itsFileName,'\0',sizeof(itsFileName));
- //memset(itsPageData,0,sizeof(itsPageData));
- cout << endl;
- cout << "== TBB ====================================================== read flash ====" << endl;
- cout << endl;
- cout << "TBB Info" << endl;
- cout << "--- -------------------------------------------------------" << endl;
+ //memset(itsFileName,'\0',sizeof(itsFileName));
+ //memset(itsPageData,0,sizeof(itsPageData));
+ cout << endl;
+ cout << "== TBB ====================================================== read flash ====" << endl;
+ cout << endl;
+ cout << "TBB Info" << endl;
+ cout << "--- -------------------------------------------------------" << endl;
}
//-----------------------------------------------------------------------------
void ReadfCmd::send()
{
- TBBReadImageEvent event;
- event.board = getBoard();
- event.image = itsPage;
- cout << formatString(" %2d reading flash memory of image %d", getBoard(), itsPage) << endl;
- cout << endl;
- cout << " reading will take about 12 seconds" << endl;
- itsPort.send(event);
- itsPort.setTimer((long)24);
+ TBBReadImageEvent event;
+ event.board = getBoard();
+ event.image = itsPage;
+ cout << formatString(" %2d reading flash memory of image %d", getBoard(), itsPage) << endl;
+ cout << endl;
+ cout << " reading will take about 30 seconds" << endl;
+ itsPort.send(event);
+ itsPort.setTimer(24.0);
}
//-----------------------------------------------------------------------------
GCFEvent::TResult ReadfCmd::ack(GCFEvent& e)
{
- TBBReadImageAckEvent ack(e);
+ TBBReadImageAckEvent ack(e);
- if (ack.status_mask & TBB_SUCCESS) {
- cout << formatString(" %2d image is read",getBoard()) << endl;
- } else {
- cout << formatString(" %2d %s",getBoard(), getDriverErrorStr(ack.status_mask).c_str()) << endl;
- }
+ if (ack.status_mask & TBB_SUCCESS) {
+ cout << formatString(" %2d image is read",getBoard()) << endl;
+ } else {
+ cout << formatString(" %2d %s",getBoard(), getDriverErrorStr(ack.status_mask).c_str()) << endl;
+ }
-
- setCmdDone(true);
-
+
+ setCmdDone(true);
+
- return(GCFEvent::HANDLED);
+ return(GCFEvent::HANDLED);
}
//---- WRITE IMAGE -----------------------------------------------------------
WritefCmd::WritefCmd(GCFPortInterface& port) : Command(port)
- ,itsPage(0)
+ ,itsPage(0)
{
- memset(itsFileNameTp,'\0',sizeof(itsFileNameTp));
- memset(itsFileNameMp,'\0',sizeof(itsFileNameMp));
- cout << endl;
- cout << "== TBB ===================================================== write flash ====" << endl;
- cout << endl;
- cout << "TBB Info" << endl;
- cout << "--- -------------------------------------------------------" << endl;
+ memset(itsFileNameTp,'\0',sizeof(itsFileNameTp));
+ memset(itsFileNameMp,'\0',sizeof(itsFileNameMp));
+ cout << endl;
+ cout << "== TBB ===================================================== write flash ====" << endl;
+ cout << endl;
+ cout << "TBB Info" << endl;
+ cout << "--- -------------------------------------------------------" << endl;
}
//-----------------------------------------------------------------------------
void WritefCmd::send()
{
- TBBWriteImageEvent event;
- event.board = getBoard();
- event.image = itsPage;
- event.version = static_cast<int32>(round(itsVersion * 10.));
- memcpy(event.filename_tp,itsFileNameTp,sizeof(itsFileNameTp));
- memcpy(event.filename_mp,itsFileNameMp,sizeof(itsFileNameMp));
- cout << formatString(" %2d writing flash memory of image %d", getBoard(), itsPage) << endl;
- cout << endl;
- cout << " writing will take about 25 seconds" << endl;
- itsPort.send(event);
- itsPort.setTimer((long)60);
+ TBBWriteImageEvent event;
+ event.board = getBoard();
+ event.image = itsPage;
+ event.version = static_cast<int32>(round(itsVersion * 10.));
+ memcpy(event.filename_tp,itsFileNameTp,sizeof(itsFileNameTp));
+ memcpy(event.filename_mp,itsFileNameMp,sizeof(itsFileNameMp));
+ cout << formatString(" %2d writing flash memory of image %d", getBoard(), itsPage) << endl;
+ cout << endl;
+ cout << " writing will take at least 60 seconds" << endl;
+ itsPort.send(event);
+ itsPort.setTimer(240.0);
}
//-----------------------------------------------------------------------------
GCFEvent::TResult WritefCmd::ack(GCFEvent& e)
{
- TBBWriteImageAckEvent ack(e);
- if (ack.status_mask & TBB_SUCCESS) {
- cout << formatString(" %2d image is written",getBoard()) << endl;
- } else {
- cout << formatString(" %2d %s",getBoard(), getDriverErrorStr(ack.status_mask).c_str()) << endl;
- }
-
- setCmdDone(true);
+ TBBWriteImageAckEvent ack(e);
+ if (ack.status_mask & TBB_SUCCESS) {
+ cout << formatString(" %2d image is written",getBoard()) << endl;
+ } else {
+ cout << formatString(" %2d %s",getBoard(), getDriverErrorStr(ack.status_mask).c_str()) << endl;
+ }
+
+ setCmdDone(true);
- return(GCFEvent::HANDLED);
+ return(GCFEvent::HANDLED);
}
//---- IMAGE INFO -------------------------------------------------------------
ImageInfoCmd::ImageInfoCmd(GCFPortInterface& port) : Command(port)
{
- cout << endl;
- cout << "== TBB ===================================================== image info ====" << endl;
- cout << endl;
+ cout << endl;
+ cout << "== TBB ===================================================== image info ====" << endl;
+ cout << endl;
}
//-----------------------------------------------------------------------------
void ImageInfoCmd::send()
{
- TBBImageInfoEvent event;
- event.board = getBoard();
- itsPort.send(event);
- itsPort.setTimer(DELAY);
+ TBBImageInfoEvent event;
+ event.board = getBoard();
+ itsPort.send(event);
+ itsPort.setTimer(DELAY);
}
//-----------------------------------------------------------------------------
GCFEvent::TResult ImageInfoCmd::ack(GCFEvent& e)
{
- TBBImageInfoAckEvent ack(e);
- cout << formatString("Reading image information from TBB %d", getBoard()) << endl;
- cout << endl;
- cout << "IMAGE SW Flash date_time TP file name MP file name" << endl;
- cout << "----- ------ -------------------- ---------------- ----------------" << endl;
- if (ack.status_mask & TBB_SUCCESS) {
- for (int image = 0; image < 16; image++) {
- if (ack.write_date[image] == 0xFFFFFFFF) {
- //cout << formatString(" %2d no information",image) << endl;
- cout << formatString(" %2d free",image) << endl;
- } else {
- time_t write_time;
- struct tm t;
- double version;
-
- write_time = static_cast<time_t>(ack.write_date[image]);
- t = *gmtime(&write_time);
- version = static_cast<double>(ack.image_version[image] / 10.);
- cout << formatString(" %2d V%5.1lf %02d-%02d-%4d %2d:%02d:%02d %-16.16s %-16.16s",
- image,
- version,
- t.tm_mday,t.tm_mon+1,t.tm_year+1900,
- t.tm_hour,t.tm_min,t.tm_sec,
- ack.tp_file_name[image],
- ack.mp_file_name[image]) << endl;
- //cout << "TP: " << ack.tp_file_name[image] << ", MP: " << ack.mp_file_name[image] << endl;
- }
- }
- } else {
- cout << formatString("TBB %2d %s",getBoard(), getDriverErrorStr(ack.status_mask).c_str()) << endl;
- }
-
- setCmdDone(true);
-
- return(GCFEvent::HANDLED);
+ TBBImageInfoAckEvent ack(e);
+ cout << formatString("Reading image information from TBB %d", getBoard()) << endl;
+ cout << endl;
+ cout << "IMAGE SW Flash date_time TP file name MP file name" << endl;
+ cout << "------ ------ -------------------- ---------------- ----------------" << endl;
+ if (ack.status_mask & TBB_SUCCESS) {
+ for (int image = 0; image < 16; image++) {
+ if (ack.write_date[image] == 0xFFFFFFFF) {
+ //cout << formatString(" %2d no information",image) << endl;
+ cout << formatString(" %2d free",image) << endl;
+ } else {
+ time_t write_time;
+ struct tm t;
+ double version;
+
+ write_time = static_cast<time_t>(ack.write_date[image]);
+ t = *gmtime(&write_time);
+ version = static_cast<double>(ack.image_version[image] / 10.);
+ cout << formatString("%s %2d V%5.1lf %02d-%02d-%4d %2d:%02d:%02d %-16.16s %-16.16s",
+ (ack.active_image == image)?"->":" ",
+ image,
+ version,
+ t.tm_mday,t.tm_mon+1,t.tm_year+1900,
+ t.tm_hour,t.tm_min,t.tm_sec,
+ ack.tp_file_name[image],
+ ack.mp_file_name[image]) << endl;
+ //cout << "TP: " << ack.tp_file_name[image] << ", MP: " << ack.mp_file_name[image] << endl;
+ }
+ }
+ } else {
+ cout << formatString("TBB %2d %s",getBoard(), getDriverErrorStr(ack.status_mask).c_str()) << endl;
+ }
+
+ setCmdDone(true);
+
+ return(GCFEvent::HANDLED);
}
@@ -1417,768 +1416,768 @@ GCFEvent::TResult ImageInfoCmd::ack(GCFEvent& e)
//---- READW -------------------------------------------------------------------
ReadwCmd::ReadwCmd(GCFPortInterface& port) : Command(port)
{
- cout << endl;
- cout << "== TBB ======================================================= read DDR2 ====" << endl;
- cout << endl;
- cout << "TBB Info" << endl;
- cout << "--- -------------------------------------------------------" << endl;
+ cout << endl;
+ cout << "== TBB ======================================================= read DDR2 ====" << endl;
+ cout << endl;
+ cout << "TBB Info" << endl;
+ cout << "--- -------------------------------------------------------" << endl;
}
//-----------------------------------------------------------------------------
void ReadwCmd::send()
{
- TBBReadwEvent event;
- event.board = getBoard();
- event.mp = itsMp;
- event.addr = itsAddr;
- itsPort.send(event);
- itsPort.setTimer(DELAY);
+ TBBReadwEvent event;
+ event.board = getBoard();
+ event.mp = itsMp;
+ event.addr = itsAddr;
+ itsPort.send(event);
+ itsPort.setTimer(DELAY);
}
//-----------------------------------------------------------------------------
GCFEvent::TResult ReadwCmd::ack(GCFEvent& e)
{
- TBBReadwAckEvent ack(e);
- for (int bnr=0; bnr < getMaxSelections(); bnr++) {
- if (isSelected(bnr) ) {
- if (ack.status_mask & TBB_SUCCESS) {
- cout << formatString(" %2d MP[%u] Addr[0x%08X] [0x%08X] [0x%08X]"
- ,bnr, itsMp, itsAddr, ack.wordlo, ack.wordhi ) << endl;
- } else {
- cout << formatString(" %2d %s"
- ,bnr, getDriverErrorStr(ack.status_mask).c_str()) << endl;
- itsAddr = itsStopAddr - 1;
- }
- }
- }
- //if (itsAddr == (itsStopAddr - 1))
-
- itsAddr++;
- if (itsAddr >= itsStopAddr) {
- setCmdDone(true);
- } else {
- //itsPort.setTimer((long)0);
- }
- return(GCFEvent::HANDLED);
+ TBBReadwAckEvent ack(e);
+ for (int bnr=0; bnr < getMaxSelections(); bnr++) {
+ if (isSelected(bnr) ) {
+ if (ack.status_mask & TBB_SUCCESS) {
+ cout << formatString(" %2d MP[%u] Addr[0x%08X] [0x%08X] [0x%08X]"
+ ,bnr, itsMp, itsAddr, ack.wordlo, ack.wordhi ) << endl;
+ } else {
+ cout << formatString(" %2d %s"
+ ,bnr, getDriverErrorStr(ack.status_mask).c_str()) << endl;
+ itsAddr = itsStopAddr - 1;
+ }
+ }
+ }
+ //if (itsAddr == (itsStopAddr - 1))
+
+ itsAddr++;
+ if (itsAddr >= itsStopAddr) {
+ setCmdDone(true);
+ } else {
+ //itsPort.setTimer(0.0);
+ }
+ return(GCFEvent::HANDLED);
}
//---- WRITEW -------------------------------------------------------------------
WritewCmd::WritewCmd(GCFPortInterface& port) : Command(port)
{
- cout << endl;
- cout << "== TBB ====================================================== write DDR2 ====" << endl;
- cout << endl;
+ cout << endl;
+ cout << "== TBB ====================================================== write DDR2 ====" << endl;
+ cout << endl;
}
//-----------------------------------------------------------------------------
void WritewCmd::send()
{
- TBBWritewEvent event;
- event.board = getBoard();
- event.mp = itsMp;
- event.addr = itsAddr;
- event.wordlo = itsWordLo;
- event.wordhi = itsWordHi;
- itsPort.send(event);
- itsPort.setTimer(DELAY);
+ TBBWritewEvent event;
+ event.board = getBoard();
+ event.mp = itsMp;
+ event.addr = itsAddr;
+ event.wordlo = itsWordLo;
+ event.wordhi = itsWordHi;
+ itsPort.send(event);
+ itsPort.setTimer(DELAY);
}
//-----------------------------------------------------------------------------
GCFEvent::TResult WritewCmd::ack(GCFEvent& e)
{
- TBBWritewAckEvent ack(e);
- cout << "TBB Info" << endl;
- cout << "--- -------------------------------------------------------" << endl;
- for (int bnr=0; bnr < getMaxSelections(); bnr++) {
- if (isSelected(bnr) ) {
- if (ack.status_mask & TBB_SUCCESS) {
- cout << formatString(" %2d DDR2 write TBB_SUCCESS",bnr ) << endl;
- } else {
- cout << formatString(" %2d %s",bnr, getDriverErrorStr(ack.status_mask).c_str()) << endl;
- }
- }
- }
-
-
- setCmdDone(true);
-
- return(GCFEvent::HANDLED);
+ TBBWritewAckEvent ack(e);
+ cout << "TBB Info" << endl;
+ cout << "--- -------------------------------------------------------" << endl;
+ for (int bnr=0; bnr < getMaxSelections(); bnr++) {
+ if (isSelected(bnr) ) {
+ if (ack.status_mask & TBB_SUCCESS) {
+ cout << formatString(" %2d DDR2 write TBB_SUCCESS",bnr ) << endl;
+ } else {
+ cout << formatString(" %2d %s",bnr, getDriverErrorStr(ack.status_mask).c_str()) << endl;
+ }
+ }
+ }
+
+
+ setCmdDone(true);
+
+ return(GCFEvent::HANDLED);
}
//---- TESTDDR ----------------------------------------------------------------
TestDdrCmd::TestDdrCmd(GCFPortInterface& port) : Command(port),
- itsCmdStage(0),itsMp(0), itsAddr(0), itsAddrLine(0), itsTestPatern(1), itsWordLo(0), itsWordHi(0),
- itsAddrLineErrors(0), itsDataLineErrors(0)
+ itsCmdStage(0),itsMp(0), itsAddr(0), itsAddrLine(0), itsTestPatern(1), itsWordLo(0), itsWordHi(0),
+ itsAddrLineErrors(0), itsDataLineErrors(0)
{
- cout << endl;
- cout << "==== TBB-board, test ddr =================================================" << endl;
- cout << endl;
+ cout << endl;
+ cout << "==== TBB-board, test ddr =================================================" << endl;
+ cout << endl;
}
//-----------------------------------------------------------------------------
void TestDdrCmd::send()
{
- if ((itsCmdStage == 0)&&(itsMp == 0)&&(itsAddrLine == 0)) {
- cout << formatString("Testing DDR memory address lines of board %d",getBoard()) << endl;
- cout << endl;
- cout << "Mp Addr Write Read " << endl;
- cout << "Nr Line DDR DDR Info " << endl;
- cout << "-- ----- ----- ----- -----------------------------" << endl;
- }
-
- if ((itsCmdStage == 2)&&(itsMp == 0)&&(itsTestPatern == 1)) {
- cout << endl;
- cout << formatString("Testing DDR memory data lines of board %d",getBoard()) << endl;
- cout << endl;
- cout << "Mp Write Read Write Read " << endl;
- cout << "Nr WordLow WordLow WordHigh WordHigh Info " << endl;
- cout << "-- -------- -------- -------- -------- ------------------------" << endl;
- }
- switch (itsCmdStage) {
-
- case 0: {
- TBBWritewEvent event;
- event.board = getBoard();
- event.mp = itsMp;
- event.addr = itsAddr;
- event.wordlo = itsAddrLine;
- event.wordhi = (itsMp << 8) + itsAddrLine;
- itsPort.send(event);
- } break;
-
- case 1: {
- TBBReadwEvent event;
- event.board = getBoard();
- event.mp = itsMp;
- event.addr = itsAddr;
- itsPort.send(event);
- } break;
-
- case 2: {
- TBBWritewEvent event;
- event.board = getBoard();
- event.mp = itsMp;
- event.addr = itsAddr;
- event.wordlo = itsTestPatern;
- event.wordhi = ~itsTestPatern;
- itsPort.send(event);
- } break;
-
- case 3: {
- TBBReadwEvent event;
- event.board = getBoard();
- event.mp = itsMp;
- event.addr = itsAddr;
- itsPort.send(event);
- } break;
-
- default: break;
- }
-
- itsPort.setTimer(DELAY);
+ if ((itsCmdStage == 0)&&(itsMp == 0)&&(itsAddrLine == 0)) {
+ cout << formatString("Testing DDR memory address lines of board %d",getBoard()) << endl;
+ cout << endl;
+ cout << "Mp Addr Write Read " << endl;
+ cout << "Nr Line DDR DDR Info " << endl;
+ cout << "-- ----- ----- ----- -----------------------------" << endl;
+ }
+
+ if ((itsCmdStage == 2)&&(itsMp == 0)&&(itsTestPatern == 1)) {
+ cout << endl;
+ cout << formatString("Testing DDR memory data lines of board %d",getBoard()) << endl;
+ cout << endl;
+ cout << "Mp Write Read Write Read " << endl;
+ cout << "Nr WordLow WordLow WordHigh WordHigh Info " << endl;
+ cout << "-- -------- -------- -------- -------- ------------------------" << endl;
+ }
+ switch (itsCmdStage) {
+
+ case 0: {
+ TBBWritewEvent event;
+ event.board = getBoard();
+ event.mp = itsMp;
+ event.addr = itsAddr;
+ event.wordlo = itsAddrLine;
+ event.wordhi = (itsMp << 8) + itsAddrLine;
+ itsPort.send(event);
+ } break;
+
+ case 1: {
+ TBBReadwEvent event;
+ event.board = getBoard();
+ event.mp = itsMp;
+ event.addr = itsAddr;
+ itsPort.send(event);
+ } break;
+
+ case 2: {
+ TBBWritewEvent event;
+ event.board = getBoard();
+ event.mp = itsMp;
+ event.addr = itsAddr;
+ event.wordlo = itsTestPatern;
+ event.wordhi = ~itsTestPatern;
+ itsPort.send(event);
+ } break;
+
+ case 3: {
+ TBBReadwEvent event;
+ event.board = getBoard();
+ event.mp = itsMp;
+ event.addr = itsAddr;
+ itsPort.send(event);
+ } break;
+
+ default: break;
+ }
+
+ itsPort.setTimer(DELAY);
}
//-----------------------------------------------------------------------------
GCFEvent::TResult TestDdrCmd::ack(GCFEvent& e)
{
- switch (itsCmdStage) {
- case 0: {
- TBBWritewAckEvent ack(e);
- if (!(ack.status_mask & TBB_SUCCESS)) {
- cout << formatString(" %2d %s",getBoard(), getDriverErrorStr(ack.status_mask).c_str()) << endl;
- }
- itsAddr = (1 << itsAddrLine);
- itsAddrLine++;
- if (itsAddrLine == 28) {
- itsAddr = 0;
- itsAddrLine = 0;
- itsCmdStage = 1;
- }
- }break;
-
- case 1: {
- TBBReadwAckEvent ack(e);
- if (ack.status_mask & TBB_SUCCESS) {
- if (ack.wordlo == itsAddrLine) {
- cout << formatString("%2d %5d %5d %5d SAME",
- itsMp, itsAddrLine, itsAddrLine, ack.wordlo) << endl;
- } else {
- cout << formatString("%2d %5d %5d %5d FAULT",
- itsMp, itsAddrLine, itsAddrLine, ack.wordlo ) << endl;
- itsAddrLineErrors++;
- }
- } else {
- cout << formatString(" %2d %s",getBoard(), getDriverErrorStr(ack.status_mask).c_str()) << endl;
- }
- itsAddr = (1 << itsAddrLine);
- itsAddrLine++;
- if (itsAddrLine == 28) {
- itsAddr = 0;
- itsAddrLine = 0;
- itsCmdStage = 0;
- itsMp++;
- if (itsMp == 4) {
- itsMp = 0;
- itsAddr = 0;
- itsCmdStage = 2;
- //setCmdDone(true);
- }
- }
- } break;
-
- case 2: {
- TBBWritewAckEvent ack(e);
- if (!(ack.status_mask & TBB_SUCCESS)) {
- cout << formatString(" %2d %s",getBoard(), getDriverErrorStr(ack.status_mask).c_str()) << endl;
- }
- itsAddr++;
- itsTestPatern <<= 1;
- //if (itsTestPatern == 0) itsTestPatern == 1;
-
- if (itsTestPatern == 0x00000000) {
- itsAddr = 0;
- itsTestPatern = 1;
- itsCmdStage = 3;
- }
- }break;
-
- case 3: {
- TBBReadwAckEvent ack(e);
- if (ack.status_mask & TBB_SUCCESS) {
- if ((ack.wordlo == itsTestPatern)&&(ack.wordhi == ~itsTestPatern)) {
- cout << formatString("%2d %08X %08X %08X %08X SAME",
- itsMp, itsTestPatern, ack.wordlo, ~itsTestPatern, ack.wordhi) << endl;
- } else {
- cout << formatString("%2d %08X %08X %08X %08X FAULT",
- itsMp, itsTestPatern, ack.wordlo, ~itsTestPatern, ack.wordhi) << endl;
- itsDataLineErrors++;
- }
- } else {
- cout << formatString(" %2d %s",getBoard(), getDriverErrorStr(ack.status_mask).c_str()) << endl;
- }
- itsAddr++;
- itsTestPatern <<= 1;
- //if (itsTestPatern == 0) itsTestPatern == 1;
-
- if (itsTestPatern == 0x00000000) {
- itsAddr = 0;
- itsTestPatern = 1;
- itsCmdStage = 2;
- itsMp++;
- if (itsMp == 4) {
- cout << formatString(" == summary ==") << endl;
- if (itsAddrLineErrors != 0) {
- cout << formatString(" %d Addressline ERRORS",itsAddrLineErrors) << endl;
- } else {
- cout << formatString(" All Addresslines OK") << endl;
- }
- if (itsDataLineErrors != 0) {
- cout << formatString(" %d Dataline ERRORS",itsDataLineErrors) << endl;
- } else {
- cout << formatString(" All Datalines OK") << endl;
- }
- setCmdDone(true);
- }
- }
- } break;
-
-
- default: break;
- }
- return(GCFEvent::HANDLED);
+ switch (itsCmdStage) {
+ case 0: {
+ TBBWritewAckEvent ack(e);
+ if (!(ack.status_mask & TBB_SUCCESS)) {
+ cout << formatString(" %2d %s",getBoard(), getDriverErrorStr(ack.status_mask).c_str()) << endl;
+ }
+ itsAddr = (1 << itsAddrLine);
+ itsAddrLine++;
+ if (itsAddrLine == 28) {
+ itsAddr = 0;
+ itsAddrLine = 0;
+ itsCmdStage = 1;
+ }
+ }break;
+
+ case 1: {
+ TBBReadwAckEvent ack(e);
+ if (ack.status_mask & TBB_SUCCESS) {
+ if (ack.wordlo == itsAddrLine) {
+ cout << formatString("%2d %5d %5d %5d SAME",
+ itsMp, itsAddrLine, itsAddrLine, ack.wordlo) << endl;
+ } else {
+ cout << formatString("%2d %5d %5d %5d FAULT",
+ itsMp, itsAddrLine, itsAddrLine, ack.wordlo ) << endl;
+ itsAddrLineErrors++;
+ }
+ } else {
+ cout << formatString(" %2d %s",getBoard(), getDriverErrorStr(ack.status_mask).c_str()) << endl;
+ }
+ itsAddr = (1 << itsAddrLine);
+ itsAddrLine++;
+ if (itsAddrLine == 28) {
+ itsAddr = 0;
+ itsAddrLine = 0;
+ itsCmdStage = 0;
+ itsMp++;
+ if (itsMp == 4) {
+ itsMp = 0;
+ itsAddr = 0;
+ itsCmdStage = 2;
+ //setCmdDone(true);
+ }
+ }
+ } break;
+
+ case 2: {
+ TBBWritewAckEvent ack(e);
+ if (!(ack.status_mask & TBB_SUCCESS)) {
+ cout << formatString(" %2d %s",getBoard(), getDriverErrorStr(ack.status_mask).c_str()) << endl;
+ }
+ itsAddr++;
+ itsTestPatern <<= 1;
+ //if (itsTestPatern == 0) itsTestPatern == 1;
+
+ if (itsTestPatern == 0x00000000) {
+ itsAddr = 0;
+ itsTestPatern = 1;
+ itsCmdStage = 3;
+ }
+ }break;
+
+ case 3: {
+ TBBReadwAckEvent ack(e);
+ if (ack.status_mask & TBB_SUCCESS) {
+ if ((ack.wordlo == itsTestPatern)&&(ack.wordhi == ~itsTestPatern)) {
+ cout << formatString("%2d %08X %08X %08X %08X SAME",
+ itsMp, itsTestPatern, ack.wordlo, ~itsTestPatern, ack.wordhi) << endl;
+ } else {
+ cout << formatString("%2d %08X %08X %08X %08X FAULT",
+ itsMp, itsTestPatern, ack.wordlo, ~itsTestPatern, ack.wordhi) << endl;
+ itsDataLineErrors++;
+ }
+ } else {
+ cout << formatString(" %2d %s",getBoard(), getDriverErrorStr(ack.status_mask).c_str()) << endl;
+ }
+ itsAddr++;
+ itsTestPatern <<= 1;
+ //if (itsTestPatern == 0) itsTestPatern == 1;
+
+ if (itsTestPatern == 0x00000000) {
+ itsAddr = 0;
+ itsTestPatern = 1;
+ itsCmdStage = 2;
+ itsMp++;
+ if (itsMp == 4) {
+ cout << formatString(" == summary ==") << endl;
+ if (itsAddrLineErrors != 0) {
+ cout << formatString(" %d Addressline ERRORS",itsAddrLineErrors) << endl;
+ } else {
+ cout << formatString(" All Addresslines OK") << endl;
+ }
+ if (itsDataLineErrors != 0) {
+ cout << formatString(" %d Dataline ERRORS",itsDataLineErrors) << endl;
+ } else {
+ cout << formatString(" All Datalines OK") << endl;
+ }
+ setCmdDone(true);
+ }
+ }
+ } break;
+
+
+ default: break;
+ }
+ return(GCFEvent::HANDLED);
}
//---- READR -------------------------------------------------------------------
ReadrCmd::ReadrCmd(GCFPortInterface& port) : Command(port),
- itsMp(0), itsPid(0), itsRegId(0)
+ itsMp(0), itsPid(0), itsRegId(0)
{
- cout << endl;
- cout << "==== TBB-board, read register ================================================" << endl;
+ cout << endl;
+ cout << "==== TBB-board, read register ================================================" << endl;
}
//-----------------------------------------------------------------------------
void ReadrCmd::send()
{
- TBBReadrEvent event;
- event.board = (int32)getBoard();
- event.mp = itsMp;
- event.pid = itsPid;
- event.regid = itsRegId;
-
- itsPort.send(event);
- itsPort.setTimer(DELAY);
+ TBBReadrEvent event;
+ event.board = (int32)getBoard();
+ event.mp = itsMp;
+ event.pid = itsPid;
+ event.regid = itsRegId;
+
+ itsPort.send(event);
+ itsPort.setTimer(DELAY);
}
//-----------------------------------------------------------------------------
GCFEvent::TResult ReadrCmd::ack(GCFEvent& e)
{
- TBBReadrAckEvent ack(e);
-
- cout << "Board : " << getBoard() << endl;
- if (ack.status_mask & TBB_SUCCESS) {
- cout << "MP : " << itsMp << endl;
- cout << "PID : " << itsPid << endl;
- cout << "REGID : " << itsRegId << endl;
- cout << "Received data : ";
-
- for (int i = 0; i < (REG_SIZE[itsPid][itsRegId]); i++) {
- if (i % 4 == 0) {
- if (i != 0) cout << endl << " ";
- cout << formatString("0x%02x: ",(i * 4));
- }
- cout << formatString("%08x ",ack.data[i]);
- }
- } else {
- cout << "ERROR : " << getDriverErrorStr(ack.status_mask).c_str();
- }
-
- setCmdDone(true);
-
- return(GCFEvent::HANDLED);
+ TBBReadrAckEvent ack(e);
+
+ cout << "Board : " << getBoard() << endl;
+ if (ack.status_mask & TBB_SUCCESS) {
+ cout << "MP : " << itsMp << endl;
+ cout << "PID : " << itsPid << endl;
+ cout << "REGID : " << itsRegId << endl;
+ cout << "Received data : ";
+
+ for (int i = 0; i < (REG_SIZE[itsPid][itsRegId]); i++) {
+ if (i % 4 == 0) {
+ if (i != 0) cout << endl << " ";
+ cout << formatString("0x%02x: ",(i * 4));
+ }
+ cout << formatString("%08x ",ack.data[i]);
+ }
+ } else {
+ cout << "ERROR : " << getDriverErrorStr(ack.status_mask).c_str();
+ }
+
+ setCmdDone(true);
+
+ return(GCFEvent::HANDLED);
}
//---- WRITER -------------------------------------------------------------------
WriterCmd::WriterCmd(GCFPortInterface& port) : Command(port),
- itsMp(0), itsPid(0), itsRegId(0)
+ itsMp(0), itsPid(0), itsRegId(0)
{
- for (int i = 0; i < 16; i++) {
- itsData[i] = 0;
- }
- cout << endl;
- cout << "==== TBB-board, write register ===============================================" << endl;
- cout << endl;
+ for (int i = 0; i < 16; i++) {
+ itsData[i] = 0;
+ }
+ cout << endl;
+ cout << "==== TBB-board, write register ===============================================" << endl;
+ cout << endl;
}
//-----------------------------------------------------------------------------
void WriterCmd::send()
{
- TBBWriterEvent event;
- event.board = (int32)getBoard();
- event.mp = itsMp;
- event.pid = itsPid;
- event.regid = itsRegId;
- for (int i = 0; i < (REG_SIZE[itsPid][itsRegId]); i++) {
- event.data[i] = itsData[i];
- }
- itsPort.send(event);
- itsPort.setTimer(DELAY);
+ TBBWriterEvent event;
+ event.board = (int32)getBoard();
+ event.mp = itsMp;
+ event.pid = itsPid;
+ event.regid = itsRegId;
+ for (int i = 0; i < (REG_SIZE[itsPid][itsRegId]); i++) {
+ event.data[i] = itsData[i];
+ }
+ itsPort.send(event);
+ itsPort.setTimer(DELAY);
}
//-----------------------------------------------------------------------------
GCFEvent::TResult WriterCmd::ack(GCFEvent& e)
{
- TBBWriterAckEvent ack(e);
-
- cout << "Board : " << getBoard() << endl;
- if (ack.status_mask & TBB_SUCCESS) {
- cout << "MP : " << itsMp << endl;
- cout << "PID : " << itsPid << endl;
- cout << "REGID : " << itsRegId << endl;
- cout << "Transmitted data : ";
- for (int i = 0; i < (REG_SIZE[itsPid][itsRegId]); i++) {
- if (i % 4 == 0) {
- if (i != 0) cout << endl << " ";
- cout << formatString("0x%02x: ",(i * 4));
- }
- cout << formatString("%08x ",itsData[i]);
- }
- } else {
- cout << getDriverErrorStr(ack.status_mask).c_str();
- }
- setCmdDone(true);
-
- return(GCFEvent::HANDLED);
+ TBBWriterAckEvent ack(e);
+
+ cout << "Board : " << getBoard() << endl;
+ if (ack.status_mask & TBB_SUCCESS) {
+ cout << "MP : " << itsMp << endl;
+ cout << "PID : " << itsPid << endl;
+ cout << "REGID : " << itsRegId << endl;
+ cout << "Transmitted data : ";
+ for (int i = 0; i < (REG_SIZE[itsPid][itsRegId]); i++) {
+ if (i % 4 == 0) {
+ if (i != 0) cout << endl << " ";
+ cout << formatString("0x%02x: ",(i * 4));
+ }
+ cout << formatString("%08x ",itsData[i]);
+ }
+ } else {
+ cout << getDriverErrorStr(ack.status_mask).c_str();
+ }
+ setCmdDone(true);
+
+ return(GCFEvent::HANDLED);
}
//---- EADPAGE ------------------------------------------------------------------
ReadPageCmd::ReadPageCmd(GCFPortInterface& port) : Command(port),
- itsRcu(0),itsStartPage(0),itsPages(1),itsCmdStage(0),itsPage(0),itsTotalSize(0),itsStartAddr(0),itsSize(0),itsBoard(0),itsMp(0),
- itsStationId(0),itsRspId(0),itsRcuId(0),itsSampleFreq(0),itsTime(0),itsSampleNr(0),itsSamplesPerFrame(0),
- itsFreqBands(0),itsTotalSamples(0),itsTotalBands(0), itsBandNr(0), itsSliceNr(0)
+ itsRcu(0),itsStartPage(0),itsPages(1),itsCmdStage(0),itsPage(0),itsTotalSize(0),itsStartAddr(0),itsSize(0),itsBoard(0),itsMp(0),
+ itsStationId(0),itsRspId(0),itsRcuId(0),itsSampleFreq(0),itsTime(0),itsSampleNr(0),itsSamplesPerFrame(0),
+ itsFreqBands(0),itsTotalSamples(0),itsTotalBands(0), itsBandNr(0), itsSliceNr(0)
{
- for (int i = 0; i < 512; i++) itsData[i] = 0;
- cout << endl;
- cout << "==== TBB-board, readx register ================================================" << endl;
- cout << endl;
+ for (int i = 0; i < 512; i++) itsData[i] = 0;
+ cout << endl;
+ cout << "==== TBB-board, readx register ================================================" << endl;
+ cout << endl;
}
//-----------------------------------------------------------------------------
void ReadPageCmd::send()
{
-
- switch (itsCmdStage) {
-
- case 0: { // get info about allocated RCU's
- TBBRcuInfoEvent send;
- itsPort.send(send);
- itsPort.setTimer(DELAY);
- } break;
-
- case 1: { // get total memmory size
- TBBSizeEvent send;
- send.boardmask = (1 << itsBoard);
- itsPort.send(send);
- itsPort.setTimer(DELAY);
- } break;
-
- case 2: { // write page address to board
- TBBWriterEvent send;
-
- itsMp = static_cast<int32>((itsStartPage + itsPage) / itsTotalSize); // MP of requested addr
-
- send.board = itsBoard;
- send.mp = itsMp;
- send.pid = PID6;
- send.regid = REGID1;
- send.data[0] = (itsStartPage + itsPage);
- send.data[1] = 0;
- send.data[2] = 0;
- itsPort.send(send);
- itsPort.setTimer(DELAY);
-
- LOG_DEBUG_STR(formatString("Writer[%x][%x][%x][%x]",
- send.mp,send.pid,send.regid,send.data[0]));
- } break;
-
- case 3: { // write page-read-cmd to board
- TBBWriterEvent send;
- send.board = itsBoard;
- send.mp = itsMp;
- send.pid = PID6;
- send.regid = REGID0;
- send.data[0] = PAGEREAD;
- send.data[1] = 0;
- send.data[2] = 0;
- itsPort.send(send);
- itsPort.setTimer(DELAY);
-
- LOG_DEBUG_STR(formatString("Writer[%x][%x][%x][%x]",
- send.mp,send.pid,send.regid,send.data[0]));
- } break;
-
- case 4: { // read first part of frame
- TBBReadxEvent send;
- send.board = itsBoard;
- send.mp = itsMp;
- send.pid = PID6;
- send.regid = REGID2;
- send.pagelength = 256;
- send.pageaddr = 0;
- itsPort.send(send);
- itsPort.setTimer(DELAY);
-
- LOG_DEBUG_STR(formatString("Readx[%x][%x][%x][%x][%x]",
- send.mp,send.pid,send.regid,send.pagelength,send.pageaddr));
- } break;
-
- case 5: { // read second part of frame
- TBBReadxEvent send;
- send.board = itsBoard;
- send.mp = itsMp;
- send.pid = PID6;
- send.regid = REGID2;
- send.pagelength = 256;
- send.pageaddr = 256;
- itsPort.send(send);
- itsPort.setTimer(DELAY);
-
- LOG_DEBUG_STR(formatString("Readx[%x][%x][%x][%x][%x]",
- send.mp,send.pid,send.regid,send.pagelength,send.pageaddr));
- } break;
-
- default:{
- } break;
- }
+
+ switch (itsCmdStage) {
+
+ case 0: { // get info about allocated RCU's
+ TBBRcuInfoEvent send;
+ itsPort.send(send);
+ itsPort.setTimer(DELAY);
+ } break;
+
+ case 1: { // get total memmory size
+ TBBSizeEvent send;
+ send.boardmask = (1 << itsBoard);
+ itsPort.send(send);
+ itsPort.setTimer(DELAY);
+ } break;
+
+ case 2: { // write page address to board
+ TBBWriterEvent send;
+
+ itsMp = static_cast<int32>((itsStartPage + itsPage) / itsTotalSize); // MP of requested addr
+
+ send.board = itsBoard;
+ send.mp = itsMp;
+ send.pid = PID6;
+ send.regid = REGID1;
+ send.data[0] = (itsStartPage + itsPage);
+ send.data[1] = 0;
+ send.data[2] = 0;
+ itsPort.send(send);
+ itsPort.setTimer(DELAY);
+
+ LOG_DEBUG_STR(formatString("Writer[%x][%x][%x][%x]",
+ send.mp,send.pid,send.regid,send.data[0]));
+ } break;
+
+ case 3: { // write page-read-cmd to board
+ TBBWriterEvent send;
+ send.board = itsBoard;
+ send.mp = itsMp;
+ send.pid = PID6;
+ send.regid = REGID0;
+ send.data[0] = PAGEREAD;
+ send.data[1] = 0;
+ send.data[2] = 0;
+ itsPort.send(send);
+ itsPort.setTimer(DELAY);
+
+ LOG_DEBUG_STR(formatString("Writer[%x][%x][%x][%x]",
+ send.mp,send.pid,send.regid,send.data[0]));
+ } break;
+
+ case 4: { // read first part of frame
+ TBBReadxEvent send;
+ send.board = itsBoard;
+ send.mp = itsMp;
+ send.pid = PID6;
+ send.regid = REGID2;
+ send.pagelength = 256;
+ send.pageaddr = 0;
+ itsPort.send(send);
+ itsPort.setTimer(DELAY);
+
+ LOG_DEBUG_STR(formatString("Readx[%x][%x][%x][%x][%x]",
+ send.mp,send.pid,send.regid,send.pagelength,send.pageaddr));
+ } break;
+
+ case 5: { // read second part of frame
+ TBBReadxEvent send;
+ send.board = itsBoard;
+ send.mp = itsMp;
+ send.pid = PID6;
+ send.regid = REGID2;
+ send.pagelength = 256;
+ send.pageaddr = 256;
+ itsPort.send(send);
+ itsPort.setTimer(DELAY);
+
+ LOG_DEBUG_STR(formatString("Readx[%x][%x][%x][%x][%x]",
+ send.mp,send.pid,send.regid,send.pagelength,send.pageaddr));
+ } break;
+
+ default:{
+ } break;
+ }
}
//-----------------------------------------------------------------------------
GCFEvent::TResult ReadPageCmd::ack(GCFEvent& e)
{
- char basefilename[PATH_MAX];
- char filename[PATH_MAX];
- char timestring[256];
-
- int16 val[1400];
-
- double bar_size = 50;
- static double bar_interval = 1;
- static double bar_buff = 0;
-
- switch (itsCmdStage) {
-
- case 0: {
- TBBRcuInfoAckEvent ack(e);
- itsRcu = getRcu();
- itsState = ack.rcu_state[itsRcu];
- itsStartAddr = ack.rcu_start_addr[itsRcu];
- itsSize = ack.rcu_pages[itsRcu];
- itsBoard = ack.rcu_on_board[itsRcu];
- //itsMp = static_cast<int32>(ack.rcu_on_input[itsRcu] / 4);
- //cout << formatString("Rcu-%d Board[%d] Mp[%d]",itsRcu,itsBoard,itsMp) << endl;
-
- itsStartPage += itsStartAddr;
-
- if (itsState == 'F') {
- cout << "Rcu not allocated" << endl;
- itsCmdStage = 10;
- }
- } break;
-
- case 1: {
- TBBSizeAckEvent ack(e);
- if (!(ack.status_mask[itsBoard] & TBB_SUCCESS)) {
- cout << formatString("%s",getDriverErrorStr(ack.status_mask[itsBoard]).c_str()) << endl;
- itsCmdStage = 10;
- } else {
- itsTotalSize = ack.npages[itsBoard] / 4;
-
- if ((itsStartPage < itsStartAddr) || ((itsStartPage + itsPages) > (itsStartAddr + itsSize))) {
- cout << formatString("Requested Page belongs not to rcu %d", itsRcu) << endl;
- } else {
- //cout << formatString("StartPage = %u ",itsStartPage) << endl;
- }
- }
- } break;
-
- case 2: {
- TBBWriterAckEvent ack(e);
- if (!(ack.status_mask & TBB_SUCCESS)) {
- cout << formatString("%s",getDriverErrorStr(ack.status_mask).c_str()) << endl;
- itsCmdStage = 10;
- }
- } break;
-
- case 3: {
- TBBWriterAckEvent ack(e);
- if (!(ack.status_mask & TBB_SUCCESS)) {
- cout << formatString("%s",getDriverErrorStr(ack.status_mask).c_str()) << endl;
- itsCmdStage = 10;
- }
- } break;
-
- case 4: {
- TBBReadxAckEvent ack(e);
- if (!(ack.status_mask & TBB_SUCCESS)) {
- cout << formatString("%s", getDriverErrorStr(ack.status_mask).c_str()) << endl;
- itsCmdStage = 10;
- }
-
- // memcpy(itsData, ack.pagedata, sizeof(ack.pagedata));
- for (int32 dn = 0; dn < 256; dn++) {
- itsData[dn] = ack.pagedata[dn];
- }
- } break;
-
- case 5: {
- TBBReadxAckEvent ack(e);
- if (!(ack.status_mask & TBB_SUCCESS)) {
- cout << formatString("%s", getDriverErrorStr(ack.status_mask).c_str()) << endl;
- itsCmdStage = 10;
- }
- for (int32 dn = 0; dn < 256; dn++) {
- itsData[256 + dn] = ack.pagedata[dn];
- }
- } break;
- }
-
- // if error in communication stop
- if (itsCmdStage == 10) {
- setCmdDone(true);
- return(GCFEvent::HANDLED);
- }
-
- itsCmdStage++;
- if (itsCmdStage > 5) { // if stage > 5, received 1 frame
-
- bar_buff += 1;
- if (itsPage == 0) {
-
- itsStationId = static_cast<int>(itsData[0] & 0xFF);
- itsRspId = static_cast<int>((itsData[0] >> 8) & 0xFF);
- itsRcuId = static_cast<int>((itsData[0] >> 16) & 0xFF);
- itsSampleFreq = static_cast<int>((itsData[0] >> 24) & 0xFF);
- itsTime = static_cast<time_t>(itsData[2]);
- itsFreqBands = static_cast<int>((itsData[4] >> 16) & 0xFFFF);
-
- if (itsFreqBands == 0) {
- itsSampleNr = static_cast<uint32>(itsData[3]);
- } else {
- itsBandNr = static_cast<int>(itsData[3] & 0x03FF);
- itsSliceNr = static_cast<int>(itsData[3] >> 10);
- }
- strftime(timestring, 255, "%Y%m%d_%H%M%S", gmtime(&itsTime));
-
- cout << "Station ID : " << itsStationId << endl;
- cout << "RSP ID : " << itsRspId << endl;
- cout << "RCU ID : " << itsRcuId << endl;
- cout << "Sample freq : " << itsSampleFreq << " MHz" << endl;
- if (itsTime < 0) {
- cout << "Time : invalid" << endl;
- } else {
- cout << "Time of 1e sample/slice : " << timestring << " (" << (uint32)itsTime << ")" << endl ;
- }
- if (itsFreqBands > 0) {
- cout << "Slice number of 1e slice : " << itsSliceNr << endl;
- cout << "Band number of 1e sample : " << itsBandNr << endl;
- cout << "Number of bands : " << itsFreqBands << endl;
- cout << "Data file format : binary complex(int16 Re, int16 Im)" << endl;
- } else {
- cout << "Sample number of 1e sample : " << itsSampleNr << endl;
- cout << "Data file format : binary int16" << endl;
- }
-
- // print size of progressbar on screen
- bar_interval = itsPages / bar_size;
- int recvtime = static_cast<int>((1043. / 262144.) * itsPages); // measured 262144 pages in 1043 seconds
- int hours = recvtime / (60 * 60);
- int mins = (recvtime - (hours * 60 * 60)) / 60;
- int secs = recvtime - (hours * 60 * 60) - (mins * 60) + 1; // 1 second for overhead
- cout << endl;
- cout << " Estimated receive time " << formatString("%d:%02d:%02d",hours, mins, secs) << endl;
- cout << "Progress |";
- for (int i = 0; i < bar_size; i++) {
- cout << "-";
- }
- cout << "|" << endl ;
- cout << " |" << flush;
-
- snprintf(basefilename, PATH_MAX, "%s_%s_%02d%02d",(itsFreqBands == 0)?"rw":"sb",timestring,itsStationId,itsRcuId);
- }
- itsSamplesPerFrame = static_cast<uint32>(itsData[4] & 0xFFFF);
-
- // print receive progress on screen
- if (bar_interval < 1.) {
- int count = static_cast<int>(ceil(bar_buff / bar_interval));
- for (int i = 0; i < count; i++) {
- cout << "x" << flush;
- }
- bar_buff -= (count * bar_interval);
- } else {
- if (bar_buff >= bar_interval) {
- cout << "x" << flush;
- bar_buff -= bar_interval;
- }
- }
-
- int sample_cnt = 0;
- int val_cnt = 0;
- int data_cnt = 22; // 22 = startadress of data in frame
-
- // extract payload
- if (itsFreqBands > 0) { // if itsFreqBands > 0 then it's SPECTRAL data
- itsTotalSamples += itsSamplesPerFrame;
-
- // convert uint32 to complex int16
- while (sample_cnt < itsSamplesPerFrame) {
- val[val_cnt++] = static_cast<int16>(itsData[data_cnt] & 0xFFFF); // re part
- val[val_cnt++] = static_cast<int16>((itsData[data_cnt++] >> 16) & 0xFFFF); // im part
- sample_cnt++;
- }
- } else { // if itsFreqBands = 0, it's RAW data
-
- uint32 data[3];
- itsTotalSamples += itsSamplesPerFrame;
-
- // 1e convert uint32 to int12
- while (sample_cnt < itsSamplesPerFrame) {
- // get 96 bits from received data
- data[0] = itsData[data_cnt++];
- data[1] = itsData[data_cnt++];
- data[2] = itsData[data_cnt++];
-
- // extract 8 values of 12 bit
- val[val_cnt++] = static_cast<int16>( data[0] & 0x00000FFF);
- val[val_cnt++] = static_cast<int16>(( data[0] & 0x00FFF000) >> 12);
- val[val_cnt++] = static_cast<int16>(((data[0] & 0xFF000000) >> 24) | ((data[1] & 0x0000000F) << 8));
- val[val_cnt++] = static_cast<int16>(( data[1] & 0x0000FFF0) >> 4 );
- val[val_cnt++] = static_cast<int16>(( data[1] & 0x0FFF0000) >> 16);
- val[val_cnt++] = static_cast<int16>(((data[1] & 0xF0000000) >> 28) | ((data[2] & 0x000000FF) << 4));
- val[val_cnt++] = static_cast<int16>(( data[2] & 0x000FFF00) >> 8);
- val[val_cnt++] = static_cast<int16>(( data[2] & 0xFFF00000) >> 20);
-
- sample_cnt += 8;
- }
-
- // 2e convert all received samples from signed 12bit to signed 16bit
- for (int cnt = 0; cnt < val_cnt; cnt++) {
- if (val[cnt] & 0x0800) val[cnt] |= 0xF000;
- }
- }
-
- // write all data to file
- FILE* file;
-
- if (val_cnt > 0) {
- // save unpacked frame to file
- snprintf(filename, PATH_MAX, "%s.dat",basefilename);
- file = fopen(filename,"a");
- fwrite(&itsData[0],sizeof(uint32),22,file); // frame header 88 bytes (4 x 22)
- fwrite(&val[0],sizeof(int16),val_cnt,file); // payload
- fwrite(&itsData[509],sizeof(uint32),1,file); // payload CRC 4 bytes (4 x 1)
- fclose(file);
- }
-
- itsPage++;
- if ((itsPage < itsPages) && (itsPage < itsSize)) {
- itsCmdStage = 2;
- } else {
- // last page received, print last info on screen
- cout << "|" << endl;
- cout << endl;
- cout << "Total received pages : " << itsPage;
- if (itsPage > 1) {
- cout << " (page " << itsStartPage << " .. " << (itsStartPage + itsPage - 1) << ")" << endl;
- } else {
- cout << " (page " << itsStartPage << ")" << endl;
- }
- cout << "Total received samples: " << itsTotalSamples << endl;
-
- if (val_cnt > 0) {
- cout << "Filename : " << basefilename << ".nfo" << endl;
- cout << " : " << basefilename << ".dat" << endl;
- cout << endl;
- cout << "Each frame exists of:" << endl;
- cout << " HEADER(88 bytes) + PAYLOAD(see header for size) + PAYLOAD_CRC(4 bytes)" << endl;
- } else {
- cout << "Filename : NO DATA IN FRAME" << endl;
- }
-
-
-
- // save page information to file
- strftime(timestring, 255, "%Y-%m-%d %H:%M:%S", gmtime(&itsTime));
-
- snprintf(filename, PATH_MAX, "%s.nfo",basefilename);
- file = fopen(filename,"w");
-
- fprintf(file, "Station ID : %d",itsStationId);
- fprintf(file, "RSP ID : %d",itsRspId);
- fprintf(file, "RCU ID : %d",itsRcuId);
- fprintf(file, "Sample freq : %d MHz",itsSampleFreq);
- if (itsTime < 0) {
- fprintf(file,"Time : invalid");
- } else {
- fprintf(file,"Time of 1e sample/slice : %s (%u)",timestring,(uint32)itsTime);
- }
- if (itsFreqBands > 0) {
- fprintf(file,"Slice number of 1e slice : %d",itsSliceNr);
- fprintf(file,"Band number of 1e sample : %d",itsBandNr);
- fprintf(file,"Number of bands : %d",itsFreqBands);
- fprintf(file,"Data file format : binary complex(int16 Re, int16 Im)");
- } else {
- fprintf(file,"Sample number of 1e sample : %u",itsSampleNr);
- fprintf(file,"Total number of samples : %u",itsTotalSamples);
- fprintf(file,"Data file format : binary int16");
- fprintf(file," ");
- }
- fclose(file);
- }
- }
-
- if (itsPage == itsPages) {
- setCmdDone(true);
- }
-
- return(GCFEvent::HANDLED);
+ char basefilename[PATH_MAX];
+ char filename[PATH_MAX];
+ char timestring[256];
+
+ int16 val[1400];
+
+ double bar_size = 50;
+ static double bar_interval = 1;
+ static double bar_buff = 0;
+
+ switch (itsCmdStage) {
+
+ case 0: {
+ TBBRcuInfoAckEvent ack(e);
+ itsRcu = getRcu();
+ itsState = ack.rcu_state[itsRcu];
+ itsStartAddr = ack.rcu_start_addr[itsRcu];
+ itsSize = ack.rcu_pages[itsRcu];
+ itsBoard = ack.rcu_on_board[itsRcu];
+ //itsMp = static_cast<int32>(ack.rcu_on_input[itsRcu] / 4);
+ //cout << formatString("Rcu-%d Board[%d] Mp[%d]",itsRcu,itsBoard,itsMp) << endl;
+
+ itsStartPage += itsStartAddr;
+
+ if (itsState == 'F') {
+ cout << "Rcu not allocated" << endl;
+ itsCmdStage = 10;
+ }
+ } break;
+
+ case 1: {
+ TBBSizeAckEvent ack(e);
+ if (!(ack.status_mask[itsBoard] & TBB_SUCCESS)) {
+ cout << formatString("%s",getDriverErrorStr(ack.status_mask[itsBoard]).c_str()) << endl;
+ itsCmdStage = 10;
+ } else {
+ itsTotalSize = ack.npages[itsBoard] / 4;
+
+ if ((itsStartPage < itsStartAddr) || ((itsStartPage + itsPages) > (itsStartAddr + itsSize))) {
+ cout << formatString("Requested Page belongs not to rcu %d", itsRcu) << endl;
+ } else {
+ //cout << formatString("StartPage = %u ",itsStartPage) << endl;
+ }
+ }
+ } break;
+
+ case 2: {
+ TBBWriterAckEvent ack(e);
+ if (!(ack.status_mask & TBB_SUCCESS)) {
+ cout << formatString("%s",getDriverErrorStr(ack.status_mask).c_str()) << endl;
+ itsCmdStage = 10;
+ }
+ } break;
+
+ case 3: {
+ TBBWriterAckEvent ack(e);
+ if (!(ack.status_mask & TBB_SUCCESS)) {
+ cout << formatString("%s",getDriverErrorStr(ack.status_mask).c_str()) << endl;
+ itsCmdStage = 10;
+ }
+ } break;
+
+ case 4: {
+ TBBReadxAckEvent ack(e);
+ if (!(ack.status_mask & TBB_SUCCESS)) {
+ cout << formatString("%s", getDriverErrorStr(ack.status_mask).c_str()) << endl;
+ itsCmdStage = 10;
+ }
+
+ // memcpy(itsData, ack.pagedata, sizeof(ack.pagedata));
+ for (int32 dn = 0; dn < 256; dn++) {
+ itsData[dn] = ack.pagedata[dn];
+ }
+ } break;
+
+ case 5: {
+ TBBReadxAckEvent ack(e);
+ if (!(ack.status_mask & TBB_SUCCESS)) {
+ cout << formatString("%s", getDriverErrorStr(ack.status_mask).c_str()) << endl;
+ itsCmdStage = 10;
+ }
+ for (int32 dn = 0; dn < 256; dn++) {
+ itsData[256 + dn] = ack.pagedata[dn];
+ }
+ } break;
+ }
+
+ // if error in communication stop
+ if (itsCmdStage == 10) {
+ setCmdDone(true);
+ return(GCFEvent::HANDLED);
+ }
+
+ itsCmdStage++;
+ if (itsCmdStage > 5) { // if stage > 5, received 1 frame
+
+ bar_buff += 1;
+ if (itsPage == 0) {
+
+ itsStationId = static_cast<int>(itsData[0] & 0xFF);
+ itsRspId = static_cast<int>((itsData[0] >> 8) & 0xFF);
+ itsRcuId = static_cast<int>((itsData[0] >> 16) & 0xFF);
+ itsSampleFreq = static_cast<int>((itsData[0] >> 24) & 0xFF);
+ itsTime = static_cast<time_t>(itsData[2]);
+ itsFreqBands = static_cast<int>((itsData[4] >> 16) & 0xFFFF);
+
+ if (itsFreqBands == 0) {
+ itsSampleNr = static_cast<uint32>(itsData[3]);
+ } else {
+ itsBandNr = static_cast<int>(itsData[3] & 0x03FF);
+ itsSliceNr = static_cast<int>(itsData[3] >> 10);
+ }
+ strftime(timestring, 255, "%Y%m%d_%H%M%S", gmtime(&itsTime));
+
+ cout << "Station ID : " << itsStationId << endl;
+ cout << "RSP ID : " << itsRspId << endl;
+ cout << "RCU ID : " << itsRcuId << endl;
+ cout << "Sample freq : " << itsSampleFreq << " MHz" << endl;
+ if (itsTime < 0) {
+ cout << "Time : invalid" << endl;
+ } else {
+ cout << "Time of 1e sample/slice : " << timestring << " (" << (uint32)itsTime << ")" << endl ;
+ }
+ if (itsFreqBands > 0) {
+ cout << "Slice number of 1e slice : " << itsSliceNr << endl;
+ cout << "Band number of 1e sample : " << itsBandNr << endl;
+ cout << "Number of bands : " << itsFreqBands << endl;
+ cout << "Data file format : binary complex(int16 Re, int16 Im)" << endl;
+ } else {
+ cout << "Sample number of 1e sample : " << itsSampleNr << endl;
+ cout << "Data file format : binary int16" << endl;
+ }
+
+ // print size of progressbar on screen
+ bar_interval = itsPages / bar_size;
+ int recvtime = static_cast<int>((1043. / 262144.) * itsPages); // measured 262144 pages in 1043 seconds
+ int hours = recvtime / (60 * 60);
+ int mins = (recvtime - (hours * 60 * 60)) / 60;
+ int secs = recvtime - (hours * 60 * 60) - (mins * 60) + 1; // 1 second for overhead
+ cout << endl;
+ cout << " Estimated receive time " << formatString("%d:%02d:%02d",hours, mins, secs) << endl;
+ cout << "Progress |";
+ for (int i = 0; i < bar_size; i++) {
+ cout << "-";
+ }
+ cout << "|" << endl ;
+ cout << " |" << flush;
+
+ snprintf(basefilename, PATH_MAX, "%s_%s_%02d%02d",(itsFreqBands == 0)?"rw":"sb",timestring,itsStationId,itsRcuId);
+ }
+ itsSamplesPerFrame = static_cast<uint32>(itsData[4] & 0xFFFF);
+
+ // print receive progress on screen
+ if (bar_interval < 1.) {
+ int count = static_cast<int>(ceil(bar_buff / bar_interval));
+ for (int i = 0; i < count; i++) {
+ cout << "x" << flush;
+ }
+ bar_buff -= (count * bar_interval);
+ } else {
+ if (bar_buff >= bar_interval) {
+ cout << "x" << flush;
+ bar_buff -= bar_interval;
+ }
+ }
+
+ int sample_cnt = 0;
+ int val_cnt = 0;
+ int data_cnt = 22; // 22 = startadress of data in frame
+
+ // extract payload
+ if (itsFreqBands > 0) { // if itsFreqBands > 0 then it's SPECTRAL data
+ itsTotalSamples += itsSamplesPerFrame;
+
+ // convert uint32 to complex int16
+ while (sample_cnt < itsSamplesPerFrame) {
+ val[val_cnt++] = static_cast<int16>(itsData[data_cnt] & 0xFFFF); // re part
+ val[val_cnt++] = static_cast<int16>((itsData[data_cnt++] >> 16) & 0xFFFF); // im part
+ sample_cnt++;
+ }
+ } else { // if itsFreqBands = 0, it's RAW data
+
+ uint32 data[3];
+ itsTotalSamples += itsSamplesPerFrame;
+
+ // 1e convert uint32 to int12
+ while (sample_cnt < itsSamplesPerFrame) {
+ // get 96 bits from received data
+ data[0] = itsData[data_cnt++];
+ data[1] = itsData[data_cnt++];
+ data[2] = itsData[data_cnt++];
+
+ // extract 8 values of 12 bit
+ val[val_cnt++] = static_cast<int16>( data[0] & 0x00000FFF);
+ val[val_cnt++] = static_cast<int16>(( data[0] & 0x00FFF000) >> 12);
+ val[val_cnt++] = static_cast<int16>(((data[0] & 0xFF000000) >> 24) | ((data[1] & 0x0000000F) << 8));
+ val[val_cnt++] = static_cast<int16>(( data[1] & 0x0000FFF0) >> 4 );
+ val[val_cnt++] = static_cast<int16>(( data[1] & 0x0FFF0000) >> 16);
+ val[val_cnt++] = static_cast<int16>(((data[1] & 0xF0000000) >> 28) | ((data[2] & 0x000000FF) << 4));
+ val[val_cnt++] = static_cast<int16>(( data[2] & 0x000FFF00) >> 8);
+ val[val_cnt++] = static_cast<int16>(( data[2] & 0xFFF00000) >> 20);
+
+ sample_cnt += 8;
+ }
+
+ // 2e convert all received samples from signed 12bit to signed 16bit
+ for (int cnt = 0; cnt < val_cnt; cnt++) {
+ if (val[cnt] & 0x0800) val[cnt] |= 0xF000;
+ }
+ }
+
+ // write all data to file
+ FILE* file;
+
+ if (val_cnt > 0) {
+ // save unpacked frame to file
+ snprintf(filename, PATH_MAX, "%s.dat",basefilename);
+ file = fopen(filename,"a");
+ fwrite(&itsData[0],sizeof(uint32),22,file); // frame header 88 bytes (4 x 22)
+ fwrite(&val[0],sizeof(int16),val_cnt,file); // payload
+ fwrite(&itsData[509],sizeof(uint32),1,file); // payload CRC 4 bytes (4 x 1)
+ fclose(file);
+ }
+
+ itsPage++;
+ if ((itsPage < itsPages) && (itsPage < itsSize)) {
+ itsCmdStage = 2;
+ } else {
+ // last page received, print last info on screen
+ cout << "|" << endl;
+ cout << endl;
+ cout << "Total received pages : " << itsPage;
+ if (itsPage > 1) {
+ cout << " (page " << itsStartPage << " .. " << (itsStartPage + itsPage - 1) << ")" << endl;
+ } else {
+ cout << " (page " << itsStartPage << ")" << endl;
+ }
+ cout << "Total received samples: " << itsTotalSamples << endl;
+
+ if (val_cnt > 0) {
+ cout << "Filename : " << basefilename << ".nfo" << endl;
+ cout << " : " << basefilename << ".dat" << endl;
+ cout << endl;
+ cout << "Each frame exists of:" << endl;
+ cout << " HEADER(88 bytes) + PAYLOAD(see header for size) + PAYLOAD_CRC(4 bytes)" << endl;
+ } else {
+ cout << "Filename : NO DATA IN FRAME" << endl;
+ }
+
+
+
+ // save page information to file
+ strftime(timestring, 255, "%Y-%m-%d %H:%M:%S", gmtime(&itsTime));
+
+ snprintf(filename, PATH_MAX, "%s.nfo",basefilename);
+ file = fopen(filename,"w");
+
+ fprintf(file, "Station ID : %d",itsStationId);
+ fprintf(file, "RSP ID : %d",itsRspId);
+ fprintf(file, "RCU ID : %d",itsRcuId);
+ fprintf(file, "Sample freq : %d MHz",itsSampleFreq);
+ if (itsTime < 0) {
+ fprintf(file,"Time : invalid");
+ } else {
+ fprintf(file,"Time of 1e sample/slice : %s (%u)",timestring,(uint32)itsTime);
+ }
+ if (itsFreqBands > 0) {
+ fprintf(file,"Slice number of 1e slice : %d",itsSliceNr);
+ fprintf(file,"Band number of 1e sample : %d",itsBandNr);
+ fprintf(file,"Number of bands : %d",itsFreqBands);
+ fprintf(file,"Data file format : binary complex(int16 Re, int16 Im)");
+ } else {
+ fprintf(file,"Sample number of 1e sample : %u",itsSampleNr);
+ fprintf(file,"Total number of samples : %u",itsTotalSamples);
+ fprintf(file,"Data file format : binary int16");
+ fprintf(file," ");
+ }
+ fclose(file);
+ }
+ }
+
+ if (itsPage == itsPages) {
+ setCmdDone(true);
+ }
+
+ return(GCFEvent::HANDLED);
}
//====END OF TBB COMMANDS==========================================================================
@@ -2187,95 +2186,95 @@ GCFEvent::TResult ReadPageCmd::ack(GCFEvent& e)
//---- HELP --------------------------------------------------------------------
void TBBCtl::commandHelp(int level)
{
- cout << endl;
- cout << endl;
- cout << "> > > > tbbctl COMMAND USAGE > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > >" << endl;
- cout << endl;
- cout << " # --command : all boards or active rcu's are selected, and will be displayed" << endl;
- cout << " # --command --select=<set> : only information for all selected boards or rcu's is displayed" << endl;
- cout << " # Example: --select=0,1,4 or --select=0:6 or --select=0,1,2,8:11" << endl;
- cout << endl;
- cout << "______| CHANNEL |_________________________________________________________________________________________________________" << endl;
- cout << " tbbctl --rcuinfo [--select=<set>] # list rcu info, only allocated rcu's are listed" << endl;
- cout << " tbbctl --alloc [--select=<set>] # allocate memmory locations for selected rcu's" << endl;
- cout << " tbbctl --free [--select=<set>] # free memmory locations for selected rcu's" << endl;
- cout << " tbbctl --record [--select=<set>] # start recording on selected rcu's" << endl;
- cout << " tbbctl --stop [--select=<set>] # stop recording on selected rcu's" << endl;
- cout << " tbbctl --mode=[transient | subbands] # set mode to configure UDP/IP header for CEP tranport" << endl;
- cout << " # before using: --read, --arp or --arpmode," << endl;
- cout << " # first use --mode to setup UDP/IP header" << endl;
- cout << " tbbctl --read=rcunr,secondstime,sampletime,prepages,postpages # transfer recorded data from rcunr to CEP, " << endl;
- cout << " tbbctl --stopcep [--select=<set>] # stop sending CEP messages" << endl;
- cout << " tbbctl --arp [--select=<set>] # send 1 arp message" << endl;
- cout << " tbbctl --arpmode=mode [--select=<set>] # set arp mode, 0=manual, 1=auto" << endl;
- cout << endl;
- cout << "______| TRIGGER |_________________________________________________________________________________________________________" << endl;
- cout << " tbbctl --settings [--select=<set>] # list trigger settings for selected rcu's" << endl;
- cout << " tbbctl --release [--select=<set>] # release trigger system for selected rcu's" << endl;
- cout << " tbbctl --generate [--select=<set>] # generate a trigger for selected rcu's" << endl;
- cout << " tbbctl --setup=level,start,stop,filter,window,mode [--select=<set>]# setup trigger system for selected rcu's, mode = 0/1" << endl;
- cout << " tbbctl --coef=c0,c1,c2,c3 [--select=<set>] # set trigger coeffients for elected rcu's" << endl;
- cout << " tbbctl --triginfo=rcu # get trigger info for selected rcu" << endl;
- cout << " tbbctl --listen # put in listen mode, all triggers will be listed" << endl;
- cout << endl;
- cout << "______| INFO |____________________________________________________________________________________________________________" << endl;
- cout << " tbbctl --version [--select=<set>] # get version information from selected boards" << endl;
- cout << " tbbctl --status [--select=<set>] # get status information from selected boards" << endl;
- cout << " tbbctl --size [--select=<set>] # get installed memory size from selected boards" << endl;
- cout << endl;
- cout << "______| DDR |_____________________________________________________________________________________________________________" << endl;
- cout << " tbbctl --readpage=rcunr,startpage,npages # ddr read npages from rcunr, starting on startpage" << endl;
- if (level == 3) {
- cout << " tbbctl --testddr=board # ddr memory test, adress and data lines" << endl;
- cout << " tbbctl --readddr=board,mp,addr,size # ddr read, (size x 2) words starting on addr" << endl;
- cout << " tbbctl --writeddr=board,mp,addr,wordL,wordH # ddr write, 2 words to starting on addr" << endl;
- cout << endl;
- cout << "______| MP-REGISTER |_____________________________________________________________________________________________________" << endl;
- cout << " tbbctl --readreg=board,mp,pid,regid # register read" << endl;
- cout << " tbbctl --writereg=board,mp,pid,regid,data(hex input) # register write" << endl;
- cout << endl;
- cout << "______| FLASH |___________________________________________________________________________________________________________" << endl;
- cout << " tbbctl --eraseimage=board,image # erase image from flash" << endl;
- cout << " tbbctl --readimage=board,image # read image from flash to file" << endl;
- cout << " tbbctl --writeimage=boardnr,imagenr,version,tpfilename,mpfilename # write tp and mp file to imagenr on boardnr" << endl;
- cout << " # version is the sw version of the image stored" << endl;
- }
- if (level == 1) {
- cout << endl;
- cout << "______| FLASH |___________________________________________________________________________________________________________" << endl;
- }
- cout << " tbbctl --imageinfo=board # read info from all images on board" << endl;
- cout << " tbbctl --config=imagenr [--select=<set>] # reconfigure TP and MP's with imagenr [0..31] on " << endl;
- cout << " # selected boards" << endl;
- cout << "__________________________________________________________________________________________________________________________" << endl;
- cout << " tbbctl --templimits=high,low [--select=<set>] # set temp limts for fan control" << endl;
- cout << " tbbctl --clear [--select=<set>] # clear selected board" << endl;
- cout << " tbbctl --reset [--select=<set>] # reset to factory images on selected boards" << endl;
- cout << endl;
- cout << " tbbctl --help # this help screen" << endl;
- cout << "< < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < " << endl;
- cout << endl;
+ cout << endl;
+ cout << endl;
+ cout << "> > > > tbbctl COMMAND USAGE > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > > >" << endl;
+ cout << endl;
+ cout << " # --command : all boards or active rcu's are selected, and will be displayed" << endl;
+ cout << " # --command --select=<set> : only information for all selected boards or rcu's is displayed" << endl;
+ cout << " # Example: --select=0,1,4 or --select=0:6 or --select=0,1,2,8:11" << endl;
+ cout << endl;
+ cout << "______| CHANNEL |_________________________________________________________________________________________________________" << endl;
+ cout << " tbbctl --rcuinfo [--select=<set>] # list rcu info, only allocated rcu's are listed" << endl;
+ cout << " tbbctl --alloc [--select=<set>] # allocate memmory locations for selected rcu's" << endl;
+ cout << " tbbctl --free [--select=<set>] # free memmory locations for selected rcu's" << endl;
+ cout << " tbbctl --record [--select=<set>] # start recording on selected rcu's" << endl;
+ cout << " tbbctl --stop [--select=<set>] # stop recording on selected rcu's" << endl;
+ cout << " tbbctl --mode=[transient | subbands] # set mode to configure UDP/IP header for CEP tranport" << endl;
+ cout << " # before using: --read, --arp or --arpmode," << endl;
+ cout << " # first use --mode to setup UDP/IP header" << endl;
+ cout << " tbbctl --read=rcunr,secondstime,sampletime,prepages,postpages # transfer recorded data from rcunr to CEP, " << endl;
+ cout << " tbbctl --stopcep [--select=<set>] # stop sending CEP messages" << endl;
+ cout << " tbbctl --arp [--select=<set>] # send 1 arp message" << endl;
+ cout << " tbbctl --arpmode=mode [--select=<set>] # set arp mode, 0=manual, 1=auto" << endl;
+ cout << endl;
+ cout << "______| TRIGGER |_________________________________________________________________________________________________________" << endl;
+ cout << " tbbctl --settings [--select=<set>] # list trigger settings for selected rcu's" << endl;
+ cout << " tbbctl --release [--select=<set>] # release trigger system for selected rcu's" << endl;
+ cout << " tbbctl --generate [--select=<set>] # generate a trigger for selected rcu's" << endl;
+ cout << " tbbctl --setup=level,start,stop,filter,window,mode [--select=<set>]# setup trigger system for selected rcu's, mode = 0/1" << endl;
+ cout << " tbbctl --coef=c0,c1,c2,c3 [--select=<set>] # set trigger coeffients for elected rcu's" << endl;
+ cout << " tbbctl --triginfo=rcu # get trigger info for selected rcu" << endl;
+ cout << " tbbctl --listen # put in listen mode, all triggers will be listed" << endl;
+ cout << endl;
+ cout << "______| INFO |____________________________________________________________________________________________________________" << endl;
+ cout << " tbbctl --version [--select=<set>] # get version information from selected boards" << endl;
+ cout << " tbbctl --status [--select=<set>] # get status information from selected boards" << endl;
+ cout << " tbbctl --size [--select=<set>] # get installed memory size from selected boards" << endl;
+ cout << endl;
+ cout << "______| DDR |_____________________________________________________________________________________________________________" << endl;
+ cout << " tbbctl --readpage=rcunr,startpage,npages # ddr read npages from rcunr, starting on startpage" << endl;
+ if (level == 3) {
+ cout << " tbbctl --testddr=board # ddr memory test, adress and data lines" << endl;
+ cout << " tbbctl --readddr=board,mp,addr,size # ddr read, (size x 2) words starting on addr" << endl;
+ cout << " tbbctl --writeddr=board,mp,addr,wordL,wordH # ddr write, 2 words to starting on addr" << endl;
+ cout << endl;
+ cout << "______| MP-REGISTER |_____________________________________________________________________________________________________" << endl;
+ cout << " tbbctl --readreg=board,mp,pid,regid # register read" << endl;
+ cout << " tbbctl --writereg=board,mp,pid,regid,data(hex input) # register write" << endl;
+ cout << endl;
+ cout << "______| FLASH |___________________________________________________________________________________________________________" << endl;
+ cout << " tbbctl --eraseimage=board,image # erase image from flash" << endl;
+ cout << " tbbctl --readimage=board,image # read image from flash to file" << endl;
+ cout << " tbbctl --writeimage=boardnr,imagenr,version,tpfilename,mpfilename # write tp and mp file to imagenr on boardnr" << endl;
+ cout << " # version is the sw version of the image stored" << endl;
+ }
+ if (level == 1) {
+ cout << endl;
+ cout << "______| FLASH |___________________________________________________________________________________________________________" << endl;
+ }
+ cout << " tbbctl --imageinfo=board # read info from all images on board" << endl;
+ cout << " tbbctl --config=imagenr [--select=<set>] # reconfigure TP and MP's with imagenr [0..31] on " << endl;
+ cout << " # selected boards" << endl;
+ cout << "__________________________________________________________________________________________________________________________" << endl;
+ cout << " tbbctl --templimits=high,low [--select=<set>] # set temp limts for fan control" << endl;
+ cout << " tbbctl --clear [--select=<set>] # clear selected board" << endl;
+ cout << " tbbctl --reset [--select=<set>] # reset to factory images on selected boards" << endl;
+ cout << endl;
+ cout << " tbbctl --help # this help screen" << endl;
+ cout << "< < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < < " << endl;
+ cout << endl;
}
//-----------------------------------------------------------------------------
//====END OF COMMANDS==========================================================================
//-----------------------------------------------------------------------------
TBBCtl::TBBCtl(string name, int argc, char** argv): GCFTask((State)&TBBCtl::initial, name),
- itsCommand(0),itsActiveBoards(0),itsMaxBoards(0),itsMaxChannels(0),itsArgc(argc),itsArgv(argv)
+ itsCommand(0),itsActiveBoards(0),itsMaxBoards(0),itsMaxChannels(0),itsArgc(argc),itsArgv(argv)
{
- for(int boardnr = 0; boardnr < MAX_N_TBBBOARDS; boardnr++) {
- itsMemory[boardnr] = 0;
- }
+ for(int boardnr = 0; boardnr < MAX_N_TBBOARDS; boardnr++) {
+ itsMemory[boardnr] = 0;
+ }
registerProtocol (TBB_PROTOCOL, TBB_PROTOCOL_STRINGS);
- itsServerPort.init(*this, MAC_SVCMASK_TBBDRIVER, GCFPortInterface::SAP, TBB_PROTOCOL);
- itsCmdTimer = new GCFTimerPort(*this, "AliveTimer");
+ itsServerPort.init(*this, MAC_SVCMASK_TBBDRIVER, GCFPortInterface::SAP, TBB_PROTOCOL);
+ itsCmdTimer = new GCFTimerPort(*this, "AliveTimer");
}
//-----------------------------------------------------------------------------
TBBCtl::~TBBCtl()
{
- if (itsCommand) { delete itsCommand; }
- if (itsCmdTimer) { delete itsCmdTimer; }
+ if (itsCommand) { delete itsCommand; }
+ if (itsCmdTimer) { delete itsCmdTimer; }
}
//-----------------------------------------------------------------------------
@@ -2285,12 +2284,12 @@ GCFEvent::TResult TBBCtl::initial(GCFEvent& e, GCFPortInterface& port)
switch (e.signal) {
case F_INIT: {
- } break;
+ } break;
case F_ENTRY: {
- if (!itsServerPort.isConnected()) {
- itsServerPort.open();
- itsServerPort.setTimer(DELAY);
+ if (!itsServerPort.isConnected()) {
+ itsServerPort.open();
+ itsServerPort.setTimer(DELAY);
}
} break;
@@ -2302,33 +2301,34 @@ GCFEvent::TResult TBBCtl::initial(GCFEvent& e, GCFPortInterface& port)
}
} break;
- case TBB_DRIVER_BUSY_ACK: {
- cout << endl << "=x=x= DRIVER BUSY, try again =x=x=" << endl << flush;
- GCFTask::stop();
+ case TBB_DRIVER_BUSY_ACK: {
+ cout << endl << "=x=x= DRIVER BUSY, try again =x=x=" << endl << flush;
+ GCFTask::stop();
}
case TBB_GET_CONFIG_ACK: {
TBBGetConfigAckEvent ack(e);
- itsMaxBoards = ack.max_boards;
- itsActiveBoards = ack.active_boards_mask;
- itsMaxChannels = itsMaxBoards * 16;
+ itsMaxBoards = ack.max_boards;
+ itsActiveBoards = ack.active_boards_mask;
+ itsMaxChannels = itsMaxBoards * 16;
+
//cout << endl;
//cout << formatString("Max nr of TBB boards = %d",itsMaxBoards) << endl;
- //cout << formatString("Max nr of Channels = %d",itsMaxChannels)//cout << endl;;
- //cout << endl;
- //cout << formatString("Active boards mask = 0x%03X",itsActiveBoards)//cout << endl;;
-
- // send subscribe
+ //cout << formatString("Max nr of Channels = %d",itsMaxChannels)//cout << endl;;
+ //cout << endl;
+ //cout << formatString("Active boards mask = 0x%03X",itsActiveBoards)//cout << endl;;
+
+ // send subscribe
TBBSubscribeEvent subscribe;
- subscribe.triggers = false;
- subscribe.hardware = true;
+ subscribe.triggers = false;
+ subscribe.hardware = true;
itsServerPort.send(subscribe);
} break;
-
- case TBB_SUBSCRIBE_ACK: {
- TRAN(TBBCtl::docommand);
- } break;
-
+
+ case TBB_SUBSCRIBE_ACK: {
+ TRAN(TBBCtl::docommand);
+ } break;
+
case F_DISCONNECTED: {
//port.setTimer(DELAY);
port.close();
@@ -2338,7 +2338,7 @@ GCFEvent::TResult TBBCtl::initial(GCFEvent& e, GCFPortInterface& port)
// try again
cout << " =x=x=x=x=x=x=x=x=x=x=x=x=x=x=x=x=x=x=x=x=x=x=x=x=x=x=" << endl;
cout << " =x= TBBDriver is NOT responding =x=" << endl;
- cout << " =x=x=x=x=x=x=x=x=x=x=x=x=x=x=x=x=x=x=x=x=x=x=x=x=x=x=" << endl;
+ cout << " =x=x=x=x=x=x=x=x=x=x=x=x=x=x=x=x=x=x=x=x=x=x=x=x=x=x=" << endl;
//itsServerPort.open();
exit(EXIT_FAILURE);
} break;
@@ -2359,10 +2359,10 @@ GCFEvent::TResult TBBCtl::docommand(GCFEvent& e, GCFPortInterface& port)
switch (e.signal) {
case F_INIT: {
- } break;
-
+ } break;
+
case F_ENTRY: {
- // reparse options
+ // reparse options
itsCommand = parse_options(itsArgc, itsArgv);
if (itsCommand == 0) {
cout << "Warning: no command specified." << endl;
@@ -2379,35 +2379,35 @@ GCFEvent::TResult TBBCtl::docommand(GCFEvent& e, GCFPortInterface& port)
cout << formatString("Error: port '%s' disconnected.",port.getName().c_str()) << endl;
exit(EXIT_FAILURE);
} break;
-
- case F_TIMER: {
- if (&port == itsCmdTimer) {
- itsCommand->send();
- } else {
- cout << "Timeout, tbbctl stopped" << endl;
- cout << endl;
- TBBUnsubscribeEvent unsubscribe;
- itsServerPort.send(unsubscribe);
- GCFTask::stop();
- }
- } break;
+
+ case F_TIMER: {
+ if (&port == itsCmdTimer) {
+ itsCommand->send();
+ } else {
+ cout << "Timeout, tbbctl stopped" << endl;
+ cout << endl;
+ TBBUnsubscribeEvent unsubscribe;
+ itsServerPort.send(unsubscribe);
+ GCFTask::stop();
+ }
+ } break;
case TBB_BOARDCHANGE: {
} break;
case TBB_DRIVER_BUSY_ACK: {
- cout << "DRIVER BUSY, try again" << endl << flush;
- GCFTask::stop();
+ cout << "DRIVER BUSY, try again" << endl << flush;
+ GCFTask::stop();
}
-
+
case TBB_ALLOC_ACK:
case TBB_RCU_INFO_ACK:
case TBB_FREE_ACK:
case TBB_RECORD_ACK:
case TBB_STOP_ACK:
- case TBB_TRIG_SETTINGS_ACK:
+ case TBB_TRIG_SETTINGS_ACK:
case TBB_TRIG_RELEASE_ACK:
- case TBB_TRIG_SETUP_ACK:
+ case TBB_TRIG_SETUP_ACK:
case TBB_TRIG_COEF_ACK:
case TBB_TRIG_GENERATE_ACK:
case TBB_TRIG_INFO_ACK:
@@ -2431,15 +2431,15 @@ GCFEvent::TResult TBBCtl::docommand(GCFEvent& e, GCFPortInterface& port)
case TBB_READX_ACK:
case TBB_SUBSCRIBE_ACK:
case TBB_ARP_ACK:
- case TBB_ARP_MODE_ACK:
- case TBB_STOP_CEP_ACK:
- case TBB_TEMP_LIMIT_ACK: {
- itsServerPort.cancelAllTimers();
- status = itsCommand->ack(e); // handle the acknowledgement
- if (!itsCommand->isCmdDone() && itsCommand->isCmdSendNext()) {
- // not done send next command
- itsCmdTimer->setTimer((long)0);
- }
+ case TBB_ARP_MODE_ACK:
+ case TBB_STOP_CEP_ACK:
+ case TBB_TEMP_LIMIT_ACK: {
+ itsServerPort.cancelAllTimers();
+ status = itsCommand->ack(e); // handle the acknowledgement
+ if (!itsCommand->isCmdDone() && itsCommand->isCmdSendNext()) {
+ // not done send next command
+ itsCmdTimer->setTimer(0.0);
+ }
} break;
default: {
@@ -2450,772 +2450,772 @@ GCFEvent::TResult TBBCtl::docommand(GCFEvent& e, GCFPortInterface& port)
GCFTask::stop();
} break;
}
-
- if (itsCommand->isCmdDone()) {
- //TBBUnsubscribeEvent unsubscribe;
+
+ if (itsCommand->isCmdDone()) {
+ //TBBUnsubscribeEvent unsubscribe;
//itsServerPort.send(unsubscribe);
cout << flush;
GCFTask::stop();
}
-
+
return(status);
}
//-----------------------------------------------------------------------------
Command* TBBCtl::parse_options(int argc, char** argv)
{
- Command* command = 0;
+ Command* command = 0;
std::list<int> select;
optind = 0; // reset option parsing
//opterr = 0; // no error reporting to stderr
while(1) {
- static struct option long_options[] = {
- { "select", required_argument, 0, 'l' },
- { "alloc", no_argument, 0, 'a' },
- { "rcuinfo", no_argument, 0, 'i' },
- { "free", no_argument, 0, 'f' },
- { "record", no_argument, 0, 'r' },
- { "stop", no_argument, 0, 's' },
- { "settings", no_argument, 0, 'b' },
- { "release", no_argument, 0, 'e' },
- { "generate", no_argument, 0, 'g' },
- { "setup", required_argument, 0, 't' },
- { "coef", required_argument, 0, 'c' },
- { "triginfo", required_argument, 0, 'I' },
- { "listen", optional_argument, 0, 'L' },
- { "read", required_argument, 0, 'R' },
- { "mode", required_argument, 0, 'm' },
- { "version", no_argument, 0, 'v' },
- { "size", no_argument, 0, 'z' },
- { "status", no_argument, 0, 'A' },
- { "readpage", required_argument, 0, 'p' },
- { "arp", no_argument, 0, 'D' },
- { "arpmode", required_argument, 0, 'E' },
- { "stopcep", no_argument, 0, 'F' },
- { "templimits", required_argument, 0, 'G' },
- { "clear", no_argument, 0, 'C' },
- { "reset", no_argument, 0, 'Z' },
- { "config", required_argument, 0, 'S' },
- { "eraseimage", required_argument, 0, '1' },
- { "readimage", required_argument, 0, '2' },
- { "writeimage", required_argument, 0, '3' },
- { "imageinfo", required_argument, 0, '8' },
- { "readddr", required_argument, 0, '4' },
- { "writeddr", required_argument, 0, '5' },
- { "testddr", required_argument, 0, '9' },
- { "readreg", required_argument, 0, '6' },
- { "writereg", required_argument, 0, '7' },
- { "help", no_argument, 0, 'h' },
- { "expert", no_argument, 0, 'X' },
- { 0, 0, 0, 0 },
- };
+ static struct option long_options[] = {
+ { "select", required_argument, 0, 'l' },
+ { "alloc", no_argument, 0, 'a' },
+ { "rcuinfo", no_argument, 0, 'i' },
+ { "free", no_argument, 0, 'f' },
+ { "record", no_argument, 0, 'r' },
+ { "stop", no_argument, 0, 's' },
+ { "settings", no_argument, 0, 'b' },
+ { "release", no_argument, 0, 'e' },
+ { "generate", no_argument, 0, 'g' },
+ { "setup", required_argument, 0, 't' },
+ { "coef", required_argument, 0, 'c' },
+ { "triginfo", required_argument, 0, 'I' },
+ { "listen", optional_argument, 0, 'L' },
+ { "read", required_argument, 0, 'R' },
+ { "mode", required_argument, 0, 'm' },
+ { "version", no_argument, 0, 'v' },
+ { "size", no_argument, 0, 'z' },
+ { "status", no_argument, 0, 'A' },
+ { "readpage", required_argument, 0, 'p' },
+ { "arp", no_argument, 0, 'D' },
+ { "arpmode", required_argument, 0, 'E' },
+ { "stopcep", no_argument, 0, 'F' },
+ { "templimits", required_argument, 0, 'G' },
+ { "clear", no_argument, 0, 'C' },
+ { "reset", no_argument, 0, 'Z' },
+ { "config", required_argument, 0, 'S' },
+ { "eraseimage", required_argument, 0, '1' },
+ { "readimage", required_argument, 0, '2' },
+ { "writeimage", required_argument, 0, '3' },
+ { "imageinfo", required_argument, 0, '8' },
+ { "readddr", required_argument, 0, '4' },
+ { "writeddr", required_argument, 0, '5' },
+ { "testddr", required_argument, 0, '9' },
+ { "readreg", required_argument, 0, '6' },
+ { "writereg", required_argument, 0, '7' },
+ { "help", no_argument, 0, 'h' },
+ { "expert", no_argument, 0, 'X' },
+ { 0, 0, 0, 0 },
+ };
int option_index = 0;
int c = getopt_long(argc, argv,
- "l:afrsbegt:c:I:L::R:m:vzAp:DE:FG:CZS:1:2:3:8:4:5:9:6:7:hX",
- long_options, &option_index);
-
+ "l:afrsbegt:c:I:L::R:m:vzAp:DE:FG:CZS:1:2:3:8:4:5:9:6:7:hX",
+ long_options, &option_index);
+
if (c == -1) {
- break;
- }
-
- switch (c) {
-
- case 'l': { // --select
- if (!command->isSelectionDone()) {
- if (optarg) {
- if (!command) {
- cout << "Error: 'command' argument should come before --select argument" << endl;
- exit(EXIT_FAILURE);
- }
- select = strtolist(optarg, command->getMaxSelections());
-
- if (select.empty()) {
- cout << "Error: invalid or missing '--select' option" << endl;
- exit(EXIT_FAILURE);
- } else {
- command->setSelected(true);
- }
- } else {
- cout << "Error: option '--select' requires an argument" << endl;
- exit(EXIT_FAILURE);
- }
- } else {
- cout << "Error: channels already selected" << endl;
- }
- } break;
-
- case 'a': { // --alloc
- if (command) delete command;
- AllocCmd* alloccmd = new AllocCmd(itsServerPort);
- command = alloccmd;
- command->setCmdType(RCUCMD);
- } break;
-
- case 'i': { // --channelinfo
- if (command) delete command;
- ChannelInfoCmd* channelinfocmd = new ChannelInfoCmd(itsServerPort);
- command = channelinfocmd;
- command->setCmdType(RCUCMD);
- } break;
-
- case 'f': { // --free
- if (command) delete command;
- FreeCmd* freecmd = new FreeCmd(itsServerPort);
- command = freecmd;
- command->setCmdType(RCUCMD);
- } break;
-
- case 'r': { // --record
- if (command) delete command;
- RecordCmd* recordcmd = new RecordCmd(itsServerPort);
- command = recordcmd;
- command->setCmdType(RCUCMD);
- } break;
-
- case 's': { // --stop
- if (command) delete command;
- StopCmd* stopcmd = new StopCmd(itsServerPort);
- command = stopcmd;
- command->setCmdType(RCUCMD);
- } break;
-
- case 'b': {
- if (command) delete command;
- TriggerSettingsCmd* trigsettingscmd = new TriggerSettingsCmd(itsServerPort);
- command = trigsettingscmd;
- command->setCmdType(RCUCMD);
- } break;
-
- case 'e': { // --trigrelease
- if (command) delete command;
- TrigReleaseCmd* trigreleasecmd = new TrigReleaseCmd(itsServerPort);
- command = trigreleasecmd;
- if (optarg) {
- int rcu = 0;
- int numitems = sscanf(optarg, "%d",&rcu);
- if (numitems == 0 || numitems == EOF || rcu < 0 || rcu >= MAX_N_RCUS) {
- cout << "Error: invalid number of arguments. Should be of the format " << endl;
- cout << " '--trigclr=rcu' " << endl;
- exit(EXIT_FAILURE);
- }
- select.clear();
- select.push_back(rcu);
- command->setSelected(true);
- }
-
- command->setCmdType(RCUCMD);
- } break;
-
- case 'g': { // --triggenerate
- if (command) delete command;
- TrigGenerateCmd* triggeneratecmd = new TrigGenerateCmd(itsServerPort);
- command = triggeneratecmd;
- command->setCmdType(RCUCMD);
- } break;
-
- case 't': { // --trigsetup
- if (command) delete command;
- TrigSetupCmd* trigsetupcmd = new TrigSetupCmd(itsServerPort);
- command = trigsetupcmd;
-
- if (optarg) {
- uint32 level = 0;
- uint32 start = 0;
- uint32 stop = 0;
- uint32 filter = 0;
- uint32 window = 0;
- uint32 triggermode = 0;
-
- int numitems = sscanf(optarg, "%u,%u,%u,%u,%u,%u",&level, &start, &stop, &filter, &window, &triggermode);
- // check if valid arguments
- if ( numitems < 6 || numitems == EOF
- || level < 1 || level > 255
- || start < 1 || start > 15
- || stop < 1 || stop > 15
- || window > 6
- || triggermode > 1)
- {
- cout << "Error: invalid number of arguments. Should be of the format " << endl;
- cout << " '--trigsetup=level, start, stop, filter, window, mode' (use decimal values)" << endl;
- cout << " level=1..255, start=1..15, stop=1..15, filter=0(on) or 1(off)" << endl;
- cout << " window=0..6, mode=0(single shot) or 1(continues, don't use this mode)" << endl;
- exit(EXIT_FAILURE);
- }
-
- //================================================
- // set triggermode to single shot, continues mode
- // will give more than 6000 triggers per second per
- // board, if level is chosen to low, the driver can't
- // handle that amount of trigger per board.
- if (triggermode == 1) {
- cout << "mode=1 can generate to many triggers, auto corrected to mode=0(single-shot)" << endl;
- }
- triggermode = 0;
- //================================================
-
-
- trigsetupcmd->setLevel(static_cast<uint16>(level));
- trigsetupcmd->setStartMode(static_cast<uint8>(start));
- trigsetupcmd->setStopMode(static_cast<uint8>(stop));
- trigsetupcmd->setFilter(static_cast<uint8>(filter));
- trigsetupcmd->setWindow(static_cast<uint8>(window));
- trigsetupcmd->setOperatingMode(0);
- trigsetupcmd->setTriggerMode(static_cast<uint16>(triggermode));
- }
-
- command->setCmdType(RCUCMD);
- } break;
-
- case 'c': { // --trigcoef
- if (command) delete command;
- TrigCoefficientCmd* trigcoefficientcmd = new TrigCoefficientCmd(itsServerPort);
- command = trigcoefficientcmd;
- if (optarg) {
- uint32 c0 = 0;
- uint32 c1 = 0;
- uint32 c2 = 0;
- uint32 c3 = 0;
- int numitems = sscanf(optarg, "%u,%u,%u,%u",&c0, &c1, &c2, &c3);
- if (numitems < 4 || numitems == EOF) {
- cout << "Error: invalid number of arguments. Should be of the format " << endl;
- cout << " '--trigcoef=c0, c1, c2, c3' (use decimal values)" << endl;
- cout << " co, c1, c2, c3=16bit value"<< endl;
- exit(EXIT_FAILURE);
- }
- trigcoefficientcmd->setC0(static_cast<uint16>(c0));
- trigcoefficientcmd->setC1(static_cast<uint16>(c1));
- trigcoefficientcmd->setC2(static_cast<uint16>(c2));
- trigcoefficientcmd->setC3(static_cast<uint16>(c3));
- }
- command->setCmdType(RCUCMD);
- } break;
-
- case 'I': { // --triginfo
- if (command) delete command;
- TrigInfoCmd* triginfocmd = new TrigInfoCmd(itsServerPort);
- command = triginfocmd;
- if (optarg) {
- int rcu = 0;
- int numitems = sscanf(optarg, "%d",&rcu);
- if (numitems < 1 || numitems == EOF) {
- cout << "Error: invalid number of arguments. Should be of the format " << endl;
- cout << " '--triginfo=rcu' " << endl;
- cout << " rcu=0.." << (MAX_N_RCUS - 1) << endl;
- exit(EXIT_FAILURE);
- }
- select.clear();
- select.push_back(rcu);
- command->setSelected(true);
- }
- command->setCmdType(RCUCMD);
- } break;
-
- case 'L': { // --listen
- if (command) delete command;
- ListenCmd* listencmd = new ListenCmd(itsServerPort);
- command = listencmd;
- char listen_mode[64];
- if (optarg) {
- strcpy(listen_mode,"one_shot");
- sscanf(optarg, "%s", listen_mode);
- if ((strcmp(listen_mode,"one_shot") != 0 && strcmp(listen_mode,"continues") != 0)) {
- cout << "Error: invalid argument. Should be of the format " << endl;
- cout << " '--listen=[one_shot | continues]'" << endl;
- exit(EXIT_FAILURE);
- }
- }
- if (strcmp(listen_mode,"one_shot") == 0) {
- listencmd->setListenMode(TBB_LISTEN_ONE_SHOT);
- }
- if (strcmp(listen_mode,"continues") == 0) {
- listencmd->setListenMode(TBB_LISTEN_CONTINUES);
- }
- command->setCmdType(RCUCMD);
- } break;
-
- case 'R': { // --read
- if (command) delete command;
- ReadCmd* readcmd = new ReadCmd(itsServerPort);
- command = readcmd;
-
- if (optarg) {
- int rcu = 0;
- uint32 secondstime = 0;
- uint32 sampletime = 0;
- uint32 prepages = 0;
- uint32 postpages = 0;
- int numitems = sscanf(optarg, "%d,%u,%u,%u,%u",
- &rcu, &secondstime, &sampletime, &prepages, &postpages);
- if (numitems < 5 || numitems == EOF || rcu < 0 || rcu >= MAX_N_RCUS) {
- cout << "Error: invalid number of arguments. Should be of the format " << endl;
- cout << " '--read=rcu,secondstime,sampletime,prepages,postpages' " << endl;
- cout << " rcu=0.." << (MAX_N_RCUS - 1) << ", time = secondstime + (sampletime * sample-interval) "<< endl;
- exit(EXIT_FAILURE);
- }
- readcmd->setSecondsTime(secondstime);
- readcmd->setSampleTime(sampletime);
- readcmd->setPrePages(prepages);
- readcmd->setPostPages(postpages);
-
- select.clear();
- select.push_back(rcu);
- command->setSelected(true);
- }
- command->setCmdType(RCUCMD);
- } break;
-
- case 'm': { // --mode
- if (command) delete command;
- ModeCmd* modecmd = new ModeCmd(itsServerPort);
- command = modecmd;
- if (optarg) {
- char rec_mode[64];
- int numitems = sscanf(optarg, "%s",
- rec_mode);
- if (numitems < 1 || numitems == EOF ||(strcmp(rec_mode,"transient") != 0 && strcmp(rec_mode,"subbands") != 0)) {
- cout << "Error: invalid number of arguments. Should be of the format " << endl;
- cout << " '--udp=rec_mode'" << endl;
- cout << " rec_mode=transient or subbands" << endl;
- exit(EXIT_FAILURE);
- }
-
- if (strcmp(rec_mode,"transient") == 0)
- modecmd->setRecMode(TBB_MODE_TRANSIENT);
- if (strcmp(rec_mode,"subbands") == 0)
- modecmd->setRecMode(TBB_MODE_SUBBANDS);
- }
- command->setCmdType(BOARDCMD);
- } break;
-
- case 'v': { // --version
- if (command) delete command;
- VersionCmd* versioncmd = new VersionCmd(itsServerPort);
- command = versioncmd;
- command->setCmdType(BOARDCMD);
- } break;
-
- case 'z': { // --size
- if (command) delete command;
- SizeCmd* sizecmd = new SizeCmd(itsServerPort);
- command = sizecmd;
- command->setCmdType(BOARDCMD);
- } break;
-
- case 'A': { // --status
- if (command) delete command;
- StatusCmd* statuscmd = new StatusCmd(itsServerPort);
- command = statuscmd;
- command->setCmdType(BOARDCMD);
- } break;
-
- case 'C': { // --clear
- if (command) delete command;
- ClearCmd* clearcmd = new ClearCmd(itsServerPort);
- command = clearcmd;
- command->setCmdType(BOARDCMD);
- } break;
-
- case 'Z': { // --reset
- if (command) delete command;
- ResetCmd* resetcmd = new ResetCmd(itsServerPort);
- command = resetcmd;
- command->setCmdType(BOARDCMD);
- } break;
-
- case 'D': { // --arp
- if (command) delete command;
- ArpCmd* arpcmd = new ArpCmd(itsServerPort);
- command = arpcmd;
- command->setCmdType(BOARDCMD);
- } break;
-
- case 'E': { // --arpmode
- if (command) delete command;
- ArpModeCmd* arpmodecmd = new ArpModeCmd(itsServerPort);
- command = arpmodecmd;
- if (optarg) {
- int32 mode = 0;
- int numitems = sscanf(optarg, "%d", &mode);
- if (numitems == 0 || numitems == EOF || mode < 0 || mode > 1) {
- cout << "Error: invalid mode value. Should be of the format " << endl;
- cout << " '--arpmode=mode'" << endl;
- cout << " mode=0 or 1" << endl;
- exit(EXIT_FAILURE);
- }
- arpmodecmd->setMode((uint32)mode);
- }
- command->setCmdType(BOARDCMD);
- } break;
-
- case 'F': { // --stopcep
- if (command) delete command;
- StopCepCmd* stopcepcmd = new StopCepCmd(itsServerPort);
- command = stopcepcmd;
- command->setCmdType(BOARDCMD);
- } break;
-
- case 'G': { // --templimits
- if (command) delete command;
- TempLimitCmd* templimitscmd = new TempLimitCmd(itsServerPort);
- command = templimitscmd;
- if (optarg) {
- int32 high = 0;
- int32 low = 0;
- int numitems = sscanf(optarg, "%d,%d", &high, &low);
- if (numitems == 0 || numitems == EOF) {
- cout << "Error: invalid number of values. Should be of the format " << endl;
- cout << " '--templimits=high,low'" << endl;
- exit(EXIT_FAILURE);
- }
- templimitscmd->setLimitHigh((uint32)high);
- templimitscmd->setLimitLow((uint32)low);
- }
- command->setCmdType(BOARDCMD);
- } break;
-
-
-
- case 'S': { // --config
- if (command) delete command;
- ConfigCmd* configcmd = new ConfigCmd(itsServerPort);
- command = configcmd;
-
- if (optarg) {
- int32 imagenr = 0;
- int numitems = sscanf(optarg, "%d", &imagenr);
- if (numitems == 0 || numitems == EOF || imagenr < 0 || imagenr >= FL_N_IMAGES) {
- cout << "Error: invalid image value. Should be of the format " << endl;
- cout << " '--config=imagenr'" << endl;
- cout << " imagenr=0..15" << endl;
- exit(EXIT_FAILURE);
- }
- configcmd->setImage((uint32)imagenr);
- }
-
- command->setCmdType(BOARDCMD);
- } break;
-
- case 'p': { // --readpage
- if (command) delete command;
- ReadPageCmd* readddrcmd = new ReadPageCmd(itsServerPort);
- command = readddrcmd;
-
- if (optarg) {
- int32 rcu = 0;
- uint32 startpage = 0;
- uint32 pages = 0;
-
- int numitems = sscanf(optarg, "%d,%u,%u", &rcu,&startpage,&pages);
-
- if (numitems < 3 || numitems == EOF || rcu < 0 || rcu >= MAX_N_RCUS) {
- cout << "Error: invalid readpage value's. Should be of the format " << endl;
- cout << " '--readpage=rcu, startpage, pages'" << endl;
- cout << " rcu=0.." << (MAX_N_RCUS - 1) << endl;
- exit(EXIT_FAILURE);
- }
- readddrcmd->setStartPage(startpage);
- readddrcmd->setPages(pages);
- select.clear();
- select.push_back(rcu);
- command->setSelected(true);
- }
- command->setCmdType(BOARDCMD);
- } break;
-
- case '1': { // --erasef
- if (command) delete command;
- ErasefCmd* erasefcmd = new ErasefCmd(itsServerPort);
- command = erasefcmd;
- if (optarg) {
- int board = 0;
- int page = 0;
- int numitems = sscanf(optarg, "%d,%d", &board, &page);
-
- if (numitems < 2 || numitems == EOF || page < 0 || page >= FL_N_IMAGES || board < 0 || board >= MAX_N_TBBBOARDS) {
- cout << "Error: invalid page value. Should be of the format " << endl;
- cout << " '--eraseimage=board, image'" << endl;
- cout << " board=0.." << (MAX_N_TBBBOARDS - 1) << ", image=0..15" << endl;
- exit(EXIT_FAILURE);
- }
- erasefcmd->setPage(page);
- select.clear();
- select.push_back(board);
- command->setSelected(true);
- }
- command->setCmdType(BOARDCMD);
- } break;
-
- case '2': { // --readf
- if (command) delete command;
- ReadfCmd* readfcmd = new ReadfCmd(itsServerPort);
- command = readfcmd;
- if (optarg) {
- int board = 0;
- int page = 0;
- int numitems = sscanf(optarg, "%d,%d", &board, &page);
-
- if (numitems < 2 || numitems == EOF || page < 0 || page >= FL_N_IMAGES || board < 0 || board >= MAX_N_TBBBOARDS) {
- cout << "Error: invalid image value. Should be of the format " << endl;
- cout << " '--readimage=board, image'"<< endl;
- cout << " board=0.." << (MAX_N_TBBBOARDS - 1) << ", image=0..31" << endl;
- exit(EXIT_FAILURE);
- }
- readfcmd->setPage(page);
- select.clear();
- select.push_back(board);
- command->setSelected(true);
- }
- command->setCmdType(BOARDCMD);
- } break;
-
- case '3': { // --writef
- if (command) delete command;
- WritefCmd* writefcmd = new WritefCmd(itsServerPort);
- command = writefcmd;
- if (optarg) {
- int board = 0;
- int page = 0;
- double version = 0;
- char filename_tp[64];
- char filename_mp[64];
- memset(filename_tp,0,64);
- memset(filename_mp,0,64);
-
- int numitems = sscanf(optarg, "%d,%d,%lf,%63[^,],%63[^,]", &board, &page, &version, filename_tp, filename_mp);
- if (numitems < 5 || numitems == EOF || page < 0 || page >= FL_N_IMAGES || board < 0 || board >= MAX_N_TBBBOARDS) {
- cout << "Error: invalid values. Should be of the format " << endl;
- cout << " '--writeimage=board, image, file-tp, file-mp'"<< endl;
- cout << " board=0.." << (MAX_N_TBBBOARDS - 1) << ", image=0..31" << endl;
- exit(EXIT_FAILURE);
- }
-
- writefcmd->setPage(page);
- writefcmd->setVersion(version);
- writefcmd->setFileNameTp(filename_tp);
- writefcmd->setFileNameMp(filename_mp);
-
- select.clear();
- select.push_back(board);
- command->setSelected(true);
- }
- command->setCmdType(BOARDCMD);
- } break;
-
- case '8': { // --imageinfo
- if (command) delete command;
- ImageInfoCmd* imageinfocmd = new ImageInfoCmd(itsServerPort);
- command = imageinfocmd;
- if (optarg) {
- int board = 0;
- int numitems = sscanf(optarg, "%d", &board);
- if (numitems < 1 || numitems == EOF || board < 0 || board >= MAX_N_TBBBOARDS) {
- cout << "Error: invalid values. Should be of the format " << endl;
- cout << " '--imageinfo=board'"<< endl;
- cout << " board=0.." << (MAX_N_TBBBOARDS - 1) << endl;
- exit(EXIT_FAILURE);
- }
- select.clear();
- select.push_back(board);
- command->setSelected(true);
- }
- command->setCmdType(BOARDCMD);
- } break;
-
- case '4': { // --readw
- if (command) delete command;
- ReadwCmd* readwcmd = new ReadwCmd(itsServerPort);
- command = readwcmd;
-
- if (optarg) {
- int board = 0;
- uint32 mp = 0;
- uint32 startaddr = 0;
- uint32 size = 0;
-
- int numitems = sscanf(optarg, "%d,%x,%x,%x", &board,&mp,&startaddr, &size);
-
- if (numitems < 3 || numitems == EOF || board < 0 || board >= MAX_N_TBBBOARDS || mp > 3) {
- cout << "Error: invalid read ddr value. Should be of the format " << endl;
- cout << " '--readw=board, mp, addr'" << endl;
- cout << " board=0.." << (MAX_N_TBBBOARDS - 1) << ", mp=0..3, addr=0x.." << endl;
- exit(EXIT_FAILURE);
- }
- readwcmd->setMp(mp);
- readwcmd->setStartAddr(startaddr);
- readwcmd->setStopAddr(startaddr+size);
- select.clear();
- select.push_back(board);
- command->setSelected(true);
- }
- command->setCmdType(BOARDCMD);
- } break;
-
- case '5': { // --writew
- if (command) delete command;
- WritewCmd* writewcmd = new WritewCmd(itsServerPort);
- command = writewcmd;
- if (optarg) {
- int32 board = 0;
- int32 mp = 0;
- uint32 addr = 0;
- uint32 wordlo = 0;
- uint32 wordhi = 0;
-
- int numitems = sscanf(optarg, "%d,%d,%x,%x,%x", &board,&mp,&addr,&wordlo,&wordhi);
- if (numitems < 5 || numitems == EOF || board < 0 || board >= MAX_N_TBBBOARDS || mp > 3) {
- cout << "Error: invalid write ddr value. Should be of the format " << endl;
- cout << " '--writew=board, mp, addr, wordlo, wordhi'"<< endl;
- cout << " board=0.." << (MAX_N_TBBBOARDS - 1) << ", mp=0..3, addr=0x.., wordlo=0x.., wordhi=0x.." << endl;
- exit(EXIT_FAILURE);
- }
- writewcmd->setMp(mp);
- writewcmd->setAddr(addr);
- writewcmd->setWordLo(wordlo);
- writewcmd->setWordHi(wordhi);
- select.clear();
- select.push_back(board);
- command->setSelected(true);
- }
- command->setCmdType(BOARDCMD);
- } break;
-
- case '9': { // --testddr
- if (command) delete command;
- TestDdrCmd* testddrcmd = new TestDdrCmd(itsServerPort);
- command = testddrcmd;
- if (optarg) {
- int32 board = 0;
-
- int numitems = sscanf(optarg, "%d", &board);
- if (numitems < 1 || numitems == EOF || board < 0 || board >= MAX_N_TBBBOARDS) {
- cout << "Error: invalid write ddr value. Should be of the format " << endl;
- cout << " '--testddr=board' "<< endl;
- cout << " board=0.." << (MAX_N_TBBBOARDS - 1) << endl;
- exit(EXIT_FAILURE);
- }
- select.clear();
- select.push_back(board);
- command->setSelected(true);
- }
- command->setCmdType(BOARDCMD);
- } break;
-
- case '6': { // --readr
- if (command) delete command;
- ReadrCmd* readrcmd = new ReadrCmd(itsServerPort);
- command = readrcmd;
-
- if (optarg) {
- int32 board = 0;
- uint32 mp = 0;
- uint32 pid = 0;
- uint32 regid = 0;
-
- int numitems = sscanf(optarg, "%d,%u,%u,%u", &board, &mp, &pid, ®id);
-
- if (numitems < 4 || numitems == EOF || board < 0 || board >= MAX_N_TBBBOARDS || mp > 3 || pid > 7 || regid > 7) {
- cout << "Error: invalid read register value. Should be of the format" << endl;
- cout << " '--readreg=board, mp, pid, regid'" << endl;
- cout << " board=0.." << (MAX_N_TBBBOARDS - 1) << ", mp=0..3, pid=0..7, regid=0..7" << endl;
- exit(EXIT_FAILURE);
- }
- if ((REG_TABLE_3[pid][regid] == REG_WRITE_ONLY) || (REG_TABLE_3[pid][regid] == REG_NOT_USED)) {
- cerr << "reading not posible on selected register" << endl;
- exit(EXIT_FAILURE);
- }
- readrcmd->setMp(mp);
- readrcmd->setPid(pid);
- readrcmd->setRegId(regid);
-
- select.clear();
- select.push_back(board);
- command->setSelected(true);
- }
-
- command->setCmdType(BOARDCMD);
- } break;
-
- case '7': { // --writer
- if (command) delete command;
- WriterCmd* writercmd = new WriterCmd(itsServerPort);
- command = writercmd;
-
- if (optarg) {
- int32 board = 0;
- uint32 mp = 0;
- uint32 pid = 0;
- uint32 regid = 0;
- char datastr[256];
-
- int numitems = sscanf(optarg, "%d,%u,%u,%u,%s", &board, &mp, &pid, ®id, datastr);
- if (numitems < 5 || numitems == EOF || board < 0 || board >= MAX_N_TBBBOARDS || mp > 3 || pid > 7 || regid > 7) {
- cout << "Error: invalid write register value. Should be of the format " << endl;
- cout << " '--writereg=board, mp, pid, regid, data1, data2 etc.'" << endl;
- cout << " board=0.." << (MAX_N_TBBBOARDS - 1) << ", mp=0..3, pid=0..7, regid=0..7" << endl;
- exit(EXIT_FAILURE);
- }
- if ((REG_TABLE_3[pid][regid] == REG_READ_ONLY) || (REG_TABLE_3[pid][regid] == REG_NOT_USED)) {
- cerr << "writing not posible on selected register" << endl;
- exit(EXIT_FAILURE);
- }
- writercmd->setMp(mp);
- writercmd->setPid(pid);
- writercmd->setRegId(regid);
-
- char* dstr;
- uint32 val = 0;
- int wordcnt = 0;
-
- dstr = strtok (datastr," ,");
- while (dstr != NULL)
- {
- val = strtol(dstr,NULL,16);
- //cout << formatString("%08x ",val);
- writercmd->setData(wordcnt,val);
- wordcnt++;
- dstr = strtok (NULL, " ,");
- }
- cout << endl;
- select.clear();
- select.push_back(board);
- command->setSelected(true);
- }
-
- command->setCmdType(BOARDCMD);
- } break;
-
- case 'h':
- case '?': {
- commandHelp(1);
- exit(0);
- } break;
-
- case 'X': {
- commandHelp(3);
- exit(0);
- } break;
-
- default:
- {
- commandHelp(1);
- exit(EXIT_FAILURE);
- } break;
- }
- }
-
- if (command) {
- if (!command->isSelectionDone()) { // --select not used, select all
- select.clear();
- for (int i = 0; i < command->getMaxSelections(); i++) {
- select.push_back(i);
- }
- command->setSelected(true);
- }
- command->setSelect(select);
- }
+ break;
+ }
+
+ switch (c) {
+
+ case 'l': { // --select
+ if (!command->isSelectionDone()) {
+ if (optarg) {
+ if (!command) {
+ cout << "Error: 'command' argument should come before --select argument" << endl;
+ exit(EXIT_FAILURE);
+ }
+ select = strtolist(optarg, command->getMaxSelections());
+
+ if (select.empty()) {
+ cout << "Error: invalid or missing '--select' option" << endl;
+ exit(EXIT_FAILURE);
+ } else {
+ command->setSelected(true);
+ }
+ } else {
+ cout << "Error: option '--select' requires an argument" << endl;
+ exit(EXIT_FAILURE);
+ }
+ } else {
+ cout << "Error: channels already selected" << endl;
+ }
+ } break;
+
+ case 'a': { // --alloc
+ if (command) delete command;
+ AllocCmd* alloccmd = new AllocCmd(itsServerPort);
+ command = alloccmd;
+ command->setCmdType(RCUCMD);
+ } break;
+
+ case 'i': { // --channelinfo
+ if (command) delete command;
+ ChannelInfoCmd* channelinfocmd = new ChannelInfoCmd(itsServerPort);
+ command = channelinfocmd;
+ command->setCmdType(RCUCMD);
+ } break;
+
+ case 'f': { // --free
+ if (command) delete command;
+ FreeCmd* freecmd = new FreeCmd(itsServerPort);
+ command = freecmd;
+ command->setCmdType(RCUCMD);
+ } break;
+
+ case 'r': { // --record
+ if (command) delete command;
+ RecordCmd* recordcmd = new RecordCmd(itsServerPort);
+ command = recordcmd;
+ command->setCmdType(RCUCMD);
+ } break;
+
+ case 's': { // --stop
+ if (command) delete command;
+ StopCmd* stopcmd = new StopCmd(itsServerPort);
+ command = stopcmd;
+ command->setCmdType(RCUCMD);
+ } break;
+
+ case 'b': {
+ if (command) delete command;
+ TriggerSettingsCmd* trigsettingscmd = new TriggerSettingsCmd(itsServerPort);
+ command = trigsettingscmd;
+ command->setCmdType(RCUCMD);
+ } break;
+
+ case 'e': { // --trigrelease
+ if (command) delete command;
+ TrigReleaseCmd* trigreleasecmd = new TrigReleaseCmd(itsServerPort);
+ command = trigreleasecmd;
+ if (optarg) {
+ int rcu = 0;
+ int numitems = sscanf(optarg, "%d",&rcu);
+ if (numitems == 0 || numitems == EOF || rcu < 0 || rcu >= MAX_N_RCUS) {
+ cout << "Error: invalid number of arguments. Should be of the format " << endl;
+ cout << " '--trigclr=rcu' " << endl;
+ exit(EXIT_FAILURE);
+ }
+ select.clear();
+ select.push_back(rcu);
+ command->setSelected(true);
+ }
+
+ command->setCmdType(RCUCMD);
+ } break;
+
+ case 'g': { // --triggenerate
+ if (command) delete command;
+ TrigGenerateCmd* triggeneratecmd = new TrigGenerateCmd(itsServerPort);
+ command = triggeneratecmd;
+ command->setCmdType(RCUCMD);
+ } break;
+
+ case 't': { // --trigsetup
+ if (command) delete command;
+ TrigSetupCmd* trigsetupcmd = new TrigSetupCmd(itsServerPort);
+ command = trigsetupcmd;
+
+ if (optarg) {
+ uint32 level = 0;
+ uint32 start = 0;
+ uint32 stop = 0;
+ uint32 filter = 0;
+ uint32 window = 0;
+ uint32 triggermode = 0;
+
+ int numitems = sscanf(optarg, "%u,%u,%u,%u,%u,%u",&level, &start, &stop, &filter, &window, &triggermode);
+ // check if valid arguments
+ if ( numitems < 6 || numitems == EOF
+ || level < 1 || level > 255
+ || start < 1 || start > 15
+ || stop < 1 || stop > 15
+ || window > 6
+ || triggermode > 1)
+ {
+ cout << "Error: invalid number of arguments. Should be of the format " << endl;
+ cout << " '--trigsetup=level, start, stop, filter, window, mode' (use decimal values)" << endl;
+ cout << " level=1..255, start=1..15, stop=1..15, filter=0(on) or 1(off)" << endl;
+ cout << " window=0..6, mode=0(single shot) or 1(continues, don't use this mode)" << endl;
+ exit(EXIT_FAILURE);
+ }
+
+ //================================================
+ // set triggermode to single shot, continues mode
+ // will give more than 6000 triggers per second per
+ // board, if level is chosen to low, the driver can't
+ // handle that amount of trigger per board.
+ if (triggermode == 1) {
+ cout << "mode=1 can generate to many triggers, auto corrected to mode=0(single-shot)" << endl;
+ }
+ triggermode = 0;
+ //================================================
+
+
+ trigsetupcmd->setLevel(static_cast<uint16>(level));
+ trigsetupcmd->setStartMode(static_cast<uint8>(start));
+ trigsetupcmd->setStopMode(static_cast<uint8>(stop));
+ trigsetupcmd->setFilter(static_cast<uint8>(filter));
+ trigsetupcmd->setWindow(static_cast<uint8>(window));
+ trigsetupcmd->setOperatingMode(0);
+ trigsetupcmd->setTriggerMode(static_cast<uint16>(triggermode));
+ }
+
+ command->setCmdType(RCUCMD);
+ } break;
+
+ case 'c': { // --trigcoef
+ if (command) delete command;
+ TrigCoefficientCmd* trigcoefficientcmd = new TrigCoefficientCmd(itsServerPort);
+ command = trigcoefficientcmd;
+ if (optarg) {
+ uint32 c0 = 0;
+ uint32 c1 = 0;
+ uint32 c2 = 0;
+ uint32 c3 = 0;
+ int numitems = sscanf(optarg, "%u,%u,%u,%u",&c0, &c1, &c2, &c3);
+ if (numitems < 4 || numitems == EOF) {
+ cout << "Error: invalid number of arguments. Should be of the format " << endl;
+ cout << " '--trigcoef=c0, c1, c2, c3' (use decimal values)" << endl;
+ cout << " co, c1, c2, c3=16bit value"<< endl;
+ exit(EXIT_FAILURE);
+ }
+ trigcoefficientcmd->setC0(static_cast<uint16>(c0));
+ trigcoefficientcmd->setC1(static_cast<uint16>(c1));
+ trigcoefficientcmd->setC2(static_cast<uint16>(c2));
+ trigcoefficientcmd->setC3(static_cast<uint16>(c3));
+ }
+ command->setCmdType(RCUCMD);
+ } break;
+
+ case 'I': { // --triginfo
+ if (command) delete command;
+ TrigInfoCmd* triginfocmd = new TrigInfoCmd(itsServerPort);
+ command = triginfocmd;
+ if (optarg) {
+ int rcu = 0;
+ int numitems = sscanf(optarg, "%d",&rcu);
+ if (numitems < 1 || numitems == EOF) {
+ cout << "Error: invalid number of arguments. Should be of the format " << endl;
+ cout << " '--triginfo=rcu' " << endl;
+ cout << " rcu=0.." << (MAX_N_RCUS - 1) << endl;
+ exit(EXIT_FAILURE);
+ }
+ select.clear();
+ select.push_back(rcu);
+ command->setSelected(true);
+ }
+ command->setCmdType(RCUCMD);
+ } break;
+
+ case 'L': { // --listen
+ if (command) delete command;
+ ListenCmd* listencmd = new ListenCmd(itsServerPort);
+ command = listencmd;
+ char listen_mode[64];
+ if (optarg) {
+ strcpy(listen_mode,"one_shot");
+ sscanf(optarg, "%s", listen_mode);
+ if ((strcmp(listen_mode,"one_shot") != 0 && strcmp(listen_mode,"continues") != 0)) {
+ cout << "Error: invalid argument. Should be of the format " << endl;
+ cout << " '--listen=[one_shot | continues]'" << endl;
+ exit(EXIT_FAILURE);
+ }
+ }
+ if (strcmp(listen_mode,"one_shot") == 0) {
+ listencmd->setListenMode(TBB_LISTEN_ONE_SHOT);
+ }
+ if (strcmp(listen_mode,"continues") == 0) {
+ listencmd->setListenMode(TBB_LISTEN_CONTINUES);
+ }
+ command->setCmdType(RCUCMD);
+ } break;
+
+ case 'R': { // --read
+ if (command) delete command;
+ ReadCmd* readcmd = new ReadCmd(itsServerPort);
+ command = readcmd;
+
+ if (optarg) {
+ int rcu = 0;
+ uint32 secondstime = 0;
+ uint32 sampletime = 0;
+ uint32 prepages = 0;
+ uint32 postpages = 0;
+ int numitems = sscanf(optarg, "%d,%u,%u,%u,%u",
+ &rcu, &secondstime, &sampletime, &prepages, &postpages);
+ if (numitems < 5 || numitems == EOF || rcu < 0 || rcu >= MAX_N_RCUS) {
+ cout << "Error: invalid number of arguments. Should be of the format " << endl;
+ cout << " '--read=rcu,secondstime,sampletime,prepages,postpages' " << endl;
+ cout << " rcu=0.." << (MAX_N_RCUS - 1) << ", time = secondstime + (sampletime * sample-interval) "<< endl;
+ exit(EXIT_FAILURE);
+ }
+ readcmd->setSecondsTime(secondstime);
+ readcmd->setSampleTime(sampletime);
+ readcmd->setPrePages(prepages);
+ readcmd->setPostPages(postpages);
+
+ select.clear();
+ select.push_back(rcu);
+ command->setSelected(true);
+ }
+ command->setCmdType(RCUCMD);
+ } break;
+
+ case 'm': { // --mode
+ if (command) delete command;
+ ModeCmd* modecmd = new ModeCmd(itsServerPort);
+ command = modecmd;
+ if (optarg) {
+ char rec_mode[64];
+ int numitems = sscanf(optarg, "%s",
+ rec_mode);
+ if (numitems < 1 || numitems == EOF ||(strcmp(rec_mode,"transient") != 0 && strcmp(rec_mode,"subbands") != 0)) {
+ cout << "Error: invalid number of arguments. Should be of the format " << endl;
+ cout << " '--udp=rec_mode'" << endl;
+ cout << " rec_mode=transient or subbands" << endl;
+ exit(EXIT_FAILURE);
+ }
+
+ if (strcmp(rec_mode,"transient") == 0)
+ modecmd->setRecMode(TBB_MODE_TRANSIENT);
+ if (strcmp(rec_mode,"subbands") == 0)
+ modecmd->setRecMode(TBB_MODE_SUBBANDS);
+ }
+ command->setCmdType(BOARDCMD);
+ } break;
+
+ case 'v': { // --version
+ if (command) delete command;
+ VersionCmd* versioncmd = new VersionCmd(itsServerPort);
+ command = versioncmd;
+ command->setCmdType(BOARDCMD);
+ } break;
+
+ case 'z': { // --size
+ if (command) delete command;
+ SizeCmd* sizecmd = new SizeCmd(itsServerPort);
+ command = sizecmd;
+ command->setCmdType(BOARDCMD);
+ } break;
+
+ case 'A': { // --status
+ if (command) delete command;
+ StatusCmd* statuscmd = new StatusCmd(itsServerPort);
+ command = statuscmd;
+ command->setCmdType(BOARDCMD);
+ } break;
+
+ case 'C': { // --clear
+ if (command) delete command;
+ ClearCmd* clearcmd = new ClearCmd(itsServerPort);
+ command = clearcmd;
+ command->setCmdType(BOARDCMD);
+ } break;
+
+ case 'Z': { // --reset
+ if (command) delete command;
+ ResetCmd* resetcmd = new ResetCmd(itsServerPort);
+ command = resetcmd;
+ command->setCmdType(BOARDCMD);
+ } break;
+
+ case 'D': { // --arp
+ if (command) delete command;
+ ArpCmd* arpcmd = new ArpCmd(itsServerPort);
+ command = arpcmd;
+ command->setCmdType(BOARDCMD);
+ } break;
+
+ case 'E': { // --arpmode
+ if (command) delete command;
+ ArpModeCmd* arpmodecmd = new ArpModeCmd(itsServerPort);
+ command = arpmodecmd;
+ if (optarg) {
+ int32 mode = 0;
+ int numitems = sscanf(optarg, "%d", &mode);
+ if (numitems == 0 || numitems == EOF || mode < 0 || mode > 1) {
+ cout << "Error: invalid mode value. Should be of the format " << endl;
+ cout << " '--arpmode=mode'" << endl;
+ cout << " mode=0 or 1" << endl;
+ exit(EXIT_FAILURE);
+ }
+ arpmodecmd->setMode((uint32)mode);
+ }
+ command->setCmdType(BOARDCMD);
+ } break;
+
+ case 'F': { // --stopcep
+ if (command) delete command;
+ StopCepCmd* stopcepcmd = new StopCepCmd(itsServerPort);
+ command = stopcepcmd;
+ command->setCmdType(BOARDCMD);
+ } break;
+
+ case 'G': { // --templimits
+ if (command) delete command;
+ TempLimitCmd* templimitscmd = new TempLimitCmd(itsServerPort);
+ command = templimitscmd;
+ if (optarg) {
+ int32 high = 0;
+ int32 low = 0;
+ int numitems = sscanf(optarg, "%d,%d", &high, &low);
+ if (numitems == 0 || numitems == EOF) {
+ cout << "Error: invalid number of values. Should be of the format " << endl;
+ cout << " '--templimits=high,low'" << endl;
+ exit(EXIT_FAILURE);
+ }
+ templimitscmd->setLimitHigh((uint32)high);
+ templimitscmd->setLimitLow((uint32)low);
+ }
+ command->setCmdType(BOARDCMD);
+ } break;
+
+
+
+ case 'S': { // --config
+ if (command) delete command;
+ ConfigCmd* configcmd = new ConfigCmd(itsServerPort);
+ command = configcmd;
+
+ if (optarg) {
+ int32 imagenr = 0;
+ int numitems = sscanf(optarg, "%d", &imagenr);
+ if (numitems == 0 || numitems == EOF || imagenr < 0 || imagenr >= FL_N_IMAGES) {
+ cout << "Error: invalid image value. Should be of the format " << endl;
+ cout << " '--config=imagenr'" << endl;
+ cout << " imagenr=0..15" << endl;
+ exit(EXIT_FAILURE);
+ }
+ configcmd->setImage((uint32)imagenr);
+ }
+
+ command->setCmdType(BOARDCMD);
+ } break;
+
+ case 'p': { // --readpage
+ if (command) delete command;
+ ReadPageCmd* readddrcmd = new ReadPageCmd(itsServerPort);
+ command = readddrcmd;
+
+ if (optarg) {
+ int32 rcu = 0;
+ uint32 startpage = 0;
+ uint32 pages = 0;
+
+ int numitems = sscanf(optarg, "%d,%u,%u", &rcu,&startpage,&pages);
+
+ if (numitems < 3 || numitems == EOF || rcu < 0 || rcu >= MAX_N_RCUS) {
+ cout << "Error: invalid readpage value's. Should be of the format " << endl;
+ cout << " '--readpage=rcu, startpage, pages'" << endl;
+ cout << " rcu=0.." << (MAX_N_RCUS - 1) << endl;
+ exit(EXIT_FAILURE);
+ }
+ readddrcmd->setStartPage(startpage);
+ readddrcmd->setPages(pages);
+ select.clear();
+ select.push_back(rcu);
+ command->setSelected(true);
+ }
+ command->setCmdType(BOARDCMD);
+ } break;
+
+ case '1': { // --erasef
+ if (command) delete command;
+ ErasefCmd* erasefcmd = new ErasefCmd(itsServerPort);
+ command = erasefcmd;
+ if (optarg) {
+ int board = 0;
+ int page = 0;
+ int numitems = sscanf(optarg, "%d,%d", &board, &page);
+
+ if (numitems < 2 || numitems == EOF || page < 0 || page >= FL_N_IMAGES || board < 0 || board >= MAX_N_TBBOARDS) {
+ cout << "Error: invalid page value. Should be of the format " << endl;
+ cout << " '--eraseimage=board, image'" << endl;
+ cout << " board=0.." << (MAX_N_TBBOARDS - 1) << ", image=0..15" << endl;
+ exit(EXIT_FAILURE);
+ }
+ erasefcmd->setPage(page);
+ select.clear();
+ select.push_back(board);
+ command->setSelected(true);
+ }
+ command->setCmdType(BOARDCMD);
+ } break;
+
+ case '2': { // --readf
+ if (command) delete command;
+ ReadfCmd* readfcmd = new ReadfCmd(itsServerPort);
+ command = readfcmd;
+ if (optarg) {
+ int board = 0;
+ int page = 0;
+ int numitems = sscanf(optarg, "%d,%d", &board, &page);
+
+ if (numitems < 2 || numitems == EOF || page < 0 || page >= FL_N_IMAGES || board < 0 || board >= MAX_N_TBBOARDS) {
+ cout << "Error: invalid image value. Should be of the format " << endl;
+ cout << " '--readimage=board, image'"<< endl;
+ cout << " board=0.." << (MAX_N_TBBOARDS - 1) << ", image=0..31" << endl;
+ exit(EXIT_FAILURE);
+ }
+ readfcmd->setPage(page);
+ select.clear();
+ select.push_back(board);
+ command->setSelected(true);
+ }
+ command->setCmdType(BOARDCMD);
+ } break;
+
+ case '3': { // --writef
+ if (command) delete command;
+ WritefCmd* writefcmd = new WritefCmd(itsServerPort);
+ command = writefcmd;
+ if (optarg) {
+ int board = 0;
+ int page = 0;
+ double version = 0;
+ char filename_tp[64];
+ char filename_mp[64];
+ memset(filename_tp,0,64);
+ memset(filename_mp,0,64);
+
+ int numitems = sscanf(optarg, "%d,%d,%lf,%63[^,],%63[^,]", &board, &page, &version, filename_tp, filename_mp);
+ if (numitems < 5 || numitems == EOF || page < 0 || page >= FL_N_IMAGES || board < 0 || board >= MAX_N_TBBOARDS) {
+ cout << "Error: invalid values. Should be of the format " << endl;
+ cout << " '--writeimage=board, image, file-tp, file-mp'"<< endl;
+ cout << " board=0.." << (MAX_N_TBBOARDS - 1) << ", image=0..31" << endl;
+ exit(EXIT_FAILURE);
+ }
+
+ writefcmd->setPage(page);
+ writefcmd->setVersion(version);
+ writefcmd->setFileNameTp(filename_tp);
+ writefcmd->setFileNameMp(filename_mp);
+
+ select.clear();
+ select.push_back(board);
+ command->setSelected(true);
+ }
+ command->setCmdType(BOARDCMD);
+ } break;
+
+ case '8': { // --imageinfo
+ if (command) delete command;
+ ImageInfoCmd* imageinfocmd = new ImageInfoCmd(itsServerPort);
+ command = imageinfocmd;
+ if (optarg) {
+ int board = 0;
+ int numitems = sscanf(optarg, "%d", &board);
+ if (numitems < 1 || numitems == EOF || board < 0 || board >= MAX_N_TBBOARDS) {
+ cout << "Error: invalid values. Should be of the format " << endl;
+ cout << " '--imageinfo=board'"<< endl;
+ cout << " board=0.." << (MAX_N_TBBOARDS - 1) << endl;
+ exit(EXIT_FAILURE);
+ }
+ select.clear();
+ select.push_back(board);
+ command->setSelected(true);
+ }
+ command->setCmdType(BOARDCMD);
+ } break;
+
+ case '4': { // --readw
+ if (command) delete command;
+ ReadwCmd* readwcmd = new ReadwCmd(itsServerPort);
+ command = readwcmd;
+
+ if (optarg) {
+ int board = 0;
+ uint32 mp = 0;
+ uint32 startaddr = 0;
+ uint32 size = 0;
+
+ int numitems = sscanf(optarg, "%d,%x,%x,%x", &board,&mp,&startaddr, &size);
+
+ if (numitems < 3 || numitems == EOF || board < 0 || board >= MAX_N_TBBOARDS || mp > 3) {
+ cout << "Error: invalid read ddr value. Should be of the format " << endl;
+ cout << " '--readw=board, mp, addr'" << endl;
+ cout << " board=0.." << (MAX_N_TBBOARDS - 1) << ", mp=0..3, addr=0x.." << endl;
+ exit(EXIT_FAILURE);
+ }
+ readwcmd->setMp(mp);
+ readwcmd->setStartAddr(startaddr);
+ readwcmd->setStopAddr(startaddr+size);
+ select.clear();
+ select.push_back(board);
+ command->setSelected(true);
+ }
+ command->setCmdType(BOARDCMD);
+ } break;
+
+ case '5': { // --writew
+ if (command) delete command;
+ WritewCmd* writewcmd = new WritewCmd(itsServerPort);
+ command = writewcmd;
+ if (optarg) {
+ int32 board = 0;
+ int32 mp = 0;
+ uint32 addr = 0;
+ uint32 wordlo = 0;
+ uint32 wordhi = 0;
+
+ int numitems = sscanf(optarg, "%d,%d,%x,%x,%x", &board,&mp,&addr,&wordlo,&wordhi);
+ if (numitems < 5 || numitems == EOF || board < 0 || board >= MAX_N_TBBOARDS || mp > 3) {
+ cout << "Error: invalid write ddr value. Should be of the format " << endl;
+ cout << " '--writew=board, mp, addr, wordlo, wordhi'"<< endl;
+ cout << " board=0.." << (MAX_N_TBBOARDS - 1) << ", mp=0..3, addr=0x.., wordlo=0x.., wordhi=0x.." << endl;
+ exit(EXIT_FAILURE);
+ }
+ writewcmd->setMp(mp);
+ writewcmd->setAddr(addr);
+ writewcmd->setWordLo(wordlo);
+ writewcmd->setWordHi(wordhi);
+ select.clear();
+ select.push_back(board);
+ command->setSelected(true);
+ }
+ command->setCmdType(BOARDCMD);
+ } break;
+
+ case '9': { // --testddr
+ if (command) delete command;
+ TestDdrCmd* testddrcmd = new TestDdrCmd(itsServerPort);
+ command = testddrcmd;
+ if (optarg) {
+ int32 board = 0;
+
+ int numitems = sscanf(optarg, "%d", &board);
+ if (numitems < 1 || numitems == EOF || board < 0 || board >= MAX_N_TBBOARDS) {
+ cout << "Error: invalid write ddr value. Should be of the format " << endl;
+ cout << " '--testddr=board' "<< endl;
+ cout << " board=0.." << (MAX_N_TBBOARDS - 1) << endl;
+ exit(EXIT_FAILURE);
+ }
+ select.clear();
+ select.push_back(board);
+ command->setSelected(true);
+ }
+ command->setCmdType(BOARDCMD);
+ } break;
+
+ case '6': { // --readr
+ if (command) delete command;
+ ReadrCmd* readrcmd = new ReadrCmd(itsServerPort);
+ command = readrcmd;
+
+ if (optarg) {
+ int32 board = 0;
+ uint32 mp = 0;
+ uint32 pid = 0;
+ uint32 regid = 0;
+
+ int numitems = sscanf(optarg, "%d,%u,%u,%u", &board, &mp, &pid, ®id);
+
+ if (numitems < 4 || numitems == EOF || board < 0 || board >= MAX_N_TBBOARDS || mp > 3 || pid > 7 || regid > 7) {
+ cout << "Error: invalid read register value. Should be of the format" << endl;
+ cout << " '--readreg=board, mp, pid, regid'" << endl;
+ cout << " board=0.." << (MAX_N_TBBOARDS - 1) << ", mp=0..3, pid=0..7, regid=0..7" << endl;
+ exit(EXIT_FAILURE);
+ }
+ if ((REG_TABLE_3[pid][regid] == REG_WRITE_ONLY) || (REG_TABLE_3[pid][regid] == REG_NOT_USED)) {
+ cerr << "reading not posible on selected register" << endl;
+ exit(EXIT_FAILURE);
+ }
+ readrcmd->setMp(mp);
+ readrcmd->setPid(pid);
+ readrcmd->setRegId(regid);
+
+ select.clear();
+ select.push_back(board);
+ command->setSelected(true);
+ }
+
+ command->setCmdType(BOARDCMD);
+ } break;
+
+ case '7': { // --writer
+ if (command) delete command;
+ WriterCmd* writercmd = new WriterCmd(itsServerPort);
+ command = writercmd;
+
+ if (optarg) {
+ int32 board = 0;
+ uint32 mp = 0;
+ uint32 pid = 0;
+ uint32 regid = 0;
+ char datastr[256];
+
+ int numitems = sscanf(optarg, "%d,%u,%u,%u,%s", &board, &mp, &pid, ®id, datastr);
+ if (numitems < 5 || numitems == EOF || board < 0 || board >= MAX_N_TBBOARDS || mp > 3 || pid > 7 || regid > 7) {
+ cout << "Error: invalid write register value. Should be of the format " << endl;
+ cout << " '--writereg=board, mp, pid, regid, data1, data2 etc.'" << endl;
+ cout << " board=0.." << (MAX_N_TBBOARDS - 1) << ", mp=0..3, pid=0..7, regid=0..7" << endl;
+ exit(EXIT_FAILURE);
+ }
+ if ((REG_TABLE_3[pid][regid] == REG_READ_ONLY) || (REG_TABLE_3[pid][regid] == REG_NOT_USED)) {
+ cerr << "writing not posible on selected register" << endl;
+ exit(EXIT_FAILURE);
+ }
+ writercmd->setMp(mp);
+ writercmd->setPid(pid);
+ writercmd->setRegId(regid);
+
+ char* dstr;
+ uint32 val = 0;
+ int wordcnt = 0;
+
+ dstr = strtok (datastr," ,");
+ while (dstr != NULL)
+ {
+ val = strtol(dstr,NULL,16);
+ //cout << formatString("%08x ",val);
+ writercmd->setData(wordcnt,val);
+ wordcnt++;
+ dstr = strtok (NULL, " ,");
+ }
+ cout << endl;
+ select.clear();
+ select.push_back(board);
+ command->setSelected(true);
+ }
+
+ command->setCmdType(BOARDCMD);
+ } break;
+
+ case 'h':
+ case '?': {
+ commandHelp(1);
+ exit(0);
+ } break;
+
+ case 'X': {
+ commandHelp(3);
+ exit(0);
+ } break;
+
+ default:
+ {
+ commandHelp(1);
+ exit(EXIT_FAILURE);
+ } break;
+ }
+ }
+
+ if (command) {
+ if (!command->isSelectionDone()) { // --select not used, select all
+ select.clear();
+ for (int i = 0; i < command->getMaxSelections(); i++) {
+ select.push_back(i);
+ }
+ command->setSelected(true);
+ }
+ command->setSelect(select);
+ }
return(command);
}
@@ -3227,16 +3227,16 @@ std::list<int> TBBCtl::strtolist(const char* str, int max)
char* end = 0;
bool range = false;
long prevval = 0;
- std::list<int> resultset;
-
- resultset.clear();
+ std::list<int> resultset;
+
+ resultset.clear();
while(start) {
long val = strtol(start, &end, 10); // read decimal numbers
start = (end ? (*end ? end + 1 : 0) : 0); // determine next start
if (val >= max || val < 0) {
cout << formatString("Error: value %ld out of range",val) << endl;
- resultset.clear();
+ resultset.clear();
return(resultset);
}
@@ -3251,13 +3251,13 @@ std::list<int> TBBCtl::strtolist(const char* str, int max)
}
if (val < prevval) {
cout << "Error: invalid range specification" << endl;
- resultset.clear();
- return(resultset);
- }
+ resultset.clear();
+ return(resultset);
+ }
for(long i = prevval; i <= val; i++)
resultset.push_back(i);
} else {
- resultset.push_back(val);
+ resultset.push_back(val);
}
range = false;
} break;
@@ -3268,9 +3268,9 @@ std::list<int> TBBCtl::strtolist(const char* str, int max)
default: {
cout << formatString("Error: invalid character %c",*end) << endl;
- resultset.clear();
- return(resultset);
- } break;
+ resultset.clear();
+ return(resultset);
+ } break;
}
}
prevval = val;
@@ -3284,9 +3284,9 @@ void TBBCtl::mainloop()
{
start(); // make initial transition
GCFTask::run();
-
- TBBUnsubscribeEvent unsubscribe;
- itsServerPort.send(unsubscribe);
+
+ TBBUnsubscribeEvent unsubscribe;
+ itsServerPort.send(unsubscribe);
}
//-----------------------------------------------------------------------------
@@ -3303,12 +3303,12 @@ int main(int argc, char** argv)
}
catch (Exception e) {
cout << "Exception: " << e.text() << endl;
- cout << endl;
- cout << "== abnormal termination of tbbctl ============================================" << endl;
+ cout << endl;
+ cout << "== abnormal termination of tbbctl ============================================" << endl;
exit(EXIT_FAILURE);
}
- cout << endl;
- cout << "== normal termination of tbbctl ==============================================" << endl;
+ cout << endl;
+ cout << "== normal termination of tbbctl ==============================================" << endl;
return(0);
}
diff --git a/MAC/APL/PIC/TBBDriver/src/tbbctl.h b/MAC/APL/PIC/TBBDriver/src/tbbctl.h
index abf48521a11..e012dc42e55 100644
--- a/MAC/APL/PIC/TBBDriver/src/tbbctl.h
+++ b/MAC/APL/PIC/TBBDriver/src/tbbctl.h
@@ -38,7 +38,7 @@
namespace LOFAR {
namespace TbbCtl {
-// MAX_N_TBBBOARDS and MAX_N_RCUS come from TBB_protocol.ph
+// MAX_N_TBBOARDS and MAX_N_RCUS come from TBB_protocol.ph
static const int BOARDCMD = 1;
static const int RCUCMD = 2;
@@ -163,7 +163,7 @@ public:
int getMaxSelections(void) const
{
int maxbits = 0;
- if (itsCmdType == BOARDCMD) maxbits = MAX_N_TBBBOARDS;
+ if (itsCmdType == BOARDCMD) maxbits = MAX_N_TBBOARDS;
if (itsCmdType == RCUCMD) maxbits = MAX_N_RCUS;
return(maxbits);
}
@@ -852,7 +852,7 @@ private:
// dimensions of the connected hardware
uint32 itsActiveBoards; // mask b0 = board0, b1 = board1 ....
- int itsMemory[MAX_N_TBBBOARDS];
+ int itsMemory[MAX_N_TBBOARDS];
int itsMaxBoards;
int itsMaxChannels;
diff --git a/MAC/APL/PIC/TBBDriver/test/TBBTest.cc b/MAC/APL/PIC/TBBDriver/test/TBBTest.cc
index eb71e799a4a..48566b6f5d6 100644
--- a/MAC/APL/PIC/TBBDriver/test/TBBTest.cc
+++ b/MAC/APL/PIC/TBBDriver/test/TBBTest.cc
@@ -129,7 +129,7 @@ GCFEvent::TResult TBBTest::test001(GCFEvent& e, GCFPortInterface& port)
{
TBBAllocAckEvent ack(e);
LOG_INFO_STR(formatString ("Ack status = 0X%08X", ack.status_mask));
- for (int boardnr = 0; boardnr < MAX_N_TBBBOARDS;boardnr++) {
+ for (int boardnr = 0; boardnr < MAX_N_TBBOARDS;boardnr++) {
TESTC_ABORT(ack.status_mask[boardnr] == TBB_SUCCESS, TBBTest::final);
}
LOG_INFO_STR("Alloc test OK");
@@ -183,7 +183,7 @@ GCFEvent::TResult TBBTest::test002(GCFEvent& e, GCFPortInterface& port)
{
TBBAllocAckEvent ack(e);
LOG_INFO_STR(formatString ("Ack status = 0X%08X", ack.status_mask));
- for (int boardnr = 0; boardnr < MAX_N_TBBBOARDS;boardnr++) {
+ for (int boardnr = 0; boardnr < MAX_N_TBBOARDS;boardnr++) {
TESTC_ABORT(ack.status_mask[boardnr] == TBB_SUCCESS, TBBTest::final);
}
LOG_INFO_STR("Free test OK");
@@ -237,7 +237,7 @@ GCFEvent::TResult TBBTest::test003(GCFEvent& e, GCFPortInterface& port)
{
TBBRecordAckEvent ack(e);
- for (int boardnr = 0; boardnr < MAX_N_TBBBOARDS;boardnr++) {
+ for (int boardnr = 0; boardnr < MAX_N_TBBOARDS;boardnr++) {
TESTC_ABORT(ack.status_mask[boardnr] == TBB_SUCCESS, TBBTest::final);
}
LOG_INFO_STR("Record test OK");
@@ -291,7 +291,7 @@ GCFEvent::TResult TBBTest::test004(GCFEvent& e, GCFPortInterface& port)
{
TBBStopAckEvent ack(e);
- for (int boardnr = 0; boardnr < MAX_N_TBBBOARDS;boardnr++) {
+ for (int boardnr = 0; boardnr < MAX_N_TBBOARDS;boardnr++) {
TESTC_ABORT(ack.status_mask[boardnr] == TBB_SUCCESS, TBBTest::final);
}
LOG_INFO_STR("Stop test OK");
@@ -446,7 +446,7 @@ GCFEvent::TResult TBBTest::test007(GCFEvent& e, GCFPortInterface& port)
{
TBBModeAckEvent ack(e);
- for (int boardnr = 0; boardnr < MAX_N_TBBBOARDS; boardnr++) {
+ for (int boardnr = 0; boardnr < MAX_N_TBBOARDS; boardnr++) {
TESTC_ABORT(ack.status_mask[boardnr] == TBB_SUCCESS, TBBTest::final);
}
LOG_INFO_STR("Udp test OK");
@@ -512,7 +512,7 @@ GCFEvent::TResult TBBTest::test008(GCFEvent& e, GCFPortInterface& port)
LOG_INFO_STR(formatString("mp3version = 0X%08X", ack.mp3version[cnt]));
}
//LOG_INFO_STR(formatString ("Ack status = 0X%08X", ack.status_mask));
- for (int boardnr = 0; boardnr < MAX_N_TBBBOARDS;boardnr++) {
+ for (int boardnr = 0; boardnr < MAX_N_TBBOARDS;boardnr++) {
TESTC_ABORT(ack.status_mask[boardnr] == TBB_SUCCESS, TBBTest::final);
}
LOG_INFO_STR("Version test OK");
@@ -568,7 +568,7 @@ GCFEvent::TResult TBBTest::test009(GCFEvent& e, GCFPortInterface& port)
{
TBBSizeAckEvent ack(e);
- for (int boardnr = 0; boardnr < MAX_N_TBBBOARDS;boardnr++) {
+ for (int boardnr = 0; boardnr < MAX_N_TBBOARDS;boardnr++) {
TESTC_ABORT(ack.status_mask[boardnr] == TBB_SUCCESS, TBBTest::final);
}
LOG_INFO_STR("Size test OK");
@@ -622,7 +622,7 @@ GCFEvent::TResult TBBTest::test010(GCFEvent& e, GCFPortInterface& port)
{
TBBSizeAckEvent ack(e);
- for (int boardnr = 0; boardnr < MAX_N_TBBBOARDS;boardnr++) {
+ for (int boardnr = 0; boardnr < MAX_N_TBBOARDS;boardnr++) {
TESTC_ABORT(ack.status_mask[boardnr] == TBB_SUCCESS, TBBTest::final);
}
LOG_INFO_STR("Size test OK");
--
GitLab