Mirror/Momentum-Firmware
1
0
Fork 0
mirror of https://github.com/Next-Flip/Momentum-Firmware.git synced 2026-05-26 05:54:46 -07:00
Code Issues Packages Projects Releases Wiki Activity

DigitalSignal: use cyclic DMA buffer for sequences

Browse Source
This commit is contained in:
g3gg0.de
2023-02-04 01:39:56 +01:00
parent 61ac844f56
commit ae1e93e519
2 changed files with 234 additions and 202 deletions
Download Patch File Download Diff File Expand all files Collapse all files

435
lib/digital_signal/digital_signal.c
View File

@@ -8,13 +8,15 @@
#include <stm32wbxx_ll_dma.h>
#include <stm32wbxx_ll_tim.h>
/* must be on bank B */
#define DEBUG_OUTPUT gpio_ext_pb3
struct ReloadBuffers {
uint32_t** buffers; /* pointers to the shadow buffers, either one or two. NULL if none */
uint32_t count; /* number of allocated buffers, 0, 1 or 2 */
uint32_t size; /* maximum entry count of a single buffer */
uint32_t current; /* current buffer index, the other one is most likely being used */
uint32_t entries; /* entries in the current buffer */
struct ReloadBuffer {
uint32_t* buffer; /* DMA ringbuffer */
uint32_t size; /* maximum entry count of the ring buffer */
uint32_t write_pos; /* current buffer write index */
uint32_t read_pos; /* current buffer read index */
bool dma_active;
};
struct DigitalSequence {
@@ -27,17 +29,20 @@ struct DigitalSequence {
const GpioPin* gpio;
uint32_t send_time;
bool send_time_active;
struct ReloadBuffers* reload;
LL_DMA_InitTypeDef dma_config_gpio;
LL_DMA_InitTypeDef dma_config_timer;
uint32_t* gpio_buff;
struct ReloadBuffer* dma_buffer;
};
struct DigitalSignalInternals {
uint64_t factor;
uint32_t reload_reg_entries;
uint32_t reload_reg_remainder;
uint32_t gpio_buff[2];
const GpioPin* gpio;
LL_DMA_InitTypeDef dma_config_gpio;
LL_DMA_InitTypeDef dma_config_timer;
struct ReloadBuffers* reload;
};
#define TAG "DigitalSignal"
@@ -56,9 +61,8 @@ DigitalSignal* digital_signal_alloc(uint32_t max_edges_cnt) {
signal->internals = malloc(sizeof(DigitalSignalInternals));
DigitalSignalInternals* internals = signal->internals;
internals->reload = NULL;
internals->reload_reg_entries = 0;
internals->reload_reg_remainder = 0;
internals->factor = 1024 * 1024;
internals->dma_config_gpio.Direction = LL_DMA_DIRECTION_MEMORY_TO_PERIPH;
internals->dma_config_gpio.Mode = LL_DMA_MODE_CIRCULAR;
@@ -92,12 +96,6 @@ void digital_signal_free(DigitalSignal* signal) {
free(signal->edge_timings);
free(signal->reload_reg_buff);
if(signal->internals->reload) {
if(signal->internals->reload->buffers) {
free(signal->internals->reload->buffers);
}
free(signal->internals->reload);
}
free(signal->internals);
free(signal);
}
@@ -191,8 +189,8 @@ void digital_signal_prepare_arr(DigitalSignal* signal) {
uint32_t bit_reset = internals->gpio->pin << 16;
#ifdef DEBUG_OUTPUT
bit_set |= gpio_ext_pb3.pin;
bit_reset |= gpio_ext_pb3.pin << 16;
bit_set |= DEBUG_OUTPUT.pin;
bit_reset |= DEBUG_OUTPUT.pin << 16;
#endif
if(signal->start_level) {
@@ -208,7 +206,17 @@ void digital_signal_prepare_arr(DigitalSignal* signal) {
internals->reload_reg_entries = 0;
for(size_t pos = 0; pos < signal->edge_cnt; pos++) {
uint32_t pulse_duration = signal->edge_timings[pos] + internals->reload_reg_remainder;
uint32_t edge_scaled = (internals->factor * signal->edge_timings[pos]) / (1024 * 1024);
uint32_t pulse_duration = edge_scaled + internals->reload_reg_remainder;
if(pulse_duration < 10 || pulse_duration > 10000000) {
FURI_LOG_D(
TAG,
"[prepare] pulse_duration out of range: %lu = %lu * %llu",
pulse_duration,
signal->edge_timings[pos],
internals->factor);
pulse_duration = 100;
}
uint32_t pulse_ticks = (pulse_duration + T_TIM_DIV2) / T_TIM;
internals->reload_reg_remainder = pulse_duration - (pulse_ticks * T_TIM);
@@ -216,22 +224,6 @@ void digital_signal_prepare_arr(DigitalSignal* signal) {
signal->reload_reg_buff[internals->reload_reg_entries++] = pulse_ticks - 1;
}
}
/* in case there are no shadow buffers defined, allocate and use the precalced data */
if(!internals->reload || !internals->reload->count) {
if(internals->reload) {
free(internals->reload);
}
internals->reload = malloc(sizeof(struct ReloadBuffers));
internals->reload->count = 1;
internals->reload->size = signal->edges_max_cnt;
internals->reload->buffers = malloc(sizeof(uint32_t*));
internals->reload->buffers[0] = malloc(internals->reload->size * sizeof(uint32_t));
memcpy(
internals->reload->buffers[0],
signal->reload_reg_buff,
internals->reload_reg_entries * sizeof(uint32_t));
}
}
static void digital_signal_stop_dma() {
@@ -268,17 +260,15 @@ static bool digital_signal_setup_dma(DigitalSignal* signal) {
furi_assert(signal);
DigitalSignalInternals* internals = signal->internals;
uint32_t buffer_entries = internals->reload->entries;
if(!buffer_entries || !internals->reload || !internals->reload->buffers) {
if(!signal->internals->reload_reg_entries) {
return false;
}
digital_signal_stop_dma();
internals->dma_config_gpio.MemoryOrM2MDstAddress = (uint32_t)internals->gpio_buff;
internals->dma_config_gpio.PeriphOrM2MSrcAddress = (uint32_t) & (internals->gpio->port->BSRR);
internals->dma_config_timer.MemoryOrM2MDstAddress =
(uint32_t)internals->reload->buffers[internals->reload->current];
internals->dma_config_timer.NbData = buffer_entries;
internals->dma_config_timer.MemoryOrM2MDstAddress = (uint32_t)signal->reload_reg_buff;
internals->dma_config_timer.NbData = signal->internals->reload_reg_entries;
/* set up DMA channel 1 and 2 for GPIO and timer copy operations */
LL_DMA_Init(DMA1, LL_DMA_CHANNEL_1, &internals->dma_config_gpio);
@@ -288,9 +278,6 @@ static bool digital_signal_setup_dma(DigitalSignal* signal) {
LL_DMA_EnableChannel(DMA1, LL_DMA_CHANNEL_1);
LL_DMA_EnableChannel(DMA1, LL_DMA_CHANNEL_2);
/* buffer is used now by DMA, skip to next */
internals->reload->current = (internals->reload->current + 1) % internals->reload->count;
return true;
}
@@ -323,12 +310,12 @@ void digital_signal_send(DigitalSignal* signal, const GpioPin* gpio) {
signal->edge_cnt--;
}
void digital_sequence_alloc_signals(DigitalSequence* sequence, uint32_t size) {
static void digital_sequence_alloc_signals(DigitalSequence* sequence, uint32_t size) {
sequence->signals_size = size;
sequence->signals = malloc(sequence->signals_size * sizeof(DigitalSignal*));
}
void digital_sequence_alloc_sequence(DigitalSequence* sequence, uint32_t size) {
static void digital_sequence_alloc_sequence(DigitalSequence* sequence, uint32_t size) {
sequence->sequence_used = 0;
sequence->sequence_size = size;
sequence->sequence = malloc(sequence->sequence_size);
@@ -344,12 +331,31 @@ DigitalSequence* digital_sequence_alloc(uint32_t size, const GpioPin* gpio) {
sequence->gpio = gpio;
sequence->bake = false;
sequence->reload = malloc(sizeof(struct ReloadBuffers));
sequence->reload->count = 2;
sequence->reload->size = 512;
sequence->reload->buffers = malloc(sizeof(uint32_t*));
sequence->reload->buffers[0] = malloc(sequence->reload->size * sizeof(uint32_t));
sequence->reload->buffers[1] = malloc(sequence->reload->size * sizeof(uint32_t));
sequence->dma_buffer = malloc(sizeof(struct ReloadBuffer));
sequence->dma_buffer->size = 32;
sequence->dma_buffer->buffer = malloc(sequence->dma_buffer->size * sizeof(uint32_t));
sequence->dma_config_gpio.Direction = LL_DMA_DIRECTION_MEMORY_TO_PERIPH;
sequence->dma_config_gpio.Mode = LL_DMA_MODE_CIRCULAR;
sequence->dma_config_gpio.PeriphOrM2MSrcIncMode = LL_DMA_PERIPH_NOINCREMENT;
sequence->dma_config_gpio.MemoryOrM2MDstIncMode = LL_DMA_MEMORY_INCREMENT;
sequence->dma_config_gpio.PeriphOrM2MSrcDataSize = LL_DMA_PDATAALIGN_WORD;
sequence->dma_config_gpio.MemoryOrM2MDstDataSize = LL_DMA_MDATAALIGN_WORD;
sequence->dma_config_gpio.NbData = 2;
sequence->dma_config_gpio.PeriphRequest = LL_DMAMUX_REQ_TIM2_UP;
sequence->dma_config_gpio.Priority = LL_DMA_PRIORITY_VERYHIGH;
sequence->dma_config_timer.Direction = LL_DMA_DIRECTION_MEMORY_TO_PERIPH;
sequence->dma_config_timer.Mode = LL_DMA_MODE_CIRCULAR;
sequence->dma_config_timer.PeriphOrM2MSrcIncMode = LL_DMA_PERIPH_NOINCREMENT;
sequence->dma_config_timer.MemoryOrM2MDstIncMode = LL_DMA_MEMORY_INCREMENT;
sequence->dma_config_timer.PeriphOrM2MSrcDataSize = LL_DMA_PDATAALIGN_WORD;
sequence->dma_config_timer.MemoryOrM2MDstDataSize = LL_DMA_MDATAALIGN_WORD;
sequence->dma_config_timer.PeriphOrM2MSrcAddress = (uint32_t) & (TIM2->ARR);
sequence->dma_config_timer.MemoryOrM2MDstAddress = (uint32_t)sequence->dma_buffer->buffer;
sequence->dma_config_timer.NbData = sequence->dma_buffer->size;
sequence->dma_config_timer.PeriphRequest = LL_DMAMUX_REQ_TIM2_UP;
sequence->dma_config_timer.Priority = LL_DMA_PRIORITY_HIGH;
digital_sequence_alloc_signals(sequence, 32);
digital_sequence_alloc_sequence(sequence, size);
@@ -364,17 +370,10 @@ void digital_sequence_free(DigitalSequence* sequence) {
return;
}
/* de-assign the shared reload buffer */
for(int pos = 0; pos < sequence->signals_size; pos++) {
if(sequence->signals[pos]) {
sequence->signals[pos]->internals->reload = NULL;
}
}
free(sequence->signals);
free(sequence->sequence);
free(sequence->reload->buffers);
free(sequence->reload);
free(sequence->dma_buffer->buffer);
free(sequence->dma_buffer);
free(sequence);
}
@@ -386,38 +385,10 @@ void digital_sequence_set_signal(
furi_assert(signal);
furi_assert(signal_index < sequence->signals_size);
/* if there is already a signal, unassign the shared reload buffer */
if(sequence->signals[signal_index]) {
sequence->signals[signal_index]->internals->reload = NULL;
}
sequence->signals[signal_index] = signal;
signal->internals->gpio = sequence->gpio;
signal->internals->reload_reg_remainder = 0;
/* free the original reload buffer */
if(signal->internals->reload) {
if(signal->internals->reload->buffers) {
for(uint32_t pos = 0; pos < signal->internals->reload->count; pos++) {
free(signal->internals->reload->buffers[pos]);
}
free(signal->internals->reload->buffers);
}
free(signal->internals->reload);
}
/* assign the sequence's shared reload buffer */
signal->internals->reload = sequence->reload;
/* ensure it is big enough and reallocate if not */
if(sequence->reload->size < signal->edges_max_cnt) {
free(sequence->reload->buffers);
sequence->reload->size = signal->edges_max_cnt;
sequence->reload->buffers[0] = malloc(sequence->reload->size * sizeof(uint32_t));
sequence->reload->buffers[1] = malloc(sequence->reload->size * sizeof(uint32_t));
}
digital_signal_prepare_arr(signal);
}
@@ -440,71 +411,26 @@ void digital_sequence_add(DigitalSequence* sequence, uint8_t signal_index) {
sequence->sequence[sequence->sequence_used++] = signal_index;
}
static void digital_signal_update_dma(DigitalSignal* signal) {
struct ReloadBuffers* reload = signal->internals->reload;
/* keep them prepared in registers so there is less delay when writing */
register bool restart_needed = false;
register volatile uint16_t len = reload->entries;
register volatile uint32_t addr = (uint32_t)reload->buffers[reload->current];
static bool digital_sequence_setup_dma(DigitalSequence* sequence) {
furi_assert(sequence);
/* first make sure it will still count down, else we will risk waiting infinitely */
const uint32_t wait_ms = 10;
const uint32_t wait_ticks = wait_ms * 1000 * furi_hal_cortex_instructions_per_microsecond();
uint16_t prev_remain = LL_DMA_GetDataLength(DMA1, LL_DMA_CHANNEL_2);
uint32_t prev_timer = DWT->CYCCNT;
digital_signal_stop_dma();
while(prev_remain == LL_DMA_GetDataLength(DMA1, LL_DMA_CHANNEL_2)) {
if(DWT->CYCCNT - prev_timer > wait_ticks) {
restart_needed = true;
break;
}
}
sequence->dma_config_gpio.MemoryOrM2MDstAddress = (uint32_t)sequence->gpio_buff;
sequence->dma_config_gpio.PeriphOrM2MSrcAddress = (uint32_t) & (sequence->gpio->port->BSRR);
if(!restart_needed) {
/* if transfer was already active, wait till DMA is done and the last timer ticks are running */
while(LL_DMA_GetDataLength(DMA1, LL_DMA_CHANNEL_2)) {
}
} else {
FURI_LOG_D(TAG, "digital_sequence_send_signal: DMA hung, restart needed");
}
/* set up DMA channel 1 and 2 for GPIO and timer copy operations */
LL_DMA_Init(DMA1, LL_DMA_CHANNEL_1, &sequence->dma_config_gpio);
LL_DMA_Init(DMA1, LL_DMA_CHANNEL_2, &sequence->dma_config_timer);
LL_DMA_DisableChannel(DMA1, LL_DMA_CHANNEL_2);
LL_DMA_SetDataLength(DMA1, LL_DMA_CHANNEL_2, len);
LL_DMA_SetMemoryAddress(DMA1, LL_DMA_CHANNEL_2, addr);
/* enable both DMA channels */
LL_DMA_EnableChannel(DMA1, LL_DMA_CHANNEL_1);
LL_DMA_EnableChannel(DMA1, LL_DMA_CHANNEL_2);
if(restart_needed) {
LL_TIM_GenerateEvent_UPDATE(TIM2);
}
reload->current = (reload->current + 1) % reload->count;
}
static bool digital_sequence_send_signal(DigitalSequence* sequence, DigitalSignal* signal) {
/* the first iteration has to set up the whole machinery */
if(!LL_DMA_IsEnabledChannel(DMA1, LL_DMA_CHANNEL_1)) {
if(!digital_signal_setup_dma(signal)) {
FURI_LOG_D(TAG, "digital_sequence_send_signal: Signal has no entries, aborting");
return false;
}
digital_signal_setup_timer();
/* if the send time is specified, wait till the core timer passed beyond that time */
if(sequence->send_time_active) {
sequence->send_time_active = false;
while(sequence->send_time - DWT->CYCCNT < 0x80000000) {
}
}
digital_signal_start_timer();
} else {
/* configure next polarities and timings */
digital_signal_update_dma(signal);
}
return true;
}
DigitalSignal* digital_sequence_bake(DigitalSequence* sequence) {
static DigitalSignal* digital_sequence_bake(DigitalSequence* sequence) {
furi_assert(sequence);
uint32_t edges = 0;
@@ -528,14 +454,94 @@ DigitalSignal* digital_sequence_bake(DigitalSequence* sequence) {
return ret;
}
static void digital_sequence_update_pos(DigitalSequence* sequence) {
struct ReloadBuffer* dma_buffer = sequence->dma_buffer;
dma_buffer->read_pos = dma_buffer->size - LL_DMA_GetDataLength(DMA1, LL_DMA_CHANNEL_2);
}
static const uint32_t wait_ms = 10;
static const uint32_t wait_ticks = wait_ms * 1000 * 64;
static void digital_sequence_finish(DigitalSequence* sequence) {
struct ReloadBuffer* dma_buffer = sequence->dma_buffer;
if(dma_buffer->dma_active) {
uint32_t prev_timer = DWT->CYCCNT;
uint32_t end_pos = (dma_buffer->write_pos + 1) % dma_buffer->size;
do {
uint32_t last_pos = dma_buffer->read_pos;
digital_sequence_update_pos(sequence);
/* we are finished, when the DMA transferred the 0xFFFFFFFF-timer which is the current write_pos */
if(dma_buffer->read_pos == end_pos) {
break;
}
if(last_pos != dma_buffer->read_pos) {
prev_timer = DWT->CYCCNT;
}
if(DWT->CYCCNT - prev_timer > wait_ticks) {
FURI_LOG_D(
TAG,
"[SEQ] hung %lu ms in finish (ARR 0x%08lx, read %lu, write %lu)",
wait_ms,
TIM2->ARR,
dma_buffer->read_pos,
dma_buffer->write_pos);
break;
}
} while(1);
}
digital_signal_stop_timer();
digital_signal_stop_dma();
}
static void digital_sequence_queue_pulse(DigitalSequence* sequence, uint32_t length) {
struct ReloadBuffer* dma_buffer = sequence->dma_buffer;
if(dma_buffer->dma_active) {
uint32_t prev_timer = DWT->CYCCNT;
uint32_t end_pos = (dma_buffer->write_pos + 1) % dma_buffer->size;
do {
uint32_t last_pos = dma_buffer->read_pos;
digital_sequence_update_pos(sequence);
if(dma_buffer->read_pos != end_pos) {
break;
}
if(last_pos != dma_buffer->read_pos) {
prev_timer = DWT->CYCCNT;
}
if(DWT->CYCCNT - prev_timer > wait_ticks) {
FURI_LOG_D(
TAG,
"[SEQ] hung %lu ms in queue (ARR 0x%08lx, read %lu, write %lu)",
wait_ms,
TIM2->ARR,
dma_buffer->read_pos,
dma_buffer->write_pos);
break;
}
} while(1);
}
dma_buffer->buffer[dma_buffer->write_pos] = length;
dma_buffer->write_pos = (dma_buffer->write_pos + 1) % dma_buffer->size;
dma_buffer->buffer[dma_buffer->write_pos] = 0xFFFFFFFF;
}
bool digital_sequence_send(DigitalSequence* sequence) {
furi_assert(sequence);
struct ReloadBuffers* reload = sequence->reload;
struct ReloadBuffer* dma_buffer = sequence->dma_buffer;
furi_hal_gpio_init(sequence->gpio, GpioModeOutputPushPull, GpioPullNo, GpioSpeedVeryHigh);
#ifdef DEBUG_OUTPUT
furi_hal_gpio_init(&gpio_ext_pb3, GpioModeOutputPushPull, GpioPullNo, GpioSpeedVeryHigh);
furi_hal_gpio_init(&DEBUG_OUTPUT, GpioModeOutputPushPull, GpioPullNo, GpioSpeedVeryHigh);
#endif
if(sequence->bake) {
@@ -547,74 +553,88 @@ bool digital_sequence_send(DigitalSequence* sequence) {
}
int32_t remainder = 0;
FURI_CRITICAL_ENTER();
bool traded_first = false;
for(uint32_t pos = 0; pos < sequence->sequence_used; pos++) {
uint8_t signal_index = sequence->sequence[pos];
FURI_CRITICAL_ENTER();
dma_buffer->dma_active = false;
dma_buffer->buffer[0] = 0xFFFFFFFF;
dma_buffer->read_pos = 0;
dma_buffer->write_pos = 0;
for(uint32_t seq_pos = 0; seq_pos < sequence->sequence_used; seq_pos++) {
uint8_t signal_index = sequence->sequence[seq_pos];
DigitalSignal* sig = sequence->signals[signal_index];
DigitalSignal* sig_next = NULL;
bool last_signal = ((seq_pos + 1) == sequence->sequence_used);
if(pos + 1 < sequence->sequence_used) {
sig_next = sequence->signals[sequence->sequence[pos + 1]];
/* all signals are prepared and we can re-use the GPIO buffer from the fist signal */
if(seq_pos == 0) {
sequence->gpio_buff = sig->internals->gpio_buff;
}
if(!sig) {
FURI_LOG_D(
TAG,
"digital_sequence_send: Signal at index %u, used at pos %lu is NULL, aborting",
signal_index,
pos);
break;
}
/* if the first edge is handled by prolonging the last pulse of the previous signal, skip it here */
reload->entries = sig->edge_cnt - (traded_first ? 1 : 0);
memcpy(
reload->buffers[reload->current],
&sig->reload_reg_buff[traded_first ? 1 : 0],
reload->entries * sizeof(uint32_t));
traded_first = false;
/* when we are too late more than half a tick, make the first edge temporarily longer */
if(remainder >= T_TIM_DIV2) {
remainder -= T_TIM;
reload->buffers[reload->current][0] += 1;
}
/* update the total remainder */
remainder += sig->internals->reload_reg_remainder;
/* when a signal ends with the same level as the next signal begins, let the fist signal generate the whole pulse */
if(sig_next) {
/* beware, we do not want the level after the last edge, but the last level before that edge */
bool end_level = sig->start_level ^ ((sig->edge_cnt % 2) == 0);
/* take from the next, add it to the first */
if(end_level == sig_next->start_level) {
/* add the traded prolongation to the last pulse */
reload->buffers[reload->current][reload->entries - 1] +=
sig_next->reload_reg_buff[0];
traded_first = true;
for(uint32_t pulse_pos = 0; pulse_pos < sig->internals->reload_reg_entries; pulse_pos++) {
if(traded_first) {
traded_first = false;
continue;
}
}
uint32_t pulse_length = 0;
bool last_pulse = ((pulse_pos + 1) == sig->internals->reload_reg_entries);
/* transmit */
bool success = digital_sequence_send_signal(sequence, sig);
pulse_length = sig->reload_reg_buff[pulse_pos];
if(!success) {
break;
/* when we are too late more than half a tick, make the first edge temporarily longer */
if(remainder >= T_TIM_DIV2) {
remainder -= T_TIM;
pulse_length += 1;
}
remainder += sig->internals->reload_reg_remainder;
/* last pulse in that signal and have a next signal? */
if(last_pulse) {
if((seq_pos + 1) < sequence->sequence_used) {
DigitalSignal* sig_next = sequence->signals[sequence->sequence[seq_pos + 1]];
/* when a signal ends with the same level as the next signal begins, let the fist signal generate the whole pulse */
/* beware, we do not want the level after the last edge, but the last level before that edge */
bool end_level = sig->start_level ^ ((sig->edge_cnt % 2) == 0);
/* take from the next, add it to the current if they have the same level */
if(end_level == sig_next->start_level) {
pulse_length += sig_next->reload_reg_buff[0];
traded_first = true;
}
}
}
digital_sequence_queue_pulse(sequence, pulse_length);
/* start transmission when buffer was filled enough */
bool start_send = sequence->dma_buffer->write_pos >= (sequence->dma_buffer->size - 4);
/* or it was the last pulse */
if(last_pulse && last_signal) {
start_send = true;
}
/* start transmission */
if(start_send && !dma_buffer->dma_active) {
digital_sequence_setup_dma(sequence);
digital_signal_setup_timer();
/* if the send time is specified, wait till the core timer passed beyond that time */
if(sequence->send_time_active) {
sequence->send_time_active = false;
while(sequence->send_time - DWT->CYCCNT < 0x80000000) {
}
}
digital_signal_start_timer();
dma_buffer->dma_active = true;
}
}
}
/* wait until last dma transaction was finished */
while(LL_DMA_GetDataLength(DMA1, LL_DMA_CHANNEL_2)) {
}
digital_signal_stop_timer();
digital_signal_stop_dma();
digital_sequence_finish(sequence);
FURI_CRITICAL_EXIT();
return true;
@@ -625,3 +645,14 @@ void digital_sequence_clear(DigitalSequence* sequence) {
sequence->sequence_used = 0;
}
void digital_sequence_timebase_correction(DigitalSequence* sequence, float factor) {
for(uint32_t sig_pos = 0; sig_pos < sequence->signals_size; sig_pos++) {
DigitalSignal* signal = sequence->signals[sig_pos];
if(signal) {
signal->internals->factor = (uint32_t)(1024 * 1024 * factor);
digital_signal_prepare_arr(signal);
}
}
}