HII
does any one implemented an spi kernel module , so once i receive one byte of data on the spi bus i get an interrupt ?
i saw an example regarding a gpio , and was wondering how to do the same for spi or i2c or even a uart
You will need to use those two in your c code.
#include <epoll.h>
#include <pthreads.h>
Also highly recommend getting the book Beaglebone by Derrik Malloy. That is pretty much a goto book with the all the information in one location.
1 Like
hii thanks for your help , but do you have a c code that shows the implantation ?
Yes, we are using it so I cannot disclose it. Plenty of others on here that can do that and are able to publicly post.
You are better off puzzling it out on your own so you can better implement it in your project. Pretty sure if you search for epoll.h you can find some samples, that one is not too bad. Threading it would be best to find a good book on it and work out the examples and understand how it is implemented.
Also, if you are using GTK use the g_thread and g_thread_pool instead of pthread.h. You did not mention if you have a cli or desktop project.
Just thought about this option, we have been doing some testing with bing’s chat bot.
Here is the results for:
how to use epoll.h
epoll.h is a header file that defines the epoll API, a mechanism for monitoring multiple file descriptors for I/O events. The epoll API can be used in two modes: level-triggered and edge-triggered. Level-triggered mode notifies the caller whenever there is data to read or write on a file descriptor. Edge-triggered mode notifies the caller only when there is a change in the state of a file descriptor, such as when new data arrives or the buffer becomes full.
To use the epoll API, you need to follow these steps:
Create an epoll instance with epoll_create or epoll_create1.
Register interest in file descriptors with epoll_ctl, specifying the events you want to monitor, such as EPOLLIN for read or EPOLLOUT for write.
Call epoll_wait to wait for I/O events, optionally blocking the calling thread until some events are available.
Once epoll_wait returns, iterate through the events buffer and perform the appropriate I/O operations on the file descriptors that are ready.
Here is a simple example of using the epoll API in C:
#include <stdio.h> // for fprintf ()
#include <unistd.h> // for close ()
#include <sys/epoll.h> // for epoll_create1 ()
int main() {
int epoll_fd = epoll_create1(0); // create an epoll instance
if (epoll_fd == -1) {
fprintf(stderr, "Failed to create epoll file descriptorn");
return 1;
}
// register interest in stdin (file descriptor 0)
struct epoll_event event;
event.events = EPOLLIN; // monitor for read events
event.data.fd = 0; // associate stdin with this event
if (epoll_ctl(epoll_fd, EPOLL_CTL_ADD, 0, &event) == -1) {
fprintf(stderr, "Failed to add file descriptor to epoln");
return 1;
}
// wait for events
struct epoll_event events[10];
int num_events = epoll_wait(epoll_fd, events, 10, -1); // block until some events are available
if (num_events == -1) {
fprintf(stderr, "Failed to wait on epoln");
return 1;
}
// handle events
for (int i = 0; i < num_events; i++) {
if (events[i].events & EPOLLIN) { // check if the event is a read event
char buffer[100];
int bytes_read = read(events[i].data.fd, buffer, 100); // read from the file descriptor
if (bytes_read == -1) {
fprintf(stderr, "Failed to read from file descriptorn");
return 1;
}
printf("Read %d bytes: %s", bytes_read, buffer); // print what was read
}
}
// close the epoll file descriptor
if (close(epoll_fd)) {
fprintf(stderr, "Failed to close epoll file descriptorn");
return 1;
}
return 0;
}
Here is some more using the search query:
How to poll uart in c using epoll.h
#include <stdio.h> // for fprintf ()
#include <unistd.h> // for close (), read (), write ()
#include <sys/epoll.h> // for epoll_create1 (), epoll_ctl (), struct epoll_event
#include <termios.h> // for tcgetattr (), tcsetattr (), struct termios
#include <fcntl.h> // for open (), O_RDWR
#define UART_DEVICE "/dev/ttyUSB0" // change this to your UART device file
#define BAUD_RATE B9600 // change this to your desired baud rate
#define EPOLL_MAX_EVENTS 10 // maximum number of events to handle at a time
int main() {
// open the UART device file
int uart_fd = open(UART_DEVICE, O_RDWR | O_NOCTTY | O_NDELAY);
if (uart_fd == -1) {
fprintf(stderr, "Failed to open UART device %sn", UART_DEVICE);
return 1;
}
// configure the UART settings
struct termios options;
tcgetattr(uart_fd, &options); // get the current options
cfsetispeed(&options, BAUD_RATE); // set the input baud rate
cfsetospeed(&options, BAUD_RATE); // set the output baud rate
options.c_cflag |= (CLOCAL | CREAD); // enable the receiver and set local mode
options.c_cflag &= ~PARENB; // disable parity
options.c_cflag &= ~CSTOPB; // use one stop bit
options.c_cflag &= ~CSIZE; // mask the character size bits
options.c_cflag |= CS8; // use 8 data bits
options.c_lflag &= ~(ICANON | ECHO | ECHOE | ISIG); // use raw input mode
options.c_iflag &= ~(IXON | IXOFF | IXANY); // disable software flow control
options.c_oflag &= ~OPOST; // use raw output mode
tcsetattr(uart_fd, TCSANOW, &options); // set the new options
// create an epoll instance
int epoll_fd = epoll_create1(0);
if (epoll_fd == -1) {
fprintf(stderr, "Failed to create epoll file descriptorn");
return 1;
}
// register interest in the UART file descriptor
struct epoll_event event;
event.events = EPOLLIN | EPOLLOUT; // monitor for read and write events
event.data.fd = uart_fd; // associate the UART file descriptor with this event
if (epoll_ctl(epoll_fd, EPOLL_CTL_ADD, uart_fd, &event) == -1) {
fprintf(stderr, "Failed to add UART file descriptor to epoln");
return 1;
}
// wait for events
struct epoll_event events[EPOLL_MAX_EVENTS];
int num_events;
char buffer[100];
int bytes_read, bytes_written;
for (;;) {
num_events = epoll_wait(epoll_fd, events, EPOLL_MAX_EVENTS, -1); // block until some events are available
if (num_events == -1) {
fprintf(stderr, "Failed to wait on epoln");
return 1;
}
// handle events
for (int i = 0; i < num_events; i++) {
if (events[i].events & EPOLLIN) { // check if the event is a read event
bytes_read = read(events[i].data.fd, buffer, 100); // read from the UART file descriptor
if (bytes_read == -1) {
fprintf(stderr, "Failed to read from UART file descriptorn");
return 1;
}
printf("Read %d bytes: %s", bytes_read, buffer); // print what was read
}
if (events[i].events & EPOLLOUT) { // check if the event is a write event
bytes_written = write(events[i].data.fd, "Hello UARTn", 12); // write to the UART file descriptor
if (bytes_written == -1) {
fprintf(stderr, "Failed to write to UART file descriptorn");
return 1;
}
printf("Wrote %d bytes: Hello UARTn", bytes_written); // print what was written
}
}
}
// close the UART and epoll file descriptors
if (close(uart_fd)) {
fprintf(stderr, "Failed to close UART file descriptorn");
return 1;
}
if (close(epoll_fd)) {
fprintf(stderr, "Failed to close epoll file descriptorn");
return 1;
}
return 0;
}
Both do compile and run.
hii thanks for your reply , i think that i got the idea ,thanks so much for help 
1 Like