Curso gratuito de Programación en C para microcontroladores

Incrementos y decrementos

2011-04-05T00:00:00.000-03:00

Post-incrementos y post-decrementos

Volviendo al caso del contador, hay una forma aún más corta de escribirlo, y es la siguiente:

char A;

paso 1: A = 1;

paso 2: A++;

paso 3: Volver al paso 2

Vemos ahora que se ha cambiado la instrucción del paso 2 por A++. Esto significa que es equivalente hacer:

A = A + 1

A += 1

A++

A los fines prácticos. Es exactamente lo mismo elegir un caso u otro para nuestro programa. Sin embargo, el uso del operador post-incremento que es así como se llama cuando colocamos la instrucción A++ tiene otras ventajas.

La más visible de todas, es que en los microcontroladores existe normalmente una instrucción que se llama incremento. Por lo tanto, el hecho de colocar una línea tal como A++ significa para el microcontrolador una sola instrucción de código. Diferente es cuando se hace A+=1 o A = A +1. Ya que normalmente, el compilador toma el valor de A y le suma el valor 1. Para después copiar el resultado en la variable A.

Pero hay otra ventaja de utilizar post-incrementos. Podemos realizar en una misma línea algo como ésto:

B = 10 + A++;

¿Que es esto que les acabo de poner? A simple vista no hay ninguna ventaja, pero veamos lo que hace el compilador. Supongamos que la variable A cuando pasa el micro por la línea que les acabo de mostrar, vale por ejemplo 10. Entonces, el compilador toma el valor de A y le suma 10. El resultado de la suma será 20 que será guardado en la variable B. Sin embargo, inmediatamente después de haber leído el compilador el valor de la variable A le hace un post-incremento. Esto es, al finalizar la ejecución de la línea, la variable A terminará con el valor 11.

Si nos gustan las cosas complicadas también podemos escribir algo totalmente válido en C:

B = 10 + A++ + A;

¿Se ve muy raro, no es cierto? Sin embargo no es inválido. El C lo permite. Analicemos que hace. Supongamos que de nuevo la variable A vale 10 al ingresar en la línea. Entonces el compilador resuelve el primer término de la suma, ésto es, en una variable temporal hará 10 + 10= 20. Pero inmediatamente de haber tomado el valor de la variable A por primera vez, la incrementa, por lo tanto cuando evalúa el segundo término, la variable A vale ahora 11. Entonces, la variable temporal que iba a obtener el resultado evaluará en un segundo paso: 20 + 11 = 31. O sea, la variable A fue modificada en el medio de la evaluación de la operación aritmética y a su vez el resultado dependió de esa modificación.

De la misma manera que hicimos A++, podemos hacer A--.

A = A - 1

A -= 1

A--

Donde ahora, si ponemos una línea de código que dice A-- significa que la variable A se debe decrementar en un valor. O lo que es lo mismo, restar 1 al valor de la variable A y almacenar el resultado en la misma variable. De igual manera que con el post-incremento, tiene las mismas características. Si bien, no todos los microcontroladores poseen una instrucción decremento, la mayoría si, por lo tanto para el compilador es una conversión directa entre la instrucción A-- y una instrucción de decremento. También puede utilizase dentro de operaciones aritméticas, o dentro de otras instrucciones el operador post-decremento, que hará que se decremente el valor de la variable A ni bien se terminó de obtener el valor para evaluarlo en la fórmula o instrucción donde deba ser utilizado.

Pre-incrementos y pre-decrementos

De forma similar a las operaciones de post-incremento y/o post-decrementos, donde se incrementa o decrementa la variable afectada, después de haber evaluado el valor. Es posible indicarle al compilador, que primero incremente o decremente una variable cualquiera, y después tome el valor para procesar la operación donde está siendo afectada. Para indicar un pre-incremento o un pre-decremento, se anteponen dos signos ++ a la variable o dos signos -- para el caso de que sea una operación de decremento.

Si la operación consiste en implementar un simple contador, tal como lo hemos visto en el programa anterior, no hay diferencias entre elegir un pre-incremento o un post-incremento. Ya que el resultado será el mismo.

++A;

--A;

Sin embargo, si lo utilizamos dentro de una operación aritmética, o dentro de una función, la operación cambia. Veamos un ejemplo.

Supongamos que tenemos una operación en una línea de programa como la siguiente:

B = 10 + ++A;

Supongamos que la variable A vale inicialmente el valor 10. Entonces, el microcontrolador cuando llegue a ejecutar dicha línea, la primera tarea que realizará será el incremento de la variable A. En éste caso, como dijimos que valía 10, al incrementarla queda en 11. Entonces, luego para calcular el valor de la variable B, hace 10 + 11 = 21.

Notemos la diferencia cuando en vez de utilizar un pre-incremento, elegimos un post-incremento. Si la línea hubiese sido escrita de la siguiente manera:

B = 10 + A ++;

En éste caso, si la variable A originalmente hubiera tenido cargado el valor 10, el compilador evaluaría el valor de ésta como 10 para ejecutar la suma, por lo tanto B sería igual a 10 + 10, o sea 20. Y la variable A se incrementa inmediatamente después de haber sido evaluada. Terminando ésta en el valor 11. Para el caso del pre-incremento, la variable A también termina valiendo 11, pero en la fórmula entra el valor incrementado previamente a procesar la operación.

Sintaxis de operaciones

2011-04-01T15:06:00.000-03:00

Sintaxis de operaciones

Entremos ahora más en el mundo del lenguaje C. Hasta éste momento, los programas que fuimos viendo, estuvieron hechos de una manera si se quiere primitiva. Explícitamente les colocaba muchos pasos para realizar las diferentes tareas. Todo esto buscando que los programas que les iba presentando queden lo más claro posible.

Ahora, vamos a ver instrucciones que son del lenguaje C, que nos permiten ahorrar líneas de código, y que tienen su correlato con instrucciones soportadas dentro del microcontrolador. Aunque la mayoría de los compiladores tienen muy buenos algoritmos de optimización. Si utilizamos las operaciones con la sintaxis del C de manera más eficiente, ayudamos al compilador a tomar la decisión por el resultado más optimizado.

Recordemos el programita que les había presentado que implementaba un contador sencillo. El programa era el siguiente:

char A;

char B;

Paso 1 : A=1;

Paso 2: B = A + 1;

Paso 3: A = B;

Paso 4: Volver a ejecutar el paso 2.

Operadores de asignación

Veamos, que en nuestro programa ejemplo, había utilizado dos variables A y B. Donde B la utilizaba como variable temporal que tomaba el valor de la variable A y le sumaba el valor 1. Para luego asignarle el valor de la variable B nuevamente a la variable A.

El mismo programita lo podría haber reescrito de una manera diferente. Con menos código, pero que sea exactamente el mismo resultado.

char A;

Paso 1: A=1;

Paso 2: A = A + 1;

Paso 3: Volver al paso 2

Como vemos, en éste último programa que les acabo de pasar, ya no utilizo más la variable B. Directamente le digo al compilador que tome el valor de la variable A, que le sume uno al valor de la variable A y que el resultado lo almacene dentro de la misma variable A. Además de ahorrarnos una línea en el código que escribimos, nos ahorramos algo más valioso: Una posición de memoria RAM que se ocupaba para la variable B. Cuando hablamos de microcontroladores, una variable más o una variable menos es algo importante. Recordemos que en los PICs hay modelos que sólo tienen 20 bytes de RAM. Por lo tanto, la cantidad de variables que ocupemos tienen su implicancia.

Ahora, podemos volver a reescribir el código del programita, ahorrando un poco más todavía.

char A;

Paso 1: A =1;

Paso 2: A+=1;

Paso 3: Volver al paso 2

Acá, en la línea 2, lo que acabo de hacer, es simplemente un ahorro cosmético si se quiere. Es exactamente lo mismo poner la línea:

A = A + 1;

Como también poner la línea

A += 1;

Cuando se antepone el signo del operador + al signo igual, significa para el compilador que tome el valor que está a la derecha del signo igual, y lo acumule en la variable A.

También por ejemplo podemos hacer lo siguiente:

A += 2;

El funcionamiento de ésta instrucción, es decirle al compilador que sume 2 al valor de la variable A y que el resultado se guarde nuevamente en la variable A. Es como poner la línea A=A+2.

De la misma manera, se pueden utilizar los otros operadores, -, *, /, &, etcétera.

Entonces tenemos las siguientes posibilidades:

Operación	Equivalente
A += B	A = A + B
A -= B	A = A - B
A *= B	A = A * B
A /= B	A = A / B
A &= B	A = A & B
A \|= B	A = A \| B
A ^= B	A = A ^ B
A << = B	A = A << B
A >>= B	A = A >> B
A &&= B	A = A && B
A \|\|= B	A = A \|\| B

Si bien la diferencia es mínima. Es muy común que los programas escritos en C tomen la operación con la forma descripta en la columna de la izquierda de la tabla. Ambas formas de escribir las operaciones funcionan correctamente en C. Según el tipo de compilador que estén usando serán compiladas iguales o nó. Para ello, deben probar ambas operaciones escritas de diferentes maneras y observar el código resultante en assembler para ver las diferencias. A modo práctico, normalmente se usa la forma de la columna de la izquierda ya que expresando de ésa manera las operaciones, posiblemente el compilador tomará la opción de menor cantidad de código. La forma de escribir los operadores de la manera que están en la columna de la izquierda es lo que se conoce como operadores de asignación.

Sintaxis de operaciones

2011-04-01T15:04:00.001-03:00

Sintaxis de operaciones

Recordemos el programita que les había presentado que implementaba un contador sencillo. El programa era el siguiente:

char A;

char B;

Paso 1 : A=1;

Paso 2: B = A + 1;

Paso 3: A = B;

Paso 4: Volver a ejecutar el paso 2.

Operadores de asignación

El mismo programita lo podría haber reescrito de una manera diferente. Con menos código, pero que sea exactamente el mismo resultado.

char A;

Paso 1: A=1;

Paso 2: A = A + 1;

Paso 3: Volver al paso 2

Ahora, podemos volver a reescribir el código del programita, ahorrando un poco más todavía.

char A;

Paso 1: A =1;

Paso 2: A+=1;

Paso 3: Volver al paso 2

Acá, en la línea 2, lo que acabo de hacer, es simplemente un ahorro cosmético si se quiere. Es exactamente lo mismo poner la línea:

A = A + 1;

Como también poner la línea

A += 1;

Cuando se antepone el signo del operador + al signo igual, significa para el compilador que tome el valor que está a la derecha del signo igual, y lo acumule en la variable A.

También por ejemplo podemos hacer lo siguiente:

A += 2;

El funcionamiento de ésta instrucción, es decirle al compilador que sume 2 al valor de la variable A y que el resultado se guarde nuevamente en la variable A. Es como poner la línea A=A+2.

De la misma manera, se pueden utilizar los otros operadores, -, *, /, &, etcétera.

Entonces tenemos las siguientes posibilidades:

Operación	Equivalente
A += B	A = A + B
A -= B	A = A - B
A *= B	A = A * B
A /= B	A = A / B
A &= B	A = A & B
A \|= B	A = A \| B
A ^= B	A = A ^ B
A << = B	A = A << B
A >>= B	A = A >> B
A &&= B	A = A && B
A \|\|= B	A = A \|\| B

Desplazamientos

2011-03-27T12:07:00.000-03:00

Desplazamientos

En el lenguaje C, nos está quedando una operación que se puede realizar con las variables y que es muy interesante e importante conocer. La operación que está faltando es el desplazamiento. Esta operación, junto con las operaciones aritméticas y lógicas; componen la familia básica de herramientas que posee el C; y que además también en la mayoría de los microcontroladores tienen implementadas por hardware. Con el uso de estas 3 operaciones básicas, me atrevo a decir que se resuelven el 90% de los casos de programas.

La operación que nos toca en éste apartado es el desplazamiento. El desplazamiento consiste en cambiar de posición los bits de una variable de algún tipo. Por ejemplo, un desplazamiento hacia la izquierda significa hacer que el bit 7 cargue lo que tiene el bit 6, luego el bit 6 carga el valor que tiene el bit 5, y así sucesivamente hasta llegar al bit 1. El bit 0, por definición del C tomará el valor 0.

El signo que se utiliza para realizar desplazamientos es el << cuando se indica que se debe realizar un desplazamiento hacia la izquierda. Y el >> cuando se quiere desplazar hacia la derecha. La variable que queda a la izquierda del doble signo “<<” o “>>” es la variable que se va a desplazar. Mientras que el valor o variable que quedan del lado derecho del signo, debe indicar la cantidad de desplazamientos que se deben realizar. El valor que está colocado a la derecha, nunca debe ser mayor a la cantidad de bits que tiene la variable o el valor que se está desplazando, puesto que si se intenta desplazar más veces que la cantidad de bit que tiene el valor original, el resultado será obligatoriamente 0, ya que se van completando los bits agregados siempre con el valor 0.

Podemos ver en forma de gráfico como se produce el desplazamiento:

Supongamos que hacemos el siguiente programita:

char A;

char B;

A = 0x55;

B = A << 1;

Este programita, indica que la variable B tiene que tener como resultado el valor de la variable A, desplazado una vez hacia la izquierda.

Numero de bit	7	6	5	4	3	2	1	0
A=0x55	0	1	0	1	0	1	0	1

A << 1 = 0xAA

Se agrega un cero

Podemos observar que al producir un desplazamiento, se agrega un cero en el bit 0 del resultado del desplazamiento. Y el bit 7 de la variable A original se descarta.

Lo interesante de ésta operación, es que cuando es un único desplazamiento. Se resuelve en un sólo paso dentro del microcontrolador. En algunos modelos de microcontroladores, y muchos DSP, tienen la posibilidad de realizar más de un desplazamiento al valor, y aún así tomar solo un ciclo del procesador.

Si lo que deseamos es realizar una mayor cantidad de desplazamientos, podemos por ejemplo escribir la línea como A << 4. Donde lo que significa que se rotará 4 veces hacia la izquierda el valor de la variable A

Numero de bit	7	6	5	4	3	2	1	0
A=0x55	0	1	0	1	0	1	0	1

A << 4 = 0x50

Se agregan 4 ceros

Este último caso, si lo que se está utilizando es un microcontrolador PIC o un Texas MSP430xxx. Necesariamente ocupará como mínimo 4 ciclos de trabajo. Ya que ninguno de los dos posee un desplazamiento mayor a una vez, implementada por hardware.

De la misma manera que se realizan los desplazamientos hacia la izquierda, se pueden realizar desplazamientos hacia la derecha. Por ejemplo:

A >> 1

Significa que se tome el valor de la variable A y se le aplique un desplazamiento de sus valores hacia los bits de la derecha:

Numero de bit	7	6	5	4	3	2	1	0
A=0x55	0	1	0	1	0	1	0	1

A >> 1 = 0x2A

El funcionamiento consiste en hacer que el bit 0 del resultado cargue el valor del bit 1, luego el bit 1 toma el valor del bit 2, y así sucesivamente hasta llegar al bit 6. El bit 7 siempre se completa con 0.

De la misma manera que los desplazamientos a la izquierda, es posible realizar mayor cantidad de desplazamientos a la derecha. Por ejemplo:

A >> 3

Numero de bit	7	6	5	4	3	2	1	0
A=0x55	0	1	0	1	0	1	0	1

A >> 1 = 0x0A

Ahora bien. ¿Para qué querría alguien usar estas operaciones?

Respondiendo a esa comprensible pregunta, volvamos a las bases, cuando hablamos de números binarios y números decimales.

Veamos que sucede en nuestro sistema decimal cuando multiplicamos un número por 10, o por 100, o por 1000.

Supongamos que tenemos un número 123 en decimal y lo multiplicamos por 10. En forma mental ¿qué hacemos?¿como realizamos una multiplicación de un número por 10?

Simplemente agregamos un cero a la derecha y el número se multiplicó por 10:

123 x 10 = 1230

Cuando multiplicamos un número por 100, le agregamos mentalmente dos ceros a la derecha. Por ejemplo:

123 x 100 = 12300

Ahora pasemos al mundo binario, el mundo de nuestros microcontroladores. No voy a multiplicar por 10 en decimal, sino por 2, por 4, y por 8. Notemos que en binario el 2 es igual a 10. El 4 en binario se representa por 100. El 8 en binario se representa por 1000.

Supongamos que tenemos el valor 6 y lo multiplicamos por 2.

6 x 2 = 12

Ahora veamos los mismos valores en binario: 6 es 110. 2 es 10. Y el 12 mágicamente es 1100

110 (6) x 10 (2) = 1100 (12)

O sea, al multiplicar un valor cualquiera por 2, que en binario es 10. Si representamos el valor del número que queremos multiplicar por 2 en binario, la multiplicación consiste en agregar un cero a la derecha del número, y desplazar todos los otros dígitos una posición hacia la izquierda.

Si repetimos el proceso para la multiplicación x 4, vamos a ver que se cumple la misma regla, pero ahora agregando dos ceros a la derecha, y desplazando dos veces el valor hacia la izquierda. Notemos que 2x2 = 4. Por lo tanto, es lo mismo multiplicar un valor por 4, que multiplicarlo dos veces consecutivas por 2. O sea, agregar dos veces consecutivas un cero a la derecha.

6 x 4 = 24

110 (6) x 100 (4) = 11000 (24)

Lo mismo sucede para multiplicar por 8, por 16, por 32, y por cualquier potencia de 2. O sea, si tenemos que realizar una multiplicación de una potencia de 2 en un programa hecho en C. Se puede resolver de dos maneras diferentes.

Por ejemplo, vamos a resolver la multiplicación de dos valores por 8. Una de la soluciones es usar la operación aritmética multiplicación y la otra usando las rotaciones.

char A;

char B;

char C;

B = A * 8;

C = A << 3;

¿Cuando conviene una forma y cuando la otra?

Recordemos que una multiplicación, en un microcontrolador que no posee multiplicador por hardware, requería de muchos pasos de procesamiento. Suponiendo que el multiplicando y el multiplicador son de 8 bits, vimos que como mínimo se requerían de 16 pasos de procesamiento. Si utilizamos el desplazamiento, para la misma multiplicación de un número por 8 sólo se usan 3 pasos. O sea, si nuestro microcontrolador trabaja a 5 MIPS, cuando se utiliza la multiplicación normal, podremos como máximo lograr 312500 operaciones por segundo. En el otro caso, podremos llegar a las 1666666 operaciones por segundo.

No se puede utilizar el desplazamiento cuando el valor es negativo ya que la información con el signo no se respeta. Para ese caso, debe hacerse un truco que consiste en preguntar previamente si el valor era positivo o negativo. Convertir el valor a positivo, desplazarlo y luego convertirlo nuevamente en negativo.

De la misma manera que desplazar hacia la izquierda implica una multiplicación por una potencia de 2. El desplazamiento hacia la derecha implica la división en una potencia de 2. De nuevo la gran ventaja de usar desplazamientos en vez de una división, cuando el divisor es una potencia de 2 es que la cantidad de ciclos de procesamiento que se utilizan son mucho menores. Así, con esta herramienta se puede lograr que un microcontrolador de los más humildes, realice tareas que son impensadas si lo intentamos programar en la forma más natural que se nos ocurriría normalmente que es usando multiplicaciones y divisiones.

Para poder usar estas herramientas como ayudas matemáticas, tenemos que acostumbrarnos al uso de las potencias de 2 como base para toda nuestra programación. Tenemos que sacarnos de la cabeza el sistema decimal y adoptar el binario y/o hexadecimal. Así, cuando hagamos por ejemplo un acumulador para tomar un valor promedio, no pensemos en usar 10 muestras y luego dividir por 10 para tener el promedio. Pensemos siempre en usar un número potencia de 2 para tomar las muestras, por ejemplo 8 o 16, y después el valor promedio se saca dividiendo por 8 o por 16, que es lo mismo que hacer una rotación del acumulador 3 veces hacia la derecha para el caso de la división por 8, o 4 veces a la derecha para el caso de la división por 16.

Incluso los compiladores mas avanzados, tienen opciones de optimización. Cuando colocamos la operación A = B / 8. Ya conoce el truco, y automáticamente en vez de hacer una operación división estándar, aplica desplazamientos hacia la derecha. Lo único que complica también en éste caso es cuando la variable B es del tipo signed. El compilador tiene que respetarlo, y eso implica mayor cantidad de código al momento de compilarlo. Por ello, es importante conocer que tipo de variable estamos utilizando, si es con signo o nó, si los valores que vamos a utilizar son siempre positivos o pueden aparecer valores negativos.

Si lo que les tira más en su carrera de la programación van a ser los DSP, o van a apuntar a tener equipos donde estén ingresando datos a una tasa de velocidad relativamente importante para un microcontrolador (que puede ser del orden de las 10000 muestras por segundo), y a esas muestras hay que aplicarle algún filtro digital, donde hay que acumular valores y efectuar multiplicaciones, van a tomarle mucho cariño al uso de los desplazamientos que le van a ayudar enormemente a encontrar la solución. En mi experiencia, he hecho cosas con PIC que para muchos eruditos en la programación y manejo de microcontroladores es totalmente imposible. Sin embargo, usando las técnicas y trucos que les estoy dando se pueden implementar. Conclusión, a lo mejor con un microcontrolador económico se pueden realizar tareas que a simple vista parecen muy difíciles o imposibles. Dichas tareas sin dudas que con un microcontrolador más grande o DSP se realizan sin dificultad. Pero, cuando hay que hacer producciones en masa, el precio del microcontrolador que elijan será determinante en el precio del producto final. Por lo tanto, hay que analizar muy bien como implementar la solución para que el resultado sea el óptimo. Si no hay restricciones de microcontrolador y pueden elegir alguno bien potente elijan ese. Ahora, si existe una imposición que se deben reducir los costos al máximo, van a tener que recurrir a herramientas como éstas para poder meter en lugares mas chicos las soluciones. Tengamos en cuenta que cuando trabajamos en el mundo de los microcontroladores es totalmente diferente al mundo de las PC. En las PC cada vez se hacen programas más pesados total cada vez las computadoras son más potentes. En los microcontroladores lo que se busca principalmente es la reducción de costos. Si bien cada día aparece un microcontrolador nuevo más potente, debemos estar atentos a lo que nos ofrece la tecnología y cual es nuestro objetivo de costo.

Operaciones lógicas bit a bit

2011-03-21T18:33:00.000-03:00

Operaciones lógicas a bit a bit: bitwise

Ya vimos como funcionan las operaciones relacionales AND, OR, y NOT. Estas operaciones se usan principalmente cuando lo que se desea realizar son comparaciones de valores. El resultado comparado puede servir para bifurcar la ejecución del programa hacia otro lado. También se usan para generar funciones matemáticas o aritméticas que cambien según que valores vayan tomando sus variables.

Sin embargo, existe otro uso para las operaciones lógicas, AND, OR, NOT y una nueva que es la XOR. Y es que éstas se pueden aplicar sobre las variables, pero afectando bit por bit en cada comparación, y a su vez, el resultado también afectado a nivel de bit.

