gpiod_test.c

Go to the documentation of this file.

#include <errno.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
#include <gpiod.h>
#include <unistd.h>
 
#include "gpio.hpp"
 
#define GPIO_FHR1 30
#define GPIO_FHR2 60
#define GPIO_LED_STATUS 45
#define GPIO_LED_ERROR 44
#define GPIO_BUTTON 26
#define GPIO_POWER 31
 
static struct gpiod_chip *gpio_chip0 = nullptr;
 
static struct gpiod_chip *gpio_led_error_chip = nullptr;
 
static struct gpiod_chip *gpio_led_status_chip = nullptr;
 
static struct gpiod_line *gpio_power = nullptr;
 
static struct gpiod_line *gpio_led_error = nullptr;
 
static struct gpiod_line *gpio_led_status = nullptr;
 
int main(void) {
    int ret = 0;
 
    gpio_chip0 = gpiod_chip_open_by_number(0);
    if (gpio_chip0 == nullptr) {
        fprintf(stderr, "Failed opening GPIO controller 0. %d message: %s\n",
                errno, strerror(errno));
        exit(EXIT_FAILURE);
    }
 
    gpio_led_error_chip = gpiod_chip_open_by_number(1);
    if (gpio_led_error_chip == nullptr) {
        fprintf(stderr, "Failed opening GPIO controller 1. %d message: %s\n",
                errno, strerror(errno));
        exit(EXIT_FAILURE);
    }
    gpio_led_status_chip = gpiod_chip_open_by_number(GPIO_LED_STATUS / 32);
    if (gpio_led_status_chip == nullptr) {
        fprintf(stderr, "Failed opening GPIO controller 1. %d message: %s\n",
                errno, strerror(errno));
        exit(EXIT_FAILURE);
    }
 
    gpio_power = gpiod_chip_get_line(gpio_chip0, GPIO_POWER);
    if (gpio_power == nullptr) {
        fprintf(stderr, "Failed opening power GPIO line. %d message: %s\n",
                errno, strerror(errno));
        exit(EXIT_FAILURE);
    }
 
    gpio_led_error =
        gpiod_chip_get_line(gpio_led_error_chip, GPIO_LED_ERROR % 32);
    if (gpio_led_error == nullptr) {
        fprintf(stderr, "Failed opening error LED GPIO line. %d message: %s\n",
                errno, strerror(errno));
        exit(EXIT_FAILURE);
    }
 
    gpio_led_status =
        gpiod_chip_get_line(gpio_led_status_chip, GPIO_LED_STATUS % 32);
    if (gpio_led_status == nullptr) {
        fprintf(stderr, "Failed opening status LED GPIO line. %d message: %s\n",
                errno, strerror(errno));
        exit(EXIT_FAILURE);
    }
 
    // get GPIO line info
    const char *gpio_power_name = gpiod_line_name(gpio_power);
    bool gpio_power_used = gpiod_line_is_used(gpio_power);
    printf("Power GPIO name: %s\t in use: %d\n", gpio_power_name,
           gpio_power_used);
 
    const char *gpio_led_error_name = gpiod_line_name(gpio_led_error);
    bool gpio_led_error_used = gpiod_line_is_used(gpio_led_error);
    printf("Error LED GPIO name: %s\t in use: %d\n", gpio_led_error_name,
           gpio_led_error_used);
 
    const char *gpio_led_status_name = gpiod_line_name(gpio_led_status);
    bool gpio_led_status_used = gpiod_line_is_used(gpio_led_status);
    printf("Error LED GPIO name: %s\t in use: %d\n", gpio_led_status_name,
           gpio_led_status_used);
 
    // request and configure power GPIO line
    ret = gpiod_line_request_output(gpio_power, "gpio_pwr", 0);
    if (ret < 0) {
        fprintf(stderr, "Failed configuring power GPIO line. %d message: %s\n",
                errno, strerror(errno));
        exit(EXIT_FAILURE);
    }
    ret = gpiod_line_request_output(gpio_led_error, "gpio_led_error", 0);
    if (ret < 0) {
        fprintf(stderr,
                "Failed configuring error LED GPIO line. %d message: %s\n",
                errno, strerror(errno));
        exit(EXIT_FAILURE);
    }
    ret = gpiod_line_request_output(gpio_led_status, "gpio_led_status", 0);
    if (ret < 0) {
        fprintf(stderr,
                "Failed configuring status LED GPIO line. %d message: %s\n",
                errno, strerror(errno));
        exit(EXIT_FAILURE);
    }
 
    // get GPIO line info
    const char *gpio_power_name1 = gpiod_line_name(gpio_power);
    bool gpio_power_used1 = gpiod_line_is_used(gpio_power);
    printf("Power GPIO name: %s\t in use: %d\n", gpio_power_name1,
           gpio_power_used1);
 
    const char *gpio_led_error_name1 = gpiod_line_name(gpio_led_error);
    bool gpio_led_error_used1 = gpiod_line_is_used(gpio_led_error);
    printf("Error LED GPIO name: %s\t in use: %d\n", gpio_led_error_name1,
           gpio_led_error_used1);
 
    const char *gpio_led_status_name1 = gpiod_line_name(gpio_led_status);
    bool gpio_led_status_used1 = gpiod_line_is_used(gpio_led_status);
    printf("Error LED GPIO name: %s\t in use: %d\n", gpio_led_status_name1,
           gpio_led_status_used1);
 
    // power up for 5 seconds
    printf("power up RocketLogger Cape\n");
    ret = gpiod_line_set_value(gpio_power, 1);
    if (ret < 0) {
        fprintf(stderr, "Failed setting power GPIO line. %d message: %s\n",
                errno, strerror(errno));
        exit(EXIT_FAILURE);
    }
    ret = gpiod_line_set_value(gpio_led_error, 1);
    if (ret < 0) {
        fprintf(stderr, "Failed setting LED error GPIO line. %d message: %s\n",
                errno, strerror(errno));
        exit(EXIT_FAILURE);
    }
    ret = gpiod_line_set_value(gpio_led_status, 1);
    if (ret < 0) {
        fprintf(stderr, "Failed setting LED status GPIO line. %d message: %s\n",
                errno, strerror(errno));
        exit(EXIT_FAILURE);
    }
 
    sleep(5);
 
    printf("power down RocketLogger Cape\n");
    ret = gpiod_line_set_value(gpio_power, 0);
    if (ret < 0) {
        fprintf(stderr, "Failed setting power GPIO line. %d message: %s\n",
                errno, strerror(errno));
        exit(EXIT_FAILURE);
    }
    ret = gpiod_line_set_value(gpio_led_error, 0);
    if (ret < 0) {
        fprintf(stderr, "Failed setting LED error GPIO line. %d message: %s\n",
                errno, strerror(errno));
        exit(EXIT_FAILURE);
    }
    ret = gpiod_line_set_value(gpio_led_status, 0);
    if (ret < 0) {
        fprintf(stderr, "Failed setting LED status GPIO line. %d message: %s\n",
                errno, strerror(errno));
        exit(EXIT_FAILURE);
    }
 
    // release resources
    gpiod_line_release(gpio_led_status);
    gpiod_line_release(gpio_led_error);
    gpiod_line_release(gpio_power);
 
    gpiod_line_update(gpio_led_status);
    gpiod_line_update(gpio_led_error);
    gpiod_line_update(gpio_power);
 
    // get GPIO line info
    const char *gpio_power_name2 = gpiod_line_name(gpio_power);
    bool gpio_power_used2 = gpiod_line_is_used(gpio_power);
    printf("Power GPIO name: %s\t in use: %d\n", gpio_power_name2,
           gpio_power_used2);
 
    const char *gpio_led_error_name2 = gpiod_line_name(gpio_led_error);
    bool gpio_led_error_used2 = gpiod_line_is_used(gpio_led_error);
    printf("Error LED GPIO name: %s\t in use: %d\n", gpio_led_error_name2,
           gpio_led_error_used2);
 
    const char *gpio_led_status_name2 = gpiod_line_name(gpio_led_status);
    bool gpio_led_status_used2 = gpiod_line_is_used(gpio_led_status);
    printf("Error LED GPIO name: %s\t in use: %d\n", gpio_led_status_name2,
           gpio_led_status_used2);
 
    gpiod_line_close_chip(gpio_led_status);
    gpiod_line_close_chip(gpio_led_error);
    gpiod_line_close_chip(gpio_power);
 
    // abstracted GPIO handling
    // //////////////////////////////////////////////////////////////////////
    printf("Wait and test GPIO API\n");
 
    sleep(2);
 
    ret = gpio_init();
    if (ret < 0) {
        fprintf(stderr, "Failed setting power GPIO line. %d message: %s\n",
                errno, strerror(errno));
        exit(EXIT_FAILURE);
    }
 
    // setup GPIO line
    gpio_power = gpio_setup(GPIO_POWER, GPIO_MODE_OUT, "gpio_pwr");
    if (gpio_power == nullptr) {
        fprintf(stderr, "Failed configuring power GPIO line. %d message: %s\n",
                errno, strerror(errno));
        exit(EXIT_FAILURE);
    }
    gpio_led_error =
        gpio_setup(GPIO_LED_ERROR, GPIO_MODE_OUT, "gpio_led_error");
    if (gpio_led_error == nullptr) {
        fprintf(stderr,
                "Failed configuring error LED GPIO line. %d message: %s\n",
                errno, strerror(errno));
        exit(EXIT_FAILURE);
    }
    gpio_led_status =
        gpio_setup(GPIO_LED_STATUS, GPIO_MODE_OUT, "gpio_led_status");
    if (gpio_led_status == nullptr) {
        fprintf(stderr,
                "Failed configuring status LED GPIO line. %d message: %s\n",
                errno, strerror(errno));
        exit(EXIT_FAILURE);
    }
 
    // power up for 5 seconds
    printf("power up RocketLogger Cape\n");
    ret = gpio_set_value(gpio_power, 1);
    if (ret < 0) {
        fprintf(stderr, "Failed setting power GPIO line. %d message: %s\n",
                errno, strerror(errno));
        exit(EXIT_FAILURE);
    }
    ret = gpio_set_value(gpio_led_error, 1);
    if (ret < 0) {
        fprintf(stderr, "Failed setting LED error GPIO line. %d message: %s\n",
                errno, strerror(errno));
        exit(EXIT_FAILURE);
    }
    ret = gpio_set_value(gpio_led_status, 1);
    if (ret < 0) {
        fprintf(stderr, "Failed setting LED status GPIO line. %d message: %s\n",
                errno, strerror(errno));
        exit(EXIT_FAILURE);
    }
 
    gpio_t *gpio_button =
        gpio_setup_interrupt(GPIO_BUTTON, GPIO_INTERRUPT_BOTH, "gpio_button");
    if (gpio_button == nullptr) {
        fprintf(stderr,
                "Failed setting up interrupt for button GPIO line. %d message: "
                "%s\n",
                errno, strerror(errno));
        exit(EXIT_FAILURE);
    }
 
    struct timespec timeout = {
        .tv_sec = 3,
        .tv_nsec = 0,
    };
 
    printf("wait for button press with timeout of %ld.%09ld sec\n",
           timeout.tv_sec, timeout.tv_nsec);
 
    do {
        ret = gpio_wait_interrupt(gpio_button, &timeout);
        if (ret < 0) {
            fprintf(
                stderr,
                "Failed waiting for button GPIO interrupt. %d message: %s\n",
                errno, strerror(errno));
            exit(EXIT_FAILURE);
        }
        printf("button interrupt triggered with level %d\n", ret);
    } while (ret != 1);
 
    printf("power down RocketLogger Cape\n");
    ret = gpio_set_value(gpio_power, 0);
    if (ret < 0) {
        fprintf(stderr, "Failed setting power GPIO line. %d message: %s\n",
                errno, strerror(errno));
        exit(EXIT_FAILURE);
    }
    ret = gpio_set_value(gpio_led_error, 0);
    if (ret < 0) {
        fprintf(stderr, "Failed setting LED error GPIO line. %d message: %s\n",
                errno, strerror(errno));
        exit(EXIT_FAILURE);
    }
    ret = gpio_set_value(gpio_led_status, 0);
    if (ret < 0) {
        fprintf(stderr, "Failed setting LED status GPIO line. %d message: %s\n",
                errno, strerror(errno));
        exit(EXIT_FAILURE);
    }
 
    gpio_release(gpio_button);
    gpio_release(gpio_power);
    gpio_release(gpio_led_error);
    gpio_release(gpio_led_status);
 
    gpio_deinit();
 
    return 0;
}