En programación, un tipo de dato informático o simplemente tipo es un atributo de los datos que indica al ordenador (y/o al programador) sobre la clase de datos que se va a trabajar. Esto incluye imponer restricciones en los datos, como qué valores pueden tomar y qué operaciones se pueden realizar.

Los tipos de datos comunes son: números enteros, números con signo (negativos), números de coma flotante (decimales), cadenas alfanuméricas, estados (booleano), etc.

Algunos tipos de datos usados en C++:

byte

Byte almacena un valor numérico de 8 bits sin decimales. Tienen un rango entre 0 y 255. Sin signo.  http://arduino.cc/en/Reference/Byte

int (entero)

Enteros son un tipo de datos primarios que almacenan valores numéricos de 16 bits sin decimales comprendidos en el rango 32,767 a -32,768.

Nota: Las variables de tipo entero “int” pueden sobrepasar su valor máximo o mínimo como consecuencia de una operación. Por ejemplo, si x = 32767 y hacemos x++, entonces x pasará a ser -32.768. ¿Porque ocurre esto? → http://en.wikipedia.org/wiki/Two%27s_complement

Ver:

• http://arduino.cc/en/Reference/Int
• http://arduino.cc/en/Reference/UnsignedInt
• http://arduino.cc/en/Reference/Word

Las constantes enteras son números utilizados en el sketch, estos números son tratados como enteros, pero podemos cambiar su comportamiento.

Las constantes enteras son tratadas como base 10 (Decimal), pero con una notación especial podemos cambiar su representación en otras bases.

• Binario – B00001110
• Octal – 0173
• Hexadecimal – 0x7C3
• Para forzar a formato unsigned: 78U ó 78u
• Para forzar a formato long: 1000L ó 1000l
• Para forzar a formato unsigned long: 2521UL ó 2521ul

Más información en: http://arduino.cc/en/Reference/IntegerConstants

long (entero largo)

El formato de variable numérica de tipo extendido “long” se refiere a números enteros (tipo 32 bits = 4 bytes) sin decimales que se encuentran dentro del rango -2147483648 a 2147483647.

Ver más información en:

• http://arduino.cc/en/Reference/Long
• http://arduino.cc/en/Reference/UnsignedLong

float (decimales)

El formato de dato del tipo “coma flotante” o “float” se aplica a los números con decimales. Los números de coma flotante tienen una mayor resolución que los de 32 bits que ocupa con un rango comprendido 3.4028235E+38 a -3.4028235E+38.

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. En Arduino el tipo de dato double es igual que el float.

Ver:

• http://arduino.cc/en/Reference/Float
• http://arduino.cc/en/Reference/Double

Las constantes de coma flotante se usan para facilitar la lectura del código, pero aunque no se use, el compilador no va a dar error y se ejecutará normalmente.

• 10.0 se evalúa como 10
• 2.34E5 ó 67e-12 (expresado en notación científica)

Más información en: http://arduino.cc/en/Reference/Fpconstants

Para entenderlo mejor: la representación de coma flotante (en inglés floating point, ‘punto flotante’) es una forma de notación científica usada en las CPU, GPU, FPU, etc, con la cual se pueden representar números racionales extremadamente grandes y pequeños de una manera muy eficiente y compacta, y con la que se pueden realizar operaciones aritméticas. El estándar para la representación en coma flotante es el IEEE 754. http://es.wikipedia.org/wiki/Coma_flotante

• Signo (s)  1: negativo , 0: positivo (bit 31)
• Mantisa (M)  La mantisa incluye 23 bits (bit 0.. 22). Representa la parte derecha de número decimal.
• Exponente (e)  El exponente incluye 8 bits (bit 23..30).

boolean

Un booleano solo tiene dos valores true y false. Cada booleano ocupa un byte de memoria. Ver:

• http://arduino.cc/en/Reference/BooleanVariables
• Lógica binaria: http://es.wikipedia.org/wiki/L%C3%B3gica_binaria

char (carácter)

Un char representa un carácter que ocupa 1 byte de memoria. Los caracteres simples se representan con comillas simples ‘a’ y para múltiples caracteres o strings se representan con comillas dobles “Hola!”.

Recordar que los caracteres se almacenan como números usando la codificación ASCII, lo que significa que es posible hacer operaciones aritméticas con los caracteres.

Ver lo siguientes enlaces del Arduino reference:

• http://arduino.cc/en/Reference/Char
• http://arduino.cc/en/Reference/ASCIIchart
• http://arduino.cc/en/Reference/UnsignedChar

Sistemas de codificación utilizados:

• Binario.
• BCD (Binario codificado a decimal)
• Hexadecimal.
• ASCII

Tipos de Datos en Visualino

En Visualino podemos definir los tipos de datos tanto en variables locales como globales:

• int
• long
• byte
• float
• String

Conversiones de tipos (Casting)

En ocasiones es necesario forzar el cambio de tipo de dato (casting). Podemos usar las siguientes funciones:

• char() – http://arduino.cc/en/Reference/CharCast
• byte() – http://arduino.cc/en/Reference/ByteCast
• int() – http://arduino.cc/en/Reference/IntCast
• word() – http://arduino.cc/en/Reference/WordCast
• long() – http://arduino.cc/en/Reference/LongCast
• float() – http://arduino.cc/en/Reference/FloatCast