Control de versiones

Después de cierto tiempo trabajando en un proyecto comienza a evidenciarse la necesidad de guardar los cambios cuando se hacen progresos y de documentar todos los cambios relevantes, para que pueda entenderse rápidamente que cambió entre una y otra versión. El concepto que engloba a estas acciones es: control de versiones.
El control de versiones puede hacerse manualmente, por ejemplo copiando la carpeta entera del proyecto a otra cada vez que se hace un cambio y describiendo los cambios en comentarios dentro de cada archivo que sufra modificaciones. ¿Suena tedioso?
Afortunadamente muchos programadores antes que nosotros pensaron lo mismo y es por eso que existe software dedicado a lidiar con estos menesteres.

El que se eligió para este proyecto por su versatilidad y simplicidad es git. Se encuentra disponible para correr sobre Linux o Windows.
Algunas de sus características son:
- almacena cambios incrementalmente, reduciendo el espacio utilizado.
- permite (¡y obliga! a) hacer un comentario cada vez que se almacenan cambios ("se hace un commit").
- permite ver las diferencias entre una versión (commit, un estado salvado) y cualquier otro en forma sencilla.
- permite desarrollo no lineal: es decir que dos (o más) programadores podrían estar trabajando sobre diferentes partes del proyecto (aunque trabajen en archivos en común) y después sumar sus cambios al proyecto en forma automática, siempre que no hayan modificado exactamente las mismas líneas, de ser así el programa le pregunta al usuario para resolver el conflicto.
- es gratuito y de código libre.

Sobre la forma de utilizarlo hay excelentes tutoriales escritos en diversas lenguas como por ejemplo Git Magic, muy bien escrito en inglés, que va de las operaciones básicas cotidianas hasta las maniobras más intrincadas e infrecuentes, mientras que en nuestra lengua tenemos disponible una introducción rápida a git.
Para instalar git en Linux sólo hace falta instalar el paquete git-core (y sus dependencias), es decir, en una distribución de Linux basada en Debian basta con abrir un terminal y poner sudo apt-get install git-core. Sin embargo, git por si mismo es sólo accesible mediante la línea de comandos, para tener una interfaz gráfica hace falta instalar git-gui. Una vez instalado ese paquete, se puede acceder usando el comando git gui. Una interfaz mejorada se obtiene instalando qgit y kompare.

Captura de git gui:


Capturas de qgit:





Captura de kompare:

Makefiles

Para compilar programas desde más de una fuente es útil confeccionar un archivo "Makefile".
Además, cuando tenemos muchos archivos que se compilan en un sólo binario, como sucede frecuentemente en los sistemas embebidos, se vuelve muy útil abreviar la forma de incluirlos en la compilación. Para esto existen macros que evitan la repetición de variables, lo cual no sólo es bueno para agilizar la escritura, sino para el mantenimiento, legibilidad y escalabilidad de los programas.
He aquí un tutorial simple y en español para escribir Makefiles.

LIBUSB

LibUSB es una librería de código abierto que permite desarrollar controladores de dispositivos USB desde espacio de usuario sin necesidad de bajar a nivel de kernel. En nuestro caso, va a ser utilizado para detectar la presencia de dispositivos de almacenamiento USB, que es donde guardaremos los datos adquiridos.
La utilización de esta librería requiere la compilación del código fuente para adaptarlo a nuestra plataforma. De esta manera se genera una librería dinamica (de extensión ".so") que es la cual se cargará en el TS.
A continuación se presentan los pasos a seguir, junto con un programa de ejemplo que busca las Flash USB conectadas y muestra datos de las mismas, incluyendo la cantidad total de dispositivos de almacenamiento detectados.


1- Descomprimimos el codigo fuente de la librería libusb-0.1.12.tar.gz

http://prdownloads.sourceforge.net/libusb/libusb-0.1.12.tar.gz

Otras versiones tal vez no funcionen.


2- Vamos a la carpeta donde descomprimimos el código y tipeamos el siguiente comando:

# CC=arm-linux-gcc CXX=arm-linux-gcc ./configure --prefix=/opt/crosstool/arm-linux/gcc-3.3.4-glibc-2.3.2/arm-linux --program-prefix=arm-linux- --host=arm-pc-linux-gnu

Donde en prefix ponemos la ruta a nuestra toolchain (suponemos que la revisión de la misma es gcc-3.3.4-glibc-2.3.2)

3- Ejecutamos los dos siguientes comandos:

make
make install

Si leemos un poco lo que muestra el ultimo comando, vemos que instala las librerías dinámicas .so en el directorio lib de nuestra toolchain. Los archivos de interés son:

libusb-0.1.so.4.4.4
libusb-0.1.so.4

Donde el primero es la librería propiamente dicha y el segundo es solo un enlace al primero, pero lo debemos tener en cuenta porque el programa que compilemos para el TS-7260 busca un archivo con dicho nombre.


4- Copiamos los dos archivos al del punto anterior a la carpeta "/lib" del TS


5- Hacemos un pequeño programa y lo compilamos con el comando:

arm-linux-gcc -o ejemplo_libusb ejemplo_libusb.c -I/usr/local/include -L. -lnsl -lm -lc -L/usr/local/lib -lusb

Luego lo subimos a la placa.

