bclose

El ámbito de las variables en Arduino

Ambito de las variables.

Objetivos

 

 

    • Presentar el concepto de ámbito de una variable.
    • Mostrar porque es necesario un ámbito de variables.
    • Variables globales y locales.
    • Variables estáticas: static.

 

 

Material requerido.

 

  Tienda España Tienda Mexico
Kit Arduino Uno  Kit inicio UNO Kit inicio UNO
Kit Arduino MEGA Kit Inicio Mega Kit Inicio Mega

 

Las variables

 

En los tutoriales de introducción a Arduino, hemos ido jugando con variables de una forma más o menos informal, por una decisión deliberada. Hemos usado los diferentes tipos de variables y hemos operado con ellas, pero sin entrar en muchos detalles.

En concreto hemos utilizado variables locales y globales, pero evitando, discretamente, hacer comentarios sobre el tema.  Sin embargo ha llegado el momento de entrar en detalle en una propiedad clave de las variables en C++ (y en prácticamente cualquier lenguaje de programación moderno), llamada el ámbito de las variables y su persistencia.

Para entender el concepto de ámbito (Scope) de una variable, nos conviene dar un pequeño rodeo y hacer historia (Tranquilos, será una batallita muy corta).

Históricamente, en los primeros lenguajes de programación, todas las variables eran variables globales. Esto quiere decir, que cuando definías una de cualquier tipo, su valor era accesible desde cualquier punto del programa. Podías leerla o modificar su valor sin restricciones.

Al principio, puede parecer lo ideal. Pero a medida que los programas van creciendo en tamaño y complejidad, la cosa se complica y tiende a generar problemas complicados de detectar y resolver.

Por ejemplo, a lo largo de las sesiones del curso de introducción hemos usado variables tipo como i, j hasta la saciedad en los bucles for, por ejemplo. Sin un programa tiene media docena de bucles, y por costumbre usamos estas nombres de variables para indexar la iteración, es cuestión de tiempo (y poco, creedme) que la variable de un bucle, se confunda o mezcle con otra de un bucle distinto.

De repente el programa empezara a actuar de  forma imprevisible, porque una variable que creemos controlada y sencilla en una zona de programa, toma valores diferentes de los previstos porque usamos ese mismo nombre en otra zona y sencillamente no nos hemos percatado de ello

Establecer la relación entre esa confusión de nombres y los problemas extraños que aparecen, puede ser mucho menos evidente en la realidad de lo que parece ahora en un ejemplo ad hoc, y a medida que el programa crece el problema tiende a crecer hacia el infinito.

Por eso, se propuso una solución muy elegante (Que son las que nos gustan), que las variables no fueran visibles en todo el ámbito del programa, si no solamente en ciertas zonas, de acuerdo a unas reglas claras.

Como C++ exige que las variables se declaren, antes de usarlas, Las variables que se declaran fuera de un bloque de código, son variables Globales, están disponibles desde cualquier punto de un programa.

 
  • Ya hablamos como sin querer en sesiones previas, del concepto de bloque de código como aquel grupo de instrucciones contenidas entre llaves (Apertura y cierre).
 

Las variables que se declaran dentro de un bloque, se llaman variables locales, y solo existen dentro del bloque en que se definen y no fuera. Cuando nuestro programa entra en el bloque, la variable que se declara, se crea sobre la marcha para su uso interno.

Cuando el programa abandona el bloque, esa variable local se destruye y desaparece en el olvido. La próxima vez que regresemos al bloque se creará de nuevo, sin recordar si ha tenido existencia previa.

De este modo, cuando necesitamos definir variables instrumentales, como para indexar un for, por ejemplo, las variables se crean ad hoc y se destruyen al salir, imposibilitando que una variable local se confunda con otra variable local de otro bloque de código.

Sencillamente no existen variables externas al bloque, excepto las globales,  y por tanto su confusión no puede provocar errores imprevistos por  utilizar el mismo nombre.

Resolvemos el problema de un plumazo y definitivamente. ¿Elegante, NO?

Vamos a ver algunos ejemplos de esto.

 

Ejemplos de variables locales y globales

 

Os recomiendo que no leáis simplemente los ejemplos que os pongo. Copiad el programa en vuestro Arduino y haced pruebas, porque el tema es más delicado de lo que parece y no es fácil ir cogiendo una idea clara.

Usaremos una variable global llamada control, para impedir que el resultado se repita en la consola. Para definir una variable global, basta con declararla fuera de un bloque. Al principio está bien

bool control = true;

void setup()
  {        Serial.begin(9600);   }