Estas operaciones lógicas, aplicadas a nivel bit a bit, son muy útiles en el mundo de los microcontroladores. Estos chips, tienen registros que son los manejan los diferentes periféricos. Dichos periféricos colocan sus resultados, y necesitan ser configurados, encendiendo y apagando bits específicos dentro de uno o varios bytes que componen los registros de configuración.

Entonces, podemos con la ayuda de estas funciones lógicas, modificar, comparar, y realizar muchas combinaciones de tareas que afectan los bits de un valor en forma particular.

Cuando se realizan operaciones del tipo bitwise, o bit a bit. El microcontrolador toma siempre dos valores para ejecutar. Estos valores pueden ser de cualquier tipo (char, int, long) y o longitud. Y va evaluando uno a uno bit por bit. Siempre toma para la operación los bits que están en la misma posición en cada uno de los valores utilizados como datos o entradas. Esto es, ejecuta la operación entre el bit 0 de un valor con el bit 0 del otro valor. Luego continúa con el bit 1 de ambos valores, y así sucesivamente hasta llegar al último bit. La ventaja es que el microcontrolador ejecuta la acción en sólo un ciclo de trabajo. No ocupa tantos ciclos de trabajo como bits tengan las variables. Por lo tanto, la acción es muy rápida.

Es importante que cuando se ejecuten operaciones lógicas a nivel de bit, los dos valores que se utilizan sean por lo menos del mismo tamaño en bits. De ser de diferentes tamaños, el compilador realiza un “casting” automático y lleva toda la operación de manera que los valores utilizados sean de la longitud del dato con mayor cantidad de bits.

Repasemos como son las funciones lógicas que conocemos hasta ahora, y veamos la función lógica XOR.

Función AND: Su salida vale uno, cuando en ambas entradas en forma simultanea hay un uno colocado. De otra manera el resultado es cero. El símbolo en C para realizar una operación lógica AND bit a bit es el &. Se diferencia de la operación lógica AND que vimos antes, que cuando se quiere aplicar bit a bit sólo lleva un símbolo & y no dos como era el otro caso.

C = A & B;

Función OR: Su salida vale uno, cuando en cualquiera de sus entradas hay un uno colocado. Sólo cuando en ambas entradas hay un cero, a su salida pone un cero. El símbolo de la operación lógica OR bitwise o bit a bit es el |. De la misma manera que la función AND se diferencia de la operación OR que vimos antes, puesto que lleva sólo un caracter | y no dos.

C = A | B ;

Función NOT: Su salida es el inverso al valor que haya en la entrada. Si hay un uno a la salida coloca un cero, y viceversa. El símbolo para indicar la operación inversión que trabaja a nivel bit a bit es ~. Acá es diferente al usado en el caso anterior que era el símbolo de exclamación ¨!¨

C = ~ A;

Función XOR: Su salida vale uno, cuando en sus entradas sólo una está en 1. Si ambas entradas están en uno, o ambas entradas están en cero, su salida es cero. El símbolo utilizado para indicar la operación XOR bit a bit es el ^. No existe la operación XOR a nivel relacional.

La tabla de verdad de la función XOR es como la siguiente:

A	B	Salida
0	0	0
1	0	1
0	1	1
1	1	0

Veremos ahora como se aplican las funciones lógicas bitwise en algunos ejemplos.

Ejemplos de uso de la función And bitwise

Comienzo con la función AND bit a bit. La forma más común de pensar en la función AND cuando se hacen las operaciones bitwise, es que tengamos en la cabeza que esta función trabaja como si fuera un filtro. Imaginemos que tenemos una especie de filtro o colador al cual solo dejamos pasar por sus huecos parte de lo que pongamos del otro lado. Por ejemplo, tengo una variable A con un valor cualquiera. Esta variable A es de 8 bits. Y quiero que en una variable B se almacenen sólo los bits 1,2 y 3 de la variable A. El resto de los bits quiero que siempre permanezcan en cero. Esta operación se resuelve muy fácilmente con la operación AND &:

char A;

char B;

A = cualquier valor

B = A & 0x0E;

Veamos ahora como funciona este programita ejemplo que les acabo de pasar. Para poder entenderlo bien, debemos convertir las variables a binario. Cosa que debemos hacer siempre cuando trabajemos con operaciones lógicas bit a bit. Que si a ésta altura ya están bien familiarizados con el sistema hexadecimal y se conocen de memoria la tabla de conversión deberían ya haber entendido lo que acabo de hacer.

Si convertimos el valor 0x0E a binario, tenemos

Numero de bit	7	6	5	4	3	2	1	0
0x0E	0	0	0	0	1	1	1	0

Ahora veamos, cualquier valor que tenga la variable A. Por ejemplo el valor 0x55 que en binario es 01010101. Coloco en la misma tabla la variable A

Numero de bit	7	6	5	4	3	2	1	0
0x0E	0	0	0	0	1	1	1	0
A	0	1	0	1	0	1	0	1

Calculemos el resultado de hacer A & 0x0E, que es el valor que se carga en la variable B. Notemos que la operación And tiene como resultado 1 sólo cuando ambos bits a comparar están en 1. El resultado de la operación va a ser:

Numero de bit	7	6	5	4	3	2	1	0
0x0E	0	0	0	0	1	1	1	0
A	0	1	0	1	0	1	0	1
B = A & 0x0E	0	0	0	0	0	1	0	0

Notemos, que en el resultado los bits 1 a 3 de la variable A se reflejan en el resultado. Los bits restantes quedan en cero.

Si coloco en forma genérica valores en A, podemos tener una operación como se ve:

Numero de bit	7	6	5	4	3	2	1	0
0x0E	0	0	0	0	1	1	1	0
A	b7	b6	b5	b4	b3	b2	b1	b0
B = A & 0x0E	0	0	0	0	b3	b2	b1	0

Seguramente, alguno de ustedes se preguntará: ¿Para que sirve hacer algo como ésto?

Cuando se trabaja con microcontroladores, muchas veces hay que configurar diferentes periféricos dentro del mismo. También, tenemos los puertos que son las entradas y salidas. Estos puertos son bits dentro de algún registro que significan que alguna de las entradas o salidas están con una señal en 0v o 5v. O que tienen una de sus patitas con un 1 lógico o con un cero lógico. Supongamos que tenemos un microcontrolador, que tiene conectado un botón en una de sus patitas. Esa patita será un bit dentro de un registro que se pone en cero o uno, según si está apretado o soltado el botón. Supongamos que además, en las otras patitas hay otras cosas, y que esas otras cosas van conmutando entre diferentes valores que no tiene sentido conocer ahora. Si nuestro programa tiene que saber si está apretado o nó el botoncito, puede hacer uso de la función And para descubrir si el botón está pulsado o nó.

Por ejemplo, si nuestro botoncito está conectado al bit 5 de uno de los puertos del microcontrolador. Y si tenemos que tomar alguna decisión cuando se pulsa el botón, nuestro programita sería algo como lo siguiente:

char A;

char B;

A = lee el puerto;

B = A & 0x20;

si B es diferente de cero el boton estaba apretado.

Notemos que la operación B = A & 0x20 es lo mismo que hacer B = A & 00100000. Eso es dejar pasar sólo el bit 5. No importa que valores tengan los otros bits en la variable A, si el bit 5 de A está en uno, el resultado siempre será 0x20, si el bit 5 de A está en cero, el resultado será siempre 0x00.

Otra operación donde muy útil la función AND, es cuando tenemos que hacer lo que se llaman bufferes rotativos. No importa todavía que es lo que significa. Pero si es interesante lo que podemos hacer con la función And para limitar un contador. Paso a explicarles.

Supongamos que tenemos una variable A. Esta variable A significa un valor o algo dentro de otra parte del programa que no interesa por ahora. Lo importante, es que esa variable A nunca puede salirse del rango. Por ejemplo, necesitamos que nuestra variable A siempre esté dentro del rango 0 a 7. Independientemente de cualquier operación que se haga con la variable A, debe estar en el rango 0 a 7. Cuando los rangos de valores que tenemos que limitar, son siempre potencias de 2. Recordemos que las potencias de 2 son 1, 2, 4, 8, 16, 32, 64, 128, etcétera. Veamos que dije que queríamos que la variable A esté en el rango 0 a 7, o sea que tome 8 valores. Por lo tanto es un rango que es potencia de 2.

Si realizo al final de cualquier operación aritmética sobre la variable A, la operación A = A & 0x7, veamos que lo que hacemos es limitar el rango de la variable A en los valores 0 a 7.

Numero de bit	7	6	5	4	3	2	1	0
0x07	0	0	0	0	0	1	1	1
A	b7	b6	b5	b4	b3	b2	b1	b0
A & 0x07	0	0	0	0	0	b2	b1	b0

Notemos que siempre quedan almacenados en A los bits 0, 1 y 2. El resto de los bits siempre quedarán en cero. Notemos que si tenemos los 3 bits menos significativos, sólo podrá tomar la variable A los valores 0 a 7. Lo que acabamos de hacer, es como si fuera crear un tipo de datos nuevo, donde los valores de este tipo de datos, pueden estar entre 0 y 7.

Recordemos que si queremos utilizar este truco, siempre debemos utilizar rangos que sean potencia de 2. Esto nos permite en un sólo ciclo de microcontrolador crear o limitar los valores de una variable. Si pensamos realizarlo de otra manera, por ejemplo, preguntando si el valor de la variable A superó el límite máximo para después descontarle el sobre-pasamiento seguramente vamos a ocupar mucho mayor cantidad de ciclos de trabajo, cuando utilizando la operación & (and) se toma sólo uno. Es muy importante recordar que los microcontroladores, especialmente los más pequeños, son limitados en su velocidad. Por lo tanto necesitamos optimizar al máximo las operaciones para que ocupen el menor tiempo posible.

Por supuesto, que a esta altura, si me está siguiendo alguien que tiene conocimientos en C ya se habrá dado cuenta que los programas que les he ido pasando no están para nada optimizados en la sintaxis. Por ejemplo, el último programita que les pasé se podría haber resumido todo en una sola línea. Más adelante vamos a ver como mejorar aun más las líneas de código. Por ahora, prefiero seguir escribiendo los programas de esta manera ya que es mas clara su lectura. Sepamos que a medida que voy avanzando, vamos a ir adentrándonos más y más en lo profundo del C.

Ejemplos de uso de la función OR bitwise

Veamos ahora algunos casos donde tenemos que actuar sobre bits, y que se resuelven fácilmente con la función OR.

La función OR podemos pensarla como que es el opuesto de la función And. En la función Or, el resultado será cero, sólo cuando ambos bits a su entrada son ceros. ¿Notamos la inversión?, en la función And el resultado era uno cuando ambos bits estaban en uno. Para la función Or, en los demás casos el resultado es siempre uno.

La función Or se puede utilizar cuando necesitamos forzar un valor de un bit a 1. Por ejemplo, si queremos colocar en uno el bit 4 de una variable A, la operación sería:

char A;

char B;

B = A | 0x10;

De nuevo, para entender el programita, pensemos en binario. Pongamos la tablita para entenderlo:

Numero de bit	7	6	5	4	3	2	1	0
0x10	0	0	0	1	0	0	0	0
A	b7	b6	b5	b4	b3	b2	b1	b0
B = A \| 0x10	b7	b6	b5	1	b3	b2	b1	b0

Notemos que la función Or dejó pasar todos los bits de la variable A, excepto el bit 4 que lo dejó forzado en 1. Observemos comparando con la tabla de la operación And, vemos que es exactamente la operación inversa. Mientras la operación And dejaba pasar todos los bits que se colocaban en la operación con su valor en 1, y los restantes los forzaba a cero. En la operación Or, deja pasar todos los bits que se comparan con el valor 0, y los restantes bits los fuerza a uno.

Supongamos que tenemos un puerto, donde tenemos conectado un LED. Un led es un diodo emisor de luz, pensémoslo como si fuera una lamparita. Suponiendo que dicha luz está conectada en el bit 4 del puerto. Entonces, si queremos encender y apagar el led, tenemos dos programitas que sirven para realizar dicha tarea.

Para encender el led:

char A;

char B;

A = leer puerto;

B = A | 0x10;

sacar por el puerto el valor de B

Para apagar el led:

A = leer puerto;

B = A & 0xEF;

sacar por el puerto el valor de B

Notemos que para encender el led utilicé la operación Or, mientras que para apagarlo utilicé la operación And. Notemos que utilicé primero la variable A para leer el valor del puerto y luego le apliqué una operación lógica. Esto lo hice de ésta manera, puesto que no quiero modificar los valores que hayan previamente cargados en los restantes bits del puerto que manejan nuestro led.

Ejemplo de uso de la función Not bitwise

Me tomo del último ejemplo que acabo de pasarles en el programita anterior, ya que me interesa demostrar el potencial de la función Not bit a bit.

Veamos en el programita anterior que utilicé la operación A | 0x10 para encender el led. Y que para apagarlo utilicé la operación A & 0xEF. Así puesto de esa manera, parece un poco complicado. Ya que hay que pensar como es el inverso de 0x10 para que cuando se ejecute la operación And queden todos los bits en 1 excepto el bit 4 que es el que quiero colocar en cero.

Sin embargo, si utilizo la función Not bitwise, la lectura del código para colocar en cero el bit 4 se hace más evidente:

char A;

char B;

A = leer el puerto;

B = A & ~0x10;

Vemos que utilicé el operador ~ y luego el número 0x10. Esto significa que antes de aplicar la operación And, tome el inverso de 0x10 y le aplique la función. ¿Vemos que es más simple leer que la operación and se hace con el inverso de 0x10, que tener que leer en forma directa el valor 0xEF?

Numero de bit	7	6	5	4	3	2	1	0
0x10	0	0	0	1	0	0	0	0
~ 0x10 = 0xEF	1	1	1	0	1	1	1	1

Ejemplo de uso de la función Xor bitwise

La función lógica Xor significa O Exclusivo. Quiere decir que su salida se coloca en uno, cuando uno de sus bits de entrada esta colocado en uno, pero no los dos. Esta operación lógica tiene una cualidad importante. Veamos eso aplicado en un ejemplo.

Supongamos que queremos hacer un programa que cambie constantemente el valor de 2 bits en una variable o registro. Por ejemplo, que con cada pasada invierta los valores de sus bits. Supongamos que tenemos conectados en un puerto dos leds o lucecitas. Arrancamos el programa colocando una de las luces encendida y la otra apagada. Y queremos que vayan moviéndose las luces como si fuera un pequeño secuenciador. Supongamos que tenemos los leds conectados en los bits 3 y 7 del registro de un puerto:

char A;

Paso 1: A = 0x80;

Paso 2: A = A ^ 0x88;

Paso 3: sacar por el puerto el valor de A

Paso 4: Volver al paso 2

Analicemos el programita. En el paso 2, se cargó la variable A con el valor 0x80 que en binario es 1000000. En el segundo paso se hace la operación Xor con el valor 0x88 que es 10001000

Numero de bit	7	6	5	4	3	2	1
A	1	0	0	0	0	0	0
0x88	1	0	0	0	1	0	0
A = A ^ 0x88	0	0	0	0	1	0	0

Observemos que en el paso 2, el bit 7 que originalmente estaba en uno, pasa a valer 0, puesto que cuando ejecuta la operación Xor los dos bits que se comparan están en uno, por lo tanto el resultado es cero. En cambio, el bit 3 en la variable A originalmente está en cero, pero el valor en el número 0x88 está en 1. El resultado para el valor final de la variable A será que el bit 3 pasó al estado lógico uno.

En la próxima pasada del programa, la variable A arranca con el valor 0x08 (00001000). Entonces la operación Xor, A = A ^ 0x88 quedará:

Numero de bit	7	6	5	4	3	2	1
A	0	0	0	0	1	0	0
0x88	1	0	0	0	1	0	0
A = A ^ 0x88	1	0	0	0	0	0	0

Como podemos ver, de nuevo se invirtieron los bits 7 y 3. De ésta manera podemos seguir indefinidamente, y en cada pasada se invertirán los bits 7 y 3.

Operaciones Logicas Relacionales

2011-03-16T18:46:00.000-03:00

Operaciones lógicas.

Además de las operaciones aritméticas que normalmente conocemos (suma, resta, multiplicación, división). En el mundo digital existen otras operaciones que pueden realizarse con los números. Especialmente si vemos a los números como valores expresados como números en binario.

Como los microcontroladores trabajan en un mundo binario, entonces las operaciones lógicas tienen todo su poder aquí en éste campo. Vamos a ver en éste apartado que estas operaciones permiten realizar tareas que serían muy difícil de lograrlas sin ayuda de las operaciones lógicas.

Las operaciones lógicas en los sistemas digitales son las que se conocen en el mundo de los microcontroladores, y la programación como AND, OR, XOR.

A su vez, en C, las operaciones lógicas tienen dos niveles de trabajo. Uno de los niveles es a nivel bit a bit o bitwise en inglés de los valores que participan. O sólo a nivel resultado, donde la operación sólo maneja un valor posible: verdadero o falso. Estas ultimas se las conoce como operaciones relacionales.

Vamos a ir viendo una por una éstas operaciones, voy a explicar en forma detallada como funcionan, y voy a darles ejemplos prácticos para que puedan descubrir parte del potencial que tiene programar en C utilizando éstas operaciones.

Operadores relacionales: Comparaciones

El primer grupo de operaciones lógicas que vamos a ver, son aquellas que se evalúan para obtener uno de los dos resultados posibles: verdadero o falso.

En C, y en la mayoría de los lenguajes de programación existe una instrucción que realiza una comparación entre dos variables o valores.

Por ejemplo, si tenemos un programa que queremos que tome una decisión sobre como continuar ejecutando las tareas cuando alguna variable tome algún valor determinado. Supongamos que retomamos el programa que habíamos hecho del contador. Supongamos que queremos detener el programa cuando la variable llegue a un valor determinado, por ejemplo 100.

Nuestro programa (todavía sin llegar a código 100% en C ) debería ser :

1- char A;

2- char B;

3- A=1;

4- B=A+1;

5- A=B;

6- Si A>100 terminar programa

7- sinó, volver al paso 4

Para nuestro caso, veamos que se agregó una línea de código en el programa, en el paso número 6. Donde preguntamos si el valor que posee la variable A es mayor que 100, que termine el programa. Si no vuelve al paso 4. Esto que les acabo de contar, en C es lo que se conoce como la instrucción if. No quiero apurarme todavía, la instrucción if la vamos a ver más adelante. Les adelanto como sería el programa realizado 100% en C.

char A;

char B;

A=1;

while (true)

{

B=A+1;

A=B;

if (A>100) break;

}

Pero no interesa si no lo entienden completamente aún al programa. No es la intención de confundirlos a ésta altura. Lo que quiero que noten es que se utilizó dentro de una instrucción, la operación A>100

Las operaciones de comparación la función que tienen es devolver un valor 1 si el valor de la comparación es verdadero, y un cero si es falso. Estas operaciones deben ser la más utilizadas en todos los programas, donde se consulta si en algún momento alguna variable ha tomado algún valor, para tomar alguna determinación.

Pero, también las operaciones de comparación, pueden ser utilizadas como operaciones matemáticas, o aritméticas. Pueden resolver problemas matemáticos de forma relativamente sencilla.

Las operaciones de comparación disponibles en C son:

Operación	Ejemplo	Descripción
Mayor	A > 10	Devuelve como resultado final un 1 si el valor a la izquierda del signo es mayor que el que está a la derecha.
Menor	A < B	Devuelve como resultado final un 1 si el valor que está a la izquierda del signo es menor que el que valor que está a la derecha del signo.
Igual	A == B	Devuelve como resultado un 1 si los dos valores son iguales.
Diferente	A != B	Devuelve como resultado un 1 si los dos valores son diferentes.

Mayor o igual	A >= B	Devuelve como resultado un 1 si el valor a la izquierda del signo, es mayor o es igual al valor que está a la derecha.
Menor o igual	A <= B	Devuelve como resultado un 1 si el valor a la izquierda del signo, es menor o es igual al valor que está a la derecha.

Supongamos que tenemos un programita como el siguiente:

char A;

char B;

char C;

A = 10;

B = 20;

C = A > B;

¿Que valor toma la variable “C”?

Analicemos el programa, en la cuarta línea, se carga la variable A con el valor 10. En la quinta línea se carga la variable B con el valor 20. Entonces, en la sexta línea, se carga la variable C con el resultado de la operación de comparación A>B. El microcontrolador cuando llega a ésta línea de código hace la pregunta ¿Es el valor que hay en A mayor que el valor que hay en B? La respuesta es que no, puesto que A vale 10 y B tiene el valor 20, por lo tanto A no es mayor que B. Entonces, la variable C se cargará con el valor 0. Si la línea hubiese sido declarada con el signo menor (C=A<B) , o la posición de las variables a comparar fuera al revés de como estaba declarada en el programita (C=B>A). El resultado de la comparación hubiera sido afirmativo. Por lo tanto, la variable C se cargaría con un 1.

Para complicarles un poco más las cosas: ¿que pasa si tenemos el siguiente programa?:

signed char A;

signed char B;

A=-10;

B=20;

C = A < B > A;

Esto que se ve “raro”, está permitido en C. Como vemos, el C permite muchas cosas. A veces esas cosas las escribimos apropósito. Otras por error en el concepto en la programación, o por error en el tipeo. Cuando lo que escribimos es apropósito, aquí es donde se ve la potencia del C. Cuando fue un error, acá aparece una complicación, puesto que a lo mejor no detectamos fácil cuando hay un problema. No importa si tiene o no sentido el ejemplo. Lo que quiero mostrarles son las posibilidades que permite el lenguaje para hacer este tipo de cosas.

En el ejemplo que les doy: C=A<B>A; veamos que sucede.

Al igual que las operaciones aritméticas, en las operaciones de comparación y las operaciones lógicas hay prioridades de procesamiento. En éste caso los signos < y > tienen el mismo nivel de prioridad, por lo tanto, no sabemos a ciencia cierta cual de los dos evaluará primero.

Supongamos que el compilador comienza por la primera comparación de la derecha, ésto es A < B. O sea, el compilador preguntará si -10 es menor que 20. El resultado será verdadero. Por lo tanto en el paso siguiente, el compilador preguntará si 1 es mayor que -10. Resultado que también es verdadero. Por lo tanto, la variable C se cargará con el valor 1.

No voy a seguir explayando más con éste ejemplo. No tiene sentido darle más vueltas, sólo mostrarles que existe la posibilidad de este tipo de usos.

Operaciones relacionales AND &&, OR ||, y NOT !

Ahora bien, supongamos que tenemos que realizar dos comparaciones. Por ejemplo, para ejecutar una condición, tenemos que saber si una variable es mayor a cierto valor, pero además otra variable es mayor a otro valor.

Para ello, existen las operaciones lógicas AND, OR, y NOT. Recordar que estamos hablando en éste capítulo de las operaciones lógicas a nivel de resultado, y no bitwise que la veremos en un próximo apartado.

La operación lógica AND significa lo que en español conocemos como la conjunción “y”. Cuando tenemos que realizar dos comparaciones de dos valores, y queremos que ambas comparaciones sean afirmativas, recién ahí evaluamos el resultado como afirmativo. En C la operación lógica AND se representa por dos signos ámpersan (&&) consecutivos. Donde evalúa si ambos valores que están a la derecha e izquierda de los signos && son diferentes de cero, entonces colocará como resultado un 1. En cambio, si cualquiera de los valores a la derecha del signo es igual a cero, entonces el resultado de la operación será cero.

Por ejemplo, la siguiente operación:

A = 10;

B = 20;

C=30;

D=40;

R=(A<B) && (C<D);

La primera tarea del microcontrolador será reemplazar las variables por su valor:

R=(10<20) && (30<40)

Ahora, como hay paréntesis en la instrucción. Los paréntesis tienen mayor prioridad que la operación &&. En realidad, los paréntesis siempre tienen máxima prioridad. Por lo tanto se evalúan las comparaciones que están dentro de ambos paréntesis. Como observamos, ambas comparaciones son positivas. Entonces, el microcontrolador reemplaza el resultado de las operaciones de comparación y vuelve a evaluar:

R = 1 && 1

Ahora, como dijimos en la definición de la operación AND, ésta devuelve un 1 cuando ambos valores a la derecha e izquierda son diferentes de cero. Por lo tanto, el resultado será:

R = 1

Recordemos que este tipo de operación AND, cuando se colocan dos signos && consecutivos, es evaluación a nivel de resultado. Va a ser diferente de la operación AND a nivel bit a bit. No perder de vista que el doble signo, sólo devuelve 0 o 1.

También es posible, evaluar en un programa, de manera sencilla cuando hay dos variables que son diferentes de cero:

A=10;

B=20;

C= A && B;

En éste caso, de nuevo la variable C va a ser igual a 1, ya que la variable A es diferente de cero. Y la variable B también es diferente de cero. Por lo tanto el resultado es uno. Si cualquiera de las dos variables es igual a cero, el resultado será cero.

Así como existe la operación AND (&&), existe la operación OR (||) que se representa por dos signos consecutivos conocidos como more, (es el palito vertical que en los teclados españoles está al lado del 1).

La operación OR, significa que devuelve un valor afirmativo o uno, cuando cualquiera de los dos valores a la derecha o izquierda del doble símbolo || es diferente de cero. Si ambos valores están en cero, entonces el resultado será también cero.

La operación NOT, que se representa por el signo “!” ( fin de exclamación). Significa inversión. Y funciona cambiando el resultado. Cuando el valor que está después del signo exclamación es diferente de cero, la operación devuelve un cero. Cuando el valor es igual a cero, la operación devuelve un 1.

En las siguientes tablas se muestran los funcionamientos de las operaciones lógicas que hemos visto hasta ahora:

AND Símbolo utilizado: && Sintaxis: A && B Donde A y B pueden ser variables de cualquier tipo, valores, o resultados de comparaciones del tipo nn1>nn2, nn1==nn2.
A	B	Resultado
0	0	0
0	Diferente de cero	0
Diferente de cero	0	0
Diferente de cero	Diferente de cero	1

OR Símbolo utilizado: \|\| Sintaxis: A \|\| B Donde A y B pueden ser variables de cualquier tipo, valores, o resultados de comparaciones del tipo nn1>nn2, nn1==nn2.
A	B	Resultado
0	0	0
0	Diferente de cero	1
Diferente de cero	0	1
Diferente de cero	Diferente de cero	1

NOT Símbolo utilizado: ¡ Sintaxis: ¡A Donde A puede ser una variable de cualquier tipo, valor numérico, o resultados de comparaciones del tipo nn1>nn2, nn1==nn2.
A	Resultado
0	1
Diferente de cero	0

Más ejemplos prácticos de como usar estos operadores lo vamos a ver nuevamente en detalle cuando veamos las instrucciones if, while, y for. Que son instrucciones donde se usan normalmente estas operaciones lógicas. Todavía sin llegar a esas instrucciones, puedo darles un ejemplo práctico para que tengan una idea de como utilizarlas.

Supongamos que tenemos que hacer un programa que haya que implementar un contador en una variable A, tal cual lo hemos visto en ejemplos anteriores. Pero, ahora queremos hacer una variable D, que se ponga en 1 cuando la variable del contador A sea igual a los valores 10, 30, 40, y cuando esté entre los valores 70 y 80.

Veamos como se puede solucionar éste problema, con sólo una línea de programa. El programa que realizaría dicha tarea puede ser:

char A;

char B;

char D;

A=1;

Paso 5:

B=A+1;

A=B;

D=(A==10) || (A==30) || (A==40) || ( (A>=70) && (A<=80));

Volver al paso 5;

Analicemos el programa que les acabo de mostrar. Hasta la línea 7, el programa no presenta dificultades, es el mismo contador que hablamos ya un par de veces anteriormente. Pero aparece esta línea nueva, que es la que evalúa y coloca valores en la variable D:

D=(A==10) || (A==30) || (A==40) || ( (A>=70) && (A<=80));

Veamos, cuando la variable A, no es igual a ninguno de los valores en la comparación: 10,30, 40 los 3 primeros términos que están en las 3 primeras comparaciones, serán igual a cero, puesto que ninguna de las comparaciones será verdadera. Como la operación entre ellas, está vinculada como una OR, entonces, el resultado seguirá siendo cero.

Veamos la segunda parte de la comparación: ( (A>=70) && (A<=80))

Supongamos que la variable A valga en un determinado momento el valor 5. Entonces, tenemos la primera comparación que tiene como resultado falso, puesto que A no es mayor que 70. La segunda comparación tiene como resultado verdadero, puesto que A si es menor que 80. Sin embargo, las dos comparaciones A>=70 y A<=80 están vinculadas por una operación lógica AND. Como uno de los dos términos está dando falso en su comparación, la función AND pondrá un cero a su salida, porque para que de verdadero, tienen que estar los dos términos dando también verdadero, o un valor distinto de cero.

Por lo tanto, para cualquier valor de A, que no sea: 10, 30, 40, y que no esté entre 70 y 80, el resultado en la variable D será un cero.

Ahora, cuando A sea igual a 10, o 30, o 40. Una de las comparaciones A==10, A==30, A==40 se hará verdadera, por lo tanto, a su salida colocará un uno. Como la vinculación entre las comparaciones se hace por una operación OR, el resultado será un 1.

Cuando A sea mayor o igual que 70 y también menor o igual que 80. Las dos comparaciones que están como último término en la instrucción se harán verdaderas. Por lo tanto, el resultado de la operación AND será verdadero, y a su salida colocará un uno. Dicho uno, está a su vez vinculado con otra operación OR, por lo tanto, no importa en que valores están las otras comparaciones. El resultado será un uno.

Como podemos ver, en una sola instrucción, pudimos hacer lo que se llama una función matemática, discreta, que toma valores en puntos exactos.

Además, es posible combinar operaciones matemáticas con operaciones lógicas, para así lograr infinitas combinaciones. El C es muy flexible, nos permite por ejemplo reescribir en el mismo programa una línea como la siguiente:

D=(A==10) + 2* (A==30) + 3* (A==40) + 4 * ( (A>=70) && (A<=80));

Veamos que hace ésta línea:

- Cuando A no vale 10, 30, 40 ni está entre 70 y 80, todas las comparaciones valen cero. Multiplicadas por cualquier cosa, sigue siendo cero. Por lo tanto la suma tiene como resultado el valor cero.

- Cuando A vale 10, el único termino que vale 1 es el primero, los demás valen cero. Un 1 sumado con ceros, da como resultado 1. Por lo tanto, cuando A es igual a 10, D =1

- Cuando A vale 30, el término A==30 vale 1, 1 multiplicado por 2 es igual a 2. Los otros términos se evalúan y dan cero como resultado. Entonces, cuando A = 30, D =2

- Cuando A vale 40, el termino A==40 es el único verdadero, que a su salida se multiplica por 3, por lo tanto, D=3

- Finalmente, cuando A vale un valor entre 70 y 80, el último término es verdadero, como su resultado es 1, y se multiplica por 4. El resultado entonces será 4.

A	D
10	1
30	2
40	3
70 hasta 80	4
otro valor	0

Castings

2011-03-14T00:00:00.002-03:00

Castings

Ya hemos visto como el compilador maneja las operaciones aritméticas cuando le pasamos una instrucción que indique realizar dicha tarea. También hablamos sobre lo que sucede cuando mezclamos diferentes tipos de variables: char, int, long. Vimos cuales pueden ser las combinaciones y los diferentes resultados que se pueden obtener.

El lenguaje C tiene un artilugio que nos permite forzar al compilador a que interprete un tipo de variable, sin importar que tipo de variable sea, que tome esa variable como si fuera de otro tipo. Esto nos permite explicitarle al compilador de que manera queremos que procese por ejemplo una operación aritmética, y cuando veamos más adelante las operaciones lógicas, también sirven.

Por ejemplo, si tenemos un programa hecho como se muestra a continuación:

unsigned char A;

unsigned int B;

unsigned int C;

A=0xFF;

B=0x3210;

C = A + B;

Hasta ahora, como habíamos dicho, la variable A se va a convertir en una variable temporal de 16 bits, a la misma se le va a cargar el valor positivo 255 (0xFF) ya que la variable A estaba declarada explícitamente como unsigned char . El resultado va a ser C=0x00FF + 0x3210 = 0x330F

Bien, pero en C, es posible hacer lo siguiente:

C = (signed char)A + B;

Colocando la línea con la operación aritmética de ésa manera, le indico al compilador, que si bien la variable A está declarada como unsigned char, le digo que al momento de crear la variable temporal de 16 bits, tome el valor como si la variable A fuera con signo, entonces, leerá la variable A como -1 y no como 255. El resultado va a ser entonces: C = 0xFFFF + 0x3210 = 0x320F

O sea, en el primer caso sumó 255 a la variable B, y en el segundo caso, restó 1 al valor de la variable B.

También puedo armar la operación aritmética como:

C =(signed char)A+(signed char)B

Ahora, le digo al compilador que fuerce el valor de la variable A a ser una variable con signo de 8 bits. Como el resultado se almacenará en una variable de 16 bits, que es la variable C. El valor temporal que tomará la variable A será -1 y en 16 bits, o sea 0xFFFF. Y a la variable B le estoy indicando al compilador que la tome como una variable de 8 bits. Como el valor original de la variable B era 0x3210 pero la estoy forzando a que se interprete como una variable de 8 bits, entonces el compilador tomará para la variable temporal de 16 bits que utilizará para el cálculo, el valor truncando el byte más significativo. Esto es la operación que se ejecutará será: C = 0xFFFF + 0x0010 = 0x000F

Vemos que tenemos una herramienta interesante para forzar al microcontrolador que haga exactamente lo que nosotros le solicitamos hacer. También vemos la diferencia importante que hay cuando no están correctamente declarados o colocados los tipos de datos. Con el mismo programa, los mismos valores de datos, pero con variables diferentemente declaradas o forzadas, se producen resultados diferentes.

Ese forzamiento de un tipo de variable, para que sea tomado como otro tipo de variables, es lo que se denomina en C casting, o cast.

El casting es muy utilizado en los programas hechos en C, especialmente cuando se trata de programas largos, donde queremos explicitar el tipo de datos que necesitamos que tome el microcontrolador antes de procesar una operación aritmética, lógica, o cuando veamos más adelante llamados de funciones y otras tareas.

Operaciones aritmeticas

2011-03-11T09:11:00.000-03:00

Operaciones aritméticas

Hasta ahora hemos hablado de las variables. Cuales son sus nombres char, int, long, float. También hemos visto cuanta memoria ocupa cada tipo de variable en la memoria RAM de los microcontroladores. De ahí fuimos hasta los sistemas de numeración. Comenzamos con una pequeña introducción al sistema de numeración que es natural para los seres humanos - el sistema decimal-. Luego les conté de la importancia de utilizar los sistemas binarios y hexadecimal.

Como continuidad del tema de variables y sistemas de numeración, debemos ahora entrar en lo que son las operaciones matemáticas. Acá vamos a ver como se comporta el microcontrolador cuando tiene que realizar tareas tales como sumas y restas. Veremos como es la representación para el C de los números negativos. También les mostraré algunos trucos del lenguaje C que nos permiten “ahorrar” un poco de líneas de código.

Operadores aritméticos y prioridades

Cuando programamos en C, tenemos las siguientes operaciones aritméticas básicas que podemos realizar: suma, resta, multiplicación y división.

Los operadores son los signos que deben utilizarse en la programación para indicarle al compilador que es lo que se quiere hacer. En nuestro caso, un cálculo aritmético sencillo. Entonces los operadores que se usan son:

suma	+
resta	-
multiplicación	*
división	/

Entonces, cuando queremos indicarle a nuestro programa que realice alguna operación aritmética sencilla, tenemos que utilizar los operadores que les mostré en la tablita anterior.

Por ejemplo, si tenemos un programa que queremos hacer que una variable llamada “C” sea igual a la suma de la variable “A” con la variable “B”, el código de programa que debemos colocar es:

C = A + B ;

Recordar que en todo código de programa escrito en C, SIEMPRE debe finalizar con un punto y coma.

Ahora, si tenemos que escribir un programa, donde una variable “C” queremos que sea igual al resultado de multiplicar la variable “A” por la variable “B” debemos colocar como línea de código la siguiente instrucción:

C = A * B;

De forma similar para las otras operaciones, resta y división:

C = A - B; <- Resta

C = A / B; <- División

Ahora, ¿que sucede cuando tenemos en una misma instrucción todo mezclado? Por ejemplo, si tenemos la siguiente instrucción:

D = A + B * C;

¿Como funciona en el microcontrolador la instrucción que les acabo de pasar? Acá es donde aparecen las prioridades en los operadores. Las mismas indican que operaciones se deben realizar primero, y cuales después.

Las prioridades entre los operadores suma, resta, multiplicación y división es la siguiente: multiplicación o división tienen mayor prioridad que la suma o resta. O sea, primero se calcula la operación de multiplicar o dividir, y después se calculan con el resultado obtenido las otras operaciones (sumas o restas).

Entonces, supongamos que tenemos una línea de código con la siguiente operación matemática:

A = 10 + 2 * 7 - 9 / 3;

El microcontrolador va a resolver primero las operaciones multiplicación y división. Como en el ejemplo que les estoy pasando hay ambas cosas, va a resolver primero una y después otra ¿cual de las dos primero?, eso no lo podemos determinar, depende del compilador y como estén declaradas los parámetros de optimización. Lo que sí es seguro que no va a resolver ambas al mismo tiempo, lo hará en dos pasos diferentes. Pero, no hay problema en que pensemos que resuelve las operaciones recorriendo la fórmula desde la izquierda a la derecha.

En un primer paso, resolverá entonces la multiplicación, en nuestro caso 2 * 7 = 14. Entonces luego de ejecutar el primer paso, la instrucción antes dada, queda como:

A = 10 + 14 - 9/3;

Ahora, vuelve a reevaluar la operación matemática nuevamente. Tenemos pendiente la división que tiene mayor prioridad, así que se debe resolver esa operación. Entonces, el microcontrolador evaluará la operación 9/3 = 3. Quedando para el próximo paso:

A = 10 + 14 - 3;

Todavía el microcontrolador no llegó al resultado, por lo tanto, tiene que continuar evaluando la instrucción. Ahora, tenemos sólo sumas y restas que tienen la misma prioridad. Igual que antes, no podemos determinar cual será el verdadero orden que utilizará el compilador para resolverlo, ya que depende de las optimizaciones y cual sea el compilador utilizado. De todas maneras, eso no afecta al resultado. Podemos asumir que se van resolviendo las operaciones desde la izquierda hacia la derecha. Entonces, el próximo paso será resolver la suma 10 + 14 = 24:

A = 24 - 3;

Finalmente, queda todavía un paso más, que es terminar de hacer la resta 24 - 3 = 21

Entonces, el último paso que ejecutará el microcontrolador, será asignar el valor resultante a la variable “A”

A = 21;

Notemos que para resolver ésta operación matemática, relativamente sencilla, hemos tenido que hacer varios pasos, mínimamente un paso por cada operación. En realidad, lo que hemos hecho, son iteraciones, ésto es, resolvimos una parte del problema y volvimos a evaluar la operación completa pero reemplazando el valor obtenido en el paso anterior.

La intención que tuve al mostrarle de ésta manera la forma de resolver una operación algebraica, es la complejidad que ésto implica. Si bien, un microcontrolador que corre a 5 millones de instrucciones por segundo, ésto no parece ningún tipo de problema. Pensemos si nuestro microcontrolador estará realizando una tarea, donde tiene que estar tomando datos con tasa alta de ingreso de datos por segundo. Por ejemplo, si nuestro microcontrolador tiene que estar capturando datos de algún periférico cualquiera. Y dicho periférico está enviando cien mil datos por segundo, y a cada dato hay que aplicarle una operación simple como esa que les mostré recién, donde se ocuparon 4 pasos solo en la resolución de ésa operación. Si nos están ingresando datos a una tasa de 100000 datos por segundo. Sólo ésta operación nos consume 4 pasos, o sea que nuestro microcontrolador tendrá que soportar ahí 400000 pasos por segundo. Todavía estamos lejos de los 5 millones de pasos por segundo. Parece que el microcontrolador podría funcionar, pero, no hay que perder de vista que nuestro programa no sólo va a ejecutar la operación aritmética que puse en el ejemplo, sino que muy probablemente tendrá decenas o cientos de otras instrucciones que tendrá que ejecutar antes de llegar a la operación aritmética. En la práctica, cuando utilizamos un microcontrolador de 8 bits, como puede ser un PIC, y que tiene colocado un cristal de 20 Mhz, que termina dando 5 MIPS o 5 millones de instrucciones por segundo (les recuerdo que los PIC cada cuatro ciclos del cristal avanza una instrucción), es muy difícil que puedan superar la barrera de los 15000 datos por segundo, incluso menos. Por lo tanto, cuando pensemos en éste tipo de microcontroladores, que están en el orden de los 5 MIPS, debemos saber donde está el límite. Para el caso de microcontroladores Texas, que tienen (los más chicos) una velocidad de procesamiento de 8 MIPS, podemos pensar proporcionalmente, y animarnos a llegar a los 24000 datos por segundo. Incluso tal vez, podemos darle un 50% más de margen ya que estos micros tienen procesamiento en 16 bits, que ayuda notablemente (ya lo voy a explicar un poco más adelante). Si tenemos un microcontrolador de la serie 8051, pensemos que se ejecuta una instrucción cada 12 ciclos de reloj, y podemos llegar a poner un cristal de hasta 30 Mhz, por lo tanto nos da un rendimiento máximo de 2,5 MIPS. Como el 8051 es un micro de 8bits, la barrera que debemos tener en mente que estaría en el orden de las 7000 muestras por segundo.

Estas barreras, son valores que a su vez son muy relativos, ya que dependen en gran medida de la cantidad de operaciones que se deben realizar con cada muestra o dato que se debe procesar. A mayor cantidad de operaciones, menor va a ser la velocidad máxima que podremos obtener y viceversa.

Volvamos al tema de las prioridades en las operaciones aritméticas. ¿Cómo puedo hacer para forzar al compilador para que me calcule primero una operación suma o resta y después una multiplicación o división? Para ello, es que en las operaciones aritméticas pueden utilizarse los paréntesis. Cuando el compilador encuentra un paréntesis dentro de una operación, procesa primero todo lo que queda encerrado dentro de éstos, y al finalizar el cálculo, continúa con lo que queda afuera del paréntesis. Si dentro del paréntesis hay otra operación aritmética que a su vez tiene varias operaciones, incluso otros paréntesis. El compilador aplicará nuevamente las prioridades. La resolución de las operaciones, cuando hay paréntesis, se ejecuta de manera que se comienza por los paréntesis más internos en la operación algebraica para ir saliendo hacia afuera.

Coloco en pasos consecutivos, una operación aritmética, y les voy mostrando como se va resolviendo:

Operación aritmética

A = 20 - 4 * 7 + (45 - 3) * 2 - 9 * (4 + (3 + 3) / 2) ;

Primer paso, resuelve paréntesis más interno

A = 20 - 4 * 7 + (45 - 3) * 2 - 9 *(4 + 6 / 2);

Segundo paso, resuelve el primero de los paréntesis de izquierda a derecha

A= 20 - 4 * 7 + 42 * 2 - 9 * ( 4 + 6 / 2);

Tercer paso, resuelve el segundo paréntesis, que a su vez, tiene internamente otras operaciones, y dentro de esas operaciones, la división tiene mayor prioridad que la suma.

A = 20 - 4 * 7 + 42 * 2 - 9 * ( 4 + 3 );

Cuarto paso, continúa resolviendo la operación dentro del único paréntesis que quedaba

A = 20 - 4 * 7 + 42 * 2 - 9 * 7;

Quinto paso, resuelve la primera multiplicación de izquierda a derecha

A = 20 - 28 + 42 * 2 - 9 * 7;

Sexto paso, resuelve la multiplicación

A = 20 - 28 + 84 - 9 * 7;

Septimo paso, resuelve la multiplicación

A = 20 - 28 + 84 - 63 ;

Octavo paso, quedan solo sumas y restas, comienza por la primer resta de izquierda a derecha

A = -8 + 84 - 63;

Noveno paso, continúa con la suma

A = 76 - 63;

Décimo paso, el resultado ¡por fín!

A = 13;

Veamos ahora, como funcionan las operaciones matemáticas, realmente dentro del microcontrolador. Que sucede con los tipos de variables cuando se ejecutan los diferentes tipos de operaciones. Así como les conté paso a paso como se resuelve una operación aritmética, también les voy a contar ahora a nivel de bit como el microcontrolador procesa los diferentes tipos de operaciones. Si comprendemos ese funcionamiento, nos va a ser más fácil detectar potenciales problemas. También vamos a tener en la mano una herramienta poderosa que puede indicarnos como plantear nuestros programas para que sean eficientes, y resuelvan la función que tenemos como objetivo en cada programa que tengamos que realizar.

Comencemos con la operación más básica:

Suma y resta

Esta es la operación matemática más básica. Vamos a ver ahora, como se aplica la suma en el sistema binario, para entender como lo interpreta el microcontrolador para los diferentes casos. Voy a poner siempre, además del número en binario, el mismo valor en hexadecimal para que vayamos acostumbrándonos a usarlo, y aprenderlo por insistencia.

Supongamos que tenemos que sumar dos números, de la siguiente manera:

A = 18 + 15;

Los valores en binario son 18 = 00010010, hexadecimal 0x12 y 15 = 00001111 en hexadecimal 0x0F.

La suma en binario se realiza de la misma manera que una suma en sistema decimal. Esto es, se comienza sumando primero los valores menos significativos y se va avanzando hacia los más significativos.

Colocamos entonces los valores en columnas

	0	0	0	1	0	0	1	0	0x12
+	0	0	0	0	1	1	1	1	0x15
=

Sumamos la primera columna de la derecha, 0 + 1 = 1

	0	0	0	1	0	0	1	0	0x12
+	0	0	0	0	1	1	1	1	0x0F
=								1

Seguimos por la segunda columna de la derecha, 1 + 1 = 10, o sea pongo un 0 y me llevo 1

						1
	0	0	0	1	0	0	1	0	0x12
+	0	0	0	0	1	1	1	1	0x0F
=							0	1

La tercera columna, es de nuevo 1 + 0 + 1 = 10, me llevo uno y pongo el 0

					1
	0	0	0	1	0	0	1	0	0x12
+	0	0	0	0	1	1	1	1	0x0F
=						0	0	1

Cuarta columna, de nuevo 1 + 0 + 1 = 10, me llevo uno y pongo el 0

				1
	0	0	0	1	0	0	1	0	0x12
+	0	0	0	0	1	1	1	1	0x0F
=					0	0	0	1

Quinta columna, es 1 + 1 + 0 = 10, me llevo uno y pongo el 0

			1
	0	0	0	1	0	0	1	0	0x12
+	0	0	0	0	1	1	1	1	0x0F
=				0	0	0	0	1

Sexta columna, es 1 + 0 + 0 = 1


	0	0	0	1	0	0	1	0	0x12
+	0	0	0	0	1	1	1	1	0x0F
=			1	0	0	0	0	1

Séptima y octava columna, son 0+0 = 0


	0	0	0	1	0	0	1	0	0x12
+	0	0	0	0	1	1	1	1	0x0F
=	0	0	1	0	0	0	0	1	0x21

Quise describir con éstos pasos como funciona la operación suma dentro de un microcontrolador, para que entendamos como es el funcionamiento bit a bit. En el 100% de los microcontroladores, ésta operación se hace en forma directa, y ocupa sólo un ciclo de instrucción cuando la suma es entre 2 variables donde ambas son de 8 bits cada una. En los microcontroladores de 16 bits, se tiene también que la suma de variables de 16 bits se realiza en un solo paso.

Puse también al costado de cada suma, sus valores en hexadecimal, para que veamos como es la suma cuando se trabaja en sistemas hexadecimales, y a partir de ahí, seguimos sólo con el sistema hexadecimal.

Veamos como es sumar 0x12 + 0x0F en hexadecimal.

	1	2
+	0	F
=

La primera suma, es 0x2 + 0xF. 0xF es el valor 15 en decimal, así que 2 + 15 = 17. 17 en decimal es 0x11 en hexadecimal. Así que 0x2 + 0xF = 0x11. O sea, pongo 1 en el primer dígito a la derecha y me llevo 1.

	1
	1	2
+	0	F
=		1

Ahora, el segundo dígito es 1+1 = 2

	1
	1	2
+	0	F
=	2	1

Evidentemente, el resultado 0x12 + 0x0F es igual a 0x21 que debe ser el mismo resultado obtenido de realizar la suma en el sistema binario. Y para corroborar, 0x12 es 18 en decimal, 0x0F es 15 en decimal, 18 + 15 = 33 que también es 0x21.

Estas cosas no son visibles para el programador, y se preguntarán porqué redundo en esto. Para el programador, todo se resuelve en sólo una instrucción. Sin embargo, si entendemos ésta característica, entenderemos que implícitamente en una misma suma se puede resolver también una resta con un truco muy sencillo que veremos a continuación.

Números negativos

Veamos que sucede cuando sumamos dos variables de 8 bits, y que tienen los valores 0x33 y 0xFF

Si nuestro hacemos un programita para esa suma, sería:

unsigned char A;

unsigned char B;

unsigned char C;

A=0x33;

B=0xFF;

C=A+B;

Hagamos entonces la suma, siguiendo el proceso que les describí, directamente usando el sistema hexadecimal.

Completo la tablita


	3	3
+	F	F
=

Sumo las unidades, 0x3 + 0xF = 0x12, tengo que colocar el 2 y me llevo 1

	1
	3	3
+	F	F
=		2

Sumo el nibble mas significativo 0x1 + 0x3 + 0xF = 0x13. Tengo que colocar el 3 y me llevo 1


	3	3
+	F	F
=	3	2

¿Donde puse el 1 que me llevaba? En ningún lado, porque las variables que estaba usando, estaban declaradas como unsigned char, o sea son de 8 bits. El resultado no entra en la variable, y se trunca a sólo los dos dígitos menos significativos.

Esta suma me produjo un desbordamiento. Por lo tanto, si yo hubiera querido almacenar toda la información del resultado, esto es: 0x33 + 0xFF = 0x132, debería haber declarado la variable C como un tipo de datos de 16 bits, como puede ser el tipo int. Acá vemos la importancia de tener en claro como se declaran los tipos de datos. Vemos que una operación suma nos puede dar un resultado no esperado, puesto que al sumar dos valores, el resultado puede ser más grande que el máximo valor posible de almacenar en el tipo de variable que hayamos declarado.

De todas maneras, el microcontrolador hará la suma, no pondrá ningún tipo de objeción y presentará el resultado como 0x32.

Puse con toda intención ese valor 0xFF, para que notemos que el resultado que obtenemos cuando en el programa hemos declarado la variable de salida también como de 8bits.

Lo que quiero que observen que hacer 0x33 + 0xFF = 0x132, y al almacenarlo en una variable de 8 bits queda como 0x32.

¿Que diferencia para nuestro programa tiene hacer 0x33 + 0xFF con 0x33 - 1? Ninguna. Lo que nos está mostrando, que para este caso 0xFF es igual a -1.

Si repito lo mismo con el valor 0xFE, veremos que hacer 0x33 + 0xFE = 0x131, o sea, para nuestro programa el resultado será 0x33 + 0xFE = 0x31. Lo que es lo mismo que hacer 0x33 - 2.

Si repito con todos los valores posibles, vamos a encontrar que todas las sumas pueden ser interpretadas siempre como una suma con un valor negativo.

La regla es que los números se pueden representar como negativos, comenzando por el -1 que equivale al 0xFF, y se van aumentando a medida que bajamos el valor desde 0xFF hasta 0x80. Así, tenemos la posibilidad de asignar valores desde -1 hasta -128 donde -1 equivale a 0xFF y 0x80 equivale a -128.

¿Por qué no sigo descendiendo hasta cero para lograr números negativos hasta -255? Por convención del estandard de C. Donde se define que los números negativos en una variable son cuando el bit más significativo está en 1. Notemos que todos los valores desde el 0x80 hasta el 0xFF siempre poseen el bit 7 o bit más significativo en 1. Les muestro los valores en binario y se van a dar cuenta:

Valor	7	6	5	4	3	2	1	0
0xFF (255)	1	1	1	1	1	1	1	1	Equivale a -1
0x80 (128)	1	0	0	0	0	0	0	0	Equivale a -128 es el número negativo más grande que puedo representar con 8 bits
0x7F (127)	0	1	1	1	1	1	1	1	Equivale a +127 siempre. El bit 7 está en cero
0x00 (0)	0	0	0	0	0	0	0	0	Equivale a 0.

Con ésta notación, algunos ya se han dado cuenta que no es necesaria la operación resta ¿ya se dieron cuenta? La resta no es más que la suma de un número positivo con otro negativo.

Algunos modelos de microcontroladores, no tienen la función resta. El compilador es el encargado de hacer la conversión. Cuando colocamos una resta tal como 10 - 4 = 6. El compilador lo que hace es cambiar la resta por una suma, pero el dato que carga es el valor cambiado de signo. Por lo que para el caso de los microcontroladores que no traen la resta, el compilador hace 10 + (-4) = 6.

Si extrapolamos el caso de 8 bits al caso de 16 y 32 bits. Vamos a ver que es exactamente lo mismo. De ahí, es que sale porqué los tipos de datos de 16 bits permiten almacenar valores con signo desde -32768 hasta +32767. Y los de 32 bits desde -2147483648 hasta +2147483648.

Sumas y/o restas de números más grandes

Si nuestro microcontrolador es de 16 bits, y queremos sumar dos números que son también de 16 bits, ya dije que no hay problema. El microcontrolador tiene incorporado dentro de sus circuitos la solución. Existe en ellos la instrucción, y la operación matemática se hace en sólo un ciclo de procesador. Por lo que si nuestro microcontrolador está funcionando a 5 millones de instrucciones por segundo, en un caso ideal (no práctico ni real) es posible realizar 5 millones de sumas por segundo.

Pero, en microcontroladores de 8 bits no es posible sumar dos números de 16 bits en forma directa ¿qué sucede cuando nuestro microcontrolador es de 8 bits y tenemos que hacer una suma de 16 bits?

Lo que tiene que hacer el compilador, es exactamente la suma, tal cual la hacemos a mano, en varios pasos hasta obtener el resultado. Por ejemplo, si tenemos que sumar dos números cualquiera de 16 bits, para almacenar el resultado en 16 bits:

int A;

int B;

int C;

A = 0x0123;

B=0x0380;

C= A+B;

El microcontrolador, puede en forma nativa sumar dos variables de 8 bits, así que agrupamos los valores en 2 grupos de 8 bits cada uno:

	01	23
+	03	80
=

Se hace primero la suma del byte menos significativo 0x23 + 0x80 = 0x103. Como 0x103 no entra en un byte, pero el resultado va a estar en 16 bits, entonces, me llevo el 1 y lo sumo a la columna de bytes mas significativos

	1
	01	23
+	03	80
=		03

Finalmente, sumo los bytes más significativos, 0x01 + 0x01 + 0x03 = 0x05

	1
	01	23
+	03	80
=	05	03

Y el resultado de sumar 0x123 + 0x380 = 0x0503.

¿Cuantos pasos se utilizaron? Tres. Se usó un primer paso para sumar los bytes menos significativos. Un segundo paso para corroborar si me llevé un uno o no. Y el tercer paso la suma de los bytes más significativos.

Esto quiere decir, que para sumar dos variables de 16 bits, en un microcontrolador de 8 bits se necesitan 3 instrucciones o 3 ciclos. Por lo tanto, ya comenzamos a notar las diferencias entre un procesador de 8 bits y otro de 16 bits. Si nuestro microcontrolador de 8 bits trabaja a 5 MIPS, entonces, la máxima cantidad de sumas posibles de dos variables de 16 bits será de 1,66 millones de sumas por segundo.

Si planteamos el mismo caso para una suma de 32 bits, vamos a obtener que con un microcontrolador de 32 bits, las sumas en 32 bits se efectúan en un sólo ciclo. Si en cambio, nuestro micro es de 16 bits, se necesitan 3 ciclos. En cambio, si nuestro microcontrolador es de 8 bits, se necesitan 9 pasos.

Resumiendo, vemos que para el doble de capacidad de procesamiento en el ancho de bits, para microcontroladores que corren a la misma velocidad, se divide por 3 el tiempo que le toma a uno respecto al otro.

	Suma 32 bits + 32 bits	Suma 16 bits + 16 bits	Suma 8 bits + 8 bits
Micro 8 bits	9	3	1
Micro 16 bits	3	1	1
Micro 32 bits	1	1	1

Comparativas de cantidad de ciclos necesarios para una operación suma según el tipo de microcontrolador, y el tipo de suma

Además, tengamos en cuenta que a medida que son más nuevos los microcontroladores, donde el ancho del bus, o cantidad de bits que pueden procesar son mayores. También la velocidad del micro es mucho mayor. Por ejemplo, los PIC de 8 bits, tienen una velocidad máxima de 5 MIPS. Los Texas mas chicos de 16 bits tienen 8 MIPS. Un ARM7 de 32 Bits ronda los 50 MIPS. Esto quiere decir, que entre un micro de 8 bits a 5 MIPS contra un ARM de 32 bits a 50 MIPS, sólo en velocidades hay una mejoría de 10 veces, pero para las sumas en 32 bits, ésto se multiplica por 9. O sea, para sumar dos valores en 32 bits, un ARM es 90 veces más rápido que un micro de 8 bits a 5 MIPS.

Sumas y/o restas entre diferentes tipos de variables. Promotion y demotion.

Ahora, metamos en una misma bolsa todo lo visto hasta aquí, ¿qué sucede si sumamos variables de diferentes tipos, por ejemplo una variable char con una variable tipo int, o cualquier otra combinación que se nos ocurra?

Para responder a ésta pregunta, tenemos que observar los siguientes puntos:

- El tamaño en bits de la variable donde se almacena el resultado.

- Los tamaños en bits de las variables que intervienen en la fórmula.

Ya vimos algo, sobre lo que pasa si el tamaño de la variable donde se almacena el resultado es menor al tamaño requerido.

Supongamos que se tienen que sumar dos variables de 16 bits, y el resultado se lo intenta almacenar en una variable de 8 bits, tendríamos un programa como el siguiente:

unsigned int A;

unsigned int B;

unsigned char C;

C = A + B;

Entonces, dependiendo de que valores tengan cargadas las variables A y B será la forma que se represente el resultado. Supongamos que las variables A y B que son de 16 bits, sumadas dan un valor resultado menor que 256. Entonces, en ése caso en la variable C va a estar almacenada la suma y el valor va a ser correcto, puesto que una variable tipo char, de 8 bits, permite almacenar como valor máximo el número 255.

Ahora, si la suma de las variables A y B, da un resultado que es mayor que 256, lo que va a suceder, es que cuando el microcontrolador haga la suma, el resultado no se va a poder almacenar dentro de la variable C en forma completa. Entonces, el resultado va a ser el byte menos significativo del resultado de la suma.

Por ejemplo, si A tiene cargado el valor 0x123 y B tiene cargado el valor 0x3123. La suma será 0x123 + 0x3123 = 0x3246. Pero como el resultado se debe almacenar en la variable C que es sólo de 8 bits, entonces la variable C tendrá como resultado el valor 0x46. En éste caso se ha perdido la información del resultado de la suma. Hay algunos casos donde justamente se busca ésto. Sin embargo, en la mayoría de las veces, debemos tener cuidado de que la variable resultado tenga la capacidad de poder almacenarlo.

Veamos ahora que sucede cuando las variables que participan en la suma son de diferentes tamaños. Por ejemplo, tenemos un programa que está escrito de la siguiente forma:

unsigned char A;

unsigned int B;

unsigned int C;

.....

C = A + B;

Ahora es donde cobra importancia saber si el tipo de variables involucradas son con o sin signo. Para el caso del programa que les muestro, todas las variables fueron declaradas como tipo unsigned, es decir, todas las variables van a poseer sólo valores positivos.

El compilador cuando va a implementar las tareas para resolver la instrucción algebraica C=A+B, lo que hace es llevar o convertir temporalmente todas sus variables a la variable de mayor tamaño.

Entonces, el compilador interpretará la fórmula de la siguiente manera:

(unsigned int)C=(unsigned int)A + (unsigned int)B

En éste caso no hay mayores complicaciones, el compilador simplemente acomodará el valor de la variable A en 2 bytes para formar una variable temporal de 16 bits, y luego realizar la suma como si fuera una suma normal entre 2 variables de 16 bits.

Ahora bien, si la variable A que es la de 8 bits tiene cargado el valor 0xFF. Ya vimos anteriormente que 0xFF para un dato de 8 bits, puede entenderse como un valor negativo o -1. Sin embargo, como esta variable A está declarada del tipo unsigned char. Entonces, el compilador reconoce esa condición, y asignará el valor +255 o 0x00FF a la variable temporal de 16 bits que reemplaza a la variable A para realizar el cálculo.

Si reescribimos el programa nuevamente, pero cambiamos la variable A de unsigned char por signed char. Estamos indicando explícitamente que queremos que la variable A sea considerada de 8 bits, pero que tenga en cuenta el signo.

signed char A;

unsigned int B;

unsigned int C;

......

C=A+B;

Lo que hace el compilador, es verificar el valor de la variable A antes de convertirlo a 16 bits. Si por ejemplo la variable A viene con el valor previamente cargado en 0xFF que significa -1. Entonces, el compilador no le va a asignar a la variable temporal de 16 bits un valor 0x00FF, sino que tomará el valor 0xFFFF. Ese valor significa -1 para los datos de 16 bits. Como regla, el microcontrolador, cuando se trata de variables con signo, y donde tiene que convertir una de las variables a una variable de mayor tamaño para realizar una cuenta, es que verifica, si la variable tiene cargado un valor positivo, entonces coloca los bits más significativos en 0. En cambio, si la variable posee cargado un valor negativo, entonces, colocará los bits más significativos en 1.

Estas operaciones que les acabo de indicar, que las realiza el compilador automáticamente, se conocen como promotion, o promoción. Que es cuando la conversión se debe hacer desde una variable con una menor cantidad de bits hacia otra con una cantidad de bits mayor. Cuando se hacen promotions no hay peligro de pérdida de bits, ya que la nueva variable puede contener el nuevo valor, pero debe tenerse muy cuidado con el tipo de variables involucradas, ya que el compilador las interpreta diferente si son con signo o sin signo.

La acción de tener que almacenar el resultado dentro de una variable de menor cantidad de bits, como vimos en el primer ejemplo, es lo que se conoce como demotion o degradación. En éste segundo podemos tener problemas con pérdida de información.

Multiplicación y división

Merece que demos un vistazo a la multiplicación y división para entender las consecuencias que ésto puede traer en nuestros equipos con microcontroladores.

Hay modelos de microcontroladores, por ejemplo el 8051, los PIC de la serie 18, y algunos modelos de los MSP430, que tienen incorporados un multiplicador por hardware.

Para los microcontroladores que ya traen incorporado un multiplicador por hardware no hay mayores complejidades. El microcontrolador ejecutará en un sólo ciclo del reloj la operación de multiplicación.

Los puntos importantes que hay que notar cuando se realiza una multiplicación son los mismos casos que en las sumas y restas. Hay que tener mucho cuidado en el tamaño de la variable donde se almacena el resultado. Y tener en cuenta el tipo de variables que intervienen en la operación. No es lo mismo multiplicar dos variables que siempre son positivas, a multiplicar dos variables que poseen signos. El compilador hace las correspondientes promociones y degradaciones de las variables para acomodarlas y poder realizar la tarea.

Si el microcontrolador a utilizar posee multiplicador por hardware no hay más nada que decir. Se cumplen las mismas o similares observaciones que las que tienen la suma y resta.

Veamos ahora que sucede con la multiplicación, cuando utilizamos un microcontrolador que no posee multiplicación por hardware. Como resuelve el microcontrolador las operaciones de multiplicación.

Para poder entender como funciona la multiplicación en un microcontrolador, debemos recordar como se multiplica en el sistema decimal. Supongamos que tenemos que multiplicar dos números de 2 cifras cada uno: 12 x 34

La operación manual para realizar esta operación implica colocar ambos números encolumnados:

	1	2
X	3	4

Luego se hace la multiplicación de las unidades del multiplicador por el multiplicando. O sea 4x12

	1	2
X	3	4
	4	8

Después, se hace la multiplicación de la decena del multiplicador por el multiplicando. O sea 3x12. Y se acomoda desplazado.

	1	2
X	3	4
	4	8
3	6

El resultado, es la suma de 48 + 380

	1	2
X	3	4
	4	8
3	6
4	0	8

Bien, lo que les conté fue solo un repaso de como multiplicamos normalmente como seres humanos, cuando tenemos que obtener el cálculo en forma manual.

En definitiva, el algoritmo que estamos aplicando en forma manual es el siguiente:

1 - Multiplicar el dígito menos significativo del multiplicador por todo el multiplicando

2 - Acumular el resultado de la multiplicación anterior

3 - Multiplicar el digito siguiente del multiplicador por todo el multiplicando. El resultado debe ser desplazado hacia la izquierda en un dígito y acumularlo con el resultado obtenido en el paso 2.

La multiplicación de dos números en el microcontrolador, se hace de la misma manera, sólo que con números binarios. La ventaja que se tiene es que la multiplicación en binario sólo tiene dos valores posibles, 0 y 1. O sea, se usa la tabla de multiplicar del 1.

Bien, para multiplicar dos dígitos en forma binaria. Se utiliza el mismo algoritmo que les mencioné hace unas pocas líneas.

Veamos, si tenemos que multiplicar dos valores del tipo char, o sea dos valores de 8 bits cada uno, entonces, aplicando el método o algoritmo que les acabo de dar, notamos inmediatamente que tenemos que ocupar como mínimo 16 pasos para multiplicar 2 números de 8 bits.

El resultado de una multiplicación de dos números de 8 bits, pueden ocupar como resultado un valor en 16 bits.

De la misma manera, si tenemos que multiplicar dos números de 16 bits, necesitaremos como mínimo 32 ciclos de instrucciones y el resultado estará expresado en un valor de 32 bits.

Esto que les cuento, es para que entendamos que sucede dentro de un microcontrolador que no posee multiplicador por hardware. Supongamos que tenemos que escribir un programa como el siguiente:

char A;

char B;

int C;

A=cualquier valor;

B=cualquier otro valor;

C=A*B;

Tengamos en cuenta que esa operación está como mínimo necesitando 16 ciclos de instrucción. Si nuestro microcontrolador está corriendo a 5 millones de instrucciones por segundo, como máximo podremos hacer hasta 312500 operaciones por segundo.

En cambio, si nuestro microcontrolador posee multiplicador por hardware, dicha operación se hace en tan sólo un ciclo de procesador.

La operación multiplicación es muy utilizada cuando se hace procesamiento digital de señales, y filtros digitales. Donde se toman muestras de algún proceso mediante un procesador y se van ingresando dichas muestras a un algoritmo que aplica operaciones matemáticas. Si van a tener que implementar un proyecto donde estarán ingresando datos a una alta tasa o velocidad, y necesitan que esas muestras tengan algún tipo de procesamiento. Donde probablemente tengan que efectuar multiplicaciones. Piensen en utilizar algún tipo de microcontrolador con multiplicador por hardware, y preferentemente un DSP. Los DSP de la serie TMS320xxx trabajan en 16 y 32 bits y con velocidades de hasta 300 MIPS, y con multiplicador por hardware. Estos últimos, son unas verdaderas bestias que se comen los datos, son especiales cuando tenemos esos casos. La programación de estos chips, también se hace en C. Y tienen costos similares o no demasiado más caro que los microcontroladores mas completos.

Las series de PIC18Fxx, tienen también multiplicador por hardware, pero su velocidad de procesamiento puede llegar hasta 10MIPS

Las series dsPIC son DSP de la firma microchips. Trabajan en 16 bits y llegan hasta los 30MIPS

Las series MSP430 de Texas, tienen microcontroladores con multiplicador que llegan hasta los 25MIPS

Capitulo 2 - Variables

2011-03-04T00:00:00.031-03:00

CAPITULO 2

Conceptos de programación

