Controlling Hardware using GUI in Raspberry Pi -(Part 32/38)

The Graphical User Interface (GUI) helps the user to communicate with the system effortlessly. The GUI is considered as the front end of an application. In a Linux operating system each hardware device is represented as a file. The device can be controlled by simply reading and writing into that file. The hardware of an operating system is on the one side and the user trying to access the hardware is on the other side, and in between them there might be several layers of process running which communicates each other using inter process communication methods. The GUI is the process which the user can use to communicate with all these process layers and finally communicate with the Hardware. This project demonstrates how to create a GUI using the QT which can control the LEDs connected to the Raspberrypi board.

The Raspberry pi is a device which uses the Broadcom controller chip which is a SoC (System on Chip). This SoC has the ARM11 processor which runs on 700 MHz at its core. The operating systems like Archlinux ARM, OpenELEC, Pidora, Raspbmc, RISC OS and the Raspbian and also Ubuntu versions are available for the Raspberrypi board. Linux operating systems especially Ubuntu is preferred for all kind of programming and development. The Raspberrypi is a board actually designed for helping computer education for remote schools but it is a nice platform for programmers especially beginners to explore various coding techniques.

[[wysiwyg_imageupload:11009:]]

This project basically requires two programs which are meant to send data in between them, and a named pipe which will be created by anyone of them. The entire system can be represented with the help of the following diagram:

Block Diagram of LED Control and GUI using pipe file

Fig. 2: Block Diagram Of LED Control And GUI Using Pipe File

In the above figure LED_CONTROL is the process which creates the NAMED PIPE and always trying to read data from the pipe. The process LED_GUI is the process which has been created using QT and when it runs, it will create a GUI window with a few buttons corresponding to each LEDs. As the user clicks on those buttons, the GUI writes a corresponding code to the NAMED PIPE.

Fig. 3: GUI Writes Code To NAMED PIPE On Clicking Buttons

The functions used in the coding of the LED_CONTROL for creating the NAMED PIPE and for the reading and writing operations are explained in the following section.

mkfifo ()

The function mkfifo() creates a temporary file at the required directory with the required access permissions set on it. The prototype of the function is declared as the following;

int mkfifo ( const char *pathname, mode_t mode );

The first argument is the required pathname of the directory where the named pipe needs to be created. The second argument is the user permission that needs to be set on the file. Using the value 0777 as the second argument allows permission to all users of the system to read from and write into that named pipe. For using this function in the C code, two header files <sys/types.h> and <sys/stat.h> should be included.

mkfifo (“/tmp/my_fifo”, 0777 );

The above function call creates a named pipe called “my_fifo” in the location “/tmp” with access permission to all the users of the system.

open ()

The open () function opens a particular file at a specified path with the required flags set and it returns a file descriptor corresponding to that file to the process which called the open function. Using that file descriptor the process can access the file.

The prototype for the open () function is declared as the following;

int open ( const char *pathname, int flags );

The first argument is the path of the location where the file needs to be opened exists and the second parameter is the flags that need to be set for the file. The flags that set on the file decide the way in which the file can be accessed.

open ( “/tmp/my_fifo”, ( O_RDONLY | O_NONBLOCK ) );

The above function call opens the file named “my_fifo” in the location “/tmp” with the flags set to access the file as Read Only. The function call will returns a small positive integer value called file descriptor using which the process can access the file. The header files needed to be included when using this function is <sys/types.h> and <fcntl.h>.

read ()

The read () function tries to read the data from a file using its file descriptor generated by the open () function while opening it. The arguments of the functions decide the maximum number of bytes that can be read at a time and where to store the read data. It also returns the number of bytes of data successfully read from the file. The prototype of the function is declared in the header file <unistd.h> as given below;

ssize_t read ( int fd, void *buf, size_t count );

The first argument of the function is the file descriptor of the file that need to be read, the second argument is pointer to a data container into which the read data needs to be stored and the third argument is the maximum number of bytes that can be read into the data container.

read ( our_input_fifo_filestream, ( void* ) rx_buffer, 255 );

The above statement can read 255 characters of data at a time and store it in an array rx_buffer, and also returns the number of data read from the file at that particular attempt.

The code for the PROCESS 1 is written into a file say fifo.c and the compiled to an executable file say fifo. It is then executed from the terminal using the command;

./fifo

This will create a temporary file called ‘my_fifo’ in the directory /tmp. The user can write data into the temporary file from the terminal itself using the ‘echo’ command as shown in the following example.

echo abcdef >> /tmp/my_fifo

The LED_CONTROL process is written in such a way that it can read data that appears on the NAMED_PIPE and it can respond to a few set of data by turning a few LEDs of the Raspberrypi board on or off. The commands that can be written to the NAMED PIPE for controlling the LEDs are listed below;

10 -> LED_1 off

11 -> LED_1 on

20 -> LED_2 off

21 -> LED_2 on

30 -> LED_3 off

31 -> LED_3 on

40 -> LED_4 off

41 -> LED_4 on

These commands can be written into the NAMED PIPE corresponding to the LED CONTROL process from the command line using the ‘echo’ command as shown in the following example;

echo 11 >> /tmp/my_fifo

The above command will turn on the LED_1.