There is a Linux-based approach to working with GPIO lines and serial buses that is worth knowing about because it provides an alternative to using the bcm2835 library. Sometimes you need this because you are working in a language for which direct access to memory isn't available. It is also the only way to make interrupts available in a C program.

 

Having Linux on a system that is being used for real time control is quite different to the situation with most microcontrollers where nothing gets between your code and the hardware. The sophistication of Linux is a great advantage when it comes to interfacing with complex hardware such as WiFi but it is as distinct disadvantage when it comes to interfacing with simple fast hardware like the GPIO. Put simply you have to learn to do things in a way that Linux finds natural even if this seems strange and convoluted to you as a microcontroller programmer. 

Take for example GPIO access - how can this be made available to the general programmer in a way that is natural to Linux? You can't simply allow direct memory access to the hardware because this cuts across Linux's control of memory allocation and security. You have to find something that Linux already supports in a general way to map the GPIO access on to.

A key principle of Linux is that everything is a file or a folder. As much as is possible Linux deals with external hardware by treating it as if it was a file system. This is reasonable because external hardware either wants to receive data as commands or something to store or display or it want to send data as responses or user input. So most hardware interacts with Linux as a source or a sink of data and this is exactly what a file is all about. 

This "everything is a file" approach only really fails when issues of performance enter the picture.

Accessing a piece of hardware as if it was a file when it isn't can be slow. In normal use direct memory access is much faster and it is what the bcm2835 library is all about. We look at how this works in more detail in a later chapter. 

So file-based access to the hardware can be slow, but it has the huge advantage that it is language-independent. Every language has the facilities needed to open, read/write and close a file and so has the facilities needed to work with hardware via the file system. 

It also has the advantage that it works with Linux rather than just ignoring it. The system knows about files and understands how to work with them. This allows it to offer advanced features like interrupts to GPIO users that fit in with the way other Linux interrupts work. More of this in the next chapter.

It may seem crazy to you, especially if you know how the underlying hardware works, to treat a single GPIO line as it if was a file but it works. Files are a fundamental data type in Linux and a GPIO line is something you read from or write too just like a file. From the Linux point of view it makes perfect sense. 

The big problem is that the details of how hardware is represented as a file system is poorly documented and you have to find out about it by guessing, trial and error, reverse engineering, or by reading code the makes use of it. 

Working with Sysfs

Sysfs is a virtual file system that provides all sorts of access to hardware and the operation of the Linux kernel. You can spend a lot of time exploring Sysfs, but the only part we are particularly interested in is the gpio folder. Sysfs is usually mounted in the sys folder and the folder that corresponds to the gpio device is usually:

/sys/class/gpio

To see what is in the folder, simply list it:

ls /sys/class/gpio

 

The list includes the gpio lines that are already in use by some process or other. Notice that the gpio numbers are not external pin numbers, but internal GPIO numbers. So for example to use the GPIO line that is on physical pin 7 on the connector you need to refer to GPIO 4.

The steps in using a line are always the same:

• Reserve or "export" the gpio line so that no other process can use it
• Set its direction and read or write it
• Unreserve it or unexport it 

You can do these steps from any language that supports file operations including the shell. 

You might ask why you have to "export" or reserve a GPIO line rather than just use it? 

The answer is that the export operation will only work if the OS hasn't claimed the GPIO line for its own use or some other process hasn't claimed it. You can think of the export/unexport process as making sure that you don't misuse GPIO lines and that you don't share them with other processes. 

To reserve a gpio line you have to write its number to the export folder and you can do this using the shell command. For example, assuming we want to work with gpio-44:

echo 4 > /sys/class/gpio/export

You can of course change 4 to any valid gpio number.

You can do the same job in C:

#include <stdio.h>
#include <string.h>

int main(int argc, char** argv) {
    int gpio = 4;
    FILE* fd = fopen("/sys/class/gpio/export", "w");
    fprintf(fd, "%d", gpio);
    fclose(fd);
    return 0;
}

​If you are not familiar with C file operations - the fopen function opens export for write, the fprintf string prints  the number of the gpio line and then the file is closed. 

Once you have the pin reserved you will see a new folder gpio4 corresponding to it in /sys/class/gpio.

Now that you have it reserved, you can set its direction and read or write it. To do you have to  read or write to the appropriate sub folder of the new gpio folder, direction or value. If you list all of the folders in gpio4 you will see 

 

Each of these folders controls some aspect of the GPIO lines functioning. The most important of these are

direction - set to in or out

and

value - set to 0 or 1 and read 0 or 1 for input.

There is also active_low which determines which way the logic operates. It determines is the line low corresponds to a one or a zero. 

For example, to read the line from the command line use:

echo "in" > /sys/class/gpio/gpio4/direction

cat /sys/class/gpio/gpio4/value

and to set the line high and then low:

echo "out" > /sys/class/gpio/gpio4/direction

echo 1 > /sys/class/gpio/gpio4/value
echo 0 > /sys/class/gpio/gpio4/value

You can do the same things using C but it is slightly more verbose due to the need to open and close files and build the appropriate strings.