Programando PICs en Linux (Ubuntu 11.04) usando makefiles - Autor: Javier Zavala

Programando PICs en Linux
(Ubuntu 11.04)
usando makefiles

                                                Autor:      Javier Zavala
                                              javierzavalaponce@gmail.com
                                        Fecha.        Septiembre 22. 2012

09/22/12                      Página 1 de 7
javierzavalaponce@gmail.com

Programando PICs en Linux (Ubuntu 11.04) usando makefiles
Septiembre 2012

por Javier Zavala.

Hace relativamente poco comencé a desenvolverme en Linux, y decidí poner en
práctica lo poco que he ido aprendiendo con el fin también de indagar sobre lo que
ocurre tras presionar el casi-mágico botoncito "build" o "build all" típico de
muchos IDEs para micros.

Este articulo describe:

Cómo esribir un Makefile para automatizar la compilación de un proyecto.

Voy a usar el SDCC -Small Device C Compiler-, se puede visitar la pagina oficial
para mayores
referencias. Abajo hago una breve descripcion de la instalación de SDCC en Ubuntu .
En cuanto al target, utilizaré el popular pic18f2550 de Microchip.

Opcionalmente     se puede consultar la última seccion de este artículo con
instrucciones     de como echar a andar el programador pickit2 para flashear el
programa sobe      un pic18f2550, insisto, e objetivo del articulo es aprender de
makefiles, por     lo que no es indispensable contar con el PIC o con el programador
pickit2.
Pickit2 info:

http://www.microchip.com/stellent/idcplg?
IdcService=SS_GET_PAGE&nodeId=1406&dDocName=en023805

RESUMEN PRÁCTICO.
El objetivo de todo esto es obtener un archivo llamado output.hex

Descargar los archivos en una carpeta, digamos SDCC_prj0, luego,

javier@javier:~$ cd SDCC_prj0/
javier@javier:~/SDCC_prj0$ make

El resultado es la generacion de (entro otros archivo) output.hex, que ya se puede
flashear en un PIC (18f2550 en este caso).

Para flashear se utilizaría:

javier@javier:~/SDCC_prj0$ make burn

(Opcional, si se cuenta con el pic , programador & cable usb-serial):

Para ver en accion el programa, se puede usar una terminal, por ejemplo minicom
configurado a 9600 bauds 8n1.
Aun cuando los makefiles son ampliamente usados y son sumamente útiles,
posiblemente algunos van a encontrar este articulo algo anticuado considerando que
las maravillas de la modernidad nos facilitan la vida al proporcionarnos IDEs que
hacen muy facil todos estos procesos pero para otros puede ser un buen vistazo a
todo lo que ocurre tras bambalinas, y además puede ser interesante para aquellos

09/22/12                           Página 2 de 7
javierzavalaponce@gmail.com

que prefieren la consola en vez de las interfaces gráficas, o bien para los que
quieres saber como comenzar un proyecto "desde cero" y no anclarse a un IDE en
partiular.
INSTALACION DE SDCC
Ir a http://sourceforge.net/projects/sdcc/files/sdcc-linux-x86/
y elegir la version 3.2 (última al escribir este articulo en Septiembre de 2012),
despues de descomprimir el archivo sdcc-3.1.0-i386-unknown-linux2.5.tar.bz2,
navegamos dentro del folder (que debe tener la siguiente lista de archivos) :

.
+--   bin
+--   INSTALL.txt
+--   README.txt
+--   share

y en una terminal:

sudo cp -r * /usr/local

Es todo lo que se necesita hacer. Si quieres mas detalles de la instalación, estos
se pueden encontrar INSTALL.txt y en README.txt

INSTALACION DE GPUTILS
GPUTILS es una coleccion de herramientas para PICs, incluye gpasm, gplink,y gplib.
Mas adelante, veremos como utilizarlos dentro de un makefile para ligar los
archivos objeto (.o), asi lo instalamos:

sudo apt-get install gputils

PREPARANDO LOS ARCHIVOS FUENTE
Todos los archivos necesarios para completar las instrucciones descritas en este
articulo son:
(en mi caso , yo los puse todos dentro de una carpeta llamada SDCC_prj0)

javier@javier:~/SDCC_prj0$ tree
.
+-- 18f2550.lkr
+-- libdev18f2550.lib
+-- libsdcc.lib
+-- main.c
+-- makefile
+-- pic18fregs.h
+-- suma.c
+-- suma.h
+-- usart.c
+-- usart.h
+-- 70-microchip.rules

En realidad 18f2550.lkr , libdev18f2550.lib , libsdcc.lib & pic18fregs.h
simplemente los copié de la instalacion del SDCC para facilitar la explicación, el
código fuente quedo dividido en tres archivos .c (main.c, usart.c & suma.c) para

09/22/12                          Página 3 de 7
javierzavalaponce@gmail.com

mostrar como compilar y ligar cuando se tiene un proyecto (como es usual) de varios
archivos. El archivo 70-microchip.rules solo sirve por si el lector consulta la
ultima seccion de este articulo (INSTALANDO EL PICKIT2).

*Tip: con find . -iname "*2550*" puedes encontrar archivos que contengan la cadena
de caracteres "2550"

SOBRE EL COMANDO MAKE
make es un comando que lee instrucciones de un archivo que nosotros creamos
llamandolo makefile que a su vez, establece las reglas de compilación, este
makefile puede hacer otras cosas como "limpiar" (borrar los archivos objeto por
ejemplo), definir como flashear el micro, entre otras maravillas. Ademas ahorra
tiempo al compilar solamente los archivos que han sido modificados.

EL MAKEFILE
Este es el contenido del makefile (solo de referencia), el makefile original viene
con lor archivos de este articulo, se debe ser muy cuidadoso con los TABS incluidos
en él:

#_____________________________________________________
CC = sdcc -S -V -mpic16 -p18f2550 --use-non-free
LINK = gplink -m -s 18f2550.lkr -o output.hex libdev18f2550.lib libsdcc.lib
ASM = gpasm

.PHONY: all burn clean

all: output.hex

.SUFFIXES:

%.asm:    %.c
   $(CC) $<

%.o:    %.asm
   $(ASM) -c $<

output.hex: suma.o usart.o main.o
   $(LINK) suma.o usart.o main.o

clean:
   rm -v *.asm *.o *.hex *.lst *.cod *.map

burn:
   pk2cmd -P PIC18F2550 -F output.hex -M -W -R -Y -J N
#_____________________________________________________

09/22/12                        Página 4 de 7
javierzavalaponce@gmail.com

EXPLICACION DEL MAKEFILE

Lo que queremos lograr con este makefile es obtener un archivo (en este caso
output.hex) que se pueda flashear al PIC, pero para lograrlo se requieren varios
pasos, inlcuidos la compilacion de todos los archivos fuente, ok, vamos por partes:

#, sirve para poner comentarios
CC, define una macro, el nombre es CC y su valor es lo que esta a la derecha del =
$(CC) , se puede leer como "el valor de la macro CC".

Los Makefiles estan formados mayoritariamente por reglas, por ejemplo,en las dos
ineas establecemos una "regla patrón":

%.asm:    %.c
   $(CC) $<

Hay un TAB en la segunda linea, se debe ser cuidadose de no usar espacios en blanco
en vez de TABS. La regla establece que el OBJETIVO (o TARGET) es crear archivos
.asm a partir de archivos .c, es decir la DEPENDENCIA es un .c, el simbolo de
porciento (%) es un comodín (o wildcard) para la generalizacion.

Además de las reglas que acabo de describir, puede haber "reglas virtuales" como
clean y burn en este makefile, que sirven para llevar a cabo otras tareas aparte de
la compilacón. Por ejemplo, al invocar en la terminal,

javier@javier:~/SDCC_prj0$ make clean

vamos a borrar todos los archivos: *.asm *.o *.hex *.lst *.cod *.map

y al invocar
(esto va a funcionar solo si tienes instalado un pickit2, mas abajo viene una
explicacion)

javier@javier:~/SDCC_prj0$ make burn

vamos a flashear al pic, tal como si hubieramos introducido

