Como se ve en el título, no hablaremos únicamente de un modelo concreto, pues éstos se agrupan por familias que tienen unas características muy similares y que, por lo tanto, se estudian a la vez. En nuestro caso hablaremos de la familia PIC16F87x, por tratarse de una de gama media que permite llevar a cabo la mayoría de las aplicaciones típicas de los microcontroladores. Así mismo, todo el código escrito de ahora en adelante será ensamblador.

En la actualidad existen compiladores para multitud de lenguajes, de forma que pueda programarse con ellos un microcontrolador. Todos ellos son de más alto nivel que ensamblador, lo que se traduce en una programación más intuitiva y menos propensa a errores. ¿Por qué usar ensamblador entonces? Porque es la base de todo: con ensamblador seremos nosotros los que indicaremos al microcontrolador que tiene que hacer en cada instante, controlando hasta el último rincón del mismo.

Esto nos dará un conocimiento sobre su funcionamiento mucho mayor que si usásemos, por ejemplo, un compilador de C que cuenta con librerías ya implementadas para llevar a cabo la mayor parte del trabajo. Podemos decir que ensamblador es para aprender y los demás para programar. Dicho esto, comenzamos.

La familia PIC16F87x

Tal y como ya comentamos, al trabajar con microcontroladores PIC se habla no tanto de un modelo concreto sino de familias, pues la diferencia entre los miembros de la misma son mínimos. Sin embargo, en última instancia y más allá de motivos académicos, se trabaja con un modelo concreto. En nuestro caso será con el PIC16F877. Por lo tanto, de ahora en adelante se usará ese modelo por comodidad.

El PIC16F877 es un microncontrolador de ocho bits y 28 0 40 pines, disponible en múltiples encapsulados. Nosotros emplearemos el PDIP, pues los de tipo SMD no son tan propensos al montaje de circuitos caseros, dada la dificultad de su manejo motivada por su pequeño tamaño.

Pueden consultarse todas sus características de forma detallada en la hoja de características facilitado por el fabricante pero, no obstante, os comento a continuación las más relevantes:

• Frecuencia de funcionamiento de hasta 20 MHz.
• Manejo de hasta 14 fuentes de interrupción.
• Watchdog interno.
• Modo Sleep de bajo consumo.
• Modo de programación serie sobre el circuito, o ICSP, mediante dos pines.
• Tres módulos temporizadores.
• Dos módulos CCP.
• Un conversor analógico digital multientrada de 10 bits.
• Módulos SPI, I2C y USART para comunicación con otros dispositivos.

Esta nueva entrega vamos a hablar de la transferencia de información entre MATLAB y Java. En el ejemplo del post anterior programamos un HelloWorld que, aunque ilustrativo, no trata un tema fundamental como es el intercambio de información entre los códigos de uno y otro lenguaje. En esta ocasión vamos a implementar un sumador, de forma que desde la aplicación Java se llame a una función MATLAB que sume los dos números que le pasemos como parámetros y que nos devuelva el resultado de la operación.

Sumador

Dado que en post anterior ya expliqué cómo generar el paquete Java, en esta ocasión me limitaré a explicar qué hay que hacer profundizar mucho en el cómo. Vamos a implementar un sumador, así que lo primero es programar el código MATLAB, al cual llamaremos add.m:

function [total] = add(a, b)
    total = a + b;
end

Como se observa, el código no tiene ningún misterio y se limita a sumar los dos números que pasamos como parámetros. Generamos mediante deploytool un paquete Java de nombre AdderProject y le añadimos una clase AdderClass que contenga el fichero add.m

En el código Java, una vez incluido la librería y el paquete MATLAB que acabamos de crear, basta con incluir el siguiente código:

    double a, b;
    Object[] results = null;
    Adder adder = new Adder();

    double a = 4;
    double b = 7;

    results = adder.add(1, a, b);

    MWArray result = (MWNumericArray) results[0];
    double[][] total = (double[][]) result.toDoubleArray();