void loop()
   {   int j = 3 ;
       if ( control)
            {  for (j=0 ; j<10 ;j++)
                  {    Serial.print("j = ");
                       Serial.println(j);
                  }
               Serial.println("...........................");
               Serial.println(j);
            }
       control = false ;   // Para que no vuelva a imprimir el resultado
   }

Piensa un momento antes de ver el resultado. ¿Cuál crees tú que será?

Fijaros que definimos la variable j al principio del loop, pero no la declaramos de nuevo en el for, sino que usamos una variable preexistente.

Por eso el for asume que queremos usar una variable pre declarada y la utiliza para la iteración

Consola arduino

El resultado es 10, naturalmente. Hagamos una ligera modificación del programa previo. Vamos a volver a declarar la variable j como int, pero dentro del for.

void loop()
   {   int j = 3 ;
       if ( control)
            {  for (int j=0 ; j<10 ;j++)     // Atentos aquí
                  {    Serial.print("j = ");
                       Serial.println(j);
                  }
               Serial.println("...........................");
               Serial.println(j);
            }
       control = false ;   // Para que no vuelva a imprimir el resultado
   }

Esta vez, el resultado cambia radicalmente:

Display de la consola de Arduino

 

La última línea es 3. La variable j del loop es diferente de la j del for, porque la hemos definido dentro de un bloque distinto. Por eso al salir del for su variable local j, se desvanece y la que existe es la variable local del loop y el resultado tras la línea de  puntos es 3 y no 10 como en el ejemplo anterior.

 
  • En la instrucción for, y en cualquier otra que se aplica a un bloque, las definiciones que   se hagan, se consideran incluidas  dentro del bloque al que afecta y no a la parte exterior.
  • Una variable solo se puede declarar una vez dentro de un bloque. Cualquier intento de declarar la misma variable por segunda vez, provocara un error fulminante del compilador:
 

Consola de errores

 

Es importante que comprendáis que esta regla no solo tiene que ver con el concepto formal del bloque, como instrucciones contenidas entre apertura y cierre de llaves, sino que se aplica también a los bloques implícitos en los que prescindimos de estas:

void loop()
   {   int j = 3 ;
       if ( control)
           {   for (int j=0 ; j<10 ;j++)         // Atentos aqui
                    Serial.println(j);
               Serial.println("...........................");
               Serial.println(j);
           }
       control = false ;
   }

Cuyo resultado es el mismo que antes, aunque ahora no hay llaves de por medio, pero si un bloque implícito:

Display de la consola de Arduino

Todos los lenguajes de programación modernos incluyen el concepto de variables locales y variables globales y aplican las reglas que hemos descrito aquí (Los lenguajes se copian unos a otros claro, y las buenas ideas se reproducen)

A esa propiedad de las variables, de existir durante un cierto tiempo, se le suele llamar persistencia de la variable.

 

Variables static

 

Esta propiedad característica de las variables locales, su persistencia, para crearse de la nada y desaparecer en el olvido al salir de un bloque, es una gran ventaja y ahorra muchas horas de vagar en pena por los pasillos a los programadores (Mientras meditan en qué demonios será lo que está mal. De aquí la injusta fama de pirados).

Pero a veces (La vida es complicada) esto puede ser un inconveniente y nos gustaría que ciertas variables locales, no desapareciesen al salir, o al menos que no perdiéramos su valor.

Imagínate un Arduino que está leyendo datos de un sensor y almacenando su valor en una variable local. Nos gustaría saber el último valor de lectura cuando volvamos a esa función.

 
  • Siempre podemos definir una variable global, pero puede no tener mucho sentido si solo se utiliza en una función en exclusiva.
 

Para esto, podemos definir una variable local como estática (static). Quiere decir que solo será accesible desde esta función, pero que su valor no desaparecerá al salir, sino que persistirá en el tiempo, mientras no cerremos el programa, conservando su último valor.

Veamos un ejemplo sencillo sacado de la Wikipedia:

void loop()
   {  if ( control)
         {   Funcion1 (); // muestra 0
             Funcion1 (); // muestra 1
             Funcion1 (); // muestra 2
         }
      control = false ; 
   }
void Funcion1 ()
   {  int x = 0;          // Declaramos x como local
      Serial.println(x);
      x = x + 1;
   }

En la definición de Funcion1, declaramos x como int, sin más, por que el resultado será así:

Resultado con variable local

 

Cuando entramos em Funcion1, la int x se declara, se crea sobre la marcha y se le asigna el valor 0.

Cada vez que salimos de Funcion1, la variable x se desvanece y se vuelve a crear la próxima vez que entremos en ella, tal y como corresponde a una variable local obediente. Y se repite el proceso.