pk2cmd -P PIC18F2550 -F output.hex -M -W -R -Y -J N

en la terminal (este ejemplo esta usando un pickit 2 de microchiip, enseguida se
explican lor argumentos del comando pk2cmd).

09/22/12                        Página 5 de 7
javierzavalaponce@gmail.com

#-P PIC18F2550 , tipo de micro
#-F output.hex ,archivo por flashear
#-M ,programa la totalidad de la memoria
#-W , El micro esta alimentado externamente, quitar -W si pk2 esta alimentando el
micro
#-R , Libera la linea /MCLR despues de flashear, para que comience a ejecutar el
programa
#-Y , Verifca el dispositivo , ENTERAMENTE
# -J N , Muestra porcentaje de avance. N = cada actualización en una nueva linea
# ademas esto puede ser util:
# pk2cmd -P PIC18F2550 detiene la ejecucion
# pk2cmd -P PIC18F2550 -r suelta la linea de reset para ejecutar el programa.

Como existe la posibilidad de que exista un archivo llamado "clean" o "burn" dentro
de nuestro proyecto, .PHONY es para que se se ejecuten los comandos necesarios aun
cuando estos supuestos archivos existan.

Mas Informacion sobre Makefiles en:

http://es.wikipedia.org/wiki/Make
http://www.gnu.org/software/make/manual/make.html

INSTALANDO EL PICKIT2
(basado en http://tuxtronics.com/node/3)

Se puede prescindir de esta parte si no se desea o no se tiene un micro o un
progrador pickit2,

En la pagina de microchip ,

http://www.microchip.com/stellent/idcplg?
IdcService=SS_GET_PAGE&nodeId=1406&dDocName=en023805

buscamos el binario:

PK2CMD V1.20 Linux Kernel 2.6 Executable Binary

que es un tar, lo descomprimimos, se deben tener estos archivos:

pk2cmd
PK2V023200.hex
usbhotplug.txt
PK2DeviceFile.dat
ReadmeForPK2CMDLinux2-6.txt

en ReadmeForPK2CMDLinux2-6.txt vienen instrucciones, vale la pena leerlas los pasos
a y b , enseguida solo muestran los comandos:

09/22/12                        Página 6 de 7
javierzavalaponce@gmail.com

a)
Cambia los permisos de pk2cmd para que (una vez copiado a ~/usr/local/bin/ ) se
pueda leer incluso sin ser root.

cd pk2cmdv1-20Linux2-6/
chmod 0755 pk2cmd
sudo cp pk2cmd /usr/local/bin/

b)
cambiamos permisos de PK2DeviceFile.dat y creamos el folder pk2

chmod 0644 PK2DeviceFile.dat
sudo mkdir /usr/share/pk2
sudo cp PK2DeviceFile.dat /usr/share/pk2/

Este nuevo folder (pk2) necesita ser añadido al PATH, asi que abrimos el archivo
.bashrc que esta en nuestra carpeta home, (javier en mi caso)

javier@javier:~$ gedit .bashrc

y añadimos al final:
export PATH=$PATH:/usr/share/pk2

es buena pracica asegurarse de dejar una linea en blanco al final del archivo,
guardamos y cerramos.

(tomado de http://tuxtronics.com/node/3 ):

Ahora necesitamos habilitar los permisos del USB device para que podamos usar
pk2cmd (y por tanto Dwarf) sin ser sudo.
Para hacer esto, necesitas decirle al sistema que es seguro permitir la escritura
directa a este dispositivo (pickit2). Para hacerlo copia el archivo

70-microchip.rules
(este archivo viene adjunto , con los archivos de ejemplo de este articulo)

en
/etc/udev/rules.d/

asi:

sudo cp 70-microchip.rules /etc/udev/rules.d/

ahora estos 2 comandos:

sudo groupadd microchip
sudo usermod -aG microchip 

Reemplaza  con tu nombre de usuario, por ejemplo:

sudo usermod -aG microchip javier

Antes de que esto surta efecto,se debe reinicirar el equipo.

Espero que esta info sea de utilidad para alguien mas. Saludos.

09/22/12                           Página 7 de 7
javierzavalaponce@gmail.com