int DAQ_Stop ()
{
int err = daq_stop(daq_mod, daq_hand);
if ( err )
LogMessage("Can't stop DAQ (%d) - %s!\n",
err, daq_get_error(daq_mod, daq_hand));
return err;
}
ListData* Engine::getList(uint64_t timeout, boost::atomic<bool>& interruptor) {
boost::unique_lock<boost::mutex> lock(mutex_);
if (!(aggregate_status_ & DeviceStatus::can_run)) {
PL_WARN << "<Engine> No devices exist that can perform acquisition";
return nullptr;
}
Spill* one_spill;
ListData* result = new ListData;
PL_INFO << "<Engine> Multithreaded list mode acquisition scheduled for " << timeout << " seconds";
CustomTimer *anouncement_timer = nullptr;
double secs_between_anouncements = 5;
get_all_settings();
save_optimization();
result->run.state = pull_settings();
result->run.detectors = get_detectors();
result->run.time = boost::posix_time::microsec_clock::universal_time();
SynchronizedQueue<Spill*> parsedQueue;
if (daq_start(&parsedQueue))
PL_DBG << "<Engine> Started device daq threads";
CustomTimer total_timer(timeout, true);
anouncement_timer = new CustomTimer(true);
while (daq_running()) {
wait_ms(1000);
if (anouncement_timer->s() > secs_between_anouncements) {
PL_INFO << " RUNNING Elapsed: " << total_timer.done()
<< " ETA: " << total_timer.ETA();
delete anouncement_timer;
anouncement_timer = new CustomTimer(true);
}
if (interruptor.load() || (timeout && total_timer.timeout())) {
if (daq_stop())
PL_DBG << "<Engine> Stopped device daq threads successfully";
else
PL_ERR << "<Engine> Failed to stop device daq threads";
}
}
delete anouncement_timer;
result->run.time = boost::posix_time::microsec_clock::universal_time();
wait_ms(500);
while (parsedQueue.size() > 0) {
one_spill = parsedQueue.dequeue();
for (auto &q : one_spill->hits)
result->hits.push_back(q);
delete one_spill;
}
parsedQueue.stop();
return result;
}
void SysTick_Handler(void){
static bool lowBat; // Set when battery voltage drops below VBAT_LOW
static uint32_t sysTickCounter;
sysTickCounter++; // Used to schedule less frequent tasks
switch(system_state){
case STATE_IDLE:
// Enable USB if VBUS is disconnected
;bool vBus = Chip_GPIO_GetPinState(LPC_GPIO, 0, VBUS);
if(!vBus){
msc_state = MSC_ENABLED;
}
// If MSC enabled, VBUS is connected, and SD card is ready, try to connect as MSC
if (msc_state == MSC_ENABLED && vBus && sd_state == SD_READY){
f_mount(NULL,"",0); // unmount file system
if (msc_init() == MSC_OK){
Board_LED_Color(LED_YELLOW);
system_state = STATE_MSC;
break;
}else{ // Error on MSC initialization
error(ERROR_MSC_INIT);
}
}
// If user has short pressed PB and SD card is ready, initiate acquisition
if (pb_shortPress() && sd_state == SD_READY){
daq_init();
system_state = STATE_DAQ;
break;
}
// Blink LED if in low battery state, otherwise solid green
if (lowBat && sysTickCounter % TICKRATE_HZ1 < TICKRATE_HZ1/2){
Board_LED_Color(LED_OFF);
} else {
Board_LED_Color(LED_GREEN);
}
break;
case STATE_MSC:
// If VBUS is disconnected or button is short pressed
;bool pb;
if (Chip_GPIO_GetPinState(LPC_GPIO, 0, VBUS) == 0 || (pb = pb_shortPress())){
if(pb){
msc_state = MSC_DISABLED;
}
msc_stop();
f_mount(fatfs,"",0); // mount file system
Board_LED_Color(LED_GREEN);
system_state = STATE_IDLE;
enterIdleTime = Chip_RTC_GetCount(LPC_RTC);
}
break;
case STATE_DAQ:
// Perform the current asynchronous daq action
daq_loop();
// If user has short pressed PB to stop acquisition
if (pb_shortPress()){
Board_LED_Color(LED_PURPLE);
daq_stop();
Board_LED_Color(LED_GREEN);
system_state = STATE_IDLE;
enterIdleTime = Chip_RTC_GetCount(LPC_RTC);
msc_state = MSC_DISABLED;
}
break;
}
// Initialize SD card after every insertion
if (Chip_GPIO_GetPinState(LPC_GPIO, 0, CARD_DETECT)){
// Card out
Board_LED_Color(LED_CYAN);
sd_state = SD_OUT;
}else{
// Card in
if (sd_state == SD_OUT){
// Delay 100ms to let connections and power stabilize
DWT_Delay(100000);
if(init_sd_spi(&cardinfo) != SD_OK) {
error(ERROR_SD_INIT);
}
switch(system_state){
case STATE_IDLE:
Board_LED_Color(LED_GREEN);
break;
case STATE_MSC:
Board_LED_Color(LED_YELLOW);
break;
case STATE_DAQ:
Board_LED_Color(LED_RED);
break;
}
sd_state = SD_READY;
}
}
/* Run once per second */
if(sysTickCounter % TICKRATE_HZ1 == 0){
float vBat = read_vBat(10);
lowBat = vBat < VBAT_LOW ? true : false; // Set low battery state
if (vBat < VBAT_SHUTDOWN){
shutdown_message("Low Battery");
}
if ((Chip_RTC_GetCount(LPC_RTC) - enterIdleTime > TIMEOUT_SECS && system_state == STATE_IDLE) ){
shutdown_message("Idle Time Out");
}
}
/* Shut down conditions */
if (pb_longPress()){
shutdown_message("Power Button Pressed");
}
/* Handle errors */
error_handler();
}
void Engine::getMca(uint64_t timeout, SpectraSet& spectra, boost::atomic<bool>& interruptor) {
boost::unique_lock<boost::mutex> lock(mutex_);
if (!(aggregate_status_ & DeviceStatus::can_run)) {
PL_WARN << "<Engine> No devices exist that can perform acquisition";
return;
}
PL_INFO << "<Engine> Multithreaded spectra acquisition scheduled for " << timeout << " seconds";
CustomTimer *anouncement_timer = nullptr;
double secs_between_anouncements = 5;
SynchronizedQueue<Spill*> parsedQueue;
boost::thread builder(boost::bind(&Qpx::Engine::worker_MCA, this, &parsedQueue, &spectra));
Spill* spill = new Spill;
get_all_settings();
save_optimization();
spill->run.state = pull_settings();
spill->run.detectors = get_detectors();
spill->run.time = boost::posix_time::microsec_clock::universal_time();
parsedQueue.enqueue(spill);
if (daq_start(&parsedQueue))
PL_DBG << "<Engine> Started device daq threads";
CustomTimer total_timer(timeout, true);
anouncement_timer = new CustomTimer(true);
while (daq_running()) {
wait_ms(1000);
if (anouncement_timer->s() > secs_between_anouncements) {
if (timeout > 0)
PL_INFO << " RUNNING Elapsed: " << total_timer.done()
<< " ETA: " << total_timer.ETA();
else
PL_INFO << " RUNNING Elapsed: " << total_timer.done();
delete anouncement_timer;
anouncement_timer = new CustomTimer(true);
}
if (interruptor.load() || (timeout && total_timer.timeout())) {
if (daq_stop())
PL_DBG << "<Engine> Stopped device daq threads successfully";
else
PL_ERR << "<Engine> Failed to stop device daq threads";
}
}
delete anouncement_timer;
spill = new Spill;
get_all_settings();
save_optimization();
spill->run.state = pull_settings();
spill->run.detectors = get_detectors();
spill->run.time = boost::posix_time::microsec_clock::universal_time();
parsedQueue.enqueue(spill);
wait_ms(500);
while (parsedQueue.size() > 0)
wait_ms(1000);
wait_ms(500);
parsedQueue.stop();
wait_ms(500);
builder.join();
}