Antes de comentar el código aquí expuesto, quiero aclarar que ésta no es la única forma de pasar y recibir datos a/desde MATLAB. De hecho, en la documentación oficial se habla de diferentes métodos. En esta guía he optado por emplear el más sencillo de ellos, pues resulta suficiente a efectos de comprender el funcionamiento de la aplicación.

El código anterior se limita a definir dos variables de tipo double: a y b, que serán los valores que vamos a sumar. En general, el tipo de datos double será el que tenga una conversión más natural entre MATLAB y Java, y por ello será el que utilicemos en lugar de otros como int, que podrían usarse perfectamente en este caso.

A continuación, se llama a la función add con los parámetros 1, a, b. En la entrega anterior había comentado que no tenía claro qué indicaba el uno del principio. Al parecer, sirve para definir cuántos datos devolverá la función. En nuestro caso, únicamente esperamos recibimos uno: el resultado de la operación. Como se observa, los parámetros se pasan directamente sin hacer ningún tipo de conversión, pues se está haciendo uso de la conversión automática que, aunque menos eficiente, es muy sencilla de emplear.

El resultado devuelto por la función se almacena en una variable de tipo Object[]. Como ya supondréis, es un vector que contendrá todos los valores devueltos por la función.

Posteriormente se crea un objecto de tipo MWArray, que contendrá uno y sólo uno de las variables devueltas. Por lo tanto, nos limitamos a escoger la que deseemos del array results, en este caso la primera y única, y la convertimos a MWNumericArray. Hecho esto, nos limitamos a convertirla en un array bidimensional de tipo double, donde almacenaremos el resultado de la suma ya listo para su empleo en Java.

Merece la pena reseñar que en MATLAB cualquier tipo de dato es una matriz. Por lo tanto, al recuperar los datos desde Java se hace como matriz también, aunque en este caso sea de dimensión 1×1.

Con esto doy por concluida esta pequeña guía de integración de MATLAB y Java. Sé que he dejado muchas cosas en el tintero, pero en principio esto es suficiente para la mayoría de aplicaciones. En cualquier caso, no dudéis en comentarme las dudas que tengáis e intentaré responderos.

En mi caso, lo que me motivo a buscar información sobre este tema no fue tanto el querer hacer cálculos desde Java, sino diseñar en Java mediante componentes Swing la interfaz gráfica de un programa escrito en MATLAB, pues, aunque bien es cierto que éste último cuenta con un editor incorporado llamado guide, deja bastante que desar si lo que se desea es un resultado más o menos profesional.

Antes de nada me gustaría aclarar que todo lo aquí expuesto no es más que una traducción/recopilación de lo visto en otras páginas webs, especialmente de la propia web de MATLAB. http://www.mathworks.com/help/toolbox/javabuilder/ug/brlu1as-1.html. Dicho esto, comenzamos.

¡Hola mundo!

En un alarde de original el ejemplo sobre el que va a girar esta primera parte será el más que clásico Hola Mundo. La idea será escribir un código en MATLAB que imprima en pantalla dicho mensaje para luego ejecutarlo desde Java. Lo primero que hay que hacer por lo tanto es escribir dicho código. Hay que recordar que, en principio, tiene que estructurarse el código en forma de funciones, de forma que luego puedan ejecutarse desde nuestra aplicación Java.

Escribimos el siguiente código en MATLAB en un fichero que llamaremos helloWorldClass.m:

function helloWorldFunction
    fprintf(1,'Hello World!\n' );

Como se observa el código no tiene ningún misterio. A continuación hay que convertir este código en otro que pueda ejecutarse desde java. Para ello, basta con ejecutar el comando deploytool. Nos aparecerá ahora un menú como el que se muestra en la siguiente imagen:

