No es la primera vez (ni la última, seguro) que nombro a los microcontroladores en mis entradas... Y posiblemente os suceda lo mismo que ocurrió en el caso de los FPGA. Así que vamos a explicar brevemente lo que es un microcontrolador y para qué sirve (o para qué puede servirnos a nosotros).
Un microcontrolador, a grandes rasgos, es como un ordenador "completo" dentro de un único circuito integrado (ala, qué bestia, tú lo flipas). Si nos fijamos, por ejemplo, en un Spectrum molón (por ser el más sencillito), podemos dividirlo en varias partes, a saber:
- Microprocesador (nuestro conocido Z80 de Zilog a 3,5Mhz)
- Memoria RAM (memoria de lectura y escritura y volátil, los famosos 48K del gomas para almacenar programas y datos)
- Memoria ROM (memoria de sólo lectura, donde reside el BASIC, por ejemplo, entre otras cosas. No se borra al apagar el equipo, al contrario de lo que ocurre con la RAM)
- Dispositivos I/O (periféricos que usamos para introducir datos al ordenador, como el teclado o la unidad de cinta externa o para extraerlos y/o visualizarlos, como puede ser la pantalla o la misma unidad de cinta cuando grabamos un programa en ella)
- Bus de expansión (donde podemos incluir el conector del casete o el propio "Bus de Expansión", que se encuentra situado en la parte trasera del Spectrum y que permite añadirle externamente ampliaciones de hardware, como ampliaciones de RAM, controladoras de disco, etc).
Básicamente, así tenemos definido un ordenador personal sencillo. Al encender nuestro equipo, el microprocesador lee primero de la ROM el programa de "inicialización", que prepara y configura el estado inicial de nuestra máquina, configura los dispositivos, limpia la RAM y arranca el interfaz de usuario que nos permitirá comunicarnos con el ordenador (en este caso, el BASIC). Todo eso reside en la ROM.
 |
| Mi proyecto USB usa este microcontrolador |
A partir de ese punto, cualquier línea de código que tecleemos (usando el teclado) o que carguemos (usando la unidad de cintas) se almacenará en la memoria RAM, y ahí seguirá hasta que reiniciemos el ordenador o lo apaguemos.
Una vez que tenemos estos conceptos más o menos claros (perdón por el discurso), ya podemos abarcar lo que es un microcontrolador con más detalle.
Hay miles de tipos distintos de microcontroladores, de todos los tamaños, de todos los precios, de distintos fabricantes... Algunos son específicos para ciertas tareas, otros son genéricos... Yo me voy a centrar en un microcontrolador genérico, que "vale para todo".
Un microcontrolador es simplemente un chip, un circuito integrado, de igual o menor tamaño que un procesasdor Z80 (depende del modelo). Dentro de este circuito integrado, podemos encontrar:
- Un Microprocesador (depende del tipo de microcontrolador; los hay de 8 bits, los más baratos y comunes y los hay de 32 bits, mucho más potentes; desde los que funcionan a 10 Mhz hasta los 80 Mhz o más)
- Memoria RAM (tambien depende del modelo...; los hay con 8Kbytes de RAM, con 64Kbytes de RAM...)
- Memoria ROM (lo mismo que antes, es un valor variable: 8Kbytes, 16Kbytes...)
- Bus I/O (digamos que es el "Bus de Expansión"; son varias señales de entrada y salida completamente programables para comunicarnos con el exterior; el número de señales disponibles también depende del modelo de microcontrolador que tengamos)
Si os habéis fijado, en un único chip prácticamente tenemos todos los componentes presentes en un ordenador completo como puede ser el Spectrum y su funcionamiento es muy parecido.
Al poner en marcha el microcontrolador (darle alimentación) el procesador lee el programa que hayamos programado en su ROM. Este programa puede ser cualquier cosa que se nos ocurra (siempre dentro de los límites de proceso y espacio del microcontrolador) y sus funciones depende directamente de ese programa. Básicamente se configuran las entradas y las salidas y se interpretan para dar un resultado que puede almacenarse en la RAM y que va en función de cálculos internos que hayamos realizado y del estado de las entradas que estemos comprobando.
 |
Patillaje: PAx, PBx, PCx y PDx son puertos
de 8 bits configurables por el usuario |
Podemos, por ejemplo programar un simple contador de segundos que nos muestre el resultado encendiendo unos leds que estén conectados en algunas de sus salidas (programadas en modo salida). En este caso, el programa no necesita ningún tipo de entrada y se limita simplemente a "contar" y darnos el resultado. También podemos mejorar ese programa y que el contador se inicie o se pare al accionar un pulsador. Este pulsador irá conectado a una patilla del microcontrolador que habremos configurado en modo "entrada" y nuestro programa en este caso deberá inspeccionar el estado de esa entrada regularmente para actuar en consecuencia parando o iniciando la rutina del contador.
Todo esto, puede complicarse mucho más, hasta el punto de que podemos crear un sistema complejo, como puede ser una consola de videojuegos, usando únicamente un microcontrolador y un par de componentes de apoyo (como la Uzebox que comenté en una entrada anterior):
 |
