CLSSIS3820ScalerControlsView::CLSSIS3820ScalerControlsView(CLSSIS3820Scaler *scaler, QWidget *parent) :
QWidget(parent)
{
// Initialize member variables.
scaler_ = 0;
// Create UI elements.
acquisitionModeBox_ = new QComboBox;
startButton_ = new QPushButton(QIcon(":/22x22/media-playback-start.png"), "Start");
startButton_->setMaximumHeight(25);
stopButton_ = new QPushButton(QIcon(":/22x22/media-playback-stop.png"), "Stop");
stopButton_->setMaximumHeight(25);
statusLabel_ = new QLabel;
dwellTimeBox_ = new QDoubleSpinBox;
dwellTimeBox_->setFixedWidth(100);
dwellTimeBox_->setAlignment(Qt::AlignCenter);
scansPerBufferBox_ = new QSpinBox;
scansPerBufferBox_->setFixedWidth(100);
scansPerBufferBox_->setAlignment(Qt::AlignCenter);
totalScansBox_ = new QSpinBox;
totalScansBox_->setFixedWidth(100);
totalScansBox_->setAlignment(Qt::AlignCenter);
// Create and set layouts.
QHBoxLayout *buttonsLayout = new QHBoxLayout;
buttonsLayout->addWidget(startButton_);
buttonsLayout->addWidget(stopButton_);
QVBoxLayout *statusLayout = new QVBoxLayout;
statusLayout->addWidget(statusLabel_, 0, Qt::AlignCenter);
statusLayout->addLayout(buttonsLayout);
statusLayout->addWidget(acquisitionModeBox_, 0, Qt::AlignCenter);
QGridLayout *controlsLayout = new QGridLayout();
controlsLayout->addWidget(new QLabel("Dwell Time: "), 0, 0, 1, 1, Qt::AlignRight);
controlsLayout->addWidget(dwellTimeBox_, 0, 1);
controlsLayout->addWidget(new QLabel("Scans per Buffer: "), 1, 0, 1, 1, Qt::AlignRight);
controlsLayout->addWidget(scansPerBufferBox_, 1, 1);
controlsLayout->addWidget(new QLabel("Total Scans: "), 2, 0, 1, 1, Qt::AlignRight);
controlsLayout->addWidget(totalScansBox_, 2, 1);
QHBoxLayout *layout = new QHBoxLayout;
layout->addLayout(statusLayout);
layout->addLayout(controlsLayout);
setLayout(layout);
// Make connections.
connect(startButton_, SIGNAL(clicked()), this, SLOT(startScanning()));
connect(stopButton_, SIGNAL(clicked()), this, SLOT(stopScanning()));
connect(acquisitionModeBox_, SIGNAL(currentIndexChanged(int)), this, SLOT(setContinuous()));
connect(dwellTimeBox_, SIGNAL(editingFinished()), this, SLOT(setDwellTime()));
connect(scansPerBufferBox_, SIGNAL(editingFinished()), this, SLOT(setScansPerBuffer()));
connect(totalScansBox_, SIGNAL(editingFinished()), this, SLOT(setTotalScans()));
// Current settings.
setScaler(scaler);
refresh();
}
bool process(void)
{
uint32_t argc;
const char **argv = getInputString(argc);
if ( argv )
{
if ( strcmp(argv[0],"scan") == 0 )
{
if ( mMode == CM_SCAN )
{
printf("Pausing block-chain scan at block #%d\r\n", mLastBlockScan );
mMode = CM_NONE;
}
else
{
printf("Scanning block-chain re-started from block %d up to a maximum of %d blocks..\r\n", mLastBlockScan, mMaxBlock);
mMode = CM_SCAN;
}
}
else if ( strcmp(argv[0],"exit") == 0 || strcmp(argv[0],"bye") == 0 || strcmp(argv[0],"quit") == 0 )
{
mMode = CM_EXIT;
}
else if ( strcmp(argv[0],"stop_scan") == 0 )
{
if ( mFinishedScanning )
{
printf("Already finished scanning the block-chain headers. Found %d blocks.\r\n", mLastBlockScan );
}
else
{
stopScanning();
}
}
else if ( strcmp(argv[0],"help") == 0 )
{
help();
}
else if ( strcmp(argv[0],"max_blocks") == 0 )
{
if ( argc >= 2 )
{
mMaxBlock = atoi(argv[1]);
if ( mMaxBlock < 1 ) mMaxBlock = 1;
printf("Maximum block scan set to %d\r\n", mMaxBlock );
}
}
else if ( strcmp(argv[0],"by_day") == 0 )
{
mStatResolution = SR_DAY;
printf("Will accumulate statistics on a per-day basis.\r\n");
if ( !mProcessTransactions )
{
printf("Note: You must enable 'statistics' for this to take effect.\r\n");
}
}
else if ( strcmp(argv[0],"by_month") == 0 )
{
mStatResolution = SR_MONTH;
printf("Will accumulate statistics on a monthly basis.\r\n");
if ( !mProcessTransactions )
{
printf("Note: You must enable 'statistics' for this to take effect.\r\n");
}
}
else if ( strcmp(argv[0],"by_year") == 0 )
{
mStatResolution = SR_YEAR;
printf("Will accumulate statistics on an annual basis.\r\n");
if ( !mProcessTransactions )
{
printf("Note: You must enable 'statistics' for this to take effect.\r\n");
}
}
else if ( strcmp(argv[0],"record_addresses") == 0 )
{
mRecordAddresses = mRecordAddresses ? false : true;
printf("record_addresses set to %s\r\n", mRecordAddresses ? "true" : "false");
}
else if ( strcmp(argv[0],"adr") == 0 )
{
if ( argc == 1 )
{
printf("You must supply an address to output.\r\n");
}
else
{
for (uint32_t i=1; i<argc; i++)
{
const char *adr = argv[i];
mBlockChain->printAddress(adr);
}
}
}
else if ( strcmp(argv[0],"process") == 0 )
{
if ( mMode == CM_PROCESS )
{
printf("Pausing processing block-chain blocks at block #%d of %d\r\n", mProcessBlock, mBlockChain->getBlockCount() );
mMode = CM_NONE;
}
else
{
if ( !mFinishedScanning )
{
stopScanning();
}
mProcessBlock = 0;
mMode = CM_PROCESS;
printf("Beginning processing of %d blocks : Gathering Statistics=%s\r\n",
mBlockChain->getBlockCount(),
mProcessTransactions ? "true":"false");
}
}
else if ( strcmp(argv[0],"statistics") == 0 )
{
mProcessTransactions = mProcessTransactions ? false : true;
if ( mProcessTransactions )
{
printf("Block Processing will gather statistics.\r\n");
printf("*** WARNING : This will consume an enormous amount of memory! ***\r\n");
}
else
{
printf("Block processing will not gather statistics.\r\n");
}
}
else if ( strcmp(argv[0],"load_record") == 0 )
{
if ( mAddresses )
{
mAddresses->release();
mAddresses = NULL;
}
printf("Loading previously recorded addresses from file 'BlockChainAddresses.bin\r\n");
mAddresses = createBlockChainAddresses("BlockChainAddresses.bin");
}
else if ( strcmp(argv[0],"min_balance") == 0 )
{
if ( argc == 1 )
{
printf("No minimum balance specified, defaulting to 1btc.\r\n");
}
else
{
mMinBalance = (uint32_t)atoi(argv[1]);
if ( mMinBalance < 1 )
{
mMinBalance = 1;
}
else
{
if ( mMinBalance > 1000000 )
{
mMinBalance = 1000000;
}
}
printf("Minimum balance set to %d bitcoins.\r\n", mMinBalance );
}
}
else if ( strcmp(argv[0],"top_balance") == 0 )
{
uint32_t tcount = 100;
if ( argc >= 2 )
{
tcount = atoi(argv[1]);
if ( tcount < 1 )
{
tcount = 1;
}
}
printf("Printing the most valuable %d bitcoin addresses with a balance of more than %d bitcoins.\r\n", tcount, mMinBalance );
mBlockChain->printTopBalances(tcount,mMinBalance);
}
else if ( strcmp(argv[0],"oldest") == 0 )
{
uint32_t tcount = 100;
if ( argc >= 2 )
{
tcount = atoi(argv[1]);
if ( tcount < 1 )
{
tcount = 1;
}
}
printf("Printing the %d oldest bitcoin addresses with a balance of more than %d bitcoins.\r\n", tcount, mMinBalance );
mBlockChain->printOldest(tcount,mMinBalance);
}
else if ( strcmp(argv[0],"zombie") == 0 )
{
uint32_t zdays = 365;
if ( argc >=2 )
{
zdays = atoi(argv[1]);
if ( zdays < 1 )
{
zdays = 1;
}
}
printf("Generating Zombie Count for addresses older than %d days with a balance of more than %d bitcoins.\r\n", zdays, mMinBalance );
mBlockChain->zombieReport(zdays,mMinBalance);
}
else if ( strcmp(argv[0],"by_day") == 0 )
{
mStatResolution = SR_DAY;
printf("Gathering statistics every day.\r\n");
}
else if ( strcmp(argv[0],"by_month") == 0 )
{
mStatResolution = SR_MONTH;
printf("Gathering statistics every month.\r\n");
}
else if ( strcmp(argv[0],"by_year") == 0 )
{
mStatResolution = SR_YEAR;
printf("Gathering statistics every year.\r\n");
}
else if ( strcmp(argv[0],"counts") == 0 )
{
mBlockChain->reportCounts();
}
else if ( strcmp(argv[0],"block") == 0 )
{
if ( argc == 1 )
{
if ( mCurrentBlock )
{
mBlockChain->printBlock(mCurrentBlock);
mCurrentBlock = mBlockChain->readBlock(mCurrentBlock->blockIndex+1);
}
}
else
{
for (uint32_t i=1; i<argc; i++)
{
uint32_t index = (uint32_t)atoi(argv[i]);
mCurrentBlock = getBlock(index);
if ( mCurrentBlock )
{
mBlockChain->printBlock(mCurrentBlock);
}
}
}
}
}
switch ( mMode )
{
case CM_PROCESS:
if ( mProcessBlock < mBlockChain->getBlockCount() )
{
mCurrentBlock = mBlockChain->readBlock(mProcessBlock);
if ( mCurrentBlock && mProcessTransactions )
{
if ( mLastTime == 0 )
{
mLastTime = mCurrentBlock->timeStamp;
mSatoshiTime = mCurrentBlock->timeStamp;
}
else
{
uint32_t currentTime = mCurrentBlock->timeStamp;
time_t tnow(currentTime);
struct tm beg;
beg = *localtime(&tnow);
time_t tbefore(mLastTime);
struct tm before;
before = *localtime(&tbefore);
bool getStats = false;
switch ( mStatResolution )
{
case SR_DAY:
if ( beg.tm_yday != before.tm_yday )
{
getStats = true;
}
break;
case SR_MONTH:
if ( beg.tm_mon != before.tm_mon )
{
getStats = true;
}
break;
case SR_YEAR:
if ( beg.tm_year != before.tm_year )
{
getStats = true;
}
break;
}
if ( getStats )
{
const char *months[12] = { "January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December" };
printf("Gathering statistics for %s %d, %d to %s %d, %d\r\n",
months[before.tm_mon], before.tm_mday, before.tm_year+1900,
months[beg.tm_mon], beg.tm_mday, beg.tm_year+1900);
mBlockChain->gatherStatistics(mLastTime,(uint32_t)zombieDate,mRecordAddresses);
mLastTime = currentTime;
}
}
mBlockChain->processTransactions(mCurrentBlock); // process transactions into individual addresses
}
mProcessBlock++;
if ( (mProcessBlock%10000) == 0 )
{
printf("Processed block #%d of %d total.\r\n", mProcessBlock, mBlockChain->getBlockCount() );
}
}
else
{
printf("Finished processing all blocks in the blockchain.\r\n");
mBlockChain->reportCounts();
if ( mProcessTransactions )
{
printf("Gathering final statistics.\r\n");
mBlockChain->gatherStatistics(mLastTime,(uint32_t)zombieDate,mRecordAddresses);
printf("Saving statistics to file 'stats.csv\r\n");
mBlockChain->saveStatistics(mRecordAddresses);
}
mMode = CM_NONE;
mProcessBlock = 0;
}
break;
case CM_SCAN:
{
bool ok = mBlockChain->readBlockHeaders(mMaxBlock,mLastBlockScan);
if ( !ok )
{
mFinishedScanning = true;
mMode = CM_NONE; // done scanning.
mLastBlockScan = mBlockChain->buildBlockChain();
printf("Finished scanning block headers. Built block-chain with %d blocks found..\r\n", mLastBlockScan);
printf("To resolve transactions you must execute the 'process' command.\r\n");
printf("To gather statistics so you can ouput balances of individual addresses, you must execute the 'statistics' command prior to running the process command.\r\n");
}
}
break;
}
return mMode != CM_EXIT;
}
long long
hokuyo::Laser::calcLatency(bool intensity, double min_ang, double max_ang, int clustering, int skip, int num, int timeout)
{
ROS_DEBUG("Entering calcLatency.");
if (!portOpen())
HOKUYO_EXCEPT(hokuyo::Exception, "Port not open.");
static const std::string buggy_version = "1.16.02(19/Jan./2010)";
if (firmware_version_ == buggy_version)
{
ROS_INFO("Hokuyo firmware version %s detected. Using hard-coded time offset of -23 ms.",
buggy_version.c_str());
offset_ = -23000000;
}
else
{
offset_ = 0;
uint64_t comp_time = 0;
uint64_t laser_time = 0;
long long diff_time = 0;
long long drift_time = 0;
long long tmp_offset1 = 0;
long long tmp_offset2 = 0;
int count = 0;
sendCmd("TM0",timeout);
count = 100;
for (int i = 0; i < count;i++)
{
usleep(1000);
sendCmd("TM1",timeout);
comp_time = timeHelper();
try
{
laser_time = readTime();
diff_time = comp_time - laser_time;
tmp_offset1 += diff_time / count;
} catch (hokuyo::RepeatedTimeException &e)
{
// We expect to get Repeated Time's when hammering on the time server
continue;
}
}
uint64_t start_time = timeHelper();
usleep(5000000);
sendCmd("TM1;a",timeout);
sendCmd("TM1;b",timeout);
comp_time = timeHelper();
drift_time = comp_time - start_time;
laser_time = readTime() + tmp_offset1;
diff_time = comp_time - laser_time;
double drift_rate = double(diff_time) / double(drift_time);
sendCmd("TM2",timeout);
if (requestScans(intensity, min_ang, max_ang, clustering, skip, num, timeout) != 0)
HOKUYO_EXCEPT(hokuyo::Exception, "Error requesting scans during latency calculation");
hokuyo::LaserScan scan;
count = 200;
for (int i = 0; i < count;i++)
{
try
{
serviceScan(scan, 1000);
} catch (hokuyo::CorruptedDataException &e) {
continue;
}
comp_time = scan.system_time_stamp;
drift_time = comp_time - start_time;
laser_time = scan.self_time_stamp + tmp_offset1 + (long long)(drift_time*drift_rate);
diff_time = laser_time - comp_time;
tmp_offset2 += diff_time / count;
}
offset_ = tmp_offset2;
stopScanning();
}
ROS_DEBUG("Leaving calcLatency.");
return offset_;
}
CLSSIS3820ScalerControlsView::CLSSIS3820ScalerControlsView(CLSSIS3820Scaler *scaler, QWidget *parent) :
QWidget(parent)
{
// Initialize member variables.
scaler_ = 0;
// Create UI elements.
modeChoice_ = new QComboBox;
modeChoice_->addItems(QStringList() << "Single Shot" << "Continuous");
modeChoice_->setCurrentIndex(0);
startButton_ = new QPushButton(QIcon(":/22x22/media-playback-start.png"), "Start");
startButton_->setMaximumHeight(25);
stopButton_ = new QPushButton(QIcon(":/22x22/media-playback-stop.png"), "Stop");
stopButton_->setMaximumHeight(25);
status_ = new QLabel;
status_->setPixmap(QIcon(":/32x32/greenLEDOff.png").pixmap(25));
time_ = new QSpinBox;
time_->setRange(0, 1000000);
time_->setValue(1000);
time_->setSuffix(" ms");
time_->setFixedWidth(100);
time_->setAlignment(Qt::AlignCenter);
scansPerBuffer_ = new QSpinBox;
scansPerBuffer_->setRange(0, 10000);
scansPerBuffer_->setValue(1);
scansPerBuffer_->setFixedWidth(100);
scansPerBuffer_->setAlignment(Qt::AlignCenter);
totalScans_ = new QSpinBox;
totalScans_->setRange(0, 10000);
totalScans_->setValue(1);
totalScans_->setFixedWidth(100);
totalScans_->setAlignment(Qt::AlignCenter);
// Create and set layouts.
QHBoxLayout *startAndStopButtons = new QHBoxLayout;
startAndStopButtons->addWidget(startButton_);
startAndStopButtons->addWidget(stopButton_);
QVBoxLayout *statusAndModeLayout = new QVBoxLayout;
statusAndModeLayout->addWidget(status_, 0, Qt::AlignCenter);
statusAndModeLayout->addLayout(startAndStopButtons);
statusAndModeLayout->addWidget(modeChoice_, 0, Qt::AlignCenter);
QHBoxLayout *timeLayout = new QHBoxLayout;
timeLayout->addWidget(new QLabel("Dwell Time:"), 0, Qt::AlignRight);
timeLayout->addWidget(time_);
QHBoxLayout *scansPerBufferLayout = new QHBoxLayout;
scansPerBufferLayout->addWidget(new QLabel("Scans per Buffer:"), 0, Qt::AlignRight);
scansPerBufferLayout->addWidget(scansPerBuffer_);
QHBoxLayout *totalScansLayout = new QHBoxLayout;
totalScansLayout->addWidget(new QLabel("Total Scans"), 0, Qt::AlignRight);
totalScansLayout->addWidget(totalScans_);
QVBoxLayout *spinBoxLayout = new QVBoxLayout;
spinBoxLayout->addLayout(timeLayout);
spinBoxLayout->addLayout(scansPerBufferLayout);
spinBoxLayout->addLayout(totalScansLayout);
QHBoxLayout *layout = new QHBoxLayout;
layout->addLayout(statusAndModeLayout);
layout->addLayout(spinBoxLayout);
setLayout(layout);
// Make connections.
connect(startButton_, SIGNAL(clicked()), this, SLOT(startScanning()));
connect(stopButton_, SIGNAL(clicked()), this, SLOT(stopScanning()));
connect(modeChoice_, SIGNAL(currentIndexChanged(int)), this, SLOT(setContinuous()));
connect(time_, SIGNAL(editingFinished()), this, SLOT(setDwellTime()));
connect(scansPerBuffer_, SIGNAL(editingFinished()), this, SLOT(setScansPerBuffer()));
connect(totalScans_, SIGNAL(editingFinished()), this, SLOT(setTotalScans()));
// Current settings.
setScaler(scaler);
}