En éste capítulo voy a comenzar a describir las nociones básicas sobre programación. Si usted es alguien que nunca ha tenido la oportunidad de programar nada, en éste capítulo encontrará conceptos y ejercicios mentales que ayudan a entender y facilitar la tarea para encarar la programación en general, no sólo de microcontroladores.

Ya en el capítulo anterior habíamos hecho una caracterización del funcionamiento de un sistema programable, como podría ser un microcontrolador. El ejercicio consistía en ponerse en el lugar de un microcontrolador. Imaginarse que uno de nosotros era un microcontrolador y pensaba como tal. Entonces, se nos daba una orden simple, que para la mayoría de los seres humanos es comprensible: limpia tu cuarto. Pero veíamos que en un microcontrolador (y en cualquier sistema programable), en realidad es una orden muy compleja y que necesita pasos más detallados.

Veíamos con esa interpretación, que un microcontrolador necesita especificar exactamente, punto por punto que es lo que se necesita realizar. Y es eso lo que sucede exactamente en cualquier sistema que lleva una CPU o microcontrolador. No existe hasta el día de hoy, o por lo menos no se conocen, equipos electrónicos que tengan capacidad propia de creación. Esto es, hoy en día es imposible esperar que un microcontrolador o cualquier computadora conocida pueda tomar alguna decisión basada en su propia imaginación. Los microcontroladores no poseen creatividad ni imaginación.

Por lo tanto, los microcontroladores sólo responden a impulsos (eléctricos), y el comportamiento será siempre lo que tenga programado que tenga que hacer. Si lo que tiene programado realizar no es correcto, el microcontrolador ejecutará las acciones en forma incorrecta. Nunca un microcontrolador cuestionará lo que tiene programado para ejecutar.

Variables

En todo sistema informático necesariamente hay lo que se denominan las variables. Es algo que viene innato, y es la esencia en su funcionamiento. Ya hablamos también en la introducción sobre la memoria RAM y para que se utilizaba. La información que se almacena en la memoria RAM es lo que llamamos las variables.

Las variables son casillas o lugares donde un microcontrolador almacena un valor, donde dicho valor es el resultado de haber realizado algún tipo de operación, como puede ser el resultado de una operación matemática, o el resultado de alguna operación lógica. Como también puede ser el resultado de saber en que estado quedó el microcontrolador al haber terminado de ejecutar alguna orden o instrucción, como por ejemplo, saber cual era el número de paso que estaba ejecutando en el momento previo anterior.

Nunca hay que perder de vista que un microcontrolador es como una persona que posee amnesia inmediata, ésto es, se olvida inmediatamente de lo que acabó de hacer. Por lo tanto, necesita dejar almacenado o guardado en algún lugar las cosas que va a necesitar recordar. Para esto está la memoria RAM, allí es donde se guarda todo ése tipo de información.

Supongamos que queremos realizar un programa cuyo objetivo sea simplemente un contador. Esto es, que arranque la ejecución del programa y cuente consecutivamente números arrancando la primera vez en el valor 1. Y que ésto sea todo el objetivo del programa.

Supongamos que tenemos la memoria RAM, y es un casillero con 8 estantes como el siguiente:

Entonces nuestro microcontrolador tendría una capacidad de 8 posiciones de memoria. Cada casillero del estante puede ser accedido por el microcontrolador en cualquier momento, puede colocar como máximo un número por vez por cada casillero.

Las órdenes que debería tener dicho programa deberían ser:

1 - Digo que el primer casillero de arriba a la izquierda se va a llamar “A”

2 - Digo que el segundo casillero, de arriba de izquierda a derecha se va a llamar “B”

3 - Coloco en el casillero A, el valor 1. O sea hago A=1

4 - Leo el valor que está en A y le sumo 1. El resultado lo guardo en B. O sea hago B= A+1

5 - Leo el valor que está en B y lo pongo en A. O sea, hago A = B

6 - Vuelvo al paso 4

Vamos entonces a ejecutar éste programa como si fuésemos un microcontrolador. Las órdenes 1 y 2 son simplemente declaraciones, adopto un nombre para dos posiciones en el casillero. Esto más adelante cuando entremos de lleno en el lenguaje C veremos que existen éstos pasos de declaraciones. En nuestro caso, lo único que hacen los pasos 1 y 2 es ponerles un nombre a los dos primeros casilleros:

El paso número 3 es lo que se llama inicialización. Es asignarle un valor inicial a una de las variables. Las inicializaciones son también pasos necesarios (y muchas veces obligatorios) en los programas reales. Son un punto de partida. Se necesita saber con que valor debe arrancar un programa. En nuestro caso, dijimos en la consigna que el contador debería contar desde 1 hacia adelante. Entonces, el paso número 3 le asigna a la variable llamada “A” el valor 1.

Ya está la variable A inicializada. Ahora, los pasos 4 al 6 son el núcleo del programa o programa principal. Vamos a realizar la ejecución paso a paso.

El paso 4 solicita leer el valor guardado en A y sumarle 1, el resultado almacenarlo en la variable B. Esto es, hacer B = A + 1.

Como observamos en el dibujo anterior, A tenía cargado el valor 1, por lo tanto 1 + 1 = 2. Este resultado lo guardamos en B

El paso 5, indica que leamos el valor guardado en B y lo copiemos a la variable A. Esto es, hacer A=B

El paso 6 indica volver a ejecutar el paso 4. Por lo tanto, vuelve a hacer B = A + 1. Esto es, ahora A estaba con el valor 2, entonces B = 2 + 1 = 3. Y ese es el nuevo valor de B.

De nuevo el paso 5 pide pasar el valor que está en la variable B a la variable A. Esta vez, copiará el valor 3.

Podríamos continuar indefinidamente, y veríamos que la variable A va a tomar infinitos valores, siempre incrementándose de 1 en 1. Ya veremos más que hay una pequeña limitación en ésto, en realidad el valor no va a incrementarse hasta el infinito. Pero, si el programa se puede continuar ejecutando infinitamente. La única forma de hacer que deje el microcontrolador de ejecutar éste programa será quitando la alimentación.

Lo que hemos visto, es un ejemplo muy sencillo, y que vemos que solo hacer lo que el microcontrolador hace, tratando de ponernos en el lugar que tiene que tomar parecen ser pasos tediosos. ¿Cuanto tiempo nos tomó en contar de ésta manera de 1 hasta 3 que es lo que muestro en el ejemplo? (y no se imaginan cuanto tiempo me tomó escribirlo). Sin embargo, esta tarea la puede realizar sin ningún inconveniente cualquier microcontrolador, y la puede realizar millones de veces por segundo. Si éste fuera el programa real, y nuestro microcontrolador trabaja a 5 millones de instrucciones por segundos (5 MIPS), nuestro contador se incrementaría una vez cada 3 instrucciones, el incremento se produce sólo en el paso número 4. El pasos 5 es la copia del valor entre la variable A y B. Y el paso 6 es la orden de volver al paso 4. Entonces, nuestro contador se incrementará 1,66 millones de veces por segundo.

A manera de ir acercándonos un poco más al lenguaje de programación. Reescribo el programa anterior en un lenguaje más cercano al lenguaje del microcontrolador. El programa reescrito sería:

1 - Definir A en posición 1

2 - Definir B en posición 2

3 - A = 1

4 - B = A + 1

5 - A = B

6 - Ir a paso 4

Todavía estamos lejos del lenguaje C, pero nos estamos acercando un poco más.

Tipos de variables

Ya habíamos dicho que el programa anterior podía dejárselo ejecutando en un microcontrolador infinitamente, pero el valor al que va a llegar la variable no va a ser infinito, va a estar limitado. Esta limitación lo define el tipo de variable que hayamos elegido para declarar las variables A o B.

Volviendo al ejemplo de ponernos en el lugar del microcontrolador, supongamos que los valores que almacenamos en las estanterías cada vez que ejecutamos un paso, es un papelito que escribimos a mano antes de guardar en la estantería. ¿Que sucede con el tamaño del papel? Supongamos que nuestro papelito mide 2x2 cm. ¿Cuantos dígitos podríamos escribir en el papel?, seguramente, 1, 2, 3 o incluso 4 dígitos podrían ingresar en nuestro papelito. Por ejemplo podríamos escribir cada vez números en un mismo tamaño:

Pero, ¿que sucede cuando superamos el valor 9999? Suponiendo que nuestro tipo de letra no nos permite achicar más la letra, no podemos escribir un número más grande. Entonces, si seguimos poniéndonos en el lugar del microcontrolador, lo que va a suceder es que como humanos vamos a comenzar a escribir el número, y nos vamos a topar con el fin del papel. Entonces, sólo vamos a haber escrito 4 dígitos en el papelito. Supongamos que la variable A estaba en el valor 9999 y al sumar 1 tenemos que escribir el valor 10000. Como seres humanos puestos desde el punto de vista del microcontrolador, vamos a comenzar a escribir en el papelito, pero se nos va a acabar en el cuarto dígito. Entonces el papelito va a quedar cargado como:

Vemos que al no haber espacio en el papelito, el resultado ya no es el esperado. En realidad, el microcontrolador tampoco escribe los números como seres humanos, la escritura del número debe hacerse de derecha a izquierda. Comenzando por las unidades para seguir por las decenas, y centenas. Por lo tanto, para el microcontrolador, cuando se acaba la capacidad del papelito, el número resultante sería:

Esto último es lo que se parece más a lo que sucede dentro de un microcontrolador cuando se sobre pasa la capacidad de almacenamiento de cada variable. Siempre se pierde lo que se llama los dígitos más significativos, ésto es en éste caso, se descarta la decena de miles y se mantienen todos los dígitos restantes.

Si nuestro programa corriera con las condiciones dadas en los ejemplos, el programa contaría desde 1 hasta 9999 y cuando pase de 9999 volvería a 0. Si nuestro programa corre a una velocidad de 1,66 millones de veces por segundo, se puede observar que 166 veces por segundo pasará de 0 a 9999.

En los microcontroladores reales, las variables se agrupan en bytes, words, doble words. Lo que define entonces la capacidad de almacenamiento está dada por el lenguaje de programación. A nosotros nos interesa el lenguaje C. Tenemos en éste lenguaje la posibilidad de elegir entre diferentes tipos de variables. Los tipos de variables definirían el tamaño del papelito que vamos a usar. Sólo que en un microcontrolador, el tipo de variable define la cantidad de bits que ésta puede almacenar.

Los tipos de variables usados en C son:

char

Este es el tipo de variable más chico que es posible utilizar en C nativo. Este tipo de variable ocupa 1 byte (8 bits) en la memoria del microcontrolador. En éste tipo de variables se pueden almacenar valores desde 0 hasta 255.

signed char

Es lo mismo que el tipo char, o sólo que se indica además que se considere como que los valores desde 0 hasta 127 son tomados como valores positivos. En cambio, los valores 128 hasta 255 son tomados como -128 hasta -1 respectivamente. En la memoria del microcontrolador, los valores son agrupados también en 8 bits. Pero cambia la forma de interpretación.

unsigned char

Es exactamente lo mismo que declarar una variable como char, solo que se especifica en forma explícita que se quiere interpretar una variable como del tipo char, y que se considera siempre que todos los valores que pueda tomar sean positivos. El rango de valores va desde 0 a 255, y ocupa 1 byte u 8 bits.

int

Es una variable que representa una palabra en el microcontrolador. El largo que ocupa este tipo de variable depende de que compilador se esté utilizando. Por ejemplo, para el compilador PICC por defecto ésta variable ocupa 8 bits. Sin embargo, para la mayoría de los compiladores ésta variable ocupa 16 bits. Para compiladores que utilizan microcontroladores de 32 bits, éste tipo de variable ocupa 32 bits de largo. Dependiendo de que compilador se esté utilizando será el rango de valores que podrá tener. Por defecto, para la mayoría de los compiladores, ésta variable se considera con signo (hay compiladores donde ésta variable por defecto sólo permite valores positivos). Es decir, acepta valores positivos y negativos. Para el caso del compilador PICC este tipo de variables puede tomar valores entre -128 y +127. Para otros compiladores (HiTech, IAR), este tipo de variables es tomado como de 16 bits, entonces los valores que podrá tomar son desde -32768 hasta +32767. En cambio, si el microcontrolador es de 32 bits, este tipo de variables podrá tomar valores desde - 2147483648 hasta +2147483647

signed int

Es la forma explícita de indicarle al compilador que el tipo de variable es int con interpretación de que se trata de una variable con signo. O sea, que puede tomar valores positivos como negativos.

unsigned int

Esta es la forma explícita de indicarle al compilador que el tipo de variable es int pero sin signo. Se indica o fuerza al compilador que éste tipo de variables debe aceptar o ser tomada siempre como con signo positivo. Para el caso de que el compilador que estén utilizando tome ésta variable como de 16 bits, entonces, este tipo de variables podrá tomar valores entre 0 y 65536.

long

Este tipo de variable indica que los datos están armados por 4 bytes, o lo que es lo mismo 32 bits. Entonces, los valores que pueden tomar éste tipo de variables pueden ir desde 0 hasta 4294967297 para el caso de que sean valores sólo positivos. O desde - 2147483648 hasta +2147483647 si la variable está declarada que es una variable con signo, o sea que permite valores positivos o negativos. De igual manera que los tipos int y char, se puede declarar las variables tipo long como unsigned long donde sólo aceptará valores positivos. O como el tipo signed long, en cuyo caso se especifica que la variable respetará signos y aceptará valores negativos.

short

Este tipo de variable, por definición en el estándar de C es una variable de 16 bits. Pero, para el caso de los compiladores para microcontroladores, no está respetado en todos los casos. Conviene revisar el compilador que se vaya a utilizar, normalmente ingresando en la ayuda del programa y averiguar que longitud le asigna a éste tipo de variables.

Hasta aquí, los todos tipos de variables que les he mostrado, son para representar siempre valores enteros, ya sean positivos o negativos. Lo que significa que sólo se pueden almacenar números sin decimales. Por ejemplo, si una variable está declarada como tipo int y se quiere guardar un valor como 25,2309. El valor que se podrá guardar será 25 o 26, pero nunca el número con la exactitud requerida.

Existen dos tipos de variables que sirven para representar valores con punto decimal.

float

Este tipo de datos es para representar valores con punto flotante. Este tipo de variables se almacena en la memoria RAM como un dato de 32 bits, o sea ocupa en la memoria RAM 4 bytes por cada variable declarada como float. Pero, el valor representado está compuesto por una mantisa y un exponente. De manera que se pueden representar números mucho más grandes en magnitud. El tipo de datos float admite números desde 1.175494351x10^-38hasta 3,402823466x10³⁸. Esto significa que se pueden representar hasta un número 3 seguido de 38 ceros. Este tipo de datos es excelente cuando se necesitan realizar operaciones matemáticas que sus resultados dan en valores con decimales. Tiene el inconveniente, que sólo puede representar hasta 7 dígitos significativos. Esto es, el número 1234567 cuando se almacene en una variable, ésta quedará cargada con el valor 1,234567x10⁶. Pero, no se puede representar un número que requiera de mayor precisión que los 7 dígitos. Por ejemplo, si queremos representar el número 12345672, el valor que quedará almacenado en la memoria será 1,234567x10⁶. Se observa que ambos números se representan igual. El segundo inconveniente que trae el tipo de datos float, en el mundo de los microcontroladores, es que cuesta mucho trabajo para el compilador interpretar éste tipo de números. Por lo tanto, si lo que se desea es implementar un software que tenga que realizar operaciones a la máxima velocidad, usar el tipo de datos float puede penalizar el resultado, limitando la velocidad.

double

Este tipo de datos, también sirve para representar números decimales. Al igual que con el tipo de datos float, es excelente el uso para cuando se requiera realizar operaciones matemáticas donde los resultados necesariamente van a estar expresados en valores con punto decimal. El tipo de datos double, se almacena en la memoria RAM como una variable de 64 bits, esto significa que ocupa 8 bytes de memoria por cada variable declarada de ésta forma. Este tipo de datos es mucho más preciso que el tipo de datos float, ya que permite representar números con 15 dígitos significativos. Los valores límites del tipo de datos double son desde 2,2550738585072014x10^-308 hasta 1,7976931348623158x10⁺³⁰⁸. Observamos que los números son bastante más grandes y poseen mayor precisión que los float. Este tipo de datos, NO está disponible en todos los compiladores C, hay que verificar en cada compilador si lo soporta o no. Igual que los float, indicarle al compilador que interprete las variables utilizando el tipo de datos double, hace que tenga que realizar muchas operaciones el microcontrolador para poder interpretarlo. Por lo tanto, también el tipo de datos double puede penalizar la velocidad de procesamiento resultante del microcontrolador.

Hay otros tipos de variables que son específicos de algunos compiladores, pero no es propio del lenguaje C sino que son características de cada empresa que proveedora de compiladores en C. Conviene revisar en el compilador que se vaya a utilizar cuales son los tipos de datos permitidos y cuales son sus tamaños y valores límites.

Volviendo al ejercicio anterior, vamos a mejorar la sintaxis del programa ejemplo que habíamos dado. Vamos a declarar las variables A y B nuevamente para que quede bien específico como queremos que cuente nuestro programita sencillo.

Por ejemplo, supongamos que elegimos que para nuestro contador, las variables sean del tipo unsigned char. Entonces, reescribimos el programita pero ahora declarando mejor las variables:

1 - unsigned char A;

2 - unsigned char B;

3 - A = 1

4 - B = A + 1

5 - A = B

6 - Volver al paso 4

Ya tenemos en los pasos 1 y 2 declaraciones que son específicas del C. Escribiendo las sentencias de ésa forma, se le indica al compilador que los casilleros llamados A y B, van a ser variables tipo char, lo cual significa que van a ser variables de 8 bits de longitud cada una.

Por lo tanto, ya sabemos entonces, que nuestro programita va a correr, comenzará contando desde el valor 1 puesto que en la línea número 3 le indicamos que tome la variable llamada “A” el valor 1. Luego comenzará a incrementarse, hasta llegar al valor 255. Cuando haga el paso B=A+1, como 255 + 1 = 256, éste valor no puede ser representado por una variable tipo char, ya que el valor máximo es 255. Todavía no hablamos de sistemas de numeración binarios, decimales y hexadecimales. Pero, créanme por ahora, que el valor 256 representado en binario es 100000000. Notemos que los 8 bits que están a la derecha del 1 están todos en 0. Casualmente en un char entran 8 bits. El microcontrolador, tomará siempre los 8 bits que están más a la derecha, o lo que es lo mismo, los 8 bits menos significativos y ese valor será el que asigne a la variable “A”. Por lo tanto, el resultado de hacer B = A + 1 donde A vale 255. Entonces B = 255 + 1 = 0.

Esto quiere decir, que nuestro contador, de manera similar al ejemplo que habíamos dado para el caso “humano” donde contábamos desde 1 hasta 9999 y luego pasamos a 0 hasta 9999. Se repite nuevamente, pero el valor que van a tomar las variables, van a pasar desde 1 hasta 255, y luego 0 hasta 255.

Algo similar sucedería, si en vez de haber elegido para las variables A y B tipos de variable char, hubiéramos elegido por ejemplo el tipo int. Suponiendo que nuestro compilador interpreta el tipo int como de 16 bits. Esto es, que utiliza 2 bytes en la memoria para cada variable declarada como int.

El código de nuestro programita, ahora sería:

1 - unsigned int A;

2 - unsigned int B;

3 - A = 1

4 - B = A + 1

5 - A = B

6 - Volver al paso 4

Si ponemos a correr el programa, la variable “A” comenzaría con el valor 1. Y comenzaría a contar a medida que avanza entre los pasos 4 al 6. Cuando llega al valor de A igual a 255, no hay problema, puesto que cuando haga B = A + 1. Hará B = 255 + 1 = 256, de nuevo, el valor 256 representado en binario es 100000000. Este valor ocupa 9 bits, y como las variables A y B son de 16 bits, entra sin inconvenientes.

Ahora bien, cuando la variable A vale 65535 y entra en el paso 4. Intentará hacer B = A + 1. Pero ahora será B = 65535 + 1 = 65535. De nuevo, créanme cuando les digo que 65536 es 10000000000000000, o sea, un 1 seguido de 16 ceros. La variable B es sólo de 16 bits, por lo tanto el 1 a la izquierda no entra. El microcontrolador, almacenará como resultado el valor 0 en la variable B.

Para este caso, entonces, la variable A contará desde 1 hasta 65535, y luego pasará a valer 0 para seguir contando hasta 65535.

Todo esto que estoy contando, y tratando de hacerles notar, es algo que sólo puede hacerse en el lenguaje C. Y aquí estamos en presencia de algo peligroso, pero muy poderoso que sólo tiene este y ningún otro lenguaje en forma tan directa. Esto, cuando seamos más expertos en la programación lo vamos a sufrir como querer mucho, ya que en muchos casos puede ser un problema, pero en muchísimos otros ayuda en la programación y hace que el lenguaje C sea uno de los mas poderosos, especialmente cuando se trabaja con microcontroladores, donde se busca la optimización de recursos. En otros lenguajes, al intentar realizar la operación B = A + 1, si el resultado produce un sobre-pasamiento, que es lo que estamos viendo, hace que el software dé un error y bloquea o detiene la ejecución del programa.

Fíjense que pasaría, si por ejemplo hacemos que la variable “A” sea del tipo char pero la variable “B” del tipo int. O sea, que pasaría si nuestro programita está escrito así:

1 - unsigned char A;

2 - unsigned int B;

3 - A = 1

4 - B = A + 1

5 - A = B

6 - Volver al paso 4

De nuevo, el programa arrancaría, y la variable “A” tomaría el valor 1. Luego comienza la ejecución y va incrementando de a uno a medida que va circulando por los pasos 4 al 6. Cuando la variable A llega al valor 255, y entra en el paso 4, hace B=A+1. Como A vale 255, entonces el paso 4 será B=255+1=256. De nuevo 256 es 100000000, éste valor tiene 9 bits de longitud. La variable “B” tiene 16 bits de longitud, por lo tanto B toma el valor 256 sin inconvenientes. Pero, cuando pasa al paso 5, donde hace A = B, intenta hacer A=256, o expresado en binario A=100000000. Pero la variable A sólo tiene 8 bits. Puesto que está declarada como char. Entonces, sólo toma el microcontrolador los bits menos significativos. O sea, la variable A va a tomar el valor 0. Cuando vuelva a pasar por el paso 4, hará B=A+1, pero como A ahora vale 0, entonces B pasará a valer el valor 1. Resumiendo, en éste caso, A valdrá 1 en el arranque. Luego se irá incrementando hasta 255, pasará a 0 y volverá a incrementarse hasta 255. Pero, notemos que la variable B siempre toma el valor de A+1, por lo tanto tomará valores que van a ser desde 1 hasta 256.

Esto último, que parece un poco enredado y trivial, es un error muy común que suele suceder cuando tenemos programas extensos en C. Confundir dos variables de distintos tipos, puede hacer que nuestro programa no responda como lo esperamos. Otras veces, esto se hace apropósito y el C lo permite (ya lo vamos a ver más adelante como hacerlo para que sea controladamente), lo que lo hace un lenguaje muy poderoso.