Como veis, es un cuadro de diálogo sin mucho misterio. Para seguir el ejemplo lo ideal sería que lo dejaseis con los mismos valores que aparecen en la imagen. A continuación nos aparecerá una ventana en la que deberemos indica qué clases queremos crear y qué ficheros .m contendrá cada una. Por lo tanto, hacemos clic en el enlace Add class y le damos el nombre que queramos, como por ejemplo, HelloWorldClass. A continuación añadimos el fichero .m creado previamente a dicha clase mediante Add files.

Hecho esto sólo resta clicar en el botón de Build situado en la parte superior de la ventana del deploytool. Si todo ha ido bien, tras un tiempo relativamente pequeño tendremos nuestro paquete Java listo para usar.

Para programar en Java yo empleo el entorno de desarrollo NetBeans, así que lo explicado a continuación supondrá que también vosotros lo usáis. No obstante se puede hacer también sin mayores problemas en otros entornos.

Creamos un nuevo proyecto Java y añadimos como librería el fichero .jar que se creó mediante deploytool y que se encuentra en el directorio c:\helloworld\contrib. Debe añadirse también de la misma forma el fichero javabuilder.jar, que puede encontrase en directorio_raiz_de_matlab\toolbox\javabuilder\jar.

Hecho esto, basta con añadir a nuestro código las siguientes líneas:

import com.mathworks.toolbox.javabuilder.*;
import HelloWorldProject.HelloWorldClass; 

En este momento, estamos listos para poder ejecutar nuestro código MATLAB desde Java. Para ello hay que limitarse a crear un objeto de la clase HelloWordClass y llamar a la función que nos interese, como se muestra en el siguiente ejemplo:

HelloWorldClass helloWorld = new HelloWorldClass();
helloWorld.helloWorldFunction(1);
if (helloWorld != null) {
    helloWorld.dispose();
}

El código es muy sencillo: como dijimos, se limita a crear un objeto y a llamar a una de las funciones que contiene, en este caso, helloWorldFunction, que fue la que definimos previamente en el fichero .m. Finalmente se liberan los recursos ocupados. Tengo que comentar que desconozco el sentido del parámetro que se pasa como argumento a nuestra función, pero venía así con los ejemplos de la web de MATLAB y sin él no funciona.

Con esto llegamos al final de la primera de las partes de este minitutorial. Espero que os haya gustado y que estéis al tanto de las partes que faltan.

Actualización: comentaba más arriba que no sabía cuál era la misión del primer parámetro que se le pasa a la función MATLAB desde Java. Parece ser que indica el número de variables que va a devolver la función, lo cual explica que el valor más habitual sea uno.

Las ramas de estudiantes son asociaciones de, valga la redundancia, estudiantes, al frente de las cuales se encuentra un profesor de la universidad correspondiente miembro del IEEE. Al menos en la nuestra, cualquier estudiante de la Universidad de Oviedo, incluso posiblemente cualquier persona interesada en la materia, puede participar.

Por el momento, somos unos treinta y nos reunimos una media de una vez a la semana para tratar temas que nos interesan como son los citados anteriormente. Aunque cada uno puedo diseñar lo que quiera, ahora mismo, estamos construyendo un pequeño robot siguelíneas o velocista (a elección del consumidor).

Realmente se trata de una buena iniciativa. Yo mismo había estado informándome sobre estas ramas de estudiantes, pero no existía una aún en la Universidad de Oviedo (a decir verdad si existía, pero estaba completamente abandonada). Esperemos que dure.

Sin embargo, además de estos micocontroladores, existen muchas otras marcas, cada una de ellas implementada generalmente por un fabricante distinto. Cabe preguntarse, por lo tanto, por qué escoger los PICs entre la gran variedad de microcontroladores existentes en el mercado. Aalgunos motivos son los siguientes:

• Gran gama de microcontroladores
• Rapidez de ejecución
• Arquitectura Harvard
• Eficiencia del código
• Juego de instrucciones reducido (RISC) de fácil aprendizaje
• Compatibilidad con dispositivos de la misma familia e incluso con los de otras distintas
• Gran soporte, así como herramientas abundantes y de bajo coste
• Protección de código frente a lecturas no deseadas

