{"id":261,"date":"2014-04-26T15:25:51","date_gmt":"2014-04-26T15:25:51","guid":{"rendered":"http:\/\/demo.themegrill.com\/accelerate\/?page_id=2"},"modified":"2023-05-04T21:31:33","modified_gmt":"2023-05-04T21:31:33","slug":"variables-y-tipos-de-datos","status":"publish","type":"page","link":"https:\/\/iaciduino.enp.unam.mx\/index.php\/manual-de-programacion-con-arduino\/variables-y-tipos-de-datos\/","title":{"rendered":"Variables y tipos de datos"},"content":{"rendered":"

En este apartado aprender\u00e1s qu\u00e9 es una variable y los tipos de datos que maneja Arduino.<\/p>\n

La tarjeta Arduino generalmente se utiliza para registrar los cambios de alg\u00fan fen\u00f3meno f\u00edsico. Estos datos deben ser representados y almacenados de manera que el microcontrolador pueda procesarlos. Para almacenar los datos que se requieren en un programa se utilizan las variables.<\/p>\n

\n<\/p>

\u00bfQu\u00e9 es una variable?<\/span><\/h2>\n
\n

Una variable<\/strong> es una localidad de memoria, asociada a un nombre, que almacena un valor que puede cambiar durante la ejecuci\u00f3n del programa.<\/p>\n<\/blockquote>\n

\n<\/p>

Para crear una variable el primer paso es identificar su tipo de dato.<\/p>\n

\n<\/p>

Tipos de datos<\/span><\/h2>\n

Un tipo de dato<\/strong> est\u00e1 compuesto por un conjunto de valores (dominio) y un conjunto de operaciones que se pueden realizar sobre dichos valores.  Arduino maneja diversos tipos de datos. Conozcamos los m\u00e1s comunes:<\/p>\n\n\n

Tipo de dato<\/strong><\/td>Descripci\u00f3n<\/strong><\/td>Dominio<\/strong><\/td>Espacio de<\/strong> memoria<\/strong><\/td>Ejemplos<\/strong><\/td><\/tr>
int<\/td>N\u00famero enteros<\/td>-32,768 a 32,767<\/td>16 bits<\/td>0, 1, 567, 5674<\/td><\/tr>
float \/ double<\/td>N\u00fameros reales<\/td>
-3.4028235E+38 a 3.4028235E+38<\/td>		32 bits<\/td>26.7, 176.0, 7345.89<\/td><\/tr>
long <\/td>N\u00fameros enteros<\/td>2,147,483,647 a -2,147,483,648<\/td>32 bits<\/td>0, 678 899, 4 889 889, 2 147 483 647
<\/td><\/tr>
bool<\/td>Valores booleanos<\/td>true o false<\/td>8 bits<\/td>true, false<\/td><\/tr>
char<\/td>Caracter alfanum\u00e9rico<\/td>Un caracter alfanum\u00e9rico<\/td>8 bits<\/td>a, 9, $, Z, 0<\/td><\/tr>
string<\/td>Caracteres alfanum\u00e9ricos<\/td>Caracteres alfanum\u00e9ricos<\/td><\/td>Hola, nombre<\/td><\/tr>
byte<\/td>N\u00famero entero positivo<\/td>0 a 255<\/td>8 bits<\/td>0, 64, 128, 250<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n

<\/p>\n

Convenciones para nombrar variables<\/span><\/h2>\n

El nombre de una variable, tambi\u00e9n conocido como identificador de variable, debe seguir algunas reglas. Las m\u00e1s comunes son:<\/p>\n

    \n
  • Debe empezar con una letra.<\/li>\n
  • NO debe contener espacios en blanco.<\/li>\n
  • Puede incluir n\u00fameros y el caracter gui\u00f3n bajo \u201c_\u201d.<\/li>\n<\/ul>\n

    El nombre de una variable debe describir lo que almacena. Un nombre como promedio facilita saber el contenido de la variable, a diferencia de si la nombramos p, ya que \u00e9ste \u00faltimo no nos da ninguna pista de la clase de datos que est\u00e1 almacenando. Tambi\u00e9n es recomendable que los nombres de tus variables no sean muy largos.<\/p>\n

    Si deseas nombrar una variable usando dos palabras, te recomendamos utilizar la regla conocida como camel Case: la primera palabra toda con min\u00fasculas, seguida de la segunda palabra con la primera letra en may\u00fascula y las dem\u00e1s en min\u00fascula, simulando la joroba del camello.<\/p>\n

    Ejemplos:<\/p>\n

    tempAmbiente<\/p>\n

    tempPromedio<\/p>\n

    <\/p>\n

    Declaraci\u00f3n de un variable<\/span><\/h2>\n

    Para crear una variable en Arduino debes indicar su tipo de dato y su nombre. La acci\u00f3n de crear una variable es conocida como declarar una variable. Arduino necesita conocer el tipo de dato porque \u00e9ste le indica la cantidad de memoria que debe reservar para la variable y c\u00f3mo representar el valor.<\/p>\n

    Sintaxis<\/span><\/h3>\n

    Para declarar una variable debes especificar el tipo de dato, dejar cuando menos un espacio en blanco, el nombre de la variable y terminar la l\u00ednea con punto y coma (;).<\/p>\n\n\n

    tipoDato nombreVariable;<\/p>\n\n\n

    Ejemplos:<\/p>\n

    Declaraci\u00f3n de una variable llamada temperatura que puede almacenar n\u00fameros reales.<\/p>\n

    float temperatura;<\/pre>\n
    Declaraci\u00f3n de una variable llamada pinLed que puede almacenar n\u00fameros enteros.<\/p>\n
    int pinLed;<\/pre>\n
    Declaraci\u00f3n de una variable llamada clase que puede almacenar un caracter.<\/p>\n
    char clase;<\/pre>\n
    \n
    \n
    \n
    \n
    \n
    \n
    \n
    \n
    \n<\/p><\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/section>\n
    \n
    \n
    \n
    \n
    \n
    \n
    \n
    \n
    \n
    Declaraci\u00f3n e inicializaci\u00f3n de una variable<\/span><\/h2>\n
    Tambi\u00e9n es posible darle un valor inicial a la variable en la misma instrucci\u00f3n en la cual la creas, es decir, puedes declarar e inicializar una variable en una misma instrucci\u00f3n.<\/p>\n
    Sintaxis<\/span><\/h3>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/section>\n\n\n
    tipoDato nombreVariable = valor;<\/p>\n\n\n
    Ejemplos:<\/p>\n
    Se declara de una variable tipo float llamada temperatura  y se inicializa con el valor 17.5<\/p>\n
    float temperatura = 17.5;<\/pre>\n
    Se declara de una variable tipo int llamada pinLed  y se inicializa con el valor 5<\/p>\n
    int pinLed = 5;<\/pre>\n
    Se declara de una variable tipo char llamada clase  y se inicializa con el valor A<\/p>\n
    char clase = 'A';<\/pre>\n
    \n
    \n
    \n
    \n
    \n
    \n
    \n
    \n
    \n
    \n
    Se declara de una variable tipo string llamada nombre  y se inicializa con el valor Arduino<\/p>\n
    string nombre = \"Arduino\";<\/pre>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/section>\n
     <\/h4>\n
    Cambiar el valor de una variable<\/span><\/h2>\n
    El valor de una variable puede cambiar durante la ejecuci\u00f3n del programa. Esta acci\u00f3n se realiza mediante una expresi\u00f3n o sentencia de asignaci\u00f3n. Las sentencias de asignaci\u00f3n inicializan o cambian el valor almacenado en una variable usando el operador de asignaci\u00f3n =<\/b> (signo de igualdad). El valor de la expresi\u00f3n del lado derecho del signo de igualdad (=) es almacenado en la variable del lado izquierdo (ver Figura 1). Estos valores pueden ser desde un simple dato, hasta expresiones m\u00e1s complejas que pueden contener operadores matem\u00e1ticos y otras variables.<\/p>\n\n
    \n
    \"\"
    Figura 1 Expresi\u00f3n de asignaci\u00f3n<\/figcaption><\/figure><\/div>\n\n
    Ejemplos:<\/p>\n
    voltaje = 5;  
    \/\/ se asigna el valor 5 a la variable voltaje

    voltaje = 4.8 * 6;  
    \/\/ se asigna el valor 28.8 a la variable voltaje

    temperatura = analogRead(0);  
    \/\/ se asigna el valor le\u00eddo en el pin anal\u00f3gico 0 a la variable temperatura

    distancia = velocidad \/ tiempo;  
    \/\/ se asigna el resultado seg\u00fan los valores de las variables <\/pre>\n
     <\/h4>\n
    \n
    \n
    \n
    \n
    \n
    \n
    \n
    \n
    \n
    \n
    \u00c1mbito de una variable<\/span><\/h2>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/section>\n
    Una variable puede ser utilizada en todo el sketch o solamente en una determinada funci\u00f3n, dependiendo del lugar en que se haga su declaraci\u00f3n.<\/p>\n
    Variables globales<\/strong><\/p>\n
    Una variable global se declara afuera de cualquier funci\u00f3n y puede ser utilizada por todas las funciones del sketch. Es recomendable declarar las variables globales al inicio del programa, antes de la funci\u00f3n setup.<\/p>\n
    Ejemplo:<\/p>\n
    En el siguiente programa, la variable valBtn es global, ya que se declara afuera de las funciones setup y loop. Observa que la variable valBtn es utilizada por las dos funciones del programa, es inicializada dentro de la funci\u00f3n setup y se modifica su valor dentro de la funci\u00f3n loop.<\/p>\n
    \/* Programa que enciende y apaga un led
    *  con un bot\u00f3n
    *\/
    int<\/span> valBtn<\/strong>; \/\/ declaraci\u00f3n de la variable global valBtn

    void<\/span> setup<\/span>() {
       valBtn = 0<\/strong>; \/\/ inicializaci\u00f3n de la variable valBtn
       pinMode<\/span>(7, OUTPUT<\/span>);\/\/ configura el pin 7 de salida (led)
       pinMode<\/span>(3, INPUT<\/span>); \/\/ configura el pin 3 de entrada (bot\u00f3n)
    }

    void loop<\/span>() {
       valBtn<\/strong> = digitalRead<\/span>(3); \/\/ lee valor del pin 3 y lo guarda  en valBtn
       digitalWrite<\/span>(7,valBtn<\/strong>); \/\/ enciende\/apaga led seg\u00fan valor valBtn
    }<\/pre>\n
    Variables locales<\/strong><\/p>\n
    Si la declaraci\u00f3n de la variable se realiza dentro de una funci\u00f3n, entonces esa variable solamente podr\u00e1 ser usada por esa funci\u00f3n en particular.<\/p>\n
    Ejemplo:<\/p>\n
    En este otro sketch, la variable valBtn es local, ya que se declara dentro de la funci\u00f3n setup. En este caso, la funci\u00f3n loop no podr\u00eda hacer uso de la variable valBtn, si se colocara alguna instrucci\u00f3n que hiciera referencia a la variable en la funci\u00f3n loop, el compilador no reconocer\u00eda la variable y marcar\u00eda un error de \u00e1mbito de variable.<\/p>\n
    \/* Programa que enciende y apaga un led
    * con un bot\u00f3n
    *\/

    void<\/span> setup<\/span>() {
       int<\/span> valBtn = 0;  <\/strong>\/\/ declaraci\u00f3n de la variable local valBtn
       pinMode<\/span>(7, OUTPUT<\/span>);\/\/ configura el pin 7 de salida (led)
       pinMode<\/span>(3, INPUT<\/span>); \/\/ configura el pin 3 de entrada (bot\u00f3n)
    }

    void<\/span> loop<\/span>() {
       valBtn<\/strong> = digitalRead<\/span>(3); \/\/ Error: 'valBtn' was not declared in this scope<\/span>
       digitalWrite<\/span>(7,valBtn<\/strong>); \/\/ Error: 'valBtn' was not declared in this scope<\/span>
    }<\/pre>\n
    <\/p>\n
    Constantes<\/span><\/h2>\n
    En ocasiones necesitamos almacenar alg\u00fan valor en una variable, pero ese valor no tendr\u00e1 ninguna modificaci\u00f3n durante la ejecuci\u00f3n del programa. En estos casos podemos definir una constante.<\/p>\n
    <\/p>\n
    \n
    Una constante es un valor que no cambia durante la ejecuci\u00f3n del programa.<\/p>\n<\/blockquote>\n
    Declaraci\u00f3n de una constante<\/span><\/h2>\n
    La declaraci\u00f3n de una constante en Arduino se realiza de manera similar al de una variable pero se antepone la palabra reservada const<\/em>.<\/p>\n
    Sintaxis<\/span><\/h3>\n\n\n
    const tipoDato nombreConstante = valor;<\/p>\n\n\n
    <\/p>\n
    Ejemplo:<\/p>\n
    const float<\/span> pi = 3.1416;<\/pre>\n
    <\/p>\n
    Podemos definir los pines de conexi\u00f3n de nuestros dispositivos como constantes. Esta acci\u00f3n nos permitir\u00e1 modificar f\u00e1cilmente el programa en caso de que la conexi\u00f3n del dispositivo cambie a otro pin.<\/p>\n
    Observa los programas 1 y 2, son iguales, excepto que en el primer caso el led est\u00e1 conectado al pin 13 y en el segundo al led 7. Si tuvi\u00e9ramos que modificar el c\u00f3digo, tendr\u00edamos que buscar todas las instrucciones relacionadas con el pin 13 y sustituirlo por el pin 7.<\/p>\n
    Ahora observa los programas 3 y 4, donde se define una constante llamada pinLed. Cuando se modifica el pin de conexi\u00f3n del led, basta con cambiar el valor inicial de la constante de 13 a 7 y ninguna otra instrucci\u00f3n se modifica.<\/p>\n
    <\/p>\n\n\n
    \n
    \n
    PROGRAMA 1<\/strong>

    \/* Parpadeo de un led
    *  conectado al pin digital 13
    *\/
    void<\/span> setup<\/span>() {
       pinMode<\/span>(13<\/strong><\/span>, OUTPUT<\/span>);
    }

    void<\/span> loop<\/span>() {
       digitalWrite<\/span>(13<\/strong><\/span>, HIGH<\/span>);
       delay<\/span>(1000);
       digitalWrite<\/span>(13<\/strong><\/span>, LOW<\/span>);
       delay<\/span>(1000);
    }<\/pre>\n\n\n\n
    PROGRAMA 3<\/strong>

    \/* Parpadeo de un led
    *  conectado al pin digital 13
    *\/

    const int pinLed = 13;<\/strong><\/span>

    void<\/span> setup<\/span>() {
       pinMode<\/span>(pinLed<\/strong><\/span>, OUTPUT<\/span>); 
    }

    void<\/span> loop<\/span>() {
       digitalWrite<\/span>(pinLed<\/strong><\/span>, HIGH<\/span>);
       delay<\/span>(1000);
       digitalWrite<\/span>(pinLed<\/strong><\/span>, LOW<\/span>);
       delay<\/span>(1000);
    }<\/pre>\n<\/div>\n\n\n\n
    \n
    PROGRAMA 2<\/strong>

    \/* Parpadeo de un led
    *  conectado al pin digital 7
    *\/
    void<\/span> setup<\/span>() {
       pinMode<\/span>(7<\/strong><\/span>, OUTPUT<\/span>);
    }

    void<\/span> loop<\/span>() {
       digitalWrite<\/span>(7<\/strong><\/span>, HIGH<\/span>);
       delay<\/span>(1000);
       digitalWrite<\/span>(7<\/strong><\/span>, LOW<\/span>);
    delay<\/span>(1000);
    }<\/pre>\n\n\n\n
    PROGRAMA 4<\/strong>

    \/* Parpadeo de un led
    *  conectado al pin digital 7
    *\/

    const int pinLed = 7;<\/strong><\/span>

    void<\/span> setup<\/span>() {
     pinMode<\/span>(pinLed<\/strong><\/span>, OUTPUT<\/span>); 
    }

    void<\/span> loop<\/span>() {
     digitalWrite<\/span>(pinLed<\/strong><\/span>, HIGH<\/span>);
     delay<\/span>(1000);
     digitalWrite<\/span>(pinLed<\/strong><\/span>, LOW<\/span>);
     delay<\/span>(1000);
    }<\/pre>\n<\/div>\n<\/div>\n\n\n\n
    <\/div>\n\n\n\n
    \n
    \n
    \"logo-autoevaluaci\u00f3n\"<\/figure>\n<\/div>\n\n\n\n
    \n
    Autoevaluaci\u00f3n<\/span><\/h2>\n<\/div>\n<\/div>\n\n\n