Raspberry Pi Pico y FreePascal

Raspberry Pi Pico, no es una Raspberry como otras placas de la fundación Raspberry que son un microordenador. Sino que es una microcontrolador. La diferencia es que un microordenador es un microprocesador con todos sus periféricos, tarjeta de vídeo, puertos usb, etc. En cambio un microcontrolador es solo un el microprocesador.

Al programar un microcontrolador, como por ejemplo los famosos Arduinos, se suele hacer en C, el cual es un lenguaje compilado. Lo que significa que el código que escribamos será traducido al lenguaje que entiende el microprocesador, y ejecutado.

Raspberry Pi Pico, permite ser programada además de en C, en Micropython, el cual es un lenguaje interpretado. La principal diferencia está en que un programa escrito en un lenguaje interpretado siempre tiene un rendimiento menor que un lenguaje compilado. Ya que lo que ocurre con los lenguajes interpretados es que son leídos línea a línea por un interprete, traducido a lenguaje del microcontrolador y ejecutado. Todo esto según se ejecuta nuestro programa, lo cual hace que el microprocesador tenga más trabajo.

El lenguaje C, es un lenguaje con el cual, los programas al ejecutarse obtienen un gran rendimiento pero para muchas personas se hace complicado trabajar con él, en gran medida por su sintaxis. Por otra parte Pascal en un lenguaje dónde la sintaxis es más amigable, y como en C, los programas tiene un gran rendimiento.

FreePascal, en sus versiones trunk o desarrollo, próximas a publicarse, soporta gran cantidad de sistemas embebidos entre ellos las nueva placa Raspberry Pi Pico.

Preparando el entorno.

Antes de nada debemos instalar FreePascal, y su entorno desarrollo, o IDE, llamado Lazarus. Tal como comenté, FreePascal en su versión actual no soporta Raspberry Pi Pico, pero si en su versión «Trunk» o desarrollo.

La mejor manera de instalar todo lo necesario es utilizar la aplicación Fpcupdeluxe. Descarga la última versión desde su página. Escoge la versión para tu sistema operativo.

Aspecto de Fpcupdeluxe

Lo primero es seleccionar un carpeta dónde realizar la instalación, para ello pulsa en el botón Set InstallDir.

Seleccionar directorio.

Ahora, abajo de todo. Pulsa sobre el botón que pone Pico y que tiene una imagen de la placa Raspberry Pi Pico.

Botón instalar Pico

Ahora, pulsa en Install/Update FPC+LAZ. Ya solo queda esperar. Fpcupdeleuxe se encargará de descargar todos los archivos necesarios e instalarlos. El proceso pude tardar más o menos dependiendo de la conexión a internet y de tu ordenador.

Una vez descargado e instalado todo, Fpcupdeleuxe creará un icono en el escritorio para iniciar Lazarus. Antes de abrir el programa, descarga los ejemplos de este github.

Algunos ajustes previos

Abre el entorno Lazarus, usando el acceso directo que se creó en el escritorio de tu pc. Por defecto aparece en inglés. Para cambiar el idioma, selecciona el menú Tool y dentro de este Options. En la ventana que aparece, selecciona General, y selecciona Lenguage.

Cambiar el idioma.

Para que el cambio sea efectivo cierra Lazarus y vuelve a abrirlo. O desde el menú File, selecciona Restart.

Reiniciar Lazarus

Primer programa

Como es tradición, vamos hacer parpadear un LED, en este caso es un LED, que viene integrado en la placa.

Selecciona el menú Proyecto y dentro de este selecciona, Abrir proyecto. Busca la carpeta dónde hayas descargado los ejemplos y selecciona el proyecto Blinky.

Abrir proyecto Blinky

Ahora, desde el menú Ejecutar selecciona Compilar. También puedes usar el atajo Ctrl+F9. Te recomiendo que recuerdes esta combinación de teclas, ya que la usarás mucho.

Compilar programa

En la ventana de mensajes, puedes ver como se produce el proceso de compilado y el resultado del mismo. Si todo ha ido bien, mostrará un mensaje indicando que ha sido un éxito.

Ventana mensajes.

Ahora solo queda cargar nuestro programa en la Raspberry Pi Pico. Conecta la placa a tu ordenador en un puerto usb. Mantén pulsado el botón BOOTSEL, conecta el cable micro USB y suelta el botón BOOTSEL. En el ordenador se montará una unidad nueva llamada RPI-RP2,como si fuera una unidad USB.

Unidad RPI-RP2 montada al conectar la placa Pico

Para ello abre la carpeta dónde está el programa que acabas de abrir. Dentro de este hay una carpeta llamada Bin, dentro de esta última hay un archivo llamado blinky.uf2. Cópialo dentro de la la unidad RPI-RP2. La placa Rasperry pi Pico se reiniciará y empezará a ejecutar el programa. En esta caso parpadeará el Led de color verde que lleva incorporado.

El programa que hemos cargado es muy sencillo, vamos a ver algunos detalles del mismo.

program blinky;
{$MODE OBJFPC}
{$H+}
{$MEMORY 10000,10000}

uses
  pico_gpio_c,
  pico_timer_c;

begin
  gpio_init(TPicoPin.LED);
  gpio_set_dir(TPicoPin.LED,TGPIODirection.GPIO_OUT);
  repeat
    gpio_put(TPicoPin.LED,true);
    busy_wait_us_32(500000);
    gpio_put(TPicoPin.LED,false);
    busy_wait_us_32(500000);
  until 1=0;
end.      

El primer detalle que debemos fijarnos es en la línea cuatro. La directiva de compilación {$MEMORY 10000,10000} indica al compilador que debe reservar debe reservar 10000 bytes de la memoria para la el stack (pila) y otros 10000 para el heapsize (montículo). Sino tienes claro para que sirve para cosa, te recomiendo que visites esta página. Recordar que estamos programando un microcontrolador, y no existe sistema operativo que gestione la memoria

Las siguientes líneas indican las unidades o librerías que vamos usar, en este caso: pico_gpio_c y pico_timer_c. Estas librerías fueron instaladas previamente.

En las líneas 11 y 12, preparamos la salida. Primero inicializándola y luego indicando que será una salida. TPicoPin.LED es una constante que contiene el número de pin en el cual está conectado el LED que está incluido en la placa.

Después, entramos en un bucle en el cual se repetirá hasta que sea cumpla la condición indicada en la línea 18. La cual nunca se cumplirá por lo cual siempre estará ejecutándose el código que hay en el interior.

La línea 14, activa la salida que hemos definido antes.

La línea 15 espera 50000 microsegundos, osea 500 milisegundos.

La línea 16, desactiva la salida.

La línea 17 vuelve a esperar 50000 microsegundos.

Con lo cual conseguimos que la salida esté activa durante medio segundo, y desactivada otro medio segundo.

Conclusión.

De una manera sencilla podemos preparar el entorno para programar nuestra Raspberry Pi Pico, usando un lenguaje compilado, y aprovechar así todo su potencial.

Saludos.

Deja una respuesta