Sistemas de numeración: Binario, Decimal y Hexadecimal

Antes de continuar, creo que es muy conveniente y necesario dar un repaso a lo que es el sistema binario, decimal y hexadecimal. Para aquellos que dominan el tema de cambios de base, pueden pasar al próximo capítulo. Pero sólo recomiendo que saltee éste capítulo si usted sabe de memoria el concepto de cambio de base, especialmente entre estas 3 bases. En la programación en C, y especialmente cuando se trabaja con microcontroladores, es fundamental dominar éste tema. Me resultaría imposible entender que alguien entienda y domine la programación de microcontroladores sin conocer y manejar correctamente estos cambios de base. Toda la bibliografía existente en el mercado, y todos los microcontroladores existentes se basan en tablas las cuales vienen codificadas a niveles de bits, y eso lleva indefectiblemente a una representación directa en hexadecimal o en binario. Muy raras veces nos vamos a encontrar con programas hechos para microcontroladores que se hable en decimal, tal cual lo hablamos nosotros los seres humanos. Por lo tanto, recomiendo repasar para los que ya conocen, y aprender muy bien para los demás, lo que significa el cambio de base y la forma de representar los números.

El sistema decimal

El sistema decimal es el tipo de representación de los números que utilizamos normalmente como seres humanos. En el sistema decimal tenemos 10 signos, que sirven para representar todas las combinaciones de números posibles. Los signos son 0,1,2,3,4,5,6,7,8, y 9.

Cuando decimos por ejemplo que tenemos 123 naranjas, estamos queriendo decir que tenemos 100 naranjas junto con 20 naranjas mas junto con 3 naranjas mas. O sea, si decimos que tenemos 123 naranjas, es lo mismo que decir que tenemos:

100 + 20 + 3 = 123 naranjas

Dicho en una forma normalizada, el valor 123 equivale a decir 1 centena 2 decenas y 3 unidades.

Expresado en forma matemática, lo mismo dicho anteriormente se puede representar como:

123 = 100 + 20 + 3

También se representa como

123 = 1 x 100 + 2 x 10 + 3

Entonces, cualquier número que armemos en el sistema decimal, se representa como una suma de potencias de 10. Las potencias de 10 son 1, 10, 100, 100, etc.

Una regla práctica que siempre usé y me parece muy visual, es armar los números utilizando casilleros, donde pongo casilleros con las potencias de la base que se está manejando.

Por ejemplo, en base decimal, en el casillero coloco en la fila superior las potencias de 10, ordenadas desde la derecha hacia la izquierda, comenzando con la potencia más baja (1) , y aumentando a medida que se avanza hacia la izquierda con las otras potencias 10, 100 , 1000.

Y en la fila inferior, coloco el número que quiero representar, ordenando siempre las cifras menos significativas de manera que quede colocada en el casillero que está más a la derecha.

En nuestro ejemplo, el número era 123 en base decimal.

Potencias de 10	100	10	1
Número a representar	1	2	3

Luego, para obtener el número representado en la base, multiplico columna por columna el valor del casillero superior con el valor del casillero inferior.

Potencias de 10	100	10	1
Número a representar	1	2	3
	100 x 1 = 100	10 x 2 = 20	1 x 3 = 3

Finalmente sumo los resultados de las multiplicaciones:

100 + 20 + 3 = 123

Todo esto, que parece muy trivial y que no tiene mucho sentido, si lo va a tener cuando comencemos a ver los otros sistemas de representación. Lo que intento explicitar, es como funciona la representación decimal. Vamos a ver en las otras representaciones que es exactamente lo mismo pero cambiando las potencias que se utilizan.

El sistema binario

Este sistema, es el que se utiliza en los circuitos electrónicos, ya que es una de las mejores maneras que hay para poder transmitir o almacenar información. Ya que se asigna el valor cero lógico cuando en un pedazo de pista o chip, mas bien en un cable que comunica dos partes de un circuito, se tiene que no hay tensión, o su valor está en el rango entre 0 y 0,7 volts.

Por otro lado, el valor uno lógico, se asigna cuando en ese mismo pedazo de cable, la tensión que lleva está entre los 2 y 5 volts.

De ésta manera, con ésos límites es mucho mas sencillo, electrónicamente hablando de discriminar si ese pedazo de circuito está en un valor lógico 0 o 1, ya que hay un salto relativamente importante de tensión. Así, todas las computadoras y microcontroladores, cuando almacenan información o datos en la memoria, y cuando realizan cualquier tarea, siempre trabajan a nivel de bits. Los bits sólo pueden tener dos valores: 0 o 1, y no hay otra posibilidad. Por ello, es necesario conocer el funcionamiento del sistema binario, ya que programar microcontroladores, indefectiblemente nos inducirá a pensar en algún momento en bits y por lo tanto, entender como tratarlos.

En el sistema binario se tiene una codificación, o forma de expresar los valores que es similar a la forma de representarlos que en la forma decimal. La diferencia es que sólo se poseen 2 dígitos diferentes, son el 0 y el 1. Con ceros y unos se arman todas las combinaciones de números.

¿Cómo es posible esto? Bien, veamos entonces un ejemplo práctico.

Supongamos que tenemos que contar desde 0 hasta 15 en el sistema decimal conocido por nosotros, la cuenta que hacemos normalmente es: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, ¿que pasa cuando llegamos al 9 y queremos pasar al dígito siguiente? Automáticamente incrementamos la decena y ponemos en cero la unidad, así los dígitos continúan 10, 11, 12, 13, 14, 15.

Llevando la misma forma de pensar, pero al sistema binario. Supongamos que queremos contar desde 0 hasta 7.

Comenzamos 0,

Y acá se nos acabaron los dígitos. Pero, razonando igual que para el sistema decimal, incrementamos entonces ahora un dígito a la izquierda del número. Entonces ponemos en 1 un dígito más

Y ahora, cuando queramos sumar uno a éste último valor. Pensemos que pasa cuando tenemos por ejemplo que incrementar en 1 el número 99, se incrementa la unidad, pero el incremento hace que se incremente también la decena. Entonces, al incrementar la decena, también se terminan los dígitos, por lo tanto hace que se incremente la centena.

Llevado de nuevo al caso binario, incrementamos la unidad, esto hace que tengamos que incrementar el dígito siguiente a su izquierda, que a su vez, al incrementar ése dígito se acaban los números posibles, entonces, tenemos que agregar o incrementar el dígito siguiente a su izquierda:

11 + 1 = 100

100

101

110

111

Puesto en forma de tabla, les muestro los números 0 al 16 representado en sistema binario

Decimal
0				0
1				1
2			1	0
3			1	1
4		1	0	0
5		1	0	1
6		1	1	0
7		1	1	1
8	1	0	0	0
9	1	0	0	1
10	1	0	1	0
11	1	0	1	1
12	1	1	0	0
13	1	1	0	1
14	1	1	1	0
15	1	1	1	1

Y les aconsejo encarecidamente que esa tablita anterior la tengan siempre presente. Esa tablita tiene que ser nativa y ley máxima para todo programador que se digne experto en programación de microcontroladores. Con el tiempo me van a dar la razón, se van a dar cuenta que si se dedican a esto que esa tablita la van a considerar fundamental. Sacando un poco de lado la filosofía fundamentalista de la programación de microcontroladores, volvamos a revisar la tabla anterior. Y también recordemos la tabla que les había armado para el caso del sistema decimal.

Recordemos que en el sistema decimal, 123 significaba 1 centena + 2 decenas + 3 unidades, o lo que es lo mismo 1x100 + 2x10 + 3 = 123.

Ahora veamos, que 100 = 10 x 10. Y que una unidad de mil, o sea 1000 = 10 x 10 x 10.

Si, replanteamos el tema de las unidades, decenas y centenas pero para el sistema binario. Podemos armar otra tablita como

2x2x2

2x2

O también, armar siempre desde la derecha hacia la izquierda, comenzando por el primer dígito de la derecha siempre en 1. E ir multiplicando en el dígito consecutivo a la izquierda como el doble del dígito de la derecha. De ésta forma

512

256

128

De nuevo, estos valores son fundamentales para entender el sistema binario. Esos valores mostrados son lo que se llaman potencias de 2, y equivalen a hacer 2ⁿ. O elevar el número 2 a la potencia que se desee. Esta segunda tablita es importante dominarla y conocerla de memoria.

Ahora, si tenemos un número binario cualquiera, por ejemplo: 0100100110, lo cargamos en ésta segunda tablita y obtenemos

512	256	128	64	32	16	8	4	2	1
0	1	0	0	1	0	0	1	1	0

De igual manera a lo que habíamos hecho para el sistema decimal, el número binario aquí representado, se puede obtener multiplicando el valor de cada casilla superior de cada columna, por el valor en cada casilla inferior, y luego sumar todos los valores. Ese es el valor que representa en decimal, el mismo número en binario.

Del ejemplo, el número 0100100110 según la tablita se representa como

512 x 0 + 256 x 1 + 0 x 128 + 0 x 64 + 1 x 32 + 0 x 16 + 0 x 8 + 1 x 4 + 1 x 2 + 0 x 1

O lo que es lo mismo: 256 + 32 + 4 + 2 = 294

O lo que es más fácil, sumar sólo las casillas que tienen puesto un 1 en el valor

Fíjense, ahora de nuevo en la tabla que les había dado al principio sobre los valores 0 a 15, que les recomiendo que la sepan de memoria. Como se clarifica si les completo las casillas que había dejado apropósito en blanco. Sólo sumen en forma horizontal los valores que tienen cada casilla en 1 y van a obtener los números representados.

Decimal	8	4	2	1
0				0
1				1
2			1	0
3			1	1
4		1	0	0
5		1	0	1
6		1	1	0
7		1	1	1
8	1	0	0	0
9	1	0	0	1
10	1	0	1	0
11	1	0	1	1
12	1	1	0	0
13	1	1	0	1
14	1	1	1	0
15	1	1	1	1

Por ejemplo, el número 7, se representa por 4 + 2 + 1 = 7

Además, fíjense que en ésta tablita he usado 4 bits. Y que no es posible representar mas valores. El máximo valor posible de representar en un nibble, o en 4 bits entonces es 8 + 4 + 2 + 1 =15.

Corroboremos cual es el máximo valor posible de representar en un char, o en un byte, que tiene 8 bits. La tabla con las potencias de 2 sería:

128	64	32	16	8	4	2	1
1	1	1	1	1	1	1	1

El valor máximo posible de representar en un byte, o en 8 bits es 128 + 64 + 32 + 16 + 8 + 4 + 2 + 1 que es igual a 255.

Notemos algo interesante. Un nibble o 4 bits permiten representar como número máximo al número 15. Pero, ¿cual es la potencia de 2 inmediata siguiente que corresponde al bit en la posición 5? Fíjense en la segunda tablita, que la potencia de 2 es 16. O sea, que el máximo valor del nibble es la potencia de 2 inmediata siguiente menos 1.

Lo mismo sucede con el tipo de datos char, cuando tenemos 8 bits, el máximo número que se puede representar es 255. Y la potencia de 2 que corresponde a hacer 2⁸, o el valor inmediato que se debería colocar a la izquierda de la tablita es 256. Por lo tanto el valor del numero máximo que se puede almacenar en un char es 256-1.

Fijémonos otra cosa, el valor más grande para un nibble es 15, y el valor más chico es 0. Pero entre 0 y 15 hay 16 números posibles. Por lo tanto la cantidad de combinaciones o números que se pueden representar con 4 bits, es igual a la potencia de 2. Y en éste caso es 2⁴=16. Que es también el número inmediato que se debe colocar a la izquierda de la tablita conversora.

Hago estos remarcamientos, para machacar la idea de la forma de pensar en el sistema binario. Es importante tratar de amigarse con ésta representación, tratar de entenderla, y encontrar todas éstas relaciones. Son obvias para muchos, pero al momento de aplicarlas cuando se hagan programas reales, estas “trampas” o formas de ver los números ayudan a comprender y encontrar mejores y más formas de solucionar problemas, para implementar nuestros algoritmos. Lo que he hecho miles de veces, es escribir cosas similares, en una hoja cuadriculada para así poder ver el número en binario y realizar la conversión en forma automática, les aseguro que después el programa que vayan a implementar fluye desde sus cerebros como por un tubo y sale sin más problemas.

El sistema Hexadecimal

¿Ya dominan el sistema binario?, ¿Están seguros? Les hago estas preguntas, puesto que recién ahora les conviene entrar en el sistema hexadecimal.

El sistema hexadecimal, es más usado todavía que el sistema binario. Especialmente cuando se programa con microcontroladores. En C, estimo que el 80% y tal vez más de los programas hechos para microcontroladores tienen en sus valores expresados en sistema hexadecimal.

¿Por qué es tan usado el sistema hexadecimal? Por una razón muy sencilla, convertir de hexadecimal a binario es directo, no hay que hacer mayores cálculos. Realizar pasajes de números desde el sistema hexadecimal para expresarlos en binario, también es muy simple. ¿Cual es la clave?, conocer de memoria la tablita que les pasé en el ejemplo anterior con la representación en 4 bits de los números 0 al 15.

El sistema hexadecimal está compuesto por 16 dígitos diferentes. Se utilizan los números 0,1,2,3,4,5,6,7,8,9 y para completar los 6 dígitos restantes. Se utilizan las letras A,B,C,D,E, y F.

La letra A vale 10, y la letra F vale 15. Entonces, les presento la tabla de conversión entre los sistemas decimal, hexadecimal y binario de los números 0 al 15.

Decimal	Hexa Decimal	Binario
Decimal	Hexa Decimal	8	4	2	1
0	0	0	0	0	0
1	1	0	0	0	1
2	2	0	0	1	0
3	3	0	0	1	1
4	4	0	1	0	0
5	5	0	1	0	1
6	6	0	1	1	0
7	7	0	1	1	1
8	8	1	0	0	0
9	9	1	0	0	1
10	A	1	0	1	0
11	B	1	0	1	1
12	C	1	1	0	0
13	D	1	1	0	1
14	E	1	1	1	0
15	F	1	1	1	1

Insisto, esta tablita que les estoy presentando arriba, deben aprendérsela de memoria, va a ser muy práctica cuando hagan sus programas en microcontroladores.

Ahora, la base del sistema hexadecimal, es 16. Por lo tanto, podemos volver a generar la tabla de conversión entre esta base para llevarla al sistema decimal, dicha tabla queda como sigue:

4096

256

Quiero que observen algo interesante. ¿Se acuerdan de la misma tabla para el sistema binario? La copio nuevamente aquí para el caso de un número con 16 bits:

32768

16384

8192

4096

2048

1024

512

256

128

Observemos más detenidamente que pasa cada 4 bits. Recordemos que 4 bits en el sistema binario representan números del 0 al 15. Que casualmente, en el sistema hexadecimal también utilizamos 16 dígitos, del 0 al 9, y de la A a la F.

Pongo juntas, las dos tablas, la del sistema hexadecimal con la del sistema binario

4096				256				16					1
32768	16384	8192	4096	2048	1024	512	256		128	64	32	16	8	4	2	1

¿Notan las coincidencias? El bit para el sistema binario, que están en la posición 5 desde la izquierda a la derecha, está apuntando al mismo valor en las potencias que el caso del mismo dígito en hexadecimal. Lo mismo sucede con el bit en la posición 9 y el bit en la posición 13.

Con ésto quiero hacerles notar, que si tienen un número cualquiera en binario, y lo agrupan en nibbles, o lo agrupan de a 4 bits. Pueden buscar en la tabla de conversión hexadecimal a binario y representar el mismo número en forma directa.

Por ejemplo, el número 011101100100011111 en binario, le hacemos la conversión directa al sistema hexadecimal de la siguiente manera.

Primero, reescribimos el mismo número, pero agrupándolo de a 4 bits. Comenzamos la agrupación, siempre desde derecha hacia izquierda (no olvidar nunca esto).

Entonces, el mismo número queda:

1101

1001

0001

1111

Ahora, buscamos en la tablita de conversión que les pasé, y ponemos los valores equivalentes en hexadecimal:

01	1101	1001	0001	1111
1	D	9	1	F

Y listo, el número que antes estaba expresado en binario como 011101100100011111, queda expresado en hexadecimal como 1D91F. Se ve que la conversión en muy sencilla.

La sintaxis para indicar que un número está escrito en hexadecimal, es anteponer al número un cero seguido por una equis y después el valor en hexadecimal (0xnnnn). Esta es la forma que tiene definido el estandard de C para declarar números en base hexadecimal. Los siguientes son números expresados en hexadecimal siguiendo la codificación del lenguaje C. A partir de ahora, voy a comenzar a indicar los números de ésta manera cuando estén escritos en hexadecimal:

0x00 -> Significa el valor 0 expresado en hexadecimal

0x12 -> Significa el valor 18 expresado en hexadecimal

0xFF -> Significa el valor 255 expresado en hexadecimal

Veamos que la conversión inversa, desde hexadecimal a binario también es directa. Por ejemplo, si tenemos el valor 0xC5 para pasarlo a binario, de nuevo recurrimos a la tablita de conversión:

C	5
1100	0101

El valor en binario 0xC5 será 11000101

Para realizar la conversión de hexadecimal a decimal, hay que usar la tabla con las potencias de 16. Por ejemplo, para pasar el número 0x3D2 a decimal se debe hacer

256	16	1
3	D	2

Entonces el valor convertido a decimal, será:

256 x 3 + 16 x D + 1 x 2

Pero, ¿cómo se multiplica 16 x D? Acá lo puse así para que caigan en una pequeña trampa. En realidad el valor D significa 13 en decimal, por lo tanto lo que debimos haber puesto en la tabla es:

256	16	1
3	D en hexadecimal es 13 en decimal	2

Entonces, el valor convertido a decimal es 256 x 3 + 16 x 13 + 1 x 2 = 978

¿Se nota que es mucho más difícil convertir de decimal a hexadecimal, o de decimal a binario que convertir entre binario y hexadecimal? Es por ello, que el sistema hexadecimal es muy utilizado en los programas en C y en la programación de microcontroladores. Ya lo vamos a ver más adelante, pero les cuento que todos los microcontroladores poseen registros que tienen un montón de bits, y cada bit tiene un significado especial. Entonces, en las hojas de datos vienen indicados los significados de éstos registros, pero expresados en forma de byte y dentro de ese byte, indicando que significa cada bit. Es mucho más fácil pensar directamente con números en binario o hexadecimales para poner en cero o uno cada bit en forma individual, que intentar pensar en decimal para ver como hacer para poner en cero o uno el mismo bit.

Por ejemplo, supongamos que tenemos una variable “A” del tipo char. Es decir, es una variable de 8 bits.

Supongamos que por la razón que sea, necesitamos poner en 1 el bit 4 de ésta variable. Y todos los demás bits en 0. Entonces, veamos la variable “A” en forma de tabla.

7	6	5	4	3	2	1	0
128	64	32	16	8	4	2	1
0	0	0	1	0	0	0	0

En la fila de arriba, coloqué los números de bit. Por convención, siempre los números de bits en cualquier campo, ya sea un byte, word, nibble, etcétera, se comienza numerando desde la derecha hacia la izquierda, y se comienza con el valor 0. Esto tiene una justificación muy simple, y es que corresponde con las potencias de la base. No importa si no conoce nada de potencias, les cuento que 2⁰=1, luego 2¹=2, 2²=4 y así sucesivamente. Estas potencias están escritas en la segunda fila de la tabla. En la tercer fila, coloqué en cero todos los bits que no quiero encender, y en 1 el bit 4.

Volviendo al ejemplo, nos solicitaron que coloquemos sólo el bit 4 de la variable “A” en el valor 1.

Podemos resolverlo en forma decimal, para ello, tenemos que ver cual es el valor de la potencia que corresponde al bit 4. En nuestro caso es 16. El programa resuelto en forma “decimal” queda:

char A;

A=16;

Esto que les acabo de pasar, de nuevo ya es código C puro. Notemos que todas las instrucciones finalizan SIEMPRE con un punto y coma. Es cosa de la sintaxis en C.

Volvamos al ejemplo, veamos que para colocar el bit 4 en 1, tuvimos que pensar o hacer la tablita de conversión, para encontrar cual es el valor de la potencia de 2⁴ que hacer que en binario la variable resultante quede con el bit 4 en 1.

Supongamos que hubiéramos pedido encender simultáneamente el bit 4 y el bit 3. Ya se complica, volvemos a poner la misma tabla, pero con 2 bits encendidos:

7	6	5	4	3	2	1	0
128	64	32	16	8	4	2	1
0	0	0	1	1	0	0	0

Entonces, el valor a cargar en la variable A, será 16 + 8 = 24. Quedando nuestro programa así:

char A;

A=24;

Ahora volvamos a resolver el mismo problema, pero pensando sólo en hexadecimal. Vamos a ver que es mucho más sencillo.

Para el primer caso, que necesitábamos colocar sólo el bit 4 en 1. La tablita ahora sería sólo:

7	6	5	4	3	2	1	0
0	0	0	1	0	0	0	0

Si reagrupo el valor en binario, de a 4 bits. El valor en binario agrupado queda como 0001 0000.

Si busco en la tablita de conversión entre binario y hexadecimal, tengo un 0x1 para la primera agrupación y un 0x0 para la segunda. Entonces el valor en hexadecimal es 0x10.

Para el caso que necesitábamos encender o poner en 1 los bits 4 y 3 la tabla queda:

7	6	5	4	3	2	1	0
0	0	0	1	1	0	0	0

Que reagrupados de a 4 bits el número en binario es: 0001 1000. Busco nuevamente en la tablita de conversión entre hexadecimal a binario (ya a ésta altura tienen que saberla de memoria) y tenemos que el número en hexadecimal es 0x18

Entonces, el primer programita, que encendía sólo el bit 4 de la variable A quedaba:

char A;

A=0x10;

Y el segundo programita, que enciende los bits 3 y 4 es como el siguiente:

char A;

A=0x18;

Si ahora hacemos el pasaje inverso, es decir, tenemos el programa y no sabemos que es lo que hace, podemos hacer la conversión directa desde el hexadecimal al binario de los valores que se cargan en la variable A.

Para el primer caso, convertimos el valor 0x10 a binario. Para ello, buscamos primero la conversión directa entre el valor 1 en hexadecimal a binario. De la tablita, sacamos que 0x1 es 0001. Luego, convertimos 0 en hexadecimal a binario. De la tablita sacamos que 0x0 es 0000. Agrupamos los dos resultados y obtenemos 00010000. Podemos observar que lo que se hace con éste programa es encender el bit 4 de la variable A.

Si realizamos lo mismo con el segundo caso, tenemos que convertir 0x18 a binario. Primero buscamos el valor 1 en hexadecimal, y encontramos que es 0001 en binario. Luego buscamos el valor 8 en hexadecimal y es 1000 representado en binario. Finalmente el número en binario son los dos resultados agrupados: 00011000. Y vemos que el segundo código de programa, está encendiendo los bits 3 y 4 de la variable A.