Pueden bajar el programa de ejemplo "ejemplo_libusb.c" desde el siguiente servidor ftp:

ftp://mandrakenet.com

usr: ts7260
pass: ts7260

6- Una vez subido a la placa el programa, cargamos los modulos USB ejecutando el siguiente Script:

/usr/bin/loadUSBModules.sh

Montamos el sistema de archivos USB con:

mount -t usbdevfs none /proc/bus/usb

7- Por último, podemos ejecutar el programa, se muestra la cantidad de dispositivos flash USB conectados al TS y algunas características de los mismos.

Tutorial

Un excelente tutorial para aprender a hacer scripts en linux.
El nivel es básico y está en inglés.

Del origen de los fondos

La Universidad Nacional de la Patagonia Austral (UNPA) ha abordado un Proyecto Federal de Innovación Productiva, que consiste en la construcción de un sistema de suministro energético con energía eólica y solar para escuela rural Nº 25 Casimiro Biguá (Pasaje Glencross, Santa Cruz).

El equipamiento a instalar en la Escuela Rural Glencross consistirá un subsistema eléctrico-eólico y otro de tipo solar térmico. El primero consta de 2 aerogeneradores de 1kW de potencia nominal eléctrica, dotados de un generador del tipo imán permanente de 48V y origen nacional. Se incluirá además un banco de baterías de 660Ah en 48V y un inversor capaz de entregar 3.6kW de potencia. La presencia de dos grupos diesel en Glencross, hará necesaria la instalación de una llave conmutadora. El segundo subsistema de tipo solar térmico se conectará en serie con el termo-tanque, y se instalará una llave de bypass para que el sistema pueda replicar el funcionamiento actual ante cualquier problema con el panel o subcircuito.

Es dentro de este marco que estamos desarrollando el software de la placa TS-7260 para llevar a cabo funciones de registro de datos y control de algunas variables. Todo el hardware para el proyecto es provisto por dicha universidad.

Creando .csv

Nos informa correctamente wikipedia.org:

Los ficheros CSV (del inglés comma-separated values) son
un tipo de documento sencillo para representar datos en forma de tabla,
en las que las columnas se separan por comas (o punto y coma) y las
filas por saltos de línea.

El siguiente programa en C muestra como crear un archivo .csv.

#include <stdio.h>
int main()
{
    FILE * fp ;
    fp=fopen("miarchivo.csv","a");
    fprintf(fp,"Dato,");
    fclose(fp);
    return 0;
}


Primero se declara fp como puntero a archivo.
En la segunda línea, se utiliza el comando fopen() para abrir un archivo (si no existe miarchivo.csv, se crea un nuevo archivo con ese nombre). La opción "a", indica que se debe abrir el archivo para añadir contenido al final del mismo, se pueden ver otras opciones en el link proporcionado o bien tipeando en la consola man fopen.
En la tercera línea se ejecuta fprintf(), para escribir donde apunte fp, en este caso al final del archivo miarchivo.csv. Notese que al final del dato debe agregarse la coma.
Si bien en este caso tan simple no se nota la diferencia, es buena práctica liberar el puntero como se hace en la última línea con fclose(). Esta acción libera el archivo para que pueda ser utilizado por otros procesos y libera recursos del sistema operativo.

El primer programa: "Hola Mundo"

El primer paso a seguir es escribir el programa en algún editor de texto tradicional (en nuestro caso VIM). El archivo holamundo.c tiene un código es exactamente igual a cualquier programa escrito en C:

#include <stdio.h>
int main(){
    printf("Hola Mundo!\n");
    return(0);
}

Luego debemos proceder a la complación del mismo. La compilación se realizará en una PC, la cual tiene una arquitectura diferente al TS-7260. Es por ello que necesitamos realizar una compilación cruzada, utilizando el "Entorno de Compilación Cruzada" (llamado Cross-Toolchain en inglés) provisto por el fabricante.
Descomprimimos entonces el archivo crosstool-linux-gcc-4.0.1-glibc-2.3.5.tar.bz2 que viene en el CD, por ejemplo en el directorio /opt. Para lograr compilar en cualquier directorio en el que estemos parados sin especificar la ruta en la que esta el compilador debemos agregar su PATH al sistema operativo, de manera que el mismo sepa donde buscar el compilador cuando ejecutemos el comando en la consola. Para ello hacemos:

export PATH=$PATH:/opt/crosstool/gcc-4.0.1-glibc-2.3.5/arm-unknown-linux-gnu/bin/arm-unknown-linux-gnu-gcc

donde arm-unknown-linux-gnu-gcc es el compilador propiamente dicho.
Ahora nos paramos en el directorio donde este guardado holamundo.c y ejecutamos el comando de compilación:

arm-unknown-linux-gnu-gcc holamundo.c -o holamundo

Tendremos entonces, si todo salio bien, el ejecutable listo para bajar al TS, lo cual podemos hacer con cualquier cliente FTP (nosotros utilizamos gFTP). Nos logueamos en el mismo vía telnet por ejemplo, nos paramos en el directorio donde hayamos bajado holamundo y tipeamos:

./holamundo

Con esto, recibiremos el famoso y alentador mensaje que queremos ver. En la imágen el ejecutable holamundo se llama holas y responde de una manera mas agradable, pero con la misma finalidad.