TUTORIAL PROGRAMACIÓN DE PIC EN PC (Windows /
Linux)
AEDIII – ITSB – Lomas de Zamora
Edición 03.24
En esta edición NO se detalla el proceso de programación en lenguaje C.
Requisitos: Windows 10/11 o Linux basado en Debian. Compilador de PIC XC8.
Programador PICKit2. IDE Visual Studio Code / VSCodium. Proteus versión 8.13 o
superior (con versiones más viejas no van a poder abrir los proyectos de simulación que
les pase). Todos estos programas pueden encontrarlos en la sección “Software” del
campus virtual.
1) Agregar compiladores de PIC-AS y C al PATH de mi sistema
operativo
Un compilador se utiliza para convertir el código que un programador haya escrito en
código de máquina que el dispositivo en cuestión pueda interpretar. Los compiladores que
Microchip ofrece son programas que se ejecutan por línea de comando. Para poder
utilizarlos adecuadamente, debemos agregar sus carpetas raíz al PATH del sistema.
La variable de entorno PATH de un sistema operativo contiene directorios de instalación
de programas ejecutables por consola, para que el mismo sepa dónde se alojan. Esto
permite que, si yo quiero utilizar un programa ejecutable por consola en un directorio
distinto al de instalación del mismo (o sea, el 99% de los casos), el sistema sabe dónde
buscar el programa que deseo. Para agregar un programa al PATH, primero debo conocer
el directorio donde este se aloja, en nuestro caso el compilador XC8. Por defecto, el
mismo se encuentra en estas locaciones:
Ejecutable XC8 – compilador de C
• Windows: C:\Program Files\Microchip\xc8\vX.XX\bin
• Linux: /opt/microchip/xc8/vX.XX/bin
Ejecutable PIC-AS – compilador de assembler
• Windows: C:\Program Files\Microchip\xc8\vX.XX\pic-as\bin
• Linux: /opt/microchip/xc8/vX.XX/pic-as/bin
… donde vX.XX es la versión del compilador que han instalado.
Para agregar estos archivos al PATH:
• En Windows:
Panel de Control > Editar variables de entorno del sistema (pestaña Opciones
Avanzadas) > Variables de entorno… > Seleccionar variable “Path” > Editar >
Nuevo (pegar locación de ejecutable, editando “vX.XX” por la versión que tengan
instalada, ej. “v2.41”).
• En Linux:
Pegar en Bash las siguientes líneas, editando la versión correspondiente a la
instalada (ej. “vX.XX” → “v2.41”).
sudo ln -s /opt/microchip/xc8/vX.XX/bin/xc8 /usr/bin/
sudo ln -s /opt/microchip/xc8/vX.XX/pic-as/bin/pic-as /usr/bin/
2) Configurar entorno de trabajo
En primer lugar y con el objetivo de trabajar de manera prolija, vamos a crear una carpeta
donde se alojarán todos los programas que codifiquemos durante la cursada. Pueden
asignarle el nombre que quieran y crearla donde consideren oportuno, pero por
conveniencia me referiré a la misma como “carpeta madre” de ahora en más.
El IDE que utilizaremos para codificar nuestros programas será Visual Studio Code
(VSCode). El mismo ya es conocido por ustedes de la materia Lenguajes Electrónicos de
5to año, por lo que saben que es una herramienta poderosa y altamente configurable. Si
bien quiero brindarles la libertad de utilizar las configuraciones/extensiones que deseen,
hay algunas pautas que debo sugerirles:
• Dentro de la carpeta madre, creen una carpeta de nombre “.vscode”, y a su vez
creen dentro de esta un archivo de nombre “settings.json”. Abran este archivo con
VSCode y peguen dentro del mismo el contenido del archivo “Configuración
VSCode” que encuentran en el campus virtual, en la sección de Software. Estas
son configuraciones que recomiendo para la programación en assembler y que
sólo se aplicarán al programa cuando abran la carpeta madre, por lo que no
interfieren con otros entornos de trabajo.
• Instalen la extensión “PIC18 Assembler Syntax Highlighter“ de Kabak, la cuál
encuentran en el campus virtual bajo el nombre “Extensión de sintaxis VSCode” en
la sección de Software. La misma resaltará las palabras claves del lenguaje
ensamblador para facilitar la lectura de código. El archivo que descarguen para
esta extensión es de terminación .vsix. Instalar extensiones a partir de un
archivo .vsix es muy sencillo:
Aquí se les abre un selector de archivos, y, por supuesto, eligen la extensión que
descargaron.
• Sepan que existe una extensión llamada “Live Share”, que les permite crear una
sesión de programación en la que varias personas pueden trabajar sobre un mismo
archivo. Considero oportuno mencionarles esto para que puedan trabajar con sus
compañeros de grupo más fácilmente.
2.5) (SÓLO WINDOWS) Cambiar terminal por defecto de
VSCode
Windows tiene dos “shells” o consolas: CMD y PowerShell. La CMD es más vieja y menos
potente, pero es la que vamos a usar para compilar nuestros proyectos, porque la
PowerShell no soporta el comando del compilador por algún motivo que desconozco.
Dentro de VSCode, presionan Ctrl + Shift + P, lo que abre la “paleta” de comandos (no
como el fiambre, sino más bien como la de los pintores). Aquí escriben “Terminal: Select
Default Profile”, y seleccionan Command Prompt, o sea, la CMD.
Pueden abrir la consola dentro de VSCode presionando Ctrl + Ñ.
3) Programar
Ya estamos listos para codificar nuestros primeros programas. En primer lugar, abran con
VSCode la carpeta madre: Archivo (File) > Abrir carpeta (Open folder) > [Seleccionar
carpeta madre]. Dentro de la misma, vamos a crear una carpeta para cada programa que
hagamos, donde vamos a alojar todos los archivos necesarios; denle a cada carpeta un
nombre descriptivo de lo que hace el programa, les va a hacer la vida más fácil. Adentro
de cada carpeta proyecto, creen otro directorio al que van a llamar “build”, lo utilizaremos
más adelante.
Para programar, deben crear un archivo “main.asm” con el botón “New file” (seleccionado
en la imágen). Presten atención a que se cree fuera del directorio “build”, pero dentro de
la carpeta projecto. En este archivo van a escribir su código de assembler. Tienen un
ejemplo de código en assembler en el campus virtual, para que puedan compilar más
adelante y comprobar que todo funcione correctamente.
4) Compilar
Una vez hayan terminado el código, lo compilan abriendo la consola de VSCode, y
pegando las sentencias que encuentran debajo. Para pegar texto en la consola, Ctrl + V
no funciona, porque es un acceso directo reservado para una señal que se envía al
sistema. Deben en su lugar utilizar Ctrl + Shift + V.
(Windows) pic-as -mcpu=16F628A -o build\program.hex main.asm -xassembler-with-cpp -
Wa,-a
(Linux) pic-as -mcpu=16F628A -o build/program.hex main.asm -xassembler-with-cpp -
Wa,-a
… donde “main.asm” es el nombre de su programa.
Tengan en consideración que deben ubicar la consola en la carpeta donde se encuentre
su programa, tal que el compilador encuentre los archivos donde uno le impone en sus
parámetros. VSCode ubica la consola en la carpeta que ustedes hayan abierto con “Open
Folder” por defecto, en nuestro caso sería la carpeta madre que crearon en el paso 2).
Para moverse entre carpetas, se utiliza la operación “cd” en la línea de comandos, tanto
en Windows como Linux.
Carpeta madre > Carpeta de proyecto: cd “nombre carpeta”
Carpeta de proyecto > Carpeta madre: cd ..
Si el programa compiló adecuadamente, debe mostrarles un pequeño resumen de cómo
queda ordenada la memoria del microcontrolador. Si muestra warnings, consultar con el
profe Juanse, NO IGNOREN LAS WARNINGS!!!
Al compilar obtienen una variedad de archivos en la carpeta build. El único que nos
interesa es el archivo de terminación .hex, ya que contiene el código binario que
cargamos tanto en Proteus como con PICKit 2 al microcontrolador.
5) Simulación en Proteus
Como vieron en Diseño Asistido en 5to Año, el simulador de Proteus es una herramienta
útil para el desarrollo de proyectos, ya que si bien es de funcionamiento “ideal”, permite
diagnosticar fallas en un circuito fácilmente. Estas cualidades se mantienen al programar
código en microcontroladores, gracias a que permite visualizar el valor de los registros de
memoria interna de los mismos en tiempo real.
Afortunadamente Proteus tiene en sus librerías una gran variedad de microcontroladores
de la línea PIC, por lo que no hace falta instalar ningún archivo adicional. Sólo es
necesario cargar el archivo .hex que generó el compilador en las propiedades del PIC.
En “Program File” cargan el archivo .hex, y en “Processor Clock Frequency” deben
ingresar 4MHz en caso de utilizar el oscilador interno.
Para visualizar la memoria del microcontrolador, una vez que estén simulando, deben
dirigirse a “Debug > PIC CPU”, y allí pueden visualizar todos los registros de interés del
mismo: la pila, memoria de datos, EEPROM, etc.
6) Programación del microcontrolador
La carga de código binario al microcontrolador se realiza con el software PICKit 2 y su
placa programadora PKCLONA2.
Deben conectar la placa programadora para que el programa funcione adecuadamente.
Puede ocurrir que el software no detecte la conexión con el PKCLONA2, como se muestra
en la imagen; para solventar este error deben entrar en “Tools > Check Communication”.
De esta manera, verifican la conexión con su placa. Si el programa sigue sin encontrar la
placa programadora, puede que la misma no funcione correctamente.
Una vez que el programa detecte el programador, el archivo .hex se carga en la interfaz
en “File > Import Hex”. Luego, le dan al botón de Write y se envía el código al PIC.
