En el ámbito de la programación, una variable es la combinación de tipos de datos y un identificador (nombre) que representa una o más ubicaciones de memoria utilizadas para almacenar los datos de un programa. Una variable tiene un nombre, un valor y un tipo, y todas deben ser declaradas antes de su uso.
Los diseñadores de sistemas integrados, especialmente aquellos que trabajan con microcontroladores como el ATmega88, a menudo se encuentran con procesadores de 8 bits. En estos dispositivos, el tamaño fundamental de los datos es, por lo general, un byte. La memoria se organiza de acuerdo con los bytes, el tamaño de los registros es de un byte, y la CPU está diseñada para procesar datos de 8 bits de manera nativa.
Aunque el lenguaje C no limita el tamaño de una variable a 8 bits, incluso cuando se trabaja con un procesador de 8 bits, esto significa que una variable en el programa en lenguaje de máquina que ejecuta el microprocesador puede corresponder a múltiples registros o ubicaciones de memoria en el hardware. Hay muchos tipos de variables disponibles, y la lista completa, así como los detalles de la implementación del hardware, variarán según el compilador que se utilice.
Declaración de Variables de 8 bits
Para trabajar eficientemente con microcontroladores de 8 bits, el tipo de dato de 8 bits es fundamental. En el entorno de Arduino, la palabra reservada Byte representa una variable de 8 bits. Este tipo de variable puede usarse para guardar valores enteros desde 0 hasta 255. También es útil para guardar caracteres leídos de un puerto serial. Es equivalente a un unsigned char en C estándar.
La sintaxis básica para declarar una variable de tipo Byte es:
Lea también: IVA 21% Excel
Byte nombreVariable = ValorEnteroInicial;
Ejemplos de Declaración
- Ejemplo 1. Declaración de una variable con un valor inicial:
Byte variable1 = 255;
- Ejemplo 2. Declarar una variable y usarla en una función:
Byte entradaBoton = 13;void setup( ) { pinMode(entradaBoton, INPUT_PULLUP);}
El calificador unsigned, que se puede aplicar a tipos de datos enteros, indica al compilador que interprete la variable como un valor sin signo en lugar de un valor con signo. Esto es crucial para tipos de 8 bits como char, donde unsigned char garantiza un rango de 0 a 255, mientras que un char (con signo por defecto en muchos sistemas) va de -128 a 127.
Tipos de Datos y Eficiencia en Microcontroladores AVR
Se pueden definir variables con tamaños que van desde los 8 bits hasta los 32 bits, ya sea en representación con o sin signo. Sin embargo, en un procesador nativo de 8 bits como el Atmel ATmega328P (utilizado en muchas placas Arduino), no todos los tipos de datos son igual de eficientes.
El procesador en el corazón de la placa Arduino es un procesador nativo de 8 bits sin soporte incorporado para números de punto flotante. Esto significa que funciona mejor al procesar valores de 8 bits y peor al procesar números de punto flotante, ya que requiere que el compilador genere código adicional para emular estas operaciones.
A continuación, se presenta una tabla con los tipos de datos comunes en Arduino (basados en C++) y sus características en un contexto de microcontrolador AVR:
Lea también: Guía IVA reducido
| Tipo de Dato | Tamaño (bits) | Rango Típico | Descripción |
|---|---|---|---|
| boolean | 8 (1 byte) | true o false | Almacena valores lógicos. Aunque conceptualmente es 1 bit, ocupa un byte. |
| char | 8 (1 byte) | -128 a 127 | Almacena un carácter ASCII; es un número con signo. |
| byte (unsigned char) | 8 (1 byte) | 0 a 255 | Almacena un número entero sin signo. Ideal para datos de 8 bits. |
| int | 16 (2 bytes) | -32768 a 32767 | Número entero con signo. |
| unsigned int (word) | 16 (2 bytes) | 0 a 65535 | Número entero sin signo. |
| long | 32 (4 bytes) | -2,147,483,648 a 2,147,483,647 | Número entero largo con signo. |
| unsigned long | 32 (4 bytes) | 0 a 4,294,967,295 | Número entero largo sin signo. |
| float | 32 (4 bytes) | -3.4028235E38 a 3.4028235E38 | Número de punto flotante (con decimales). |
Impacto en el Tamaño del Código y el Rendimiento
El uso de tipos de datos que requieren más de 8 bits de almacenamiento (como int, long o float) requiere que el compilador genere más código máquina real para que las operaciones se realicen, ya que el procesador en sí mismo no tiene la capacidad de admitir datos más grandes de forma nativa. Por ejemplo, el tamaño de compilación puede ser de 2488 bytes para int versus 2458 bytes para byte; aunque la diferencia no es masiva, existe.
En cuanto al rendimiento, las operaciones con tipos de datos más grandes suelen ser más lentas. Los tiempos transcurridos para una operación básica de suma pueden ser aproximadamente 4µs para byte, 8µs para int o long, y 12µs para float. Esto demuestra que las matemáticas "más difíciles" (operaciones con datos más grandes) toman más tiempo.
La división es un ejemplo claro de ineficiencia con tipos de datos grandes. La división de bytes no es tan mala (aproximadamente 16µs), pero para un long puede llegar a 48µs. El problema aquí es que la división NO tiene una instrucción nativa en el conjunto de instrucciones del Atmega, por lo que el compilador tiene que hacer algunos malabares para crear una. Por lo tanto, no todas las operaciones matemáticas son iguales. La división tarda mucho más que la multiplicación o la suma (o la resta), y algo como encontrar una raíz cuadrada o un seno tardaría aún más. Tanto es así que a menudo es más fácil simplemente mantener una lista de valores precalculados (tablas de búsqueda) para funciones complejas que calcularlos en tiempo real.
Consideraciones sobre Punto Flotante
Los números de punto flotante no son exactos y pueden producir resultados extraños en las comparaciones. Los cálculos matemáticos de coma flotante son también mucho más lentos que los del tipo de números enteros, por lo que debe evitarse su uso si es posible. El punto flotante en Arduino no es nativo; el compilador tiene que hacer malabares para que funcione. Si puede evitarlo, debería hacerlo.
Optimización con Campos de Bits (Bit Fields)
En la programación de microcontroladores, es bastante frecuente el chequeo y cambio de las variables, ya sea en todos sus bytes, un bit o un grupo de bits en específico. A menudo, usamos una variable para almacenar el estado lógico de un proceso (0 o 1). Si usamos una variable del tipo unsigned char para esto, estaremos desperdiciando 7 bits, ya que esta variable solo toma valores de 0 y 1, alterando únicamente el valor del bit menos significativo.
Lea también: ¿Cómo localizar tus XML del SAT?
Pero el lenguaje C tiene una potente y útil herramienta que nos permite definir un nombre para cada bit de una variable, conocida como campos de bits (Bit Fields). Con esto, por ejemplo, en una variable de unsigned char, podremos definir 8 variables que hagan referencia a cada bit del dato, incluso un bit puede no tener una referencia asociada (es decir, ese bit no se implementa).
Una estructura con campos de bits ocupa en memoria 1 byte (o el tamaño mínimo para contener todos los campos). Lo que hace es reservar un espacio de memoria correspondiente al número de bits usados dentro de la estructura. Por ejemplo, en un caso se podrían definir 5 variables unsigned char de 1 bit y 1 variable unsigned char de 3 bits, lo que sumaría un total de 1 byte.
Para ver el uso de esta característica y aplicarla a los microcontroladores AVR, se puede programar un ejemplo en C utilizando una estructura BitField para acceder y modificar individualmente a cada bit de registros como DDRx, PORTx y PINx.
Es importante saber que los registros de los puertos (y los demás registros periféricos) están mapeados en el mapa de direcciones de memoria, es decir, son direcciones de memoria. Se utiliza la macro definida en <sfr_defs.h> _SFR_MEM_ADDR(SFR) para obtener la dirección de cualquier variable o registro en memoria. En estos casos, se obtienen las direcciones de DDRB, PORTB y PINB, las cuales son mapeadas en la estructura correspondiente para permitir un acceso a nivel de bit.
Calificadores de Variables
Además de los tipos de datos, hay varias palabras clave que se pueden incluir en una definición de variable para modificar su comportamiento o indicar al compilador cómo debe tratarlas:
- unsigned: Como se mencionó, le indica al compilador que interprete la variable como un valor sin signo en lugar de un valor con signo.
- const: El calificador de tipo const indica al compilador que el valor de una variable no debe cambiar después de su inicialización. Una variable const es, en esencia, una constante que no puede ser alterada durante la ejecución del programa, solo leída. Por ejemplo: const float PI = 3.14159;.
- volatile: Los compiladores sofisticados a menudo optimizan el código. Sin embargo, esta optimización a veces puede ser problemática cuando hay eventos de hardware que interactúan con el código (por ejemplo, registros que cambian fuera del control directo del programa). El calificador volatile le dice al compilador que una variable puede ser modificada por algo externo al código (como hardware o una rutina de interrupción), y por lo tanto, no debe aplicar ciertas optimizaciones que asumen que el valor de la variable solo puede cambiar por operaciones explícitas en el código. Por ejemplo: volatile unsigned char ADC_Register; /* El registro puede ser modificado por hardware, por lo que usamos el calificador volatile para evitar optimizaciones que harían que el programa ignorara los eventos generados por hardware. */.
Ámbito de las Variables
El ámbito de una variable define dónde puede ser accedida y utilizada dentro del programa:
- Una variable puede ser declarada al inicio del programa, antes de la parte de configuración setup().
- También puede ser declarada a nivel local dentro de las funciones.
- En ocasiones, se declaran dentro de un bloque de código, como para los bucles del tipo if, for, etc.
Existen dos tipos principales de ámbito:
- Una variable global es aquella que puede ser vista y utilizada por cualquier función y estamento de un programa. Se declara fuera de cualquier función.
- Una variable local es aquella que se define dentro de una función o como parte de un bucle. Solo es visible y solo puede utilizarse dentro de la función o bloque en el que se declaró.
Terminología Básica de Bits y Bytes
Para comprender mejor el tamaño y la organización de los datos, es útil conocer algunas unidades básicas:
- Un nibble son 4 bits.
- Un byte son 8 bits.
- Una word (palabra) son 16 bits (en la mayoría de los sistemas AVR).