Mini ordenador montado con un microcontrolador AVR
(en el centro). Incluye puerto serie, de vídeo y de teclado.
¡Y hasta un intérprete de BASIC! |
Cómo veis, las posibilidades son infinitas y nos abre un mundo inmenso de posibilidades, desde la creación de periféricos hardware para nuestros equipos retro (como he hecho yo con el aparato USB para Amstrad CPC) hasta montar equipos completos (Uzebox).
Otra de las ventajas importantes es el precio de estos integrados. El microcontrolador que yo uso para mi proyecto, funciona a 16 Mhz y tiene una CPU de 8 bits (que nos da unos 16 millones de instrucciones por segundo aproximadamente, mucha más potencia que el Z80). Su aspecto es idéntico al de un Z80 (40 patillas), y todo esto por unos 6€. El mayor desembolso reside en el programador (necesitamos un aparato para programar los chips), que en mi caso me costó unos 50€ por eBay, y me permite programar miles de microcontroladores y eproms distintas.
 |
Un juego de ejemplo programado en BASIC para el
"ordenador" de la foto anterior. ¿Mola o no mola? |
El lenguaje de programación que se suele usar, es el C, aunque hay muchas posibilidades más (dependiendo del fabricante). Mucha gente los programa directamente en ensamblador, y si eres como yo (más simple que el mecanismo de un botijo) puedes hacerlo en BASIC (sí, mi interfaz USB para Amstrad está programado en BASIC). Es tan sencillo como crear el programa en el PC, compilarlo y generar el archivo que luego meteremos dentro del microcontrolador con el programador.
Un ejemplo de programa, creado en BASIC (FASTAVR) para microcontroladores ATMEL puede ser este:
----------------------------------------------------------------------------------------------
'/////////////////////////////////////////////////////////
'/// FastAVR Basic Compiler for AVR by MICRODESIGN ///
'/// 3 flashing Leds STK-500 www.FastAVR.com ///
'/////////////////////////////////////////////////////////
$Device= 8515 ' modelo de microcontrolador
$Stack = 32 ' stack depth
$Clock = 8 ' velocidad del cristal en Mhz
$Lcd = PORTC.0, Rs=PORTC.5, En=PORTC.4, 20, 4
$Timer1=Timer, Prescale=256
$Source=On
$LeadChar=" "
$Def LED0=PORTA.0 ' Asignamos nombres a los 3 primeros bits
$Def LED1=PORTA.1 ' del puerto A
$Def LED2=PORTA.2
Declare Interrupt Ovf1()
Dim time As Word
Dim tLed0 As Word, tLed1 As Word, tLed2 As Word
Dim d0 As Word, d1 As Word, d2 As Word
Dim d00 As Byte, d11 As Byte, d22 As Byte
PORTA=&hf8 ' Aquí configuramos los 3 primeros bits del puerto A
' en modo salida. 11111000 en binario
DDRA=&h07 ' Aquí inicializamos los bits. Al arrancar el
' programa los leds se encenderán.
' En binario: 00000111
' 0 = apagado, 1 = encendido
Timer1=&hf3cb ' 100 ms time
Enable Ovf1
Enable Interrupts
Start Timer1
Do
d0=time-tLed0: d00=d0 ' d00... back to 8 bit
d1=time-tLed1: d11=d1 ' because IF is shorter
d2=time-tLed2: d22=d2
If LED0 Then
If d00>8 Then
Reset LED0 ' LED0 ON
tLed0=time
End If
Else
If d00>10 Then
Set LED0 ' LED0 OFF
tLed0=time
End If
End If
If LED1 Then
If d11>10 Then
Reset LED1 ' LED0 ON
tLed1=time
End If
Else
If d11>15 Then
Set LED1 ' LED1 OFF
tLed1=time
End If
End If
If LED2 Then
If d22>12 Then
Reset LED2 ' LED2 ON
tLed2=time
End If
Else
If d22>20 Then
Set LED2 ' LED2 OFF
tLed2=time
End If
End If
Loop
'/////////////////////////////////////////////////////////
Interrupt Ovf1(), Save 1
Timer1=&hf3cb ' 100 ms time @ 8MHz
Incr time ' just incr time tick
End Interrupt
----------------------------------------------------------------------------------------------
Podéis ver que el programa es bastante sencillo de entender. Se trata simplemente de encender y apagar 3 diodos LED que están conectados al puerto A del microcontrolador. Cada puerto, por regla general, consta de 8 bits (8 patillas), con lo que podríamos controlar hasta 8 diodos LED.
En definitiva, que todo es ponerse y realmente no es complicado. Si os gusta trastear y diseñar hardware, los microcontroladores son un buen punto de partida, y no necesitáis ser expertos para hacer cosas chulas, os lo digo yo, jejejejeje.
Si queréis más información sobre microcontroladores y características específicas y modelos, os recomiendo que visitéis los sitios web de los dos principales fabricantes de microcontroladores:
Espero que alguno de vosotros os animéis a trastear con ellos. Os lo pasaréis pipa, garantizado.
Saludos.
Y para los usuarios de Commodore, en primicia os digo que... ¡Algo se cuece!