Podemos decir que estos son los motivos técnicos o más o menos objetivos. Sin embargo, existen otros motivos como son el estudio de estos microcontroladores en mucha universidades o la buena política de promoción de Microchip, que fomenta el uso de sus microcontroladores a través de, entre otras, el envío de muestras gratuitas o samples.

Acabamos de comentar que muchas casas fabrican diferentes microcontroladores y que, en concreto, Microchip diseña los PIC. Sin embargo, dentro de ellos existen, tal y como ya introdujimos previamente, una gran cantidad de modelos distintos que sigue aumentando día a día. Actualmente podemos clasificarlos en dos grandes grupos: los PICs clásicos y los dsPICs. Estos últimos incluyen características de DSP, lo que permite llevar a cabo tareas de procesamiento de audio o vídeo, entre otros.

Nosotros nos centraremos en los primeros. Los PICs clásicos se encuentran divididos en siete familias, de forma que los microcontroladores de una familia determinada comparten muchas características entre ellos y los diferencian de los de las demás. Haciendo una nueva división tenemos microcontroladores de 8, 16 y 32 bits.  Hablaremos en entregas posteriores de qué significa esto; de momento, basta saber que el PIC que será el eje de este curso, el 16F877, pertenece al primer grupo, exactamente a la familia PIC16. Así mismo, existen otras como son la PIC10, PIC12 o PIC32.

En una primera aproximación, podemos decir que, cuanto más alto sea el número identificativo de la familia, mayores prestaciones nos ofrecerán los PICs que pertenezcan a ella. Con el objetivo de ilustrar esto de una forma más aclara, abajo puede verse una gráfica comparativa extraída de la web de Microchip:

Comparativa entre las distintas familias de PICs

Hasta aquí llega esta mínima introducción a los microcontroladores PIC. En la próxima entrega nos centraremos ya en el PIC1F877, explicando sus características particulares y qué seremos capaces de llegar a desarrollar con él.

Imaginemos que estamos trabajando en el desarrollo de un procesador de texto con miles de líneas de código, en el que resulta que la opción de centrar texto no funciona correctamente. Así que nos ponemos manos a la obra y solucionamos el problema. Llegados a este punto, querremos hacer pública esta mejora y para ello tendremos dos opciones: volver a distribuir todo el código del programa o limitarnos a enviar un simple fichero que indique los cambios que han llevado a cabo sobre el programa original. Obviamente, elegiremos esta última opción pues reduciremos considerablemente la cantidad de información a transmitir.

Vista la ventaja de los parches la siguiente pregunta que cabe formularse es si existe alguna forma de automatizar este proceso, ya que sería realmente tedioso generar a mano un fichero en el que se listen las diferencias entre dos archivos para luego llevar a cabo las modificaciones pertinentes. Es aquí donde entran en juego las aplicaciones diff y patch, las cuales pueden instalarse en un sistema Debian, si es que no lo están ya, mediante aptitude:

aptitude install diff patch

La primera de ellas se encarga de generar el fichero de diferencias entre los dos archivos y la segunda de aplicarlas. Veamos esto con un ejemplo: supongamos que nuestro proyecto consta de un único fichero llamado main.cpp, el cual se muestra a continuación:

#include <iostream>

using namespace std;

int main() {

    int i=0;

    while (i<10) {
        cout << i << " ";
        i++;
    }

    return 0;
}

Como puede verse, el programa se limita a mostrar por pantalla los números del 0 al 9 separados por un espacio. Resulta que ahora decidimos que esta funcionalidad (si es que puede llamarse así) estaría mejor implementada de otra forma, por lo que creamos otro fichero llamado patch.cpp a partir del anterior:

#include <iostream>

using namespace std;

int main() {

    for (int i=0; i<10; i++0) {
        cout << i << endl;
    }

    return 0;
}