Cuando tomemos experiencia con éstas conversiones, vamos a encontrar la facilidad que significa trabajar de ésta manera. Incluso entender programas implementados por otras personas, son más sencillos de interpretar cuando están codificados con números hexadecimales que cuando los programadores han realizado operaciones con bits y/o lógicas usando números en notaciones decimales.

La notación decimal es útil cuando los resultados esperados deben ser mostrados ante seres humanos. Tal es el caso cuando las variables que se deben utilizar en un programa a su salida generan algún tipo de reporte, como puede ser una pantalla o display. O cuando se trata de conversiones de valores por ejemplo de algún tipo de sensor, que hay que aplicar matemática común. En ésos casos, sin dudas que la notación decimal es mucho más conveniente.

También es más conveniente la notación decimal cuando nos referimos a cosas lineales, por ejemplo, si tenemos que hacer un retardo o demora en nuestro programa de 1000 milisegundos, es mucho más sencillo llamar a una función retardo(1000) que indicarlo como retardo(0x3E8). 0x3E8 es el número 1000 en hexadecimal.

Sin embargo, cuando se trata de bits, la notación hexadecimal se vuelve más práctica. En todo caso, la opción existe, y queda a criterio del programador cual notación utilizar.

Capitulo I. Introducción a los microcontroladores

2011-03-02T00:00:00.036-03:00

CAPITULO I

Introducción a los microcontroladores

Y bueno aquí largamos. Una persona que recién se inicia en la electrónica y tiene muchas ganas de conocer nuevas cosas, normalmente tiene preguntas como: ¿que es un micro controlador? ¿Como funciona? ¿Para que sirve un microcontrolador? ¿Cuando debería utilizar un micro controlador y cuando nó? ¿Porqué se han hecho tan “famosos” en los electrónicos los microcontroladores? ¿Que tiene de mejor un micro controlador que no pueda ser hecho con una computadora?

Seguramente, éstas preguntas son básicas y conocen su respuesta los electrónicos con cierta experiencia, así que supongo ésta primera parte les podrá resultar un poco aburrida. Sin embargo, siempre es bueno volver a las bases, y por ahí encuentran algo que a lo mejor lo veían desde otro punto de vista y descubren algo nuevo. Para los principiantes, la respuesta a estas preguntas pueden orientarlo un poco hacia donde apuntan éstas lecciones.

Así que comencemos. La primera pregunta:

¿Qué es un micro controlador?

Visto en forma externa, un micro controlador es un circuito integrado, para los que conocen algo de electrónica, visto desde afuera, no van a encontrar nada diferente a un chip de lógica como puede ser el viejo CD4001 (chip de lógica), el cual posee 4 compuertas NOR.

El chip que se ve en la figura anterior, es uno de los circuitos integrados más sencillos que se conocen. En esta “arañita” se tienen 4 compuertas lógicas.

Si vemos fotos de micro controladores de la firma microchip, notaremos que el aspecto exterior es muy similar:

Se ven que son muy parecidos ¿no es así?

Sin embargo, internamente son muy diferentes. En el caso de la segunda foto, coloqué uno de los microcontroladores más populares, el PIC16F84 de la firma Microchip.

Para lo más viejos, que nacieron en los principios de los ‘70 (como yo) Este micro controlador es igual o más poderoso que las primeras computadoras que llegué a tocar cuando tenía 10-12 años.

En ésa época, en mi país, estaban ingresando las primeras computadoras personales. Tuve la suerte de tener mi propia CZerweny CZ1000. Todo un lujo. Era una microcomputadora que poseía un microprocesador Z80 de 1Mhz, con ¡asombrosos 2K de memoria! Como mi curiosidad era más fuerte, por supuesto que la desarmé para “espiar” como era por dentro. Tenía cerca de 20 circuitos integrados, similares a los de la foto, incluso más grandes. Había un circuito integrado que era el procesador Z80. Otro integrado encargado de administrar los periféricos (teclado y pantalla), otro integrado era la memoria ROM donde estaba guardado el sistema de la computadora, y un montón de integrados adicionales que cumplían la función de ser la memoria RAM. Cuando quería cargar algún programa para usar, tenía que utilizar los viejos casetes que demoraban varios minutos en cargar.

Ese sólo integrado mostrado en la foto, el microchip PIC16F84, que es uno viejito pero popular ya posee 1K de memoria de programa, 68 bytes de memoria RAM, 64 bytes de memoria EEPROM (para escribir configuraciones) y una velocidad de procesamiento que puede llegar a los 20Mhz (ya vamos a ver más adelante que en realidad significan 5 millones de instrucciones por segundo). Sacando que posee menos memoria RAM, respecto a lo que era la CZ1000 de aquella época, se pueden hacer más cosas con este integradito sencillo que lo que se podía hacer con la CZ1000.

Dejando la nostalgia afuera. Diré que un micro controlador, es como una pequeña computadora toda completita metida dentro de un sólo integrado. Este increíble invento, puede hacer que en muy pequeño espacio solucionemos problemas electrónicos que para resolverlos sólo con circuitos ocuparían mucho lugar o muchos componentes. Con los microcontroladores, se pueden hacer que tus placas o productos tengan su propia “inteligencia”, y que respondan a programas o softwares de la misma manera que funcionan los mejores equipos, o sistemas de computación. Salvando las distancias en las capacidades que permiten una PC o un servidor, un micro controlador puede hacer muchísimas tareas y acciones. Incluso hay cosas que un micro controlador puede ejecutar sin ningún problema, mientras que querer hacer lo mismo con una PC puede ser una tarea muy complicada o incluso imposible.

A lo mejor lo más interesante de los microcontroladores, a diferencia de los microprocesadores es que en general, la mayoría (incluso en algunos modelos) todas sus patas o pines pueden ser utilizadas como señales. Esto es, el micro controlador actúa siempre como una “caja negra”, donde según que señales, y en que tiempos aparecen en alguna de sus patas, entonces pondrá otras señales en otras de sus patas. Las acciones y condiciones de que es lo que tiene que aplicar en los diferentes pines lo hace el programa que lleva internamente.

El micro controlador que les mostré en la foto anterior, correspondía al PIC16F84 que como les decía es uno de los más viejitos. Simplemente posee esas características que les mencionaba. Y los pines sólo pueden ser utilizados de la manera descripta, como entradas y/o salidas de señales digitales. Esto es, sólo acepta en cada uno de sus pines una señal que puede ser considerada como un 1 o un 0 lógico. Entendiendo (para el caso de ese integrado), que un cero lógico es cuando en una de sus patas hay una tensión menor que 0,7V. Mientras que un uno lógico es cuando hay en la misma una señal mayor que 2V.

En el dibujo anterior, se muestra el diagrama en bloques de lo que hay internamente en el microcontrolador PIC16F84. Se puede observar que es toda una micro computadora, donde se posee la memoria de programa, una memoria de RAM (de registros), y se puede observar los pines de entradas y salidas RA3:RA0, RB7:RB1, RB0.

Ya con las tecnologías más modernas de microcontroladores, se tienen modelos que poseen más funciones. Mayor capacidad de memoria, mayores velocidades de procesamiento y algo muy interesante: más y nuevos periféricos.

En los modelos más nuevos de micro controladores, empiezan a aparecer periféricos tales como conversores ADC, generadores de PWM, circuitos de comunicación seriales UART, USB, comunicación Ethernet. Hay una línea de micro controladores que poseen un generador de señales de RF, haciendo que directamente transmitan por radio frecuencia señales sin el agregado de hardware demasiado complicado.

Estas últimas funciones hacen mucho más poderoso a un micro controlador, ya que muchas cosas son resueltas directamente por el mismo chip, sin necesidad que el programa que hayamos grabado dentro del chip tenga que estar ejecutando las acciones o pasos, y gastando recursos del mismo para poder dar servicio a dichas funciones.

Por ejemplo, un hermano mayor del PIC16F84 es el PIC16F627. El cual posee mas o menos la misma capacidad de memoria que el PIC16F84, pero trae incorporados un comparador para señales analógicas, la comunicación serial USART, y la posibilidad de generar señales PWM y/o capturar y medir tiempos en señales con un hardware dedicado a ello, todo ésto dentro del mismo chip:

En el caso de las tecnologías de micro controladores de Texas. Está la línea MSP430, de los cuales el más modesto de ellos, trae similar tamaño de memoria que el PIC16F627. Con casi los mismos periféricos, pero con algunas ventajas importantes: El procesamiento de los datos es en 16 bits mientras que en los PIC de la línea 16 son en 8 bits. Y la velocidad de procesamiento, en los PIC16 la máxima velocidad es de 5 millones de instrucciones por segundo, en la línea más modesta de Texas son 8 millones de instrucciones por segundo.

Sin intención de crear una discusión, sobre que marca es mejor, si Microchip, Texas o cualquier otra. A medida que avancemos vamos a ir viendo las ventajas y desventajas (que las hay) de usar una marca u otra. Según cual sea la aplicación será que hay que observar y elegir cual modelo y marca de micro controlador se adapta a las necesidades. Si se va a consultar al fabricante, seguro que ellos tienen muchas mas razones para decir que ellos son los mejores. Hay que aprender a observar las características de uno u otro y luego decidir.

De las líneas más nuevas de micro controladores de Microchip, hay algunos que traen mucha mayor cantidad de memoria, con capacidades mayores que 128K de EEPROM y mayores que 32K de RAM, con velocidades de procesamiento que llegan a los 40 millones de instrucciones por segundo.

En el caso de Texas, tienen micro controladores aún más grandes, en el orden de los 512K de memoria EEPROM y más de 64K de RAM. Y velocidades de procesamiento en el orden de los 150 millones de instrucciones por segundo, estoy hablando de la línea TMS320F28xx con palabras de 32 bits. Unas verdaderas bestias peludas para resolver muchísimas aplicaciones de equipos embebidos.

Otras tecnologías, son los microcontroladores ARM que hay de muchísimos fabricantes. Estos arrancan en los 50 millones de instrucciones por segundo para arriba. Trabajan en 16 y 32 bits, y las capacidades de memoria (dentro del mismo chip) son aún mayores.

Lo que cambia, y que es un problema para muchos hobbistas y principiantes. Es que a medida que aumenta la tecnología, aumenta la cantidad de periféricos, tareas y señales simultáneas que puede manejar el nuevo micro controlador. Esto trae inmediatamente asociado, mayor cantidad de pines o patas. Entonces, cambian los tipos de encapsulados, y para muchos se le complica o se le hace imposible soldarlos.

Y ni que hablar de un micro controlador con encapsulado BGA o similares.

A no asustarse, todavía hay muchas opciones válidas para los principiantes y hobbistas con micro controladores respetables con encapsulados “soldables” fácil a mano como son los DIPs. Incluso, si tienen que usar un encapsulado del tipo TQFP o BGA existen empresas que se dedican a soldarlos. Por lo tanto, si cuando tienen que elegir un micro controlador se topan con el karma del encapsulado, que eso no sea un impedimento. Hay opciones y formas de hacerlo.

Bueno, hasta ahora les he contado un poco de historia y dado algunos pantallazos sobre el aspecto externo de los microcontroladores. También les mostré un poco que es lo que hay dentro de algunos modelos. Viene a consecuencia de ésto la otra pregunta:

¿Cómo funciona un micro controlador?

Como les conté anteriormente, un micro controlador es como una pequeña computadora metida toda dentro de un sólo circuito integrado o micro chip. Esta pequeña computadora está diseñada para poder dar solución a pequeños equipos que requieren algo más que un hardware sencillo para funcionar o dar solución al objetivo para el que fue diseñado.

Un microcontrolador es como un empleado en una cocina dedicado y minucioso que cumple a raja tabla las recetas de cocina que le pasan para que les prepare a sus jefes. Cuando le solicitan que cocine algún plato en particular, éste tiene una receta escrita de ése plato y respeta al pie de la letra las órdenes que les dan. A un microcontrolador se le pasan las recetas y éste las cumple al pie de la letra. A diferencia de un ser humano (que puede ser el cocinero), el microcontrolador hará exactamente lo que tiene escrito que debe realizar. Si le falta algún dato en la receta, o si el microcontrolador debe elegir entre una opción u otra, éste no posee la capacidad de resolver ningún problema, excepto lo que le dice exactamente la receta. Esa receta, es el programa. Entonces, un microcontrolador es un equipo o hardware que sabe leer el programa (la receta) y cumple paso a paso lo que tiene escrito.

Como seres humanos que somos, si por ejemplo nuestra madre nos ordena limpiar el cuarto, seguramente, si es un día que está de buen humor, nos diría: Por favor, necesito que vayas a limpiar el cuarto. O también: ¡Ve inmediatamente al limpiar el cuarto! O puede haber otra forma de indicar la orden. Pero, finalmente sabríamos que hacer para limpiarlo.

En cambio, si nosotros fuésemos microcontroladores, lo primero que sucedería es que sólo reconoceríamos una forma de decir la orden. Podría ser por ejemplo Ve a limpiar el cuarto. Sin embargo, si ésa fuera la orden, no entenderíamos si nos pidieran la tarea como “Ve inmediatamente a limpiar el cuarto”. Si suponemos que somos sólo un microcontrolador, esa orden escrita ligeramente diferente no la entenderíamos. Esto que parece trivial, es algo que en los microcontroladores y en la programación se llama sintaxis. Hay una forma exacta de escribir las órdenes.

Por otro lado, deberíamos tener por escrito, exactamente cuales son los pasos que debemos dar para poder realizar la tarea de limpiar el cuarto. Dichas órdenes podrían ser:

1 - Ir al armario donde se guardan los elementos de limpieza

2 - Abrir el armario

3 - Tomar la escoba

4 - Cerrar el armario

5 - Ir al cuarto

6 - Barrer

7 - Buscar la pala para recoger la basura

8 - Recoger la basura

9 - Guardar la escoba

10 - Guardar la pala

11 - Llevar la basura al basurero

Como se ve, un microcontrolador parece que necesita órdenes “tontas” que para un ser humano son obvias (obviamente hay que abrir el armario para sacar la escoba). Sin embargo, el microcontrolador va a llegar al armario y si no le decimos que abra la puerta va a querer tomar la escoba con el armario cerrado.

Así, si se ponen a analizar más detenidamente, hay que explicar en detalle como hacer cada paso. Por ejemplo como hacer para ir hasta el armario, que camino hay que seguir. Luego, como hacer para abrirlo. Por ejemplo: Tomar el picaporte, girarlo lentamente unos 45° en sentido antihorario, tirar hacia atrás la puerta unos centímetros... Etcétera. Y lo mismo para todo el resto de las órdenes.

Si bien, a lo mejor me estoy adelantando un poco ya en la parte de programación, podemos observar que una tarea que para un ser humano es trivial y sencilla. Querer decirle todo eso a un microcontrolador como se ve, puede ser un programa de miles o millones de órdenes consecutivas. Imagínense todas las otras tareas como caminar (mover las piernas, esquivar obstáculos, etcétera), y barrer (mover las manos).

Volviendo al mundo de los microcontroladores, la receta o listado de pasos es lo que está almacenado o escrito en la memoria ROM. Para el caso de la mayoría de los microcontroladores, dicha memoria está fabricada y se muestra como memoria EEPROM o memoria Flash.

ROM significa Read Only Memory, o memoria de sólo escritura. Hay microcontroladores en los cuales se les graba o escribe por única vez el listado de tareas o programa. Entonces, el microcontrolador posee esa única tarea y durante toda su vida útil será lo único que hará: lo que está escrito en la memoria ROM.

EEPROM y Flash son también memorias de sólo lectura. EEPROM significa Electrical Erasable Programmable Read Only Memory, o memoria de sólo lectura borrable para programación en forma eléctrica. Flash es una memoria similar a la EEPROM. En ésta memoria se escribe el programa que tiene que ejecutar el microcontrolador. La ventaja de los microcontroladores con éste tipo de memoria, es que puede borrarse y volverse a escribir nuevamente (dentro de ciertos límites) con otro programa. Esto es muy útil ya que nos permite cambiar la receta de ser necesario. La diferencia entre flash y EEPROM es de tecnología. Lo que cambia es la forma de grabarlos, cambian los niveles eléctricos de tensión, y la cantidad de veces que se pueden reescribir. En las hojas de datos de cada microcontrolador, indica hasta cuantas veces se puede borrar y grabar un nuevo programa en ellos. Las cantidades normales van desde los 10000 hasta 1 millón de veces según cual sea la tecnología de memoria utilizada.

El microcontrolador entonces, cuando se lo enciende comienza a leer el contenido del programa que está escrito en la memoria flash o EEPROM, que a partir de ahora la llamaré memoria de programa.

Tal cual la receta que vimos para limpiar el cuarto, en la memoria de programa los pasos están numerados. Por lo general, se comienza con el paso número cero y se va avanzando de un paso por vez. Es como leer un libro de “elige tu propia aventura”, uno comienza leyendo por la primera página y va avanzando, por ahí, en el libro se nos indica que si elegimos un camino u otro cambiar a una pagina u otra. En el programa también hay saltos y cambios de números de página.

En la memoria de programa, lo que era el número de paso es la dirección de memoria. Según el tamaño de la memoria que posea el microcontrolador y el largo de palabra será la cantidad máxima de instrucciones que podemos colocar dentro de ésta.

Por ejemplo, si se tiene una memoria de programa de 1Kbyte y el microcontrolador utilizado es de 8 bits por instrucción, entonces la cantidad de pasos en el programa o instrucciones puede llegar a 1K o 1024 instrucciones máximas (1Kbyte es igual a 1024 bytes). Si nuestro microcontrolador utiliza instrucciones de 16 bits (como es el caso de los Texas MSP430xxx) y la memoria de programa es de 1Kbyte entonces la cantidad máxima de instrucciones posibles en nuestro microcontrolador será de 512 instrucciones ya que cada instrucción ocupará 2 bytes.

Un breve repaso antes de seguir:

Bits, Nibbles, Bytes, Words, Kbytes, Mbytes, GBytes

Bit es la unidad mínima o más chica que entiende un microcontrolador. Es la base de funcionamiento de todos los circuitos lógicos. Un bit es un valor que puede ser un 1 o un 0. Donde un 1 para los microcontroladores que trabajan en 5V significa que hay un cablecito que en un momento está teniendo 5V en éste. Para los microcontroladores de 3,3v ése cablecito tendrá 3,3v. El 0 de la misma manera, es que en ése cablecito hay 0v.

Ahora ¿que sucede si queremos sumar dos bits? Por ejemplo, si se quiere hacer 1 + 1 = 2 ¿cómo se hace si sólo tenemos 0 y 1? Aquí es donde aparece el sistema de numeración binario. Para ello es que se agregan más cablecitos, en el caso particular de 1 + 1 = 2, representado en sistema binario la respuesta es 1 + 1 = 10 y se ocupan 2 bits.

Por las cosas del destino, las personas que diseñaron las primeras computadoras eligieron agrupar los bits en grupos de 8. En realidad ésto tiene una explicación cuando les cuente más adelante sobre los sistemas binarios, decimal y hexadecimal. Pero por ahora, digamos que si tenemos 8 bits todos éstos forman el byte.

Byte: Son 8 bits agrupados, cada bit puede tener su valor 0 o 1. Sin embargo, en sistema binario, agrupar 8 bits nos da la posibilidad de tener 256 combinaciones de 1s y 0s. Entonces, podemos tener 256 datos diferentes en un byte. Que ocupan sólo 8 bits. Además, si adoptamos que la mitad de los valores sean positivos y la otra mitad negativos, podemos tomar que un byte puede valer desde -127 hasta +128. Esto ya lo vamos a ver más adelante en el significado de un byte con o sin signo. Por ahora entendamos que un byte en un grupo de 8 bits que puede tomar un valor entre 0 y 255 o -127 hasta 128. Entendamos también que pueden significar 256 diferentes tipos de órdenes. Entonces, en la memoria EEPROM podemos escribir 256 diferentes órdenes que tienen 256 diferentes significados.

Nibble: Es la mitad de un byte. Lo pongo en segundo orden después del byte porque en realidad el byte es el significado más usado, pero cuando avancemos en la programación en C vamos a ver que los nibbles van a cobrar un poco más de importancia. Por ahora digamos que en un byte entran 2 nibbles. Un nibble es la agrupación de 4 bits, y pueden tomar valores que van desde 0 hasta 15. Esto es en cada nibble hay 16 combinaciones de valores posibles. Ya les puedo ir adelantando lo siguiente: Si juntamos 2 nibbles entonces se formará un byte 4 bits + 4 bits = 8 bits. Que por otro lado: 16 combinaciones (nibble) x 16 combinaciones (nibble) = 256 combinaciones (byte)

Word: Word en inglés significa “palabra”. En programación llamamos palabra a la agrupación de 16 bits. Un word o palabra tiene la posibilidad de generar 65536 combinaciones. O sea, si unimos 2 bytes para formar un word: 8 bits + 8 bits = 16 bits, que es lo mismo 256 combinaciones (byte) x 256 combinaciones (byte) = 65536 combinaciones (word). Además, también podemos adoptar que la mitad de la palabra signifique valores positivos y la otra mitad valores negativos. Así, en un word podemos almacenar desde -32768 valores hasta +32767. Ya estamos viendo algunas de las ventajas entre utilizar un microcontrolador de 16 bits contra otro de 8 bits. Lo que aparece inmediatamente es que si tenemos un micro de sólo 8 bits podemos tener 256 diferentes tipos de órdenes, mientras en uno de 16 bits nos permite con sólo la lectura de un word muchísimas mayor cantidad de combinaciones.

Kilobyte, o Kbyte: Es la agrupación de 1024 bytes. ¿Por qué el numero caprichoso 1024 y no 1000? Bueno, esto viene por la historia de los microcontroladores y microprocesadores. Resulta que al ser circuitos electrónicos que viven en un mundo binario, 1024 es potencia de 2, o sea es un 2 elevado a la 10. La representación en base binaria de 1024 es: 100000000. Para alguien que piensa en binario 1024 es un número redondo. En cambio si fuera sólo 1000 el valor en binario se representa como 1111101000 ¿mucho más difícil visto así, o no? Recordemos entonces 1 Kilobyte son 1024 bytes.

MegaByte: Un megabyte es la agrupación de 1024 kilobytes. Esto es 1MegaByte = 1024 x 1024 bytes o sea, un megabyte son 1048576 bytes.

Gigabyte: Es la agrupación de 1024 Megabytes. Esto es 1 GByte = 1024 x 1048576 bytes = 1073741824

Estas son las definiciones de Kilobyte, Megabyte y Gigabyte aceptadas. Aunque hay algunos programas que ya toman a 1 Megabyte como 1000 kbytes y 1 Gbyte como 1000 Megabytes. Pero, en el mundo de los microcontroladores, les recomiendo tomarlos como potencias de 2, esto es 1024 y 1024 respectivamente. Más adelante, cuando le tomen la mano a la programación y a los sistemas binarios y hexadecimales van a verlo con mucho más cariño al número 1024 y todas las potencias de 2, ya que van a ver que es mucho más sencillo de pensarlo de ésa manera a la hora de la programación.

