Siguenos en ...

Google+facebooktwitter

youtubepinterest RSS aquihayapuntes

Últimos Tutoriales

Licencia

Creative Commons

 

Todo el contenido de este sitio está bajo una licencia de Creative Commons

 

Raspberry Pi: Programando el puerto GPIO con Qt Creator

Raspberry Pi GPIO con QtEste es un tutorial que recopila las pruebas y video tutoriales que he realizado con Qt y el control del puerto GPIO de la Raspberry Pi por medio de sencillas interfaces gráficas creadas con Qt creator. El tutorial describe paso a paso y con vídeos demostrativos la instalación y configuración de Qt creator en la Raspberry Pi con el sistema operativo Raspbian previamente instalado así como el código fuente de los ejemplos.

 

 

 

 

 

Instalación y configuración de Qt Creator

Qt es un entorno de programación que apareció hace ya unos cuantos años y que hoy en día se sigue abriendo camino con paso firme y ganando popularidad día a día siendo una alternativa multiplataforma para el desarrollo de aplicaciones con o sin interfaz gráfica. Podéis ver su evolución histórica en la wikipedia.

Al ser multiplataforma podemos reutilizar el código fuente y compilarlo en diferentes plataformas y arquitecturas sin apenas modificaciones. El siguiente vídeo tutorial es una introducción de cómo podemos utilizar Qt y sus herramientas de desarrollo en un sistema embebido como es la Raspberry PI.


 

Programando el puerto GPIO de la Raspberry Pi con Qt Creator

La Raspberry Pi dispone de un puerto de expansión de entradas y salidas de propósito general conocido como GPIO y que se accede a él a través de un conector de cabecera rotulado como P1 en la placa. Todos los pines menos los de alimentación y masa son reconfigurables y por tanto podremos adaptarlos a nuestras necesidades, aunque por defecto una serie de pines están configurados para la conexión de las interfaces UART, I2C y SPI. La disposición y funciones de sus pines para la placa perteneciente a la Rev 2 es la que se muestra en la figura de abajo, los pines GPIO 4, GPIO 17, GPIO 27, GPIO 22, GPIO18, GPIO23, GPIO 24 y GPIO 25 son los que viene configurados por defecto para entradas y salidas digitales.

 

Pinout Raspberry Pi

 

Nota: La Rev.2 de la placa incluye otro conector con ocho pines de expansión que están a la izquierda del principal y que no tiene soldado ningún zócalo y que por detrás de la placa viene rotulado como P5 (ese conector no lo utilizaremos en estos ejemplos), al final del artículo viene un enlace donde se explica en detalle todos los conectores de la Raspberry Pi.

Hay que tener en cuenta también que el puerto GPIO de la Raspberry Pi no está protegido ante cortocircuitos y sobretensiones. Los pines son compatibles con niveles de 3.3V y como máximo la corriente que pude circular por cada pin es de 50 mA por tanto si queremos conectar dispositivos que funcionan a niveles de 5V o que consuman una corriente mayor deberemos hacerlo a través de un Buffer o cualquier otro circuito que nos adapte los niveles de tensión y de corriente, de no hacerlo así podremos provocar daños en el hardware de nuestra raspberry Pi.

 

Un ejemplo de ON/OFF de una bombilla de 220 V AC.

 

 

 

Esquema de conexión:

Esquema conexión

 

Comentario:

El circuito es muy sencillo, como comento en el vídeo se utilizan dos adaptadores de niveles: por un lado el Buffer 74LS126 cuyo datasheet lo podéis descargar desde aquí.

Y que permite adaptar los 3.3 V de la Raspberry Pi a los 5v necesarios para el relé de potencia y el otro adaptador es el propio relé que a través de sus contactos nos permite encender o apagar una bombilla de 220 V AC de 60 W de potencia.

El esquema de la placa del circuito impreso donde va soldado el relé de potencia es el siguiente:

Esquema relé de Potencia

Aunque el módulo se puede conseguir fácilmente por Internet y a muy buen precio.

Código fuente:

GPIO.pro

 
 
#------------------------------------------------- 
# 
# Project created by QtCreator 2013-06-29T18:24:51 
# 
#------------------------------------------------- 
QT += core gui 
greaterThan(QT_MAJOR_VERSION, 4): QT += widgets 
TARGET = GPIO__1 
TEMPLATE = app 
SOURCES += main.cpp\ 
 mainwindow.cpp 
HEADERS += mainwindow.h 
FORMS += mainwindow.ui 
RESOURCES += \ 
 iconos.qrc 
 
 


mainwindows.h

 
#ifndef MAINWINDOW_H 
#define MAINWINDOW_H 
#include <QMainWindow> 
namespace Ui { 
class MainWindow; 
} 
class MainWindow : public QMainWindow 
{ 
 Q_OBJECT 
 
public: 
 explicit MainWindow(QWidget *parent = 0); 
 ~MainWindow(); 
 
private slots: 
 
 void on_Encender_clicked(); 
 void on_Apagar_clicked(); 
 void on_actionConfigurar_triggered(); 
 void on_actionSalir_triggered(); 
private: 
 Ui::MainWindow *ui; 
}; 
#endif // MAINWINDOW_H 
 
 


main.cpp

 
 
#include "mainwindow.h" 
#include "ui_mainwindow.h" 
MainWindow::MainWindow(QWidget *parent) : 
 QMainWindow(parent), 
 ui(new Ui::MainWindow) 
{ 
 ui->setupUi(this); 
} 
MainWindow::~MainWindow() 
{ 
 delete ui; 
} 
void MainWindow::on_Encender_clicked() 
{ 
 system("echo 0 >/sys/class/gpio/gpio23/value"); 
} 
void MainWindow::on_Apagar_clicked() 
{ 
 system("echo 1 >/sys/class/gpio/gpio23/value"); 
} 
void MainWindow::on_actionConfigurar_triggered() 
{ 
 system("echo 23 >/sys/class/gpio/export"); 
 system("chmod 777 -R /sys/class/gpio/gpio23 "); 
 system("echo out >/sys/class/gpio/gpio23/direction"); 
} 
void MainWindow::on_actionSalir_triggered() 
{ 
 system("echo 23 >/sys/class/gpio/unexport"); 
 exit(0); 
} 
 


Comentario:

El código es muy sencillo y no necesita ninguna librería adicional, se utilizan comandos del sistema operativo que seguro que muchos de vosotros los habréis utilizado ya, pero quizás escribiéndolos desde la consola de comandos de Linux.

Nota: al final del artículo hay un enlace donde se explican los comandos utilizados.

Qt permite la llamada a comandos del sistema a través de la función system().Por tanto solo hay que incluir esa función con los comandos del sistema que queramos dentro de las funciones de la señales clic de los botones que incluyamos en la interfaz gráfica que diseñemos y que en este ejemplo es la siguiente:

 

Interfaz Gráfica

Fácil ¿no? ..

 

Configurando el puerto serie de la Raspberry Pi

 

A diferencia de la Beagleboard en la Raspberry Pi la UART viene por defecto configurada para ser utilizada como entrada y salida de datos de la consola de comandos del sistema operativo (esto es útil como “debugger” para saber que está ocurriendo en nuestra Raspberry Pi cuando por ejemplo no tengamos salida de vídeo). Esto significa que para poder utilizar el puerto serie como usuario en nuestras aplicaciones, previamente deberemos de configurarlo para ello. En el siguiente vídeo tutorial se describe dicho proceso paso a paso:

 

Programando el puerto serie de la Raspberry Pi con Qt

 

Para poder programar el puerto serie con Qt necesitamos utilizar librerías adicionales. Qt creator no dispone de un componente en la tabla de herramientas como tienen otros IDES de programación como por ejemplo Microsoft Visual Studio, para arrastrarlo a la interfaz gráfica de nuestra aplicación y simplemente configurarlo con los parámetros necesarios para empezar a trabajar con él. Esto que en un principio puede parecer un inconveniente en realidad no lo es, ya que te da más flexibilidad a la hora de elegir la librería que quieres utilizar en tú proyecto. Cuando yo empecé a programar el puerto serie con Qt en la BeagleBoard

una de las librerías más extendida para la gestión del puerto serie con Qt era qextserialport. Más adelante cuando Nokia abandono Qt y Digia se quedo por completo con todo su desarrollo tanto para las librerías libres como para las comerciales sus desarrolladores decidieron dar soporte a QtSerialPort que a su vez está basada en la librería QSerialDevice.

Hoy en día ambas librerías están actualizadas y funcionan bien tanto en Qt4 como en Qt5 y disponen de ejemplos tanto de consola como con interfaz gráfica para empezar a usarlas y entender su funcionamiento.

En el siguiente vídeo se muestra como crearnos una interfaz gráfica en la Raspberry Pi para comunicarnos con un terminal de puerto serie en un PC de escritorio.



Fuentes de información

Gobernar un Microcontrolador desde la BeagleBoard
http://qt-project.org/wiki/QtSerialPort
http://elinux.org/RPi_Low-level_peripherals
http://elinux.org/GPIO
http://code.google.com/p/qextserialport/
http://www.raspberrypi.org/
BCM2835 Datasheet

 

Mi conclusión

Los desarrolladores de Raspberry Pi decidieron poner como lenguaje oficial de la Raspberry Pi Phyton un lenguaje muy poderoso sin duda pero basado en script, aunque hay programas para hacer interfaces gráficas con Phyton los sistemas operativos disponibles y optimizados para la Raspberry Pi no incluyen ninguno. Bajo mi punto de vista sí que es verdad que un sistema embebido con limitados recursos hardware no es ideal para correr complejas aplicaciones gráficas ya que se comerían todos los recursos del sistema solo para presentar y refrescar la interfaz gráfica del usuario, pero también es verdad que a veces podemos necesitar crear pequeñas aplicaciones con un entorno gráfico como las mostradas en este artículo y en ese caso Qt va muy bien bajo mi punto de vista.

Me gustaría que los desarrolladores de la Raspberry dieran mas soporte a Qt tanto en la actualización de las librerías de Qt en sus repositorios como un mayor apoyo a la hora de utilizar compiladores cruzados. He creado una versión en .pdf del artículo que podéis descargar desde aquí. Para que los que opinen igual que yo lo podáis distribuir libremente y así el uso de Qt en la Raspberry pueda llegar a más gente que aún no lo conozca. No sé, quizás si fuéramos muchos los que pensáramos así algún día veamos alguna distribución para la Raspberry Pi con Qt instalado.


Si conocéis otra alternativa mejor para crear aplicaciones con interfaz gráfica para la raspberry Pi podéis comentarlo en el siguiente subforo. Tú opinión sí que importa.

Un saludo y hasta la próxima.





 

 

 

© 2007-2017 AquiHayapuntes.com