En esta ocasión, mostramos cada número en cada línea en lugar de todos seguidos. Ya tenemos, además del código original, el modificado. Así que llega el momento de ejecutar el comando diff, que hallará las diferencias entre ambos ficheros. Para poder trabajar con ellas más tarde, las volcaremos en el fichero main.diff:

diff main.cpp patch.cpp > main.diff

Ahora sólo resta aplicar los cambios, empleando para ello el comando patch:

patch -o main2.cpp main.cpp main.diff

que creará el fichero main2.cpp, que será el resultado de aplicar las modificaciones indicadas en el fichero main.diff sobre el archivo main.cpp.

La solución pasó por buscar en Google. Así llegué a un foro en el que comentaban que se debía a un problema con la variable de entorno $TERM, que indica el tipo de terminal que estamos utilizando en ese momento. Si esta variable de entorno no está bien configurada, los diferentes programas con los que trabajemos no reconocerán bien todos los caracteres que tecleemos.

Supongo que mi problema en concreto se debía a que, por un motivo que aún desconozco, $TERM cambió de valor, provocando los ya citados problemas con el teclado numérico. Para arreglarlo, basta con ejecutar el siguiente comando:

export $TERM=linux

De esta forma, establecemos linux como valor de $TERM.

Actualización: tras escribir este post me di cuenta de que esta solución no es eficaz, pues a pesar de conseguir que funcionara el teclado numérico hacía fallas las teclas especiales, como inicio o fin. Seguí buscando en Google pero no encontré nada. Sin embargo, al final lo solucioné de casualidad cambiando la configuración de Konsole. Exactamente a través de la opción Editar perfil… del menú Preferencias. En la ventana que nos aparecerá basta con eligir, dentro de la pestaña Entrada, la opción Consola Linux.

La CPU

Podemos decir que la CPU, siglas en inglés de unidad central de proceso, es el núcleo del microcontrolador. Se encarga de ejecutar las instrucciones almacenadas en la memoria, de la que hablaremos más adelante. Es lo que habitualmente llamamos procesador o microprocesador, término que a menudo se confunde con el de microcontrolador. En esta línea cabe aclarar que, tal y como estamos viendo, ambos términos no son lo mismo: el microprocesador es una parte de un microcontrolador y sin él no sería útil; un microcontrolador, en cambio, es un sistema completo que puede llevar a cabo de forma autónoma una labor.

Podemos ver al microprocesador como el cerebro de una persona y al microcontrolador como el cuerpo: el cerebro se encarga de procesar toda la información, pero necesita a los demás órganos para funcionar. De la misma forma, el microprocesador, que únicamente se encarga de ejecutar las instrucciones, necesita, por un lado, un lugar donde almacenarlas, es decir, la memoria, y por otro, un medio para interactuar con el exterior, es decir, los dispositivos de entrada/salida.

Memoria

Entendemos por memoria los diferentes componentes del microcontrolador que se emplean para almacenar información durante un periodo determinado de tiempo. La información que necesitaremos durante la ejecución del programa será, por un lado, el propio código, y por otro, los diferentes datos que usemos durante la ejecución del mismo. Hablaremos por tanto de memoria de programa y de memoria de datos, respectivamente.

La diferente naturaleza de la información que hay que almacenar hace necesario el uso de diferentes tipos memorias. Sin hacer especial énfasis en este apartado, sí habrá que tener en cuenta una clasificación básica, que distingue entre memoria volátil y no volátil. La primera es aquella que pierde la información que almacena al desconectarla de la alimentación; la segunda, como resulta obvio, no. Por lo tanto, se hace evidente que al menos la memoria de programa deberá ser no volátil: no sería práctico que el programa grabado en el microcontrolador se borrara cada vez que apagáramos el dispositivo. Con respecto a la memoria de datos, diremos por el momento según la situación puede interesarnos una u otra.

