clarity surrounding event buffer, waiting, reading and getting event

[Maru006]

Can I please get some clarity on the sequence of storing events.

My understanding is, to eventually read the stored buffer I must first:

initialising buffer to a MAX_BUFFER == 20 (hypothetically speaking)
gpiod_edge_event_buffer *buffer = gpiod_edge_event_buffer_new(MAX_BUFFER);

initialise a line to get inputs...
struct (properly intialised input line with edge detection for both) *line...

wait for an event...
gpiod_line_request_wait_Edge_Events(*gpiod_line, nsec);

read that event...
int read = gpiod_line_request_read_edge_events(line -> gpiod_line_request...);

store the event when detected into the initialised buffer..
struct gpiod_edge_event *event = gpiod_edge_event_buffer_get_event(buffer, index);

from here I can access the variables of event...

like uint64_t timestamps
enum gpiod_edge_event_type
etc...

Say index ++ if index < 10...

My question is

1. if I surround [wait and read_edge_events] while x < index. Will waiting and reading populate my buffer up to 10?
2. Could I then theoretically then access attributes for each event's timstamps and event type by index in the buffer stored?

I seem to be able to read index from a buffer manually, but looping through it i get an Assertion failed.

[Ablu]

I am not entirely sure what the question is. The example code you provide is a bit garbled. But if you want to know how far you can read in the buffer then you can check your read variable. It will tell you how many events got read into the buffer.

Also see this example code: https://github.com/brgl/libgpiod/blob/4254100/examples/watch_line_rising.c#L115-L126

[Maru006]

Sorry about the lack of actual legal syntax. I thought metaphorically speaking was sufficient and I've already added tons of abstraction on top of the lgpiod library for my use case - so I cant really quote from it.

But on to the sample code. My issue with this is:

for (i = 0; i < ret; i++) {
event = gpiod_edge_event_buffer_get_event(event_buffer,
i);

does not follow a wait_edge_event. I can see there is a ret = gpiod_line_request_read_edge_events(request, event_buffer, event_buf_size);

So what exactly is the point of waiting if reading will also block if there are no queued events. Does read que events or wait?

[brgl]

Being able to timeout vs blocking indefinitely.