1#include "run/manager.h"
2#include "mode/counters.h"
9#include <utils/logging.h>
13#include <run/handlers.h>
19FLASHMEM
void run::drivers::SleepRun::run() {
24 constexpr uint32_t max_num_samples = 16'384;
25 const int num_channels =
run.daq_config.get_num_channels();
26 const uint32_t optime_us =
run.config.op_time / 1000;
29 if (num_channels > 0 &&
run.daq_config.get_sample_rate() != 0) {
32 elapsedMicros sampling_time_us_counter;
33 volatile auto hopefully_not_optimized_out = daq::sample_raw();
34 sampling_time_us = sampling_time_us_counter;
66 uint32_t sampling_total_us = optime_us / max_num_samples;
70 (sampling_total_us < sampling_time_us) ? 0 : (sampling_total_us - sampling_time_us);
72 uint32_t num_samples = optime_us / (sampling_sleep_us + sampling_time_us);
73 uint32_t optime_left_us = optime_us % (sampling_sleep_us + sampling_time_us);
76 if (num_samples > max_num_samples)
77 num_samples = max_num_samples;
79 const int num_buffer_entries = num_samples * num_channels;
81 LOGMEV(
"optime_us=%d, sampling_time_us=%d, sampling_sleep_us=%d, num_samples=%d, num_channels=%d",
82 optime_us, sampling_time_us, sampling_sleep_us, num_samples, num_channels);
88 constexpr int padding = daq::NUM_CHANNELS;
92 int16_t *buffer =
nullptr;
93 if (num_channels > 0) {
95 buffer = (int16_t *)malloc((num_buffer_entries + padding) *
sizeof(int16_t));
97 LOG_ERROR(
"Could not allocated a large run buffer for a traditional Run.");
101 mode::RealManualControl::enable();
103 LOGMEV(
"IC TIME: %lld",
run.config.ic_time);
104 LOGMEV(
"OP TIME: %lld",
run.config.op_time);
106 mode::RealManualControl::to_ic();
114 delayNanoseconds(
run.config.ic_time);
115 mode::RealManualControl::to_op();
116 elapsedMicros actual_op_time_timer;
119 for (
uint32_t sample = 0; sample < num_samples; sample++) {
123 auto data = daq::sample_raw();
124 memcpy(buffer + sample * num_channels, data.data(), num_channels);
126 delayMicroseconds(sampling_sleep_us);
129 delayMicroseconds(optime_left_us);
136 delayNanoseconds(
run.config.op_time);
139 uint32_t actual_op_time_us = actual_op_time_timer;
140 mode::RealManualControl::to_halt();
144 alt_data_handler->handle((uint16_t *)buffer, num_samples, num_channels,
run);
149 if(
run.daq_config.should_sample_op_end() && alt_data_handler) {
150 auto singlebuf = daq::sample_raw();
152 alt_data_handler->handle(singlebuf.data(), 1, num_channels,
run);
155 auto res = (num_channels && !buffer) ? RunState::ERROR : RunState::DONE;
156 auto result =
run.to(res, actual_op_time_us * 1000);
157 if (
run.config.write_run_state_changes && state_change_handler)
158 state_change_handler->handle(result,
run);
161FLASHMEM
void run::drivers::FlexIORun::run() {
164 data_handler->prepare(
run);
165 bool daq_error =
false;
169 run.config.halt_on_overload ? mode::OnOverload::HALT
170 : mode::OnOverload::IGNORE,
171 mode::OnExtHalt::IGNORE)) {
172 LOG_ERROR(
"Error while initializing state machine.")
173 auto change =
run.to(RunState::ERROR, 0);
174 if(state_change_handler)
175 state_change_handler->handle(change,
run);
179 auto data_stream =
daq::stream::get(
run, data_handler);
181 data_handler->init();
183 mode::FlexIOControl::force_start();
184 delayMicroseconds(1);
186 while (!
mode::FlexIOControl::is_done()) {
187 if (!data_stream.process()) {
188 LOG_ERROR(
"Streaming error, most likely data overflow.");
200 delayMicroseconds(20);
202 if (!data_stream.process(
true)) {
203 LOG_ERROR(
"Streaming error during final partial stream.");
209 auto &perf = mode::PerformanceCounter::get();
210 perf.add(mode::Mode::IC,
run.config.ic_time / 1000);
211 perf.add(mode::Mode::OP, actual_op_time / 1000);
215 auto change =
run.to(RunState::ERROR, actual_op_time);
216 if(state_change_handler)
217 state_change_handler->handle(change,
run);
222 auto change =
run.to(RunState::DONE, actual_op_time);
223 if(state_change_handler)
224 state_change_handler->handle(change,
run);
227FLASHMEM
void run::drivers::SeriesRun::run() {
228 const int num_channels = daq_config.get_num_channels();
229 int16_t* raw_results =
nullptr;
230 if(alt_data_handler) {
231 raw_results = (int16_t*) malloc(num_channels * series_length *
sizeof(int16_t));
233 LOG_ERROR(
"Could not allocate a large run buffer for Series Run.");
237 elapsedMicros timer_us;
239 mode::RealManualControl::enable();
240 int16_t* raw_results_cur = raw_results;
241 for(
size_t cur_series = 0; cur_series < series_length; cur_series++) {
242 mode::RealManualControl::to_ic();
243 delayNanoseconds(config.ic_time);
244 mode::RealManualControl::to_op();
245 delayNanoseconds(config.op_time);
246 mode::RealManualControl::to_halt();
249 auto samples = daq::sample_raw();
250 for(
size_t channel=0; channel<num_channels; channel++)
251 *(raw_results_cur++) = samples[channel];
255 auto result = to(RunState::DONE, timer_us*1000);
256 if(state_change_handler)
257 state_change_handler->handle(result, *
this);
259 if(raw_results && data_handler)
260 alt_data_handler->handle((uint16_t *)raw_results, series_length, num_channels, *
this);
static unsigned long long get_actual_op_time()
static bool init(unsigned long long ic_time_ns, unsigned long long op_time_ns, mode::OnOverload on_overload=mode::OnOverload::HALT, mode::OnExtHalt on_ext_halt=mode::OnExtHalt::IGNORE, mode::Sync sync=mode::Sync::NONE)
if(((src) >=(0x60000000) &&(src)<(0x60000000)+(0x800000)))
while(offset< size &&error==0)
Routines for data acquisition (DAQ) using the internal analog-to-digital converters (ADC).