La existencia de dos tipos de información a almacenar, nos lleva también al concepto de arquitectura. Entendemos por arquitectura el conjunto de componentes del microcontrolador y la forma en la que éstos se relacionan. Las más conocidas son la arquitectura Harvard y la arquitectura Von Neumann. En la primera, datos y programa estas almacenados en dos memorias físicamente separadas, cada una de ellas con un bus de comunicaciones propio. En la segunda, datos y programa se encuentran en el mismo dispositivo de memoria, por lo que comparten un mismo.

Arquitectura Harvard

Arquitectura Von Neumann

Unidades de entrada/salida

Ya hemos visto qué parte del microcontrolador ejecuta las instrucciones de nuestro programa y de dónde las lee. Ahora sólo nos falta ver qué son las unidades de entrada/salida. Las unidades de entrada/salida son los sistemas que emplea el microcontrolador para comunicarse con el exterior. Imaginemos una televisión: por un lado tiene un dispositivo de salida, como es la pantalla, y por otro lado, de entrada, como son los botones de subir o bajar volumen y de cambio de canal. Así, los dispositivos de entrada nos permitirán introducir información en el microcontrolador y los de salida nos servirán para que éste la saque al exterior.

En el futuro haremos mucho más hincapié en estos dispositivos, pues son fundamentales a la hora de desarrollar una aplicación: ¿qué sentido tendría diseñar un programa que hiciera ciertas operaciones para al final no mostrar ningún resultado al usuario final?

El post de hoy ha sido una pequeña introducción teórica a los conceptos básicos que rodean al funcionamiento interno del microcontrolador. Es posiblemente uno de los temas más aburridos, por tratarse únicamente de teoría. Era de todas formas una lección necesaria y que nos ayudará en el futuro a comprender el comportamiento de un microcontrolador.

Así que, empezando por el principio, un microchip o circuito integrado es una pastilla de silicio en la que se implementan ciertos componentes electrónicos para que juntos puedan llevar a cabo una función determinada. Este trozo de silicio se encuentra recubierto generalmente por una cápsula de plástico para protegerlo del exterior. La conexión con el exterior se lleva a cabo mediante unas patillas metálicas denominadas pines.

Circuitos integrados con ventana que permite ver su interior

El microchip supone una gran ventaja de cara a la miniaturización,

de un dispositivo, sino a su encapsulado, es decir, la forma en la que se presenta. El gran avance que supuso el microchip radica en que se redujo drásticamente el tamaño necesario para montar un circuito, pues todo lo necesario venía integrado y miniaturizado.

Existen circuitos integrados que desempeñan multitud de funciones: amplificación, regulación de tensión, conversión analógico/digital y digital/analógico, temporización… Y es que, el término microchip no hace referencia a la función del dispositivo, sino que simplemente engloba a todos aquellos dispositivos electrónicos encapsulados de una forma similar a la de los que vemos en la imagen.

El disponer en el mercado de circuitos integrados que realizan una labor completa de forma autónoma es una gran ventaja y ayuda enormemente en el diseño de un proyecto más complejo. Sin embargo, la situación podría ser más favorable  aún si en lugar de tener muchos dispositivos que llevan a cabo una función concreta, tuviéramos sólo uno, pero que pudiera llevar a cabo distintas funciones según nuestros intereses. Eso es lo que conocemos como microcontrolador.

Un microcontrolador es un dispositivo programable que ejecuta las instrucciones grabadas en su memoria. De esta forma, el microcontrolador se convierte en un pequeño ordenador y es el desarrollador el encargado de programarlo según sus necesidades. Además de la flexibilidad que esto aporta, los microcontroladores suelen contar con otros módulos  que añaden nuevas funcionalidades que analizaremos más adelante, como temporizadores, conversores analógico digital, módulos CCP…

Todas estas características convierten a los microcontroladores en dispositivos todoterreno con un sin fin de aplicaciones: desde un reloj despertador como el que todos tenemos en la mesilla de noche hasta el control de tracción de un coche.