Advise on storing gpiod variables/structs and executing them.

[Maru006]

If for example, I have made a struct out of all the settings to request a line as below code refers:

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <gpiod.h>

#define CHIP0 "/dev/gpiochip0"

#define operation 4 //milliseconds

struct requests
{
	struct gpiod_line_settings *gpiodline_settings;
	struct gpiod_line_config *gpiodline_config;
	struct gpiod_request_config *gpiodreq_config;
	struct gpiod_chip *gpiodchip;

};

struct requests *request_line(int direction, int *offsets, size_t size_offsets, const char *gpiodfd, const char *consumer)
{
	struct gpiod_chip *chip = gpiod_chip_open(gpiodfd);
	if (!chip) 
	{
		printf("Failed to opened %s", gpiodfd);
		return NULL;
	}

	struct gpiod_request_config *req_config = gpiod_request_config_new();
	if (!req_config)
	{
		printf("Failed to create new config");
		goto clean;
	} 

	gpiod_request_config_set_consumer(req_config, consumer);


	struct gpiod_line_config *line_config = gpiod_line_config_new();
	if(!line_config)
	{
		printf("Failed to set configurations");
		goto clean;
	}

	struct gpiod_line_settings *line_settings = gpiod_line_settings_new();
	if(!line_settings)
	{
		printf("Failed to create new line settings");
		goto clean;
	}

	int setDirection, setValue, add_config_offsets; 

	switch(direction)
	{
		case 1:
			setValue = gpiod_line_settings_set_output_value(line_settings, GPIOD_LINE_VALUE_ACTIVE);

			if(setValue < 0)
			{
				printf("Failed to set line to active state");
				goto clean;
			}

			setDirection = gpiod_line_settings_set_direction(line_settings, GPIOD_LINE_DIRECTION_OUTPUT);

			if(setDirection < 0)
			{
				printf("Failed to set direction to output");
				goto clean;
			}

			add_config_offsets = gpiod_line_config_add_line_settings(line_config, offsets, size_offsets, line_settings);

			if(add_config_offsets < 0)
			{
				printf("Bulk settings failed to apply to offsets");
				goto clean;
			}
			break;

		case 0:
			setDirection = gpiod_line_settings_set_direction(line_settings, GPIOD_LINE_DIRECTION_INPUT);
			if(setDirection < 0)
			{
				printf("Failed to set direction to input");
				goto clean;	
			}

			add_config_offsets = gpiod_line_config_add_line_settings(line_config, offsets, size_offsets, line_settings);
			if(add_config_offsets < 0)
			{
				printf("Bulk settings failed to apply to offsets");
				goto clean;
			}
			break;
		default:
			printf("direction was set to %d. This must be either 1: Output or 0: Input", direction);
			goto clean;
	}	

	struct requests *results = malloc(sizeof(struct requests));
        if (!results) {
                printf("Memory allocation failed\n");
                goto clean;
        }

	results-> gpiodline_settings = line_settings;
        results-> gpiodline_config = line_config;
        results-> gpiodreq_config = req_config;
        results-> gpiodchip = chip;

        return results;

clean:
	if (line_settings)
		gpiod_line_settings_free(line_settings);
	if (line_config)
		gpiod_line_config_free(line_config);
	if (req_config)
		gpiod_request_config_free(req_config);
	if (chip)
		gpiod_chip_close(chip);
	return NULL;

}

int main()
{	
	int lines[1];  

	lines[0] = 20;
	
	//struct requests *request_line(int direction, int *offsets, size_t size_offsets, const char *gpiodfd, const char *consumer)	
	struct requests *dht11out = request_line(1 ,lines, 1, CHIP0, "DHT11-OUTPUT"); 
	if(!dht11out)
	{
		printf("Failed to request output lines");
		return -1;
	}
	
	
	//how could i reference dht11out variables to "actually execute them".


	sleep(2);

	gpiod_line_settings_free(dht11out->gpiodline_settings);  // Free the line settings
	gpiod_line_config_free(dht11out->gpiodline_config);          // Free the line configuration
	gpiod_request_config_free(dht11out->gpiodreq_config);        // Free the request configuration
	gpiod_chip_close(dht11out->gpiodchip);                       // Close the chip
	free(dht11out);
}


How would I actually go about executing things and start "turning on output" lines in main? Or, is it supported?

[brgl]

I'm afraid, I don't understand the question. What exactly do you want to do? What do you mean by "executing things"?

[Maru006]

Thanks for responding. I think my question was, once I set line configurations on the heap, how would I go about setting values to each lines using the configuration. Must I initialise the hierarchy again: chip -> configs -> line settings before calling set values?

A further issue i am encountering is int gpiod_line_request_set_values(struct gpiod_line_request *request, const enum [gpiod_line_value]) demands a gpiod_line_request *request which is by no means defined when doing bulk operations.

I seem to remember reading about another function with "gpiod_line_set_values_bulk" but this has dissappeared?

Thanks for your patience.

[brgl]

There are examples in the repo, please look here in general and here in particular.

[Maru006]

I must confess, despite looking at the docs, I was still struggling. However, I found the answer I was looking for.

It turns out I needed to set my mind straight that some of the functions are simply "to configure" things. Others, were to "toggle" things.

Essentially, what was missing in my code was two things:

struct gpiod_line_request *gpiod_chip_request_lines(struct gpiod_chip *chip, struct gpiod_request_config *req_cfg, struct gpiod_line_config *line_cfg);

int gpiod_line_request_set_values(struct gpiod_line_request *request, const enum [gpiod_line_value];

Therefore, for each switch statement for 0 or 1 in my code, I had to add (return into my struct):

gpiod_line_request *line = gpiod_chip_request_lines(chip, req_config, line_config);

And in my main, I had to pass this line into:

int toggle = gpiod_line_request_set_value(DHT11power-> gpiodline, lines[0], GPIOD_LINE_VALUE_ACTIVE);

brgl, I am new and I feel there could some edits made to the library for it to read better? Maybe it could advise on a hierarchy. I feel there should be a distinction between 'config' set-ups and 'toggles'. I am aware this point of view may not be shared by experts, but I thought I'd say anyway as you've been helpful!

[brgl]

Sure! Contributions are welcome! Especially for documentation. Please do try to wrap up what you learned in a way that you think may benefit new users and I'll be more than glad to include it.

[Maru006]

Since 3 weeks ago, I managed to complete this code. https://github.com/Maru006/contrib.git
It's using your library to operate DHT11 Humidity and Temperature sensor. I thought maybe u are interested to have it up as a sample code? I think it's pretty basic and shows how to request, free, and read from event buffer - this after seeing other examples there really did help me understand the library.

[brgl]

I'm not really sure what this one has that the examples already present in the repo don't?

[Maru006]

For some reason, going back to your repo examples, they make sense and appears comprehensive already - I forgot what I was struggling so much at the beginning - shame!

Maybe the more the merrier?

Also, I am happy for you to close this thread as I think I've solved my issue now. Thanks!