Pero hagamos un pequeño cambio. En Funcion1 vamos a declarar la variable x como static.

void loop()
   {  if ( control)
         {   Funcion1 (); // muestra 0
             Funcion1 (); // muestra 1
             Funcion1 (); // muestra 2
         }
      control = false ; 
   }
void Funcion1 ()
   {  static int x = 0;          // Declaramos x como static
      Serial.println(x);
      x = x + 1;
   }

El resultado es, que la variable x no se desvanece ya al salir, sino que conserva su valor para la próxima vez que volvemos a Funcion1. Sigue siendo una variable local, no puede ser usada por ningún programa o función fuera de Funcion1, pero no desaparece al salir sino que persiste.

Resultado con variable estatica

Nótese además, de que como la variable estática no se destruye al salir,  se crea solo una vez y persiste indefinidamente. La declaración de variable y la asignación de la variable se realizan una única vez.

 
  • Esto hace que a x solo se le asigna el valor 0 cuando se crea y no cada vez que entra en la Funcion1, como podría pensarse inicialmente. Mucho cuidado con esto
 

 

Resumen de la sesión

 

En este curso arduino hemos aprendido lo siguiente:

 

 
    • Hemos visto las diferencias entre variables locales y las variables globales.
    • La propiedad de las variables que define donde existen y pueden ser usadas y donde no, se le conoce como ámbito de la variable.
    • Hemos visto unos pocos ejemplos sencillos que ilustran ese comportamiento, un tanto anti intuitivo que se derivan de la definición ámbito.
    • Hemos visto también el concepto de variables estáticas, como variables locales que persisten, aun cuando abandonamos su ámbito de referencia.
 

 

 

 

Para porder realizar consultas a nuestros expertos, tienes que ser suscriptor. Suscribiendote nos ayudas a mantener este proyecto en marcha.

¡ Quiero Suscribirme !

Si ya eres premium y no puedes comentar haz login. Hacer login

(26) Comments

  • Avatar for Charly
    • Ivan Uriarte

    Puedes declara la variable como global (antes del setup) para poder usarla en cualquier parte, o cambiar la funcion de tipo a int y devolver el valor con un return. Un saludo.

  • Avatar for Charly
    • Janofonsagrada

    PERDON, CORRIJO CODIGO
    Hola, enhorabuena por el articulo.
    Si el valor de la variable UmbralTem lo define una función, ¿cómo puedo utilizarlo en otra funcion?

    if ((hora>=20) or (hora<=14))
    {
    const int UmbralTem=22;
    }
    if ((hora14))
    {
    const int UmbralTem=18;
    }
    ////////////
    void TemperaturaAlta() {
    Temps = (TemI) + (TemS);
    TemM = ((Temps) / 2);
    if(((EstV == 0) && (TemM)) > (UmbralTem))
    {
    EstV = 1;
    digitalWrite(vent, HIGH); // encender ventilador
    }
    if((EstV == 1 && TemM) < (UmbralTem))
    {
    EstV = 0;
    digitalWrite(vent, LOW); // apagar ventilador
    }
    }//////////FIN FUNCION TEMPERATURA ALTA/////////

  • Avatar for Charly
    • Janofonsagrada

    Hola, enhorabuena por el articulo.
    Si el valor de la variable UmbralTem lo define una función, ¿cómo puedo utilizarlo en otra funcion?
    if ((hora>=20) or (hora<=14))
    {
    UmbralTem=22;
    }

    if ((hora14))
    {
    UmbralTem=18;
    }
    ////////////////////
    void HumedadAlta() {
    if((EstV == 0) && (HumA >= UmbralHum))
    {
    EstV = 1;
    digitalWrite(vent, HIGH); // encender ventilador
    }
    if((EstV == 1) && (HumA <= UmbralHum))
    {
    EstV = 0;
    digitalWrite(vent, LOW); // apagar ventilador
    }
    }

  • Avatar for Charly
    • Ivan Uriarte

    Tienes que guardarlo en la memoria EEPROM.

  • Avatar for Charly
    • Guille

    y como puedo hacer para que una variable asignada en una lectura (de un dato o cadena de texto recibida por serial o bluetooth) se quede permanentemente aunque reinicie el arduino?

  • Avatar for Charly
    • Dimates

    Excelente tutorial… pasoa a paso

Para porder realizar consultas a nuestros expertos, tienes que ser suscriptor. Suscribiendote nos ayudas a mantener este proyecto en marcha.

¡ Quiero Suscribirme !

Si ya eres premium y no puedes comentar haz login. Hacer login