From ae1e93e519d6289f67d83ae0f114ca100ecc347f Mon Sep 17 00:00:00 2001 From: "g3gg0.de" Date: Sat, 4 Feb 2023 01:39:56 +0100 Subject: [PATCH] DigitalSignal: use cyclic DMA buffer for sequences --- lib/digital_signal/digital_signal.c | 435 +++++++++++++++------------- lib/digital_signal/digital_signal.h | 1 + 2 files changed, 234 insertions(+), 202 deletions(-) diff --git a/lib/digital_signal/digital_signal.c b/lib/digital_signal/digital_signal.c index 4ceca2ead..59278277c 100644 --- a/lib/digital_signal/digital_signal.c +++ b/lib/digital_signal/digital_signal.c @@ -8,13 +8,15 @@ #include #include +/* 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); + } + } +} diff --git a/lib/digital_signal/digital_signal.h b/lib/digital_signal/digital_signal.h index 2cb107486..40afb1e41 100644 --- a/lib/digital_signal/digital_signal.h +++ b/lib/digital_signal/digital_signal.h @@ -61,6 +61,7 @@ void digital_sequence_set_sendtime(DigitalSequence* sequence, uint32_t send_time void digital_sequence_add(DigitalSequence* sequence, uint8_t signal_index); bool digital_sequence_send(DigitalSequence* sequence); void digital_sequence_clear(DigitalSequence* sequence); +void digital_sequence_timebase_correction(DigitalSequence* sequence, float factor); #ifdef __cplusplus }