Hasta ahora no hay ninguna razón por la que utilizar una FPGA para ejecutar código Arduino: es mejor y más barato programar una Arduino convencional. En este capítulo se van a discutir y explicar varias razones para emular Arduino -o cualquier microcontrolador- en una FPGA:
1. Aceleración
Una FPGA puede realizar operaciones complejas en uno o pocos ciclos de reloj. Un microcontrolador está especializado en hacer un gran número de operaciones sencillas por segundo. En algunos casos es muy beneficioso resolver un problema con lógica reprogramable. Los ámbitos interesantes son: criptología, tratamiento de imágenes, reconocimiento de voz, radioastronomía...
Es una ventaja interesante especialmente para la investigación. Hay pocos usos en los que una FPGA sea más rápido que un microprocesador moderno o una GPU. En el ámbito Arduino (bajo coste), no importa demasiado.
2. Obsolescencia
Este problema se presenta especialmente en la industria: un microcontrolador utilizado hace años en un proyecto aún en producción, se deja de fabricar. Normalmente el código programado para microcontroladores están especialmente concebidos para un modelo concreto e incluso con una frecuencia de reloj concreta.
Este problema no existe si se emula el microcontrolador en una FPGA. Aunque la FPGA se deje de fabricar, se puede emular el mismo código, con el mismo comportamiento, en cualquier modelo parecido de chip reprogramable.
En el ámbito de Arduino este problema no se suele dar: es más fácil cambiar el código.
3. Paralelismo
Esta es la primera ventaja que sí es interesante en el mundo hazlo-tú-mismo/Arduino.
Ejemplo I: es necesario encender 8 LEDS exactamente a la vez, sin un retraso mayor de un ciclo de reloj entre la primera y la última. Además, hay que encender sólo algunos, dependiendo de una entrada.
Ejemplo II: se está generando una señal con la Arduino que se transmite por radio. Una modulación PWM cuya distorsión debe ser mínima. Además, hay que generar 5 con distintas frecuencias. Además, hay que usar el micro para leer del puerto serie y otros trabajos que utilizan el microcontrolador por períodos indeterminados de tiempo.
Ejemplo III: en un sistema que controla un robot se están utilizando 4 timers, 30 LEDS, 8 entradas analógicas y varios sensores que piden interrupciones para dar su dato.
En estos tres ejemplos una Arduino convencional estaría saturada o no sería capaz de cumplir requisitos. Un número importante de interrupciones puede saturar el microcontrolador y, sobre todo, convertir el desarrollo del proyecto en un auténtico infierno.
Una solución podría ser la siguiente: un microcontrolador para cada sensor, uno para cada salida PWM, uno para cada LED, uno para cada servo y cada motor y una Arduino para gobernarlos a todos.
Con una FPGA es posible llegar a un término medio y es una de sus aplicaciones más comunes: un microcontrolador gobierna un sistema de módulos independientes con un sistema de comunicación entre ellos eficiente y simple.
Entonces, en el ejemplo I se programaría en VHDL un módulo que gestione 8 salidas digitales a la vez, en el mismo ciclo de reloj, en el momento que le llegue la orden del microcontrolador.
En el ejemplo II se programaría un módulo VHDL que genera una señal PWM. Para ello utilizaría un contador, parecido al timer del microcontrolador pero sin interferir con él. Para generar 5 señales sólo hay que instanciar este módulo 5 veces y conectarlos con las salidas correspondientes. Cualquier pin físico sería válido.
En el ejemplo III se generaría un módulo en VHDL para cada timer, módulos de gestión de cada sensor, etc. El microcontrolador sólo tendría que atender las entradas de usuario y enviar los mensajes correspondientes a cada módulo. Todo a máxima velocidad y mínima saturación del micro.
La comunicación entre módulos se hace utilizando las direcciones de ram externa que no están siendo utilizadas en el proyecto AVR8. Se definen tantos registros como sea necesario para cada módulo.
4. Personalización
Tener el código del microcontrolador a utilizar tiene sus ventajas. Es posible, por ejemplo, aumentar el número de salidas digitales o analógicas (y hacerlo de forma más eficiente gracias al punto anterior).
En el siguiente ejemplo se crea una Arduino emulada y se modifica para tener 48 salidas pseudo-analógicas PWM.
- 48 módulos independientes con un temporizador de una resolución de 8 bits.
- Cada módulo se conecta a un pin de la Papilio.
- 48 direcciones de memoria externa reservadas para la comunicación entre Arduino y los módulos.
- Si el valor en cada registro es mayor que el contador, a la salida del módulo se pone un uno. Si no, un cero.
Herramienta Oruga
Además, se baja el módulo PWMout.vhd que está preparado para ser utilizado con un proyecto Oruga. Es un módulo que recoge un valor de 8 bits de un registro de memoria (cuya dirección es definida en el momento de instanciarlo) y lo utiliza para generar una señal PWM con un ciclo de trabajo proporcional al valor que le llegue.
En el siguiente código (auto-generado por Oruga) se instancia el módulo que se configura con la dirección de memoria E/S 0x0FE0 y se conecta con el pin físico 0 del puerto A. Además, se configura ese pin para ser de salida en la última línea.
OrugaA_0:component Oruga_PWMout
GENERIC MAP(
io_base_address_generic => x"0fe0")
PORT MAP(
nReset => nrst,
clk => clk16M,
adr => core_adr,
dbus_in => core_dbusout,
iore => core_iore,
iowe => core_iowe,
output_sig => porta(0)
);
DDRAReg(0)<='0';
GENERIC MAP(
io_base_address_generic => x"0fe0")
PORT MAP(
nReset => nrst,
clk => clk16M,
adr => core_adr,
dbus_in => core_dbusout,
iore => core_iore,
iowe => core_iowe,
output_sig => porta(0)
);
DDRAReg(0)<='0';
Se genera un proyecto con 48 pines conectados a instancias de módulos PWMout. Por defecto se reservan dos direcciones de memoria para cada módulo. El primer módulo tendrá las direcciones 0xFE0 y 0xFE1, el segundo 0xFE2 y 0xFE3 y así hasta el último módulo: 0x103e y 0x103f. Esto es así para poder utilizar un byte de escritura y otro de lectura, pero en este caso sólo es necesario enviar datos al módulo PWM (sólo se usan las direcciones pares).
El esquema con los 48 módulos es peculiar:
El código Arduino inicial va a ser:
void setup()
{
for (int i = 0; i<48; i++){
writePWM(i, 256*i/48);
}
}
void loop()
{
}
{
for (int i = 0; i<48; i++){
writePWM(i, 256*i/48);
}
}
void loop()
{
}
#define io_start_address 0x0FE0
byte writePWM(int pin, byte value){
_SFR_IO8(io_start_address+pin*2) = value;
}
byte writePWM(int pin, byte value){
_SFR_IO8(io_start_address+pin*2) = value;
}
Este sketch va a configurar el estado inicial de cada módulo PWM con código Arduino, por lo que la configuración va a hacerla el microcontrolador, módulo a módulo.
Se puede observar que en 800 microsegundos (menos de un milisegundo) se han configurado los 48 canales, cada uno con un valor distinto de ciclo de trabajo, con 3 líneas de Arduino y ni una sola de VHDL, gracias a la herramienta Oruga. Además, la función loop() de Arduino está vacía, por lo que el microcontrolador está totalmente libre para otros trabajos.
No hay comentarios:
Publicar un comentario