Volviendo al funcionamiento de los microcontroladores. Habíamos dicho que el microcontrolador era algo que leía las instrucciones guardadas en la memoria de programa. A esas instrucciones, el microcontrolador las respeta exactamente como están guardadas en el programa. Ahora bien, ¿de que sirve tener sólo una receta para hacer algún plato o comida si no se tienen utensillos, las ollas, la cocina y los ingredientes? Se necesita entonces de otras cosas adicionales. En el microcontrolador existe otra memoria, es la memoria RAM.

RAM significa: Random Access Memoria, que traducida significa memoria de acceso aleatorio. No dice mucho. Pero, significa que es una memoria a la cual se puede leer y escribir cuantas veces uno quiera. La diferencia más importante es que esta memoria puede ser escrita y leída infinitas veces. No tiene un límite de escrituras y no necesita un proceso de grabación especial como sí lo poseen las memorias EEPROM y flash. Esta memoria es la que utilizan los microcontroladores para almacenar o memorizar valores que se van produciendo durante la ejecución del programa. La memoria RAM es como un cuaderno borrador en el cual podemos ir escribiendo anotaciones a medida que vamos realizando la receta. Volviendo al ejemplo de limpiar el cuarto, el microcontrolador sería como alguien que posee nula memoria temporal. Esto es, cuando hace algo, no recuerda lo que pasó en el momento exactamente anterior. La memoria RAM viene a auxiliar éste problema ya que por ejemplo podría ser cuando tomamos la escoba, anotamos en el cuaderno: “tomé la escoba”, y además, muy importante: “acabo de hacer el paso nro 3”. Entonces, un segundo más tarde el microcontrolador se pregunta: ¿que acabo de hacer? Lee entonces el cuaderno y le dice: “ya tomaste la escoba e hiciste el paso 3”. Entonces, sabe que tiene que hacer el paso 4 y así sucesivamente. Otro de los usos de ése cuaderno (la memoria RAM) es por ejemplo para resolver problemas. Supongamos que una de las órdenes es calcular el resultado de una suma, por ejemplo 2 + 3. El microcontrolador hace el cálculo en su “cerebro” o CPU y coloca el escribe en la memoria RAM. ¿Y si después tiene que hacer algo más con el resultado de esa suma? Por ejemplo, podría decírsele al microcontrolador que al resultado de la suma le haga otro cálculo, o que lo incremente. Entonces, el microcontrolador, necesita de algún lugar donde poder leer y escribir valores que se van produciendo mientras va haciendo o ejecutando los pasos descriptos en su programa. Esta memoria es la memoria RAM o memoria de lectura y escritura.

En base a lo que se mencionó antes, se puede observar que hay algunas cosas que son necesarias para poder realizar las órdenes que están escritas en la memoria del programa. Una de las cosas que se necesitan, es por ejemplo saber cual es el número de paso que se tiene que ejecutar. Esto en la mayoría de los microcontroladores es lo que se llama Program Counter. El program counter o contador del programa, en un valor que se guarda en la memoria RAM, en un casillero o dirección específico y dedicado para ello. El microcontrolador sabe que el paso que tiene que ejecutar cada vez, es el que está indicado por éste valor de memoria. Cuando ejecuta una orden o instrucción, inmediatamente suma uno a éste valor. Así, cuando se enciende el microcontrolador el program counter se coloca con el valor 0. Entonces, el microcontrolador leerá de la memoria de programa la instrucción que está almacenada en la posición de memoria cero, la ejecuta y si la instrucción guardada en ésa dirección de memoria no dice otra cosa, inmediatamente después, el microcontrolador hará que el valor almacenado en la memoria RAM como program counter valga 1. Después ejecuta la instrucción en la posición 1 y lo vuelve a incrementar a la siguiente, y así sucesivamente con el resto de las instrucciones.

Otra de las cosas que se observó en los ejemplos simples que les conté anteriormente, es que es necesario disponer de algo en el microcontrolador que pueda realizar operaciones matemáticas como sumar, restar, y otras. Esto es lo que se conoce como ALU, en inglés Arithmetic Logical Unit, o unidad lógica aritmética. Es la encargada de ejecutar cuando llega una orden como por ejemplo sumar dos valores, de encontrar el resultado.

A su vez, al resultado de una operación matemática, hay que almacenarlo en alguna otra posición o lugar en la memoria RAM. Esta posición en los microcontroladores tiene también un nombre especial: El registro acumulador. No es más que una posición dentro de la memoria RAM donde se almacena el resultado de otras operaciones, como puede ser el resultado de una suma. En general en el acumulador se almacenan los resultados de la mayoría de las operaciones.

Existen otros módulos dentro del microcontrolador que son necesarios para su funcionamiento. Uno de ellos es lo que se llama el registro de Stack, o Stack pointer, o puntero de la pila en español. Es otra dirección dentro de la memoria RAM donde se guardan valores en forma temporal, esos valores temporales que una vez que cumplieron su función pueden ser descartados. La pila o stack, es como una pila de papeles donde vamos tirando cosas, una encima de otra. Esos papeles son direcciones de memoria RAM, luego vamos descargando dicha pila, sacando los papeles que están más arriba, vemos que había escrito, tomamos esa información los hacemos un bollito y los tiramos a la basura, o sea los descartamos. En la pila o stack, se puede guardar información importante, por ejemplo, antes de ir a hacer alguna tarea anotamos en un papel cosas que no queremos olvidarnos cuando regresemos de hacer dicha tarea. Por ejemplo, estamos limpiando el cuarto y de repente llega un amigo y nos invita a jugar a la pelota. Como somos un microcontrolador dedicado y ordenado. Anotamos en un papel que se va a guardar en el stack, en que número de paso estábamos antes de salir a jugar, también anotamos por ejemplo hasta donde habíamos llegado barriendo el cuarto, para que cuando volvamos retomemos exactamente en el mismo lugar. Colocamos entonces ese papel en la pila, y salimos a jugar. Un par de horas mas tarde, ya no nos acordamos nada de que era lo que estábamos haciendo antes de salir. Pero, por suerte está la pila con el papel que nos recuerda el punto y podemos retomarlo. Esto en programación, salir a jugar a la pelota, se interpreta como un llamado a una rutina de interrupción (algo nos interrumpió en la tarea principal). Entonces, necesitamos poder almacenar en algún lugar todo lo necesario para que cuando volvamos de la interrupción al punto donde habíamos quedado. El Stack tiene otros usos en programación, y de hecho es fundamental cuando se hacen programas en C. Ya vamos a ver que hay una diferencia importante entre los microcontroladores PIC y los Texas que hacen que uno respecto al otro sean más eficientes.

¿Alcanzan a entender mejor ahora el diagrama de bloques del PIC16F84? Se pueden observar los bloques que les estuve mencionando:

Hasta ahora les mencioné los componentes del microcontrolador: Program Counter, ALU, Stack. Faltan algunos componentes más. Para el caso del PIC16F84 está indicado como “Instruction Decode & control”. Es lo que se llama intérprete de comandos, es el corazón del microcontrolador. Es como el traductor que lee lo que está escrito en la memoria de programa y ejecuta los pasos de la receta. Este bloque es el encargado de entender que significa cada instrucción escrita en el programa que le hayamos grabado en la memoria de programa.

¿De que sirve que tengamos buenas ideas, conozcamos que debemos hacer, si no tenemos forma de expresarnos? Todos nosotros reaccionamos a lo que nos pasa en el exterior, por ejemplo, si alguien nos pide algo, tiene que hablarnos. Son nuestros oídos los que escuchan e interpretan lo que nos dicen, para luego nuestro cerebro pensar y en base a ello responder o ejecutar alguna orden o movernos, o lo que sea. Con nuestro oído escuchamos algo y reaccionamos según lo que nos dicte nuestro cerebro, o lo que tengamos internamente como “programa”. Lo mismo pasa con los otros sentidos, vista, tacto, gusto y olfato. Cuando vemos a una persona en coma o en estado vegetativo, no tenemos forma de saber que es lo que esta pasando por su mente, ya que ésta no tiene forma de comunicarnos nada. Por eso es que tenemos la voz, y podemos movernos, para poder hacer lo que nos diga nuestro programa interno que está almacenado en nuestro cerebro.

Los microcontroladores también necesitan “sentidos” o elementos por donde ingresen estímulos o señales que le indiquen que hacer. A su vez, los microcontroladores, nos “hablan” a través también de otras señales que son visibles en su exterior. El bloque que hace que los microcontroladores puedan recibir señales desde el exterior y sacar sus resultados son los Puertos y periféricos. Los puertos son circuitos electrónicos, que leen las señales que hayan en sus entradas. Por ejemplo, un puerto toma la señal que hay en un pin o pata del microcontrolador. Si la señal mide entre 0 y 0,7 el puerto entiende que ahí hay un cero lógico. En cambio, si la señal es mayor que 2 voltios, el microcontrolador entiende que en ése puerto se tiene un uno lógico. Entonces, dentro del programa sabe que hacer con ese valor que está en ése puerto en un momento determinado. Entonces, ahora es necesario que de alguna manera el microcontrolador comunique al exterior que procesó dicha señal. Por ello, es que puede sacar por otro pin, usando otro puerto una señal resultado. El resultado será entonces una señal que puede ser un uno lógico o un cero lógico, según lo que se le haya dicho en el programa. Entonces, los puertos son dispositivos que pueden ser de entrada de señales digitales y también salidas digitales.

Los periféricos, son a su vez dispositivos electrónicos que se utilizan en los microcontroladores, pero que tienen funciones más complejas que una simple entrada o salida. Pero sirven para recibir y sacar información desde y hacia el exterior del microcontrolador. Por ejemplo, existen diferentes tipos de periféricos, que se utilizan en los microcontroladores. Algunos de los más comunes son:

Conversor ADC: Analog To Digital converter. Es un dispositivo que permite leer en un pin del microcontrolador una señal, pero que no necesariamente es una señal digital con un valor 0 o 1. Sino, que mide el valor de tensión, como si fuera un tester y entonces, comunica al microcontrolador el valor de tensión medido pero para que el programa del microcontrolador tome una decisión. Por ejemplo, si un microcontrolador tiene un conversor ADC de 8 bits, y mide en su entrada tensiones entre 0 y 5 voltios, eso quiere decir que si en su entrada hay una tensión de 0 voltios el conversor ADC dará al microcontrolador la información 0 que significa 0 voltios a su entrada. En cambio, si en su entrada hay 2,5 voltios, el conversor ADC indicará 128, y para 5 voltios indicará 255.

USART: Universal Serial Asincronous Receiver Transmiter. Es un dispositivo que permite realizar la comunicación de datos por canales seriales. Con éste dispositivo es muy fácil realizar comunicaciones entre microcontroladores.

USB: Algunos microcontroladores poseen un periférico que nos permiten conectarnos por el puerto USB con otros equipos, como puede ser una PC y otros dispositivos.

Por supuesto, hay muchas más opciones. Sólo es cuestión de buscar en las hojas de datos de cada modelo.

Volviendo de nuevo a la pregunta de éste apartado: ¿como funciona un microcontrolador?, es que armé este diagrama en bloques:

En el diagrama anterior se resume básicamente como es internamente un microcontrolador. El diagrama es muy parecido para las diferentes marcas disponibles en el mercado. Resumiendo, en todo microcontrolador hay una memoria de programa que puede ser de diferentes tecnologías, pero es el lugar físico donde está almacenado la codificación que le dice al cerebro o CPU que pasos seguir. Incluso, hay microcontroladores donde ésta memoria de programa no está dentro del chip, sino que se coloca en forma externa. Tal es el caso de los microcontroladores 8031 que no poseían esa memoria de programa en forma interna. La memoria RAM está obligatoriamente en todo microcontrolador, y es el lugar donde se almacenan todas las variables temporales para el funcionamiento. En algunos modelos de microcontroladores esta memoria RAM es mínima y sólo contiene espacio para las funciones vitales, estas variables o espacios en memoria RAM son los llamados registros del microcontrolador. Ya mencioné algunos, el Program Counter, Stack Pointer y el Acumulador que son los más básicos, pero hay más. Y finalmente se tienen los periféricos, que son los bloques de comunicación entre la CPU del microcontrolador y el mundo exterior.

El clock

En todos los microcontroladores, en realidad en todos los procesadores debe necesariamente existir un motor que vaya empujando a la CPU para que avance en la ejecución de las instrucciones que tiene que cumplir. Volviendo al ejemplo de que nos digan que limpiemos el cuarto. Si somos un ejecutante “bobo” que realiza cada acción que se le indica, pero una vez que la ha finalizado, nos quedamos quieto. Necesitamos que alguien nos diga: Avanza a la orden siguiente. Algo parecido sucede con los microcontroladores, éstos van ejecutando las órdenes o instrucciones escritas en la memoria de programa, pero para avanzar a la orden siguiente, necesitan una señal que los empuje. Esta es la función básica de lo que se llama el reloj o clock en inglés. El microcontrolador avanza a la siguiente instrucción, sólo cuando el reloj le da un impulso. Es por ello que aparecen las famosas velocidades en las computadoras: 2,4 Ghz, 3 Ghz, etc. En los microcontroladores se tiene un circuito electrónico, al cual se le conecta un cristal y eso es lo que hace que el microcontrolador funcione. Con cada pulsación del cristal el micro avanza a la próxima instrucción. Así, es que tenemos que los microcontroladores de microchip más básicos, los PIC16 aceptan cristales de hasta 20Mhz, en los de la serie MSP430 de texas hay de hasta 8 Mhz, 16 Mhz y 25 Mhz. En algunos modelos de 8051 soporta hasta 30 Mhz. Pero cuidado, a no confundirse, según la tecnología, es la verdadera velocidad del microcontrolador.

Por ejemplo, los modelos de PIC16xxx ejecutan una instrucción cada 4 pulsos del reloj. Esto es, si tenemos un microcontrolador PIC con un cristal de 20Mhz, la velocidad máxima a la que funcionará el dispositivo será de 5 MIPS. MIPS significa Millones de instrucciones por segundo, que no es lo mismo que 20 Mhz.

Los modelos MSP430xxx ejecutan una instrucción por pulso de clock, entonces si el dispositivo está conectado con un cristal de 8 Mhz, funcionará a 8 MIPS. Entonces, lo que parece en un principio más lento que los PIC, puesto que los PICs publicitan que sus chips funcionan a 20 Mhz, en realidad son 5 MIPS que es menor que los 8 MIPs de los micros Texas.

Los microcontroladores de la línea 8051 aún son más lentos, ya que ejecutan una instrucción cada 12 pulsos del reloj. Esto es, si se tiene un microcontrolador con un cristal de 30Mhz, la velocidad de procesamiento será de 2,5 MIPS.

Volvamos a las preguntas originales

¿Para que sirve un microcontrolador?

Un microcontrolador es un dispositivo que nos permite resolver muchos problemas electrónicos en un reducido espacio. Cuando necesitamos armar un equipo electrónico donde se necesita cierta “inteligencia” en la forma de responder. O cuando resolver el problema electrónico que trae aparejado mediante sólo hardware es muy complicado. Si las velocidades de las señales en las entradas, y las velocidades en las señales de salidas están en el orden de los Khz, o en el orden desde 1 hasta 25000 cambios por segundo en las señales que ingresan en sus pines, probablemente con un microcontrolador podamos resolver el problema. Hoy en día hay microcontroladores en lugares insospechados: Alarmas de todo tipo, Sensores de todo tipo, televisores, celulares, tarjetas inteligentes, robots, sistemas de domótica, automóviles, puntos de venta electrónicos, y muchísimos más que nombrarlos podría llevar cientos o miles de páginas.

¿Cuando debería utilizar un micro controlador y cuando nó?

Un poco ya lo mencioné en el párrafo anterior. Cuando hay que resolver donde hay señales, principalmente digitales, esto es niveles lógicos 0s y 1s. Y las velocidades máximas que éstos conmutan hasta unos Khz, un microcontrolador puede funcionar.

No es conveniente utilizarlos cuando las señales pueden ser de velocidades bastante mayores, como tampoco cuando resolver en forma directa con hardware es más sencillo. Al momento de diseñar la solución, es conveniente hacer números y evaluar el costo de utilizar un microcontrolador, versus el costo de lo mismo resuelto sólo con hardware. Si el costo de resolverlo con hardware es similar al costo de utilizar el micro, hay que evaluar si se va a querer en forma posterior modificar el funcionamiento. Si el funcionamiento que se pretende obtener, va a ser fijo, y nunca más se va a querer modificar, resolver con hardware directo va a ser más conveniente. En cambio, si se pretende que en el futuro el mismo equipo cumpla otras funciones el micro es más conveniente ya que sólo cambiando el programa se accede a la nueva función.

La flexibilidad de tener un dispositivo que permite modificar el programa para que funcione en forma diferente, es algo extraordinario. Pero se debe evaluar muy bien la posibilidad de errores en la programación. Muchas veces, es preferible resolver un problema por hardware puro y no con un microcontrolador, son los casos donde el resultado es el inverso, el programa se vuelve muy complejo y existen altas probabilidades de que aparezcan “bugs” o errores en el software.

Cuando hay que manejar señales de velocidades mayores a lo mejor conviene saltar a otro tipo de tecnologías, como son los DSP, CPLD y FPGA. Diré que para manejar señales analógicas en órdenes de hasta algunos megahertz los DSP son mucho más adecuados. En cambio para manejar señales puramente digitales. Por ejemplo, movimiento de datos a altas velocidades ya hay que pensar en CPLDs y FPGAs. Los CPLD y FPGA son circuitos programables, es como armar un circuito electrónico dentro de un mismo chip. Siendo los FPGA los hermanos mayores, éstos últimos nos permiten meter dentro del chip hasta un DSP y un Microcontrolador. De hecho, muchos diseños de microcontroladores, se hacen primero en un FPGA y cuando están depurados se pasan a fabricar.

¿Por qué se han hecho tan “famosos” en los electrónicos los microcontroladores?

Esa flexibilidad que permite la reprogramación, imagínense el potencial. Para los que no saben nada de electrónica, cualquier solución que requiera hardware implica: Diseñar el hardware, probarlo, armar un prototipo, diseñar la placa o PCB, mandar a fabricar la placa y finalmente se tiene el hardware listo. Esta tarea puede requerir varios días, incluso meses.

En cambio, si en la misma placa hay un microcontrolador, la primera vez que se diseñe la placa, porque también requiere de una placa o PCB se va a tomar el tiempo. Pero, después, el cambio en el software o programa es rápido. Lleva minutos o segundos el cambio. Sólo hay que perder tiempo en la nueva programación.

Finalmente, me animo a decir que en el 90% de los equipos electrónicos, las señales que hay que manejar son digitales, y esas señales siempre tienen tiempos que son de unos pocos kilohertz. Esto es, muy raras veces es necesario resolver problemas con señales que cambien más de 25000 veces por segundo. Y llegado el caso, los periféricos que traen los microcontroladores, ya resuelven muchos de esos problemas cuando hay señales de esas velocidades.

¿Qué tiene de mejor un micro controlador que no pueda ser hecho con una computadora?

Hay muchas razones, voy a nombrar algunas:

- Tamaño. Un microcontrolador, con toda la placa asociada puede ser implementada en un lugar de 5x5cm. Cuando la solución requiere resolver dentro de un cierto espacio, los microcontroladores son la solución.

- Independencia de un sistema operativo. Las computadoras personales, utilizan sistemas operativos (Linux, Windows, MAC). Los microcontroladores llevan sólo el programa que fue cargado, arranca ejecutando dicho programa. Si bien los microcontroladores más grandes permiten sistemas operativos, apunto con este párrafo a las soluciones donde un pequeño microcontrolador resuelve el problema.

- Tiempos. Cuando la aplicación requiere que se tomen muestras de algo, separadas en tiempos lo más preciso posibles, el uso de microcontroladores, es mucho más conveniente que montar esa toma de muestras en una computadora personal. El microcontrolador está dedicado exclusivamente a tomar esas muestras, mientras que una computadora personal tiene además que atender todas las otras tareas que trae la propia computadora. Esto último hace que puedan haber tomas de muestras en tiempos no precisos, dicho problema es muy fácil de resolver con un microcontrolador y extremadamente difícil en una computadora personal.

- Costos. Una computadora personal tiene un costo en el orden de los U$D 100 o más. Mientras que hay microcontroladores que no llegan a U$D 0,5. Si el producto que se desea realizar, será para consumo masivo, la diferencia será muy importante y crucial.

Bienvenida!! Curso de programación en C para Microcontroladores.

2011-03-01T00:00:00.005-03:00

Hola a todos.

Hace mucho tiempo que vengo amagando con hacer algo como esto, pero hasta ahora no lo hice por uno u otro motivo. Hasta que por las cosas del destino, descubrí que esto de los blogs puede ser un muy buen lugar para expresar las ideas, y porqué no, transmitir mi experiencia y aportes al resto de la comunidad sobre temas que pueden ser te interés.

Mi propuesta con este blog, es poner los pasos básicos y no tanto para todos aquellos que son fanáticos de los microcontroladores. Como también todos aquellos que quieren empezar a hacer sus armas con éstos, puedan tener una herramienta e información sobre como trabajarlos.

En un principio, voy a ir publicando a modo de clases o lecciones sobre el lenguaje C, pero aplicado en el ámbito de los micro controladores. Aunque el contenido de las exposiciones va a ser lo más genérico posible como para que puedan aplicarse en cualquier marca de micro controlador, voy a utilizar ejemplos y códigos para las tecnologías de micro controladores que mejor conozco: Microchip y Texas. Como para que puedan tener las herramientas necesarias para dar los primeros pasos. Luego avanzaré en más profundidad para contarles los secretos y trucos que conozco para que exploten lo mejor posible los microcontroladores en sus proyectos.

Voy a tratar de explicar las cosas de la manera lo más sencilla posible (de mi punto de vista). Dando conceptos de programación (el lenguaje) como también como llevarlo a la práctica. Esto es, como hacer que un montón de letras agrupadas en una pantalla en la PC puedan ser convertidas en algo práctico y emocionante como es ver el un led que se prende y apaga cuando hacemos funcionar por primera vez un circuito electrónico. Seguramente para alguien que no conoce el tema, pensará que me emociona que un led se prenda y apague, pero les aseguro para que alguien que crea algo nuevo no hay nada más importante que poder ver que eso que ha creado tiene vida. Es como en la espera dulce de un bebé por nacer, cuando el doctor pone en la panza de la madre el estetoscopio y te hace escuchar el corazón, te aseguro que se te erizan los pelos. Algo así pasa cuando haces funcionar por primera vez un micro controlador con tu propio programa. Esa pasión por la programación, especialmente en los microcontroladores es la que voy a intentar contagiar para que los que se interesen por este humilde curso puedan compartir conmigo.