Para todos los neófitos en lenguaje C, y más aún para los desconocedores de Linux, la compilación de

programas en la Raspberry Pi puede resultar un obstáculo insalvable, pero vamos a intentar desmitificar esta
barrera y proporcionar a los más noveles en esto del C una base sólida a partir de la cual podrán comenzar a
experimentar más y más con su pequeña tarjeta Linux.

En este punto deberíamos aclarar que el sistema operativo Linux que opera en la Raspberry Pi no es,
esencialmente, tan diferente de cualquier distribución Linux instalada en un PC. Una característica que define al
sistema Linux es su total integración con el lenguaje C (no hemos de olvidar que comparten orígenes), por lo
que programar en C en nuestra RasPi no requiere instalación de software añadido alguno… si, has escuchado
bien, el C y el Linux coexisten en nuestra pequeña tarjeta.

Así que, explicado este punto, vamos a comenzar a utilizar el entorno Linux para programar en lenguaje C. Y
como no hay mejor manera de iniciarse que con un ejemplo vamos a emular a Dennis Ritchie (creador del
lenguaje C) y a recrear uno de sus más conocidos ejemplos….

Como diría Jack el destripador … “vayamos por partes”

(1) En nuestro terminal Linux verificamos que el entorno C está instalado y listo para su uso. Para ello
ejecutamos gcc -v , a continuación se nos mostrarán una serie de parámetros (en cuya descripción no
entraremos ahora) y que serán algo así:

(2) Borramos nuestra pantalla (clear) y a continuación:

– vamos a la carpeta raiz de nuestro usuario (en pincipi, pi) -> cd /home/pi

– verificamos que estamos realmente ahí -> pwd

– creamos la carpeta curso para colocar el código escrito/generado -> mkdir curso

– verificamos que la carpeta está correctamente creada -> ls -l

– entramos en la carpeta -> cd curso

– verificamos (opcionalmente) de nuevo nuestra ubicación -> pwd

 nota: este paso es opcional ya
ya suele indicarnos donde esta

1 nota: este paso es opcional ya que el cursor de Linux

2 ya suele indicarnos donde estamos

– ahora creamos un fichero vacio -> touch hola.c

– verificamos que se ha creado y está vacío (ocupa 0 bytes) -> ls -l

– lo editamos (usamos el mini editor nano) -> nano hola.c

– escribimos “algo original” en nuestro primer programa

#include <stdio.h>

int main() {
printf(“Hola Mundo desde mi RasPi ….”);
return 0;
}
– salimos y guardamos (Ctrl-X, Si, Enter)

– verificamos que hola.c ya no ocupa 0 bytes -> ls -l

– opcionalmente podemos verificar rápidamente el contenido -> more hola.c

– compilamos el programa hola.c así (es un ejemplo) -> gcc -o holaPi hola.c

vemos que en la línea de comandos hemos indicado:

gcc => llamada al compilador C del Linux

-o holaPi => indicamos el nombre de salida del fichero ejecutable

hola.c => indicamos el nombre del fichero fuente a compilar

– vemos qué es lo que se ha generado en /curso -> ls -l

 nota: se ha generado el ejecuta

<a href="http://w w w .diverteka.

nota: se ha generado el ejecutable holaPi

1
<a href="http://www.diverteka.com/wp-content/uploads/2012/11/curso_c_05.jpg"><img
2
class="aligncenter wp-image-235" title="curso_c_05" src="http://www.diverteka.com/wp-
3
content/uploads/2012/11/curso_c_05.jpg" alt="" width="581" height="128" /></a>
4
5
- y, por fín, ejecutamos nuestro primer programa -&gt; <strong><span style="color:
#0000ff;">./holaPi</span></strong>

¡¡Problema !! … vemos que el resultado no es exactamente el esperado ya que se imprime el texto programado
pero ¡¡ no se salta a la línea siguiente !!. Para solucionar esto hemos de editar nuestro programa y añadir un
caracter de control que C interprete como salto de línea. En este caso es : \n . por lo que el nuevo código
quedará así:

#include <stdio.h>

int main() {
printf(“Hola Mundo desde mi RasPi ….\n”);
return 0;
}

– editamos y corregimos

– compilamos de nuevo, obteniendo

Espero que este primer y muy básico ejemplo os haya sido de utilidad.
Errata de los essentials

Errata
Apologies for the following errata in Learn to Code with C. If you spot any errors in our books or magazines
please email us via errata@raspberrypi.org. This list also appears on the Raspberry Pi forum.

On page 28, the code block contains the line int a = 5;

This should be:

int a = 0;

On page 61 of the book, the use of the * as an argument to the program is mangled by the shell on Unix
(although it does work correctly on Windows). To fix this for Unix, replace the line:

if (*argv[2] == '*') printf ("%d\n", arg1 * arg2);

with

if (*argv[2] == 'x') printf ("%d\n", arg1 * arg2);

and use ‘x’ rather than ‘*’ for multiplication.

On page 64, the code block contains the line for (value = 30; value < 40; value++)

This should be

for (value = 48; value < 58; value++)

In the paragraph following this code block, the description “writing the bytes 30, 3…39“” should be “writing
the bytes 48, 49…57“.
En la actualidad, para raspbian se puede programar en mucho lenguajes como JAVASCRIPT, PHYTON,
C/C++, Etc. Aunque los más usados normalmente son python y C, en parte porque están implícitos en raspbian,
son lenguajes universales y básicos en programación.

Los sistemas operativos, en este caso GNU/Linux, puede ser manejado por medio de entornos gráficos. Sin
embargo no es la única forma de operar un sistema. También podemos manejarlo por medio de líneas de
comandos que se ingresan por medio de una terminal (también llamada consola) y que funciona como una
interfaz entre el usuario y el sistema operativo.

Los comandos ejecutados en la consola, son operadores o funciones que se utilizan para acceder a directorios o
archivos del sistema o para realizar tareas específicas (copiar, mover, o visualizar archivos).

 La terminal en raspbian es la forma más básica y fácil de programar, configurar e incluso instalar programas,
actualizaciones, bibliotecas, etc, sin contar que raspbian es una versión reducida de debian, por lo que existen
funciones que solo pueden ser utilizadas por medio de la propia terminal.
Para esta practica necesitaremos:

 Raspberry
 1 Led
 1 Resistencia.

Ejemplo con terminal:

 Lo primero es haber conectado y energizado nuestra raspberry (con raspbian ya instalado). Por defecto el
usuario: pi, PASWORD: raspbian
 Después de habernos autenticado se escribe el comando startx, y nos mostrará lo siguiente.

 Lo siguiente es armar un circuito sencillo para probar los puertos. El led irá a un pin gnd y al pin 17 y nos deberá
quedar algo como esto:
  Ahora la manera en la que vamos a acceder a los GPIO es como si fuesen directorios. Podemos utilizar
comandos como ‘ls‘, ‘cat‘ o ‘echo‘, entre otros, para conocer la estructura y contenidos de los directorios.

Ahora mismo no tenemos ningún pin accesible. Ni de entrada, ni de salida. Tenemos que crearlo nosotros
mismos. Queremos tener acceso al GPIO 17, así que introducimos el siguiente comando:

1 echo 17 > /sys/class/gpio/export

Tras esto, el sistema ha creado un archivo con una estructura GPIO que corresponde al número 17.

 A continuación, tenemos que informar a la Raspberry Pi si el pin va a ser de salida o de entrada. Como lo que
queremos es encender un LED, el GPIO 17 será de salida. Entonces introducimos el siguiente comando:

1 echo out > /sys/class/gpio/gpio17/direction

Con esto, el sistema ya sabe que el pin será de salida. Ahora tendremos que darle valores. Existen dos posibles:
‘0’ y ‘1’.

 Para encender el LED

1 echo 1 > /sys/class/gpio/gpio17/value

 Para apagar el LED

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

 Una vez que hayamos acabado de encender y apagar el LED, tendremos que eliminar la entrada GPIO creada, es
decir, el GPIO 17. Para ello introduciremos el siguiente comando:

1 echo 17 > /sys/class/gpio/unexport

 Con lo anterior hemos aprendido a crear , y eliminar la configuración de un GPIO, como también ponerlo en el
estado que se desea utilizando la terminal de linux.
Ahora hablaremos un poco de “C”

Dispone de las estructuras típicas de los lenguajes de alto nivel pero, a su vez, dispone de construcciones del
lenguaje que permiten un control a muy bajo nivel

Algunas propiedades:

 Un núcleo del lenguaje simple, con funcionalidades añadidas importantes, como funciones matemáticas y de
manejo de archivos, proporcionadas por bibliotecas.
 Es un lenguaje muy flexible que permite programar con múltiples estilos.
 Un sistema de tipos que impide operaciones sin sentido.
 Acceso a memoria de bajo nivel mediante el uso de punteros

Ejemplos en C:

 Ante todo, limpiamos nuestra terminal con el comando “clear”.

 Vamos a la carpeta raiz de nuestro usuario -> cd /home/pi
 Verificamos que estamos realmente ahí -> pwd
 Creamos la carpeta curso para colocar el código escrito/generado -> mkdir Ejemplo
 Verificamos que la carpeta está correctamente creada -> ls -l
 Entramos en la carpeta -> cd Ejemplo
 Verificamos (opcionalmente) de nuevo nuestra ubicación -> pwd
 Verificamos (opcionalmente) de nuevo nuestra ubicación -> pwd
 Ahora creamos un fichero vacio -> touch hola.c
 Verificamos que se ha creado y está vacío (ocupa 0 bytes) -> ls -l
 lo editamos (usamos el mini editor nano) -> nano hola.c

Escribimos “algo original” en nuestro primer programa:

#include

int main() {
printf(“Hola Mundo desde mi Raspi...\n”);
return 0;
}
  Salimos y guardamos (Ctrl-X y Enter)
 Verificamos que hola.c ya no ocupa 0 bytes -> ls -l

opcionalmente podemos verificar rápidamente el contenido -> more hola.c

Lo cual nos mostraría algo como esto:

Compilamos el programa hola.c así (es un ejemplo) ->

1 gcc -o holaPi hola.c

 Vemos que en la línea de comandos hemos indicado:

gcc => llamada al compilador C del Linux

-o holaPi => indicamos el nombre de salida del archivo ejecutable

hola.c => indicamos el nombre del archivo fuente a compilar

Vemos qué es lo que se ha generado en /Ejemplo -> ls –l

Y, por fin, ejecutamos nuestro primer programa -> ./holaPi

Y por ultimo veremos Phyton el cual es otro de los lenguajes mas utilizados en esta clase de sistemas

¿Qué es Phyton?

Python es un lenguaje de programación interpretado cuya filosofía hace hincapié en una sintaxis que favorezca
un código legible.

Es orientado a objetos, preparado para realizar cualquier tipo de programa, desde aplicaciones Windows a
servidores de red, Es un lenguaje interpretado, lo que significa que no se necesita compilar el código fuente
para poder ejecutarlo, lo que ofrece ventajas como la rapidez de desarrollo e inconvenientes como una menor
velocidad.

Ejemplo phyton:

 Instalaremos la biblioteca para poder controlar los GPIO con Python. Está alojada en SourceForge la cual
debimos haber descargado previamente, pero podemos descargarla en la Raspberry Pi con el siguiente
comando:

wget 'http://downloads.sourceforge.net/project/raspberry-gpio-python/RPi.GPIO-
1
0.5.4.tar.gz‘

 Una vez descargada, vamos a descomprimir el archivo comprimido:

 

1 tar zxvf RPi.GPIO-0.5.4.tar.gz

 En caso de tenerlo en una usb, primero vamos a la usb

1 sudo fdisk –l

 Crearemos una nueva carpeta dentro del directorio /media. La llamaremos PenDrive. Actualmente no
hay nada en esta carpeta:

 Creamos la carpeta con el siguiente comando:

1 sudo mkdir /media/PenDrive

El archivo fstab está dentro del directorio /etc (/etc/fstab). Sirve básicamente para guardar la configuración del
montaje permanentemente. Lo abriremos con nano, usando el siguiente comando:

1 sudo nano /etc/fstab

Nos aparecerá lo siguiente

A continuación, introduciremos una nueva línea, teniendo en cuenta que la separación entre cada campo se
realiza con el tabulador. Además, al tener un formato FAT32, usaremos vfat en el tercer campo. Esta línea es la
siguiente:

/dev/sda1: dirección de mi pendrive

/media/PenDrive: ruta de montaje

vfat: formato FAT32.

Aplicaremos los cambios con el comando mount. Vamos a ver sus opciones:

1 mount –help

Nos fijamos en una opción en particular: -a. Con esta opción montamos todo lo que tengamos en el
fichero /etc/fstab, que es el que hemos modificado en el punto 3.

Finalmente, ejecutamos el comando

¡Con este último paso, ya tenemos nuestro pendrive listo!

 Ahora iremos a nuestra usb, con el siguiente comando

1 cd /home/pi/Direccion de nuestra usb

Siguiendo con el tutorial de phyton:

 Una vez descargada, o estando dentro de nuestra usb vamos a descomprimir el tarball:

1 tar zxvf RPi.GPIO-0.5.4.tar.gz

 Entramos en el directorio que acabamos de descomprimir:

1 cd RPi.GPIO-0.5.4/

Ahora toca instalar la biblioteca. Por si no tenemos el paquete python-dev, introducimos el siguiente comando:

1 sudo apt-get install python-dev

 Cuando acabe la instalación del paquete anterior, procedemos a instalar la librería:

1 sudo python setup.py install

 En este tercer paso, vamos a escribir un pequeño programa en Python que haga que se enciendan y apaguen los
LEDs de forma intermitente. Creamos nuestro archivo de phyton:

1 sudo nano blink.py

 Los pines serán de salida, pues tenemos que encender LEDs. Como ya hemos hecho en el montaje, utilizaremos
los GPIO 17 y 27. La forma de tratar los pines, su declaración y el encendido y apagado:

import RPi.GPIO as GPIO

import time

GPIO.setmode(GPIO.BCM)

GPIO.setup(17, GPIO.OUT) ## GPIO 17 como salida

GPIO.setup(27, GPIO.OUT) ## GPIO 27 como salida

La función se llamará ‘blink‘.

def blink():

print "Ejecucion iniciada..."

iteracion = 0

while iteracion < 30: ## Segundos que durara la funcion

GPIO.output(17, True) ## Enciendo el 17

GPIO.output(27, False) ## Apago el 27

time.sleep(1) ## Esperamos 1 segundo

GPIO.output(17, False) ## Apago el 17

GPIO.output(27, True) ## Enciendo el 27

time.sleep(1) ## Esperamos 1 segundo

iteracion = iteracion + 2 ## Sumo 2 porque he hecho dos parpadeos

print "Ejecucion finalizada"

GPIO.cleanup() ## Hago una limpieza de los GPIO

blink() ## Hacemos la llamada a la funcion blink

Controlar Led con GPIO Raspberry Pi en C/C++

Controlar un led mediante los pines GPIO de Raspberry Pi en el lenguaje de programación C/C++.

Para realizar esta prueba tenemos que tener instalado la librería Wiring Pi para el manejo de los GPIO con
C/C++, si no la tienes en este post te mostramos como hacerlo "Instalar Wiring Pi en Raspberry Pi GPIO
C/C++".

Lo primero que tenemos que hacer es montar un led en nuestra Raspberry Pi de la misma forma que en el post
"Controlar Led con GPIO Raspberry Pi en consola".
Se tiene que crear un archivo con extensión .c por ejemplo parpadeo.c, este tendrá el código de nuestra
aplicación, abrirlo con tu editor de texto preferido, en la primera linea realizaremos la importación de la libreria
Wiring Pi.

#include <wiringPi.h>

Crearemos la función principal de nuestro programa.

int main (void) {

Luego la instrucción de configuracion de Wiring Pi.

wiringPiSetup();

Ahora indicaremos el modo del pin que usaremos, en este caso el pin 0 corresponde al GPIO 17 en BCM o en
BOARD pin 11, para ver el mapa de los pines que usa Wiring Pi solo ejecuta el siguiente comando.

Modo de salida (OUTPUT) del pin 0 (GPIO 17).

pinMode(0, OUTPUT);
Creamos una variable llamada "i" en valor "0" que sera nuestro contador de ciclos.
Después agregamos el ciclo "for" con la condición que "i" sea menor que 10, esto nos hará repetir 10 veces las
instrucciones del ciclo.

Le diremos al GPIO 17 (wPi 0) que se encienda enviando "HIGH" con la función "digitalWrite", luego
esperaremos "500" milisegundos y le diremos que se apague enviando "LOW", esperando "500" milisegundos
y el ciclo comenzara de nuevo.
Para finalizar nuestro programa retornaremos 0 y cerraremos el cuerpo de nuestro programa (main).

return 0;
}

Con esto ya podemos comenzar a programar nuestro proyecto usando los pines GPIO con C/C++ y Wiring Pi,
les dejo el código completo.

Para compilar el código solo tienes que ingresar el siguiente comando.

pi@raspberrypi ~ $ gcc -Wall -o parpadeo parpadeo.c -lwiringPi

Para ejecutarlo se tiene que llamar a nuestro programa.

pi@raspberrypi ~ $ sudo ./parpadeo