Raspberry Pi® a fondo para desarrolladores. Derek Molloy

      pi@erpi ~ $ more HelloRPiSleep.c

      #include<unistd.h>

      #include<stdio.h>

      int main(){

      int x=0;

      do{

      printf("Hello Raspberry Pi!\n");

      sleep(5);

      }while(x++<50);

      return 0;

      }

      El programa consiste en un bucle que realiza 50 iteraciones, en cada una de las cuales muestra un mensaje y espera 5 segundos. Después de guardar el archivo como HelloRPiSleep.c, lo compilaremos como un ejecutable mediante el comando siguiente (-o especifica el nombre del archivo ejecutable):

      pi@erpi ~ $ gcc HelloRPiSleep.c -o helloRPiSleep

      pi@erpi ~ $ ls -l helloRPiSleep

      -rwxr-xr-x 1 pi pi 5864 Jun 20 16:40 helloRPiSleep

      Si todo ha funcionado, tendremos tanto el archivo de código fuente como el ejecutable llamado helloRPiSleep. Observe cómo este muestra la marca, x, de archivo ejecutable. Podemos, ahora, ejecutarlo sin más:

      pi@erpi ~ $ ./helloRPiSleep

      Hello Raspberry Pi!

      Hello Raspberry Pi! ...

      Continuará mostrando este mensaje cada 5 segundos. Podemos terminar su ejecución con Control+C. Sin embargo, para ejecutarlo en segundo plano tenemos dos opciones.

      Primero podemos, en lugar de pulsar Control+C para terminar el proceso, pulsar Control+Z y, luego, en el símbolo del sistema, escribir el comando bg (por background, como ya hemos visto).

      pi@erpi ~ $ ./helloRPiSleep

      Hello Raspberry Pi!

      ^Z

      [1]+ Stopped ./helloRPiSleep

      pi@erpi ~ $ bg

      [1]+ ./helloRPiSleep &

      pi@erpi ~ $ Hello Raspberry Pi!

      Hello Raspberry Pi!

      Hello Raspberry Pi!

      Cuando pulsamos Control+Z, ^Z aparece en la salida. Cuando escribimos bg, el proceso se sitúa en segundo plano, donde continúa su ejecución. De hecho, podemos continuar usando el terminal, pero resultará frustrante porque cada cinco segundos aparecerá el mensaje "Hello Raspberry Pi!" El comando fg nos permite devolver este proceso al primer plano.

      pi@erpi ~ $ fg

      ./helloRPiSleep

      Hello Raspberry Pi!

      ^C

      pi@erpi:~$

      Cuando pulsamos Control+C, que aparece como ^C, la aplicación se detiene.

      La otra manera de poner la aplicación en segundo plano consiste en añadir el símbolo ampersand, &, al final de su nombre:

      pi@erpi ~ $ ./helloRPiSleep &

      [1] 30965

      pi@erpi ~ $ Hello Raspberry Pi!

      Hello Raspberry Pi!

      El proceso se ha situado en segundo plano y su PID es 30965, en este caso. Para detener el proceso, usamos ps para encontrar el PID:

      pi@erpi ~ $ ps aux|grep hello

      pi 30965 0.0 0.0 1612 304 pts/0 S 20:14 0:00 ./helloRPiSleep

      pi 30978 0.0 0.1 4208 1828 pts/0 S+ 20:15 0:00 grep hello

      Para terminar el proceso, use el comando kill:

      pi@erpi ~ $ kill 30965

      [1]+ Terminated ./helloRPiSleep

      Podemos confirmar la terminación del proceso usando ps de nuevo. Si el proceso no termina de inmediato, usaremos el argumento -9 para asegurarnos de que lo haga. Por ejemplo: kill -9 30965. Un comando diferente, pkill, termina un proceso a partir de su nombre. Así, en este caso:

      pi@erpi ~ $ pkill helloRPiSleep

      Otro comando que merece la pena mencionar es watch. Este ejecuta un comando a intervalos regulares y muestra el resultado en terminal a pantalla completa. Por ejemplo, para ver el log de mensajes del núcleo, escribimos:

      pi@erpi ~ $ watch dmesg

      Podemos concretar la duración del intervalo entre ejecuciones mediante -n seguido del número de segundos. Una buena manera de comprender el funcionamiento de watch consiste en ejecutarlo del siguiente modo:

      pi@erpi ~ $ watch -n 1 ps a

      Every 1.0s: ps a Sat Jun 20 20:22:39 2015

      PID TTY STAT TIME COMMAND

      912 pts/0 Ss 0:06 -bash

      31184 pts/0 S+ 0:01 watch -n 1 ps a

      31257 pts/0 S+ 0:00 watch -n 1 ps a

      31258 pts/0 S+ 0:00 sh -c ps a

      31259 pts/0 R+ 0:00 ps a

      Veremos que el PID de ps, sh y watch cambia cada (1) segundo, lo que deja claro que watch está realmente ejecutando el comando (ps) al pasarlo a un nuevo intérprete de comandos mediante sh -c. La razón por la que watch aparece dos veces en la lista es que se reproduce a sí mismo temporalmente en el momento exacto en el que ejecuta ps a.

Otros temas de Linux

      En este punto del libro, el lector ha podido revisar los principales comandos para trabajar con Linux en el RPi. Sin embargo, el tema de la gestión de sistemas Linux da mucho más de sí. Por ejemplo: ¿cómo configurar un adaptador WiFi? ¿Cómo usar cron para planificar (schedule) trabajos con el RPi? Estos temas se analizarán en los capítulos restantes del libro. Sin ir más lejos: la programación de trabajos con cron se trata en el capítulo 12, en el contexto de los dispositivos IoT.

Cómo utilizar Git para el control de versiones

      De manera sencilla podemos decir que Git es un sistema que nos permite registrar cualquier cambio que se introduzca en el contenido de un proyecto de software a medida que avanza su desarrollo. Git, diseñado también por Linus Torvalds, se emplea hoy en la línea principal de desarrollo del núcleo de Linux. Git es un sistema increíblemente útil, que debemos entender bien por dos motivos principales: podemos utilizar Git en el desarrollo de nuestro propio software y además nos permite aprender a trabajar con distribuciones de código fuente del núcleo de Linux.

      Git es un sistema distribuido de control de versiones, o DVCS (Distributed Version Contol System) que facilita el control del código fuente de un proyecto. Un sistema de control de versiones, VCS, registra y gestiona cualquier cambio introducido en documentos de cualquier tipo. Normalmente, los documentos que cambiemos se destacarán con números de revisión y marcas de tiempo. Se pueden comparar revisiones y hasta regresar a versiones antiguas de los documentos. Hay dos tipos de sistemas VCS:

      ❏Centralizados (CVCS): estos sistemas, como Apache Subversion (SVN), funcionan con la premisa de que existe una copia "maestra" única del proyecto. El flujo de trabajo es simple y directo: bajamos los cambios desde un servidor central, introducimos los nuestros propios y los volvemos a subir como definitivos a la copia maestra (esta subida definitiva de los cambios se denomina "commit", término típico también de las bases de datos; en español su uso como sustantivo ("hacer commit") es abrumadoramente mayoritario en el entorno informático, y es el que usaremos aquí).

      ❏Distribuidos (DVCS): usando estos sistemas, por ejemplo Git y Selenic Mercurial, no bajamos cambios, sino que clonamos el repositorio completo, incluido todo el histórico de cambios. El clonado del repositorio produce una copia tan exacta como una copia maestra, que hasta puede llegar a actuar como tal si fuera preciso. Por fortuna, los estándares actuales hacen que los documentos de texto plano y los archivos de código fuente no ocupen mucho espacio en disco. Una precisión importante: