Mirrors_Framework/c-periphery
1
0
Fork 0
mirror of https://github.com/vsergeev/c-periphery.git synced 2026-02-06 15:12:17 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity
Files
master
c-periphery/tests/test_gpio.c
Vanya A. Sergeev fe9e870960 tests/gpio: add debounce to open/close test
2025-11-02 00:01:25 -05:00

514 lines
17 KiB
C
Raw Permalink Blame History

/*
* c-periphery
* https://github.com/vsergeev/c-periphery
* License: MIT
*/
#include "test.h"
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <sys/wait.h>
#include <pthread.h>
#include <semaphore.h>
#include <unistd.h>
#include "../src/gpio.h"
const char *device;
unsigned int pin_input, pin_output;
void test_arguments(void) {
gpio_t *gpio;
ptest();
/* Allocate GPIO */
gpio = gpio_new();
passert(gpio != NULL);
/* Invalid direction */
passert(gpio_open(gpio, device, pin_input, 5) == GPIO_ERROR_ARG);
/* Free GPIO */
gpio_free(gpio);
}
void test_open_config_close(void) {
gpio_t *gpio;
bool value;
gpio_direction_t direction;
gpio_edge_t edge;
gpio_event_clock_t event_clock;
char label[32];
gpio_bias_t bias;
gpio_drive_t drive;
bool inverted;
uint32_t debounce_us;
ptest();
/* Allocate GPIO */
gpio = gpio_new();
passert(gpio != NULL);
/* Open non-existent GPIO */
passert(gpio_open(gpio, device, -1, GPIO_DIR_IN) == GPIO_ERROR_OPEN);
passert(gpio_errno(gpio) == EINVAL);
/* Open legitimate GPIO */
passert(gpio_open(gpio, device, pin_output, GPIO_DIR_IN) == 0);
/* Check properties */
passert(gpio_line(gpio) == pin_output);
passert(gpio_fd(gpio) >= 0);
passert(gpio_chip_fd(gpio) >= 0);
/* Check default label */
passert(gpio_label(gpio, label, sizeof(label)) == 0);
passert(strncmp(label, "periphery", sizeof(label)) == 0);
/* Invalid direction */
passert(gpio_set_direction(gpio, 5) == GPIO_ERROR_ARG);
/* Invalid interrupt edge */
passert(gpio_set_edge(gpio, 5) == GPIO_ERROR_ARG);
/* Invalid event clock */
passert(gpio_set_event_clock(gpio, 5) == GPIO_ERROR_ARG);
/* Invalid bias */
passert(gpio_set_bias(gpio, 5) == GPIO_ERROR_ARG);
/* Invalid drive */
passert(gpio_set_drive(gpio, 5) == GPIO_ERROR_ARG);
/* Set direction out, check direction out, check value low */
passert(gpio_set_direction(gpio, GPIO_DIR_OUT) == 0);
passert(gpio_get_direction(gpio, &direction) == 0);
passert(direction == GPIO_DIR_OUT);
passert(gpio_read(gpio, &value) == 0);
passert(value == false);
/* Set direction out low, check direction out, check value low */
passert(gpio_set_direction(gpio, GPIO_DIR_OUT_LOW) == 0);
passert(gpio_get_direction(gpio, &direction) == 0);
passert(direction == GPIO_DIR_OUT);
passert(gpio_read(gpio, &value) == 0);
passert(value == false);
/* Set direction out high, check direction out, check value high */
passert(gpio_set_direction(gpio, GPIO_DIR_OUT_HIGH) == 0);
passert(gpio_get_direction(gpio, &direction) == 0);
passert(direction == GPIO_DIR_OUT);
passert(gpio_read(gpio, &value) == 0);
passert(value == true);
/* Set drive open drain, check drive open drain */
passert(gpio_set_drive(gpio, GPIO_DRIVE_OPEN_DRAIN) == 0);
passert(gpio_get_drive(gpio, &drive) == 0);
passert(drive == GPIO_DRIVE_OPEN_DRAIN);
/* Set drive open source, check drive open source */
passert(gpio_set_drive(gpio, GPIO_DRIVE_OPEN_SOURCE) == 0);
passert(gpio_get_drive(gpio, &drive) == 0);
passert(drive == GPIO_DRIVE_OPEN_SOURCE);
/* Set drive default, check drive default */
passert(gpio_set_drive(gpio, GPIO_DRIVE_DEFAULT) == 0);
passert(gpio_get_drive(gpio, &drive) == 0);
passert(drive == GPIO_DRIVE_DEFAULT);
/* Set inverted true, check inverted true */
passert(gpio_set_inverted(gpio, true) == 0);
passert(gpio_get_inverted(gpio, &inverted) == 0);
passert(inverted == true);
/* Set inverted false, check inverted false */
passert(gpio_set_inverted(gpio, false) == 0);
passert(gpio_get_inverted(gpio, &inverted) == 0);
passert(inverted == false);
/* Attempt to set interrupt edge on output GPIO */
passert(gpio_set_edge(gpio, GPIO_EDGE_RISING) == GPIO_ERROR_INVALID_OPERATION);
/* Attempt to set event clock on output GPIO */
passert(gpio_set_event_clock(gpio, GPIO_EVENT_CLOCK_HTE) == GPIO_ERROR_INVALID_OPERATION);
/* Attempt to set debounce on output gpio */
passert(gpio_set_debounce_us(gpio, 10) == GPIO_ERROR_INVALID_OPERATION);
/* Attempt to read event on output GPIO */
passert(gpio_read_event(gpio, &edge, NULL) == GPIO_ERROR_INVALID_OPERATION);
/* Set direction in, check direction in */
passert(gpio_set_direction(gpio, GPIO_DIR_IN) == 0);
passert(gpio_get_direction(gpio, &direction) == 0);
passert(direction == GPIO_DIR_IN);
passert(gpio_read(gpio, &value) == 0);
/* Set edge none, check edge none */
passert(gpio_set_edge(gpio, GPIO_EDGE_NONE) == 0);
passert(gpio_get_edge(gpio, &edge) == 0);
passert(edge == GPIO_EDGE_NONE);
/* Set edge rising, check edge rising */
passert(gpio_set_edge(gpio, GPIO_EDGE_RISING) == 0);
passert(gpio_get_edge(gpio, &edge) == 0);
passert(edge == GPIO_EDGE_RISING);
/* Set edge falling, check edge falling */
passert(gpio_set_edge(gpio, GPIO_EDGE_FALLING) == 0);
passert(gpio_get_edge(gpio, &edge) == 0);
passert(edge == GPIO_EDGE_FALLING);
/* Set edge both, check edge both */
passert(gpio_set_edge(gpio, GPIO_EDGE_BOTH) == 0);
passert(gpio_get_edge(gpio, &edge) == 0);
passert(edge == GPIO_EDGE_BOTH);
/* Set event clock realtime, check event clock realtime */
passert(gpio_set_event_clock(gpio, GPIO_EVENT_CLOCK_REALTIME) == 0);
passert(gpio_get_event_clock(gpio, &event_clock) == 0);
passert(event_clock == GPIO_EVENT_CLOCK_REALTIME);
/* Set event clock monotonic, check event clock monotonic */
passert(gpio_set_event_clock(gpio, GPIO_EVENT_CLOCK_MONOTONIC) == 0);
passert(gpio_get_event_clock(gpio, &event_clock) == 0);
passert(event_clock == GPIO_EVENT_CLOCK_MONOTONIC);
/* Set debounce period, check debounce period */
passert(gpio_set_debounce_us(gpio, 10) == 0);
passert(gpio_get_debounce_us(gpio, &debounce_us) == 0);
passert(debounce_us == 10);
/* Disable debounce period, check debounce period */
passert(gpio_set_debounce_us(gpio, 0) == 0);
passert(gpio_get_debounce_us(gpio, &debounce_us) == 0);
passert(debounce_us == 0);
/* Set bias pull up, check bias pull up */
passert(gpio_set_bias(gpio, GPIO_BIAS_PULL_UP) == 0);
passert(gpio_get_bias(gpio, &bias) == 0);
passert(bias == GPIO_BIAS_PULL_UP);
/* Set bias pull down, check bias pull down */
passert(gpio_set_bias(gpio, GPIO_BIAS_PULL_DOWN) == 0);
passert(gpio_get_bias(gpio, &bias) == 0);
passert(bias == GPIO_BIAS_PULL_DOWN);
/* Set bias disable, check bias disable */
passert(gpio_set_bias(gpio, GPIO_BIAS_DISABLE) == 0);
passert(gpio_get_bias(gpio, &bias) == 0);
passert(bias == GPIO_BIAS_DISABLE);
/* Set bias default, check bias default */
passert(gpio_set_bias(gpio, GPIO_BIAS_DEFAULT) == 0);
passert(gpio_get_bias(gpio, &bias) == 0);
passert(bias == GPIO_BIAS_DEFAULT);
/* Attempt to set drive on input GPIO */
passert(gpio_set_drive(gpio, GPIO_DRIVE_OPEN_DRAIN) == GPIO_ERROR_INVALID_OPERATION);
/* Close GPIO */
passert(gpio_close(gpio) == 0);
/* Open GPIO with advanced open */
gpio_config_t config = {
.direction = GPIO_DIR_IN,
.edge = GPIO_EDGE_RISING,
.bias = GPIO_BIAS_DEFAULT,
.drive = GPIO_DRIVE_DEFAULT,
.inverted = false,
.label = "test123",
};
passert(gpio_open_advanced(gpio, device, pin_input, &config) == 0);
/* Check properties */
passert(gpio_line(gpio) == pin_input);
passert(gpio_fd(gpio) >= 0);
passert(gpio_chip_fd(gpio) >= 0);
/* Check direction */
passert(gpio_get_direction(gpio, &direction) == 0);
passert(direction == GPIO_DIR_IN);
/* Check edge */
passert(gpio_get_edge(gpio, &edge) == 0);
passert(edge == GPIO_EDGE_RISING);
/* Check bias */
passert(gpio_get_bias(gpio, &bias) == 0);
passert(bias == GPIO_BIAS_DEFAULT);
/* Check drive */
passert(gpio_get_drive(gpio, &drive) == 0);
passert(drive == GPIO_DRIVE_DEFAULT);
/* Check inverted */
passert(gpio_get_inverted(gpio, &inverted) == 0);
passert(inverted == false);
/* Check label */
passert(gpio_label(gpio, label, sizeof(label)) == 0);
passert(strncmp(label, "test123", sizeof(label)) == 0);
/* Close GPIO */
passert(gpio_close(gpio) == 0);
/* Free GPIO */
gpio_free(gpio);
}
/* Threaded poll helper functions */
typedef struct {
sem_t *sem;
gpio_t *gpio;
int timeout_ms;
} gpio_poll_args_t;
void *gpio_poll_thread(void *arg) {
gpio_poll_args_t *args = (gpio_poll_args_t *)arg;
gpio_t *gpio = args->gpio;
int timeout_ms = args->timeout_ms;
assert(sem_post(args->sem) == 0);
intptr_t ret = gpio_poll(gpio, timeout_ms);
return (void *)ret;
}
void gpio_poll_start(pthread_t *thread, gpio_t *gpio, int timeout_ms) {
sem_t sem;
gpio_poll_args_t args = {.sem = &sem, .gpio = gpio, .timeout_ms = timeout_ms};
assert(sem_init(&sem, 0, 0) == 0);
assert(pthread_create(thread, NULL, &gpio_poll_thread, &args) == 0);
assert(sem_wait(&sem) == 0);
}
int gpio_poll_join(pthread_t thread) {
void *ret;
assert(pthread_join(thread, &ret) == 0);
return (intptr_t)ret;
}
void test_loopback(void) {
gpio_t *gpio_in, *gpio_out;
pthread_t poll_thread;
bool value;
gpio_edge_t edge;
ptest();
/* Allocate GPIO */
gpio_in = gpio_new();
passert(gpio_in != NULL);
gpio_out = gpio_new();
passert(gpio_out != NULL);
/* Open in and out pins */
passert(gpio_open(gpio_in, device, pin_input, GPIO_DIR_IN) == 0);
passert(gpio_open(gpio_out, device, pin_output, GPIO_DIR_OUT) == 0);
/* Drive out low, check in low */
passert(gpio_write(gpio_out, false) == 0);
passert(gpio_read(gpio_in, &value) == 0);
passert(value == false);
/* Drive out high, check in high */
passert(gpio_write(gpio_out, true) == 0);
passert(gpio_read(gpio_in, &value) == 0);
passert(value == true);
/* Check poll falling 1 -> 0 interrupt */
passert(gpio_set_edge(gpio_in, GPIO_EDGE_FALLING) == 0);
gpio_poll_start(&poll_thread, gpio_in, 1000);
passert(gpio_write(gpio_out, false) == 0);
passert(gpio_poll_join(poll_thread) == 1);
passert(gpio_read(gpio_in, &value) == 0);
passert(value == false);
passert(gpio_read_event(gpio_in, &edge, NULL) == 0);
passert(edge == GPIO_EDGE_FALLING);
/* Check poll rising 0 -> 1 interrupt */
passert(gpio_set_edge(gpio_in, GPIO_EDGE_RISING) == 0);
gpio_poll_start(&poll_thread, gpio_in, 1000);
passert(gpio_write(gpio_out, true) == 0);
passert(gpio_poll_join(poll_thread) == 1);
passert(gpio_read(gpio_in, &value) == 0);
passert(value == true);
passert(gpio_read_event(gpio_in, &edge, NULL) == 0);
passert(edge == GPIO_EDGE_RISING);
/* Set both edge */
passert(gpio_set_edge(gpio_in, GPIO_EDGE_BOTH) == 0);
/* Check poll falling 1 -> 0 interrupt */
gpio_poll_start(&poll_thread, gpio_in, 1000);
passert(gpio_write(gpio_out, false) == 0);
passert(gpio_poll_join(poll_thread) == 1);
passert(gpio_read(gpio_in, &value) == 0);
passert(value == false);
passert(gpio_read_event(gpio_in, &edge, NULL) == 0);
passert(edge == GPIO_EDGE_FALLING);
/* Check poll rising 0 -> 1 interrupt */
gpio_poll_start(&poll_thread, gpio_in, 1000);
passert(gpio_write(gpio_out, true) == 0);
passert(gpio_poll_join(poll_thread) == 1);
passert(gpio_read(gpio_in, &value) == 0);
passert(value == true);
passert(gpio_read_event(gpio_in, &edge, NULL) == 0);
passert(edge == GPIO_EDGE_RISING);
/* Check poll timeout */
passert(gpio_poll(gpio_in, 1000) == 0);
/* Test gpio_poll_multiple() API with one GPIO */
gpio_t *gpios[1] = {gpio_in};
bool gpios_ready[1] = {false};
/* Check poll falling 1 -> 0 interrupt */
passert(gpio_write(gpio_out, false) == 0);
passert(gpio_poll_multiple(gpios, 1, 1000, gpios_ready) == 1);
passert(gpios_ready[0] == true);
passert(gpio_read(gpio_in, &value) == 0);
passert(value == false);
passert(gpio_read_event(gpio_in, &edge, NULL) == 0);
passert(edge == GPIO_EDGE_FALLING);
/* Check poll rising 0 -> 1 interrupt */
passert(gpio_write(gpio_out, true) == 0);
passert(gpio_poll_multiple(gpios, 1, 1000, gpios_ready) == 1);
passert(gpios_ready[0] == true);
passert(gpio_read(gpio_in, &value) == 0);
passert(value == true);
passert(gpio_read_event(gpio_in, &edge, NULL) == 0);
passert(edge == GPIO_EDGE_RISING);
/* Check poll timeout */
passert(gpio_poll_multiple(gpios, 1, 1000, gpios_ready) == 0);
passert(gpios_ready[0] == false);
passert(gpio_close(gpio_in) == 0);
passert(gpio_close(gpio_out) == 0);
/* Open both GPIOs as inputs */
passert(gpio_open(gpio_in, device, pin_input, GPIO_DIR_IN) == 0);
passert(gpio_open(gpio_out, device, pin_output, GPIO_DIR_IN) == 0);
/* Set bias pull-up, check value is high */
passert(gpio_set_bias(gpio_in, GPIO_BIAS_PULL_UP) == 0);
usleep(1000);
passert(gpio_read(gpio_in, &value) == 0);
passert(value == true);
/* Set bias pull-down, check value is low */
passert(gpio_set_bias(gpio_in, GPIO_BIAS_PULL_DOWN) == 0);
usleep(1000);
passert(gpio_read(gpio_in, &value) == 0);
passert(value == false);
passert(gpio_close(gpio_in) == 0);
passert(gpio_close(gpio_out) == 0);
/* Free GPIO */
gpio_free(gpio_in);
gpio_free(gpio_out);
}
bool getc_yes(void) {
char buf[4];
fgets(buf, sizeof(buf), stdin);
return (buf[0] == 'y' || buf[0] == 'Y');
}
void test_interactive(void) {
gpio_t *gpio_in, *gpio_out;
char str[256];
gpio_edge_t edge;
uint64_t timestamp;
ptest();
/* Allocate GPIO */
gpio_out = gpio_new();
passert(gpio_out != NULL);
gpio_in = gpio_new();
passert(gpio_in != NULL);
/* Open output pin */
passert(gpio_open(gpio_out, device, pin_output, GPIO_DIR_OUT) == 0);
printf("Starting interactive test. Get out your multimeter, buddy!\n");
printf("Press enter to continue...\n");
getc(stdin);
/* Check tostring */
passert(gpio_tostring(gpio_out, str, sizeof(str)) > 0);
printf("GPIO description: %s\n", str);
printf("GPIO description looks OK? y/n\n");
passert(getc_yes());
/* Drive GPIO out low */
passert(gpio_write(gpio_out, false) == 0);
printf("GPIO out is low? y/n\n");
passert(getc_yes());
/* Drive GPIO out high */
passert(gpio_write(gpio_out, true) == 0);
printf("GPIO out is high? y/n\n");
passert(getc_yes());
/* Drive GPIO out low */
passert(gpio_write(gpio_out, false) == 0);
printf("GPIO out is low? y/n\n");
passert(getc_yes());
/* Open input pin */
passert(gpio_open(gpio_in, device, pin_input, GPIO_DIR_IN) == 0);
/* Set both edge and realtime event clock */
passert(gpio_set_edge(gpio_in, GPIO_EDGE_BOTH) == 0);
passert(gpio_set_event_clock(gpio_in, GPIO_EVENT_CLOCK_REALTIME) == 0);
/* Read line event with realtime event clock */
printf("Driving GPIO out high and reading GPIO in line event...");
passert(gpio_write(gpio_out, true) == 0);
passert(gpio_read_event(gpio_in, &edge, &timestamp) == 0);
passert(edge == GPIO_EDGE_RISING);
printf("Line event timestamp %zu is realtime? y/n\n", timestamp);
passert(getc_yes());
/* Set monotonic event clock */
passert(gpio_set_event_clock(gpio_in, GPIO_EVENT_CLOCK_MONOTONIC) == 0);
/* Read line event with monotonic event clock */
printf("Driving GPIO out low and reading GPIO in line event...");
passert(gpio_write(gpio_out, false) == 0);
passert(gpio_read_event(gpio_in, &edge, &timestamp) == 0);
passert(edge == GPIO_EDGE_FALLING);
printf("Line event timestamp %zu is monotonic? y/n\n", timestamp);
passert(getc_yes());
passert(gpio_close(gpio_in) == 0);
passert(gpio_close(gpio_out) == 0);
/* Free GPIO */
gpio_free(gpio_out);
gpio_free(gpio_in);
}
int main(int argc, char *argv[]) {
if (argc < 4) {
fprintf(stderr, "Usage: %s <GPIO chip device> <GPIO #1> <GPIO #2>\n\n", argv[0]);
fprintf(stderr, "[1/4] Argument test: No requirements.\n");
fprintf(stderr, "[2/4] Open/close test: GPIO #2 should be real.\n");
fprintf(stderr, "[3/4] Loopback test: GPIOs #1 and #2 should be connected with a wire.\n");
fprintf(stderr, "[4/4] Interactive test: GPIO #2 should be observed with a multimeter.\n\n");
fprintf(stderr, "Hint: for Raspberry Pi 3,\n");
fprintf(stderr, "Use GPIO 17 (header pin 11) and GPIO 27 (header pin 13),\n");
fprintf(stderr, "connect a loopback between them, and run this test with:\n");
fprintf(stderr, " %s /dev/gpiochip0 17 27\n\n", argv[0]);
exit(1);
}
device = argv[1];
pin_input = strtoul(argv[2], NULL, 10);
pin_output = strtoul(argv[3], NULL, 10);
test_arguments();
printf(" " STR_OK " Arguments test passed.\n\n");
test_open_config_close();
printf(" " STR_OK " Open/close test passed.\n\n");
test_loopback();
printf(" " STR_OK " Loopback test passed.\n\n");
test_interactive();
printf(" " STR_OK " Interactive test passed.\n\n");
printf("All tests passed!\n");
return 0;
}
Reference in New Issue View Git Blame Copy Permalink