# Lectura de un sensor con salida analógica

Abre el entorno de programación de Arduino y en la ventana que se abre sustituye la plantilla que aparece por el programa que está a continuación (otra manera de crear un archivo nuevo es escogiendo la opción `New` en el menú `File`). Cópialo todo con cuidado, fíjate que no falte ningún paréntesis, llave o punto y coma, y utiliza exactamente las mismas mayúsculas y minúsculas. Esto es muy importante, ya que si no lo haces vas a obtener un error de compilación. Por otro lado, los espacios o líneas en blanco no importan.

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

void loop() {
  int sensorValue = analogRead(0);
  Serial.println(sensorValue);
  delay(1000);
}
```

Antes de seguir adelante, veamos qué quieren decir estas líneas de código.

```cpp
void setup() {
```

Esta es la cabecera de la función `setup`. `void` se refiere al tipo de valor devuelto por la función, pero por ahora su significado no es importante, así que simplemente escríbelo tal cual. Los paréntesis después del nombre de la función son obligatorios aunque estén vacíos, así que no los olvides. La llave de apertura indica el inicio del cuerpo de la función.

```cpp
Serial.begin(9600);
```

Esta es la primera (y única) instrucción de nuestra función `setup`. En ella se inicializa la comunicación entre la placa Arduino y el monitor serie. El monitor serie no es más que una ventana que se abre en el IDE de Arduino para poder leer en el ordenador los datos enviados por Arduino. La velocidad de comunicación más habitual es 9600 baudios, o bits de datos por segundo, así que ponemos ese valor como argumento de la función `Serial.begin`. Como todas las instrucciones en Arduino, termina con un punto y coma.

```cpp
}
```

La llave de cierre indica que la función `setup` ha terminado. Ahora el programa pasa a la siguiente instrucción.

```cpp
void loop() {
```

El programa entra en la función `loop`. Esta instrucción es la cabecera de la función.

```cpp
int sensorValue = analogRead(0);
```

En la primera instrucción de la función `loop` estamos usando una función muy habitual cuando trabajamos con sensores: `analogRead`. Esta función lee la señal recibida en el pin de Arduino especificado y devuelve su valor, que es un número entero entre 0 y 1023. En este caso `analogRead(0)` lee la señal que recibe el pin 0, que es precisamente el pin al que hemos conectado el sensor de temperatura. Así podemos leer el valor que mide el sensor. Sencillo, ¿no?

Como este valor lo vamos a necesitar más adelante en el programa, tenemos que almacenarlo en algún sitio. Para ello utilizaremos una variable. Una variable no es más que un espacio en memoria al que le damos un nombre y donde almacenamos un valor. A nuestra variable la llamamos `sensorValue`, y al escribir `sensorValue = analogRead(0)` estamos asignando a dicha variable el valor devuelto por `analogRead(0)`. De esta manera podemos usar el nombre `sensorValue` cada vez que deseemos acceder al valor medido por el sensor.

Cuando declaramos una variable es necesario indicar el tipo de valores que va a contener. Como hemos dicho antes, la función `analogRead` devuelve un valor entero. Por tanto, debemos ponemos la palabra `int` antes del nombre de la variable `sensorValue` para indicar que en la variable `sensorValue` se van a almacenar valores enteros.

```cpp
Serial.println(sensorValue);
```

La instrucción `Serial.println` muestra datos en el monitor serie para que podamos leerlos en el ordenador. En este caso presenta el valor de la variable `sensorValue` creada en la instrucción anterior.

```cpp
delay(1000);
```

La función `delay` para la ejecución del programa durante el tiempo especificado en milisegundos, así que `delay(1000)` le dice al programa que espere un segundo (1000 milisegundos) antes de ejecutar la instrucción siguiente.

```cpp
}
```

La llave de cierre de la función `loop` funciona de manera diferente que la de la función `setup`. Aunque también indica que la función ha terminado, en este caso la ejecución del programa no pasa a la siguiente instrucción, sino que vuelve a la instrucción inicial de la función `loop`. En consecuencia, el cuerpo de la función `loop` se ejecuta de nuevo, y una vez más, y otra, y otra...\
\
Guarda el programa y ya estamos listos para pasar al siguiente paso.