CPiE3Programs

Article Index

Page 6 of 21

Chapter 8

Page 122

Not a full program just a function definition

#define _DEFAULT_SOURCE

#include <stdio.h>

#include <unistd.h>

#include <stdlib.h>

#include <string.h>

void checkIRQ()

{

FILE *fp = popen("sudo dtparam -l", "r");

if (fp == NULL)

{

printf("Failed to run command\n\r");

exit(1);

}

char output[1024];

int txfound = 0;

while (fgets(output, sizeof(output), fp) != NULL)

{

printf("%s\n\r", output);

fflush(stdout);

if (strstr(output, "gpio-no-irq") != NULL)

{

txfound = 1;

}

pclose(fp);

if (txfound == 0)

{

fp = popen("sudo dtoverlay gpio-no-irq", "r");

if (fp == NULL)

{

printf("Failed to run command\n\r");

exit(1);

}

pclose(fp);

}

Page 126

#include <stdio.h>

#include <stdlib.h>

#include <bcm2835.h>

#include <unistd.h>

int main(int argc, char **argv)

{

if (!bcm2835_init())

return 1;

bcm2835_gpio_fsel(RPI_BPLUS_GPIO_J8_07, BCM2835_GPIO_FSEL_INPT);

bcm2835_gpio_fen(RPI_BPLUS_GPIO_J8_07);

bcm2835_gpio_ren(RPI_BPLUS_GPIO_J8_07);

volatile int i;

uint64_t t;

while (1)

{

bcm2835_gpio_set_eds(RPI_BPLUS_GPIO_J8_07);

while (0 == bcm2835_gpio_eds(RPI_BPLUS_GPIO_J8_07)) ;

t = bcm2835_st_read();

bcm2835_gpio_set_eds(RPI_BPLUS_GPIO_J8_07);

for (i = 0; i < 5000; i++)

{

if (1 == bcm2835_gpio_eds(RPI_BPLUS_GPIO_J8_07))

break;

}

t = bcm2835_st_read() - t;

printf("%d,%llu\n\r", i, t);

fflush(stdout);

}

return (EXIT_SUCCESS);

}

Page 127

#include <stdio.h>

#include <stdlib.h>

#include <bcm2835.h>

#include <unistd.h>

int main(int argc, char **argv)

{

if (!bcm2835_init())

return 1;

bcm2835_gpio_fsel(RPI_BPLUS_GPIO_J8_07, BCM2835_GPIO_FSEL_INPT);

bcm2835_gpio_fen(RPI_BPLUS_GPIO_J8_07);

bcm2835_gpio_clr_fen(RPI_BPLUS_GPIO_J8_07);

bcm2835_gpio_fsel(RPI_BPLUS_GPIO_J8_11, BCM2835_GPIO_FSEL_OUTP);

bcm2835_gpio_write(RPI_BPLUS_GPIO_J8_11, LOW);

uint64_t t;

while (1)

{

bcm2835_gpio_set_eds(RPI_BPLUS_GPIO_J8_07);

t = bcm2835_st_read();

for (;;)

{

if (1 == bcm2835_gpio_eds(RPI_BPLUS_GPIO_J8_07))

break;

}

t = bcm2835_st_read() - t;

bcm2835_gpio_write(RPI_BPLUS_GPIO_J8_11, HIGH);

bcm2835_gpio_write(RPI_BPLUS_GPIO_J8_11, LOW);

}

return (EXIT_SUCCESS);

}

Page 128

#include <stdio.h>

#include <stdlib.h>

#include <bcm2835.h>

#include <unistd.h>

int main(int argc, char **argv)

{

if (!bcm2835_init())

return 1;

bcm2835_gpio_fsel(RPI_BPLUS_GPIO_J8_07, BCM2835_GPIO_FSEL_INPT);

bcm2835_gpio_set_pud(RPI_BPLUS_GPIO_J8_07, BCM2835_GPIO_PUD_UP);

printf("Press button \n\r");

fflush(stdout);

sleep(20);

if (0 == bcm2835_gpio_lev(RPI_BPLUS_GPIO_J8_07))

{

printf("Button pressed \n\r");

}

else

{

printf("No Button press\n\r");

};

return 0;

}

Page 129

#include <stdio.h>

#include <stdlib.h>

#include <bcm2835.h>

#include <unistd.h>

int main(int argc, char **argv)

{

if (!bcm2835_init())

return 1;

bcm2835_gpio_fsel(RPI_BPLUS_GPIO_J8_07, BCM2835_GPIO_FSEL_INPT);

bcm2835_gpio_set_pud(RPI_BPLUS_GPIO_J8_07, BCM2835_GPIO_PUD_UP);

bcm2835_gpio_fen(RPI_BPLUS_GPIO_J8_07);

bcm2835_gpio_set_eds(RPI_BPLUS_GPIO_J8_07);

printf("Press button \n\r");

fflush(stdout);

sleep(20);

if (bcm2835_gpio_eds(RPI_BPLUS_GPIO_J8_07))

{

printf("Button pressed \n\r");

}

else

{

printf("No Button press\n\r");

};

return 0;

}

Page 132

#include <string.h>

#include <stdio.h>

#include <errno.h>

#include <unistd.h>

#include <fcntl.h>

#include <sys/ioctl.h>

#include <linux/gpio.h>

#include <sys/epoll.h>

int main(int argc, char **argv) {

int fd, ret;

struct gpioevent_request req;

req.lineoffset = 4;

req.handleflags = GPIOHANDLE_REQUEST_INPUT;

req.eventflags = GPIOEVENT_REQUEST_RISING_EDGE;

strcpy(req.consumer_label, "Event test");

fd = open("/dev/gpiochip0", O_RDONLY);

ret = ioctl(fd, GPIO_GET_LINEEVENT_IOCTL, &req);

close(fd);

static struct epoll_event ev;

ev.events = EPOLLIN;

ev.data.fd = req.fd;

int epfd = epoll_create(1);

int res = epoll_ctl(epfd, EPOLL_CTL_ADD, req.fd, &ev);

int nfds = epoll_wait(epfd, &ev, 1, 20000);

if (nfds != 0) {

struct gpioevent_data edata;

read(req.fd, &edata, sizeof edata);

printf("%u,%llu", edata.id, edata.timestamp);

}

Page 137

#include <string.h>

#include <stdio.h>

#include <errno.h>

#include <unistd.h>

#include <fcntl.h>

#include <sys/ioctl.h>

#include <linux/gpio.h>

#include <sys/epoll.h>

#include <pthread.h>

uint64_t t[20];

typedef void (*eventHandler)(int);

typedef struct

{

int epfd;

int fd;

eventHandler func;

} intVec;

void myHandler(int fd)

{

struct gpioevent_data edata;

read(fd, &edata, sizeof edata);

printf("%u,%llu \n\r", edata.id, edata.timestamp);

fflush(stdout);

}

void *waitInterrupt(void *arg)

{

intVec *intData = (intVec *)arg;

struct epoll_event ev;

for (;;)

{

int nfds = epoll_wait(intData->epfd, &ev, 1, 20000);

if (nfds != 0)

{

intData->func(intData->fd);

}

int main(int argc, char **argv)

{

int fd, ret;

struct gpioevent_request req;

req.lineoffset = 4;

req.handleflags = GPIOHANDLE_REQUEST_INPUT;

req.eventflags = GPIOEVENT_REQUEST_RISING_EDGE;

strcpy(req.consumer_label, "Event test");

fd = open("/dev/gpiochip0", O_RDONLY);

ret = ioctl(fd, GPIO_GET_LINEEVENT_IOCTL, &req);

close(fd);

static struct epoll_event ev;

ev.events = EPOLLIN;

ev.data.fd = req.fd;

int epfd = epoll_create(1);

int res = epoll_ctl(epfd, EPOLL_CTL_ADD, req.fd, &ev);

intVec intData;

intData.epfd = epfd;

intData.fd = req.fd;

intData.func = &myHandler;

pthread_t intThread;

if (pthread_create(&intThread, NULL, waitInterrupt,

(void *)&intData))

{

fprintf(stderr, "Error creating thread\n");

return 1;

}

for (;;)

{

printf("Working\n\r");

fflush(stdout);

sleep(2);

}

page 140

#include <pthread.h>

#include <stdio.h>

#include <string.h>

#include <bcm2835.h>

#include <fcntl.h>

#include <unistd.h>

#include <poll.h>

#define BUFFER_MAX 50

typedef void (*eventHandler)();

int openGPIO(int pin, int direction);

int writeGPIO(int gpio, int value);

int readGPIO(int gpio);

int setEdgeGPIO(int gpio, char *edge);

void *waitInterrupt(void *arg);

int attachGPIO(int gpio, char *edge, eventHandler func);

int fd[32] = {0};

typedef struct

{

int fd;

int gpio;

eventHandler func;

} intVec;

intVec intData;

static int count;

void myIntHandler()

{

count++;

};

int main(int argc, char **argv)

{

attachGPIO(4, "both", myIntHandler);

for (;;)

{

printf("Interrupt %d\n\r", count);

fflush(stdout);

};

return 0;

}

int openGPIO(int gpio, int direction)

{

if (gpio < 0 || gpio > 31)

return -1;

if (direction < 0 || direction > 1)

return -2;

int len;

char buf[BUFFER_MAX];

if (fd[gpio] != 0)

{

close(fd[gpio]);

fd[gpio] = open("/sys/class/gpio/unexport", O_WRONLY);

len = snprintf(buf, BUFFER_MAX, "%d", gpio);

write(fd[gpio], buf, len);

close(fd[gpio]);

fd[gpio] = 0;

}

fd[gpio] = open("/sys/class/gpio/export", O_WRONLY);

len = snprintf(buf, BUFFER_MAX, "%d", gpio);

write(fd[gpio], buf, len);

close(fd[gpio]);

len = snprintf(buf, BUFFER_MAX,

"/sys/class/gpio/gpio%d/direction", gpio);

fd[gpio] = open(buf, O_WRONLY);

if (direction == 1)

{

write(fd[gpio], "out", 4);

close(fd[gpio]);

len = snprintf(buf, BUFFER_MAX,

"/sys/class/gpio/gpio%d/value", gpio);

fd[gpio] = open(buf, O_WRONLY);

}

else

{

write(fd[gpio], "in", 3);

close(fd[gpio]);

len = snprintf(buf, BUFFER_MAX,

"/sys/class/gpio/gpio%d/value", gpio);

fd[gpio] = open(buf, O_RDONLY);

}

return 0;

}

int writeGPIO(int gpio, int b)

{

if (b == 0)

{

write(fd[gpio], "0", 1);

}

else

{

write(fd[gpio], "1", 1);

}

lseek(fd[gpio], 0, SEEK_SET);

return 0;

}

int readGPIO(int gpio)

{

char value_str[3];

int c = read(fd[gpio], value_str, 3);

lseek(fd[gpio], 0, SEEK_SET);

if (value_str[0] == '0')

{

return 0;

}

else

{

return 1;

}

int setEdgeGPIO(int gpio, char *edge)

{

char buf[BUFFER_MAX];

int len = snprintf(buf, BUFFER_MAX,

"/sys/class/gpio/gpio%d/edge", gpio);

int fd = open(buf, O_WRONLY);

write(fd, edge, strlen(edge) + 1);

close(fd);

return 0;

}

int attachGPIO(int gpio, char *edge, eventHandler func)

{

openGPIO(gpio, 0);

setEdgeGPIO(gpio, edge);

readGPIO(gpio);

intData.fd = fd[gpio];

intData.gpio = gpio;

intData.func = func;

pthread_t intThread;

if (pthread_create(&intThread,

NULL, waitInterrupt, (void *)&intData))

{

fprintf(stderr, "Error creating thread\n");

return 1;

}

return 0;

}

void *waitInterrupt(void *arg)

{

intVec *intData = (intVec *)arg;

int gpio = intData->gpio;

struct pollfd fdset[1];

fdset[0].fd = intData->fd;

fdset[0].events = POLLPRI;

fdset[0].revents = 0;

for (;;)

{

int rc = poll(fdset, 1, -1);

if (fdset[0].revents & POLLPRI)

{

intData->func();

lseek(fdset[0].fd, 0, SEEK_SET);

readGPIO(gpio);

}

pthread_exit(0);

}

Article Index

Chapter 8

Page 122

Page 126

Page 127

Page 128

Page 129

Page 132

Page 137

page 140

Main Menu