Ring buffer with external reset
Once I needed to parse streaming data, and for this I needed a buffer that I could clear according to some condition. There was no such block in Engee, but it doesn't matter, because if I know what I need, then I can always implement it either in C or Julia. Let's see what I've got.
How does an externally reset ring buffer work?
Buffer Code - we use Working Variables
The simplest approach to implementing something is the best. Therefore, we will use the C Function block.
To implement it, you will need two variables-states.: the buffer itself and the counter. Let's set them up as the working variables of the block.
Working variables are special variables that serve as a statically pre-allocated memory area. When configuring this block parameter, each variable specifies how many bytes to allocate. A separate advantage is that these variables are different for each instance of the block. That is, we can say that this is the "state" of the block.
Let's look at my settings:
It can be seen that 2 variables will be used - an 80-byte buffer buffer and a one-byte counter.
To use these variables in the C Function code, you need to refer to the Work structure.
As a result, the code will look like this:
uint8_t * ptr = &(Work->buffer[0]);
double* buffer_d_ptr = (double *) ptr;
double* output1_ptr = output1;
if (RESET)
{
memset(buffer_d_ptr, 0, BUFFER_LEN_BYTES);
memset(output1_ptr, 0, BUFFER_LEN_BYTES);
(Work->pos[0]) = 0;
}
else
{
buffer_d_ptr[Work->pos[0]] = byte;
Work->pos[0]++;
memcpy(output1_ptr, buffer_d_ptr, BUFFER_LEN_BYTES);
if (Work->pos[0] > len - 1)
{
Work->pos[0] = 0;
}
}
How to work with working variables (C magic)?
Working variables are always of type uint8_t. But C is great because it allows you to work with memory any way you want. And you can also remember that any array in C is just a pointer to a piece of memory, so we can interpret it as we want.:
uint8_t * ptr = &(Work->buffer[0]);
double* buffer_d_ptr = (double *) ptr;
Both ptr and buffer_d_ptr point to the same address in memory, but buffer_d_ptr tells the compiler that there will be a double at this address. We can also work with this pointer as with an array.:
buffer_d_ptr[Work->pos[0]] = byte;
Note that we don't use dynamic memory allocation at all!
Testing the block
Let's create a test harness of the form:
let's run a simulation of the model:
sys = engee.open(joinpath(@__DIR__,"cirbuf.engee"))
engee.run(sys)
engee.close(;force=true)
And let's look at the results.:
using DataFrames
df = DataFrame(time=zero(Float64),Buffer=[zeros(Float64,16)],RESET = zero(UInt8))
for i =1:length(RESETEVT.time)
push!(df,(time = collect(RESETEVT).time[i],
Buffer = collect(BUFFER).value[i],
RESET = collect(RESETEVT).value[i]))
end
show(df, allrows=true, allcols=true)
Conclusions
We made a cyclic buffer block with an external reset and learned how to work with working variables, and at the same time remembered how to work with pointers in C.