7 ENTRADAS ANALOGICAS

 

7 Entradas y salidas análogas

Cuando ingresas una señal al puerto de sensores analógicos en Arduino, lo primero que hace Arduino es convertir la señal analógica en una señal digital mediante un convertidor analógico-digital (ADC).

Este proceso ocurre en los siguientes pasos:

Muestreo: Arduino toma un valor instantáneo de la señal analógica.

Cuantización: La señal se convierte en un número discreto dentro del rango del ADC (en un Arduino típico de 10 bits, los valores van de 0 a 1023).

Conversión a digital: El valor cuantizado se almacena en una variable digital para su procesamiento en el código

.

Proceso de conversion 

Para convertir un valor de temperatura de 23°C a una representación de 10 bits en Arduino, sigues estos pasos:

1. Convertir de temperatura a una lectura digital (ADC)

Arduino mide voltajes, no temperaturas, por lo que necesitas conocer cómo el sensor traduce la temperatura en voltaje. Supongamos que usas un sensor LM35, que entrega 10 mV por cada °C.

23 grados equivalen al numero binario 0000101111

la mitad

Paso 1: Obtener el voltaje del sensor

El sensor LM35 entrega:

$$V_{\text{salida}} = 23°C \times 10 \text{mV} = 230 \text{mV} = 0.23V$$

Paso 2: Convertir a nivel digital (10 bits)

El conversor ADC de Arduino toma valores entre 0V y 5V, asignando 1024 niveles (0-1023). La conversión es:

$$\text{Lectura ADC} = \left( \frac{V_{\text{salida}}}{V_{\text{referencia}}} \right) \times 1023$$

Sustituyendo valores:

$$\text{Lectura ADC} = \left( \frac{0.23V}{5V} \right) \times 1023$$ $$\approx 47$$

Por lo tanto, el valor digital almacenado en Arduino será 47 (en decimal), que en binario de 10 bits es:

$$47_{10} = 0000101111_2$$

---

2. Convertir de digital a analógico (recuperar temperatura)

Para recuperar la temperatura:

$$V_{\text{salida}} = \frac{\text{Lectura ADC} \times V_{\text{referencia}}}{1023}$$ $$V_{\text{salida}} = \frac{47 \times 5V}{1023} \approx 0.23V$$

Luego, usando la conversión del sensor LM35:

$$T = \frac{V_{\text{salida}}}{10 \text{mV/°C}} = \frac{0.23V}{0.01V/°C} = 23°C$$

---

Resumen del procedimiento

1. De temperatura a digital:

   • Convertir °C a voltaje según el sensor.
   • Convertir voltaje a nivel ADC usando $\frac{V}{5V} \times 1023$.
   • Representar el resultado en binario (10 bits).

2. De digital a temperatura:

   • Convertir el valor ADC a voltaje usando $\frac{\text{ADC} \times 5V}{1023}$.
   • Aplicar la fórmula inversa del sensor para recuperar la temperatura.

Este mismo proceso aplica para cualquier sensor que entregue una señal analógica. ¿Quieres un código en Arduino para probarlo?

¿Qué es la Comunicación Serial?

La comunicación serial es un método para enviar y recibir datos secuencialmente, bit por bit, a través de un solo canal de datos. En Arduino, se utiliza principalmente para la transmisión de datos entre la placa y otros dispositivos, como computadoras, módulos de comunicación o sensores avanzados.

2. Características Principales

• Utiliza los pines TX (transmisión) y RX (recepción).

• Soporta diferentes velocidades de transmisión de datos (baud rate), como 9600 baudios.

• Permite depurar programas y monitorear datos en tiempo real mediante el Monitor Serial del IDE de Arduino.

3. ¿Qué es el Baud Rate o Baudios?

El baud rate (o baudios) es la velocidad de transmisión de datos en un sistema serial, medida en bits por segundo (bps). Por ejemplo, un baud rate de 9600 significa que se transmiten 9600 bits por segundo. Es importante que el baud rate configurado en Arduino coincida con el de los dispositivos con los que se comunica, como el Monitor Serial.

MONITOR SERIAL TINKERCAD

El Monitor Serial en Arduino es una herramienta integrada en el Entorno de Desarrollo Integrado (IDE) que permite la comunicación entre la placa Arduino y un ordenador. A través de esta interfaz, es posible enviar y recibir datos en formato de texto, lo cual es especialmente útil para depurar programas, monitorear valores de sensores en tiempo real y controlar dispositivos conectados a la placa desde el ordenador.

Para utilizar el Monitor Serial, es necesario inicializar la comunicación serie en el programa de Arduino mediante la función Serial.begin(velocidad), donde "velocidad" es la tasa de baudios, comúnmente 9600. Una vez establecida la comunicación, se pueden emplear las funciones Serial.print() y Serial.println() para enviar datos al ordenador, y Serial.read() para recibir datos desde el mismo.

El Monitor Serial es una herramienta esencial para el desarrollo de proyectos con Arduino, ya que facilita la interacción y el intercambio de información entre la placa y el usuario, permitiendo una mejor comprensión y control del comportamiento del programa.

ACTIVIDAD 1

EJECUTAR EL SIGUIENTE CIRCUITO:

Código:

int valor; // Declaramos una variable llamada "valor" que almacenará datos del sensor

void setup() {
    pinMode(LED_BUILTIN, OUTPUT); // Configuramos el LED interno de la placa como salida
}

void loop() {
    analogRead(A3); // Leemos el valor del sensor conectado a la entrada analógica A3
    digitalWrite(LED_BUILTIN, HIGH); // Encendemos el LED interno
    delay(1000); // Esperamos 1 segundo (1000 milisegundos)
    digitalWrite(LED_BUILTIN, LOW); // Apagamos el LED interno
    delay(1000); // Esperamos otro segundo antes de repetir el ciclo
}

---

Explicación Línea por Línea:

1. int valor;

   • Se declara una variable llamada valor, que se usará para almacenar datos de un sensor.
   • Aunque en este código no se usa la variable valor, en otros programas puede ser útil para guardar datos y hacer cálculos con ellos.

2. void setup() {

   • Esta es una función especial que se ejecuta una sola vez al encender la placa Arduino o al reiniciarla.
   • Se usa para inicializar configuraciones, como definir si un pin es de entrada o salida.

3. pinMode(LED_BUILTIN, OUTPUT);

   • pinMode() es una función que configura un pin para que funcione como entrada (INPUT) o salida (OUTPUT).
   • LED_BUILTIN es el LED que ya viene en la placa Arduino (normalmente en el pin 13).
   • Al ponerlo en OUTPUT, indicamos que lo vamos a encender y apagar en el programa.

4. void loop() {

   • Esta función se ejecuta en un bucle infinito (se repite para siempre).
   • Aquí escribimos el código que queremos que la placa ejecute constantemente.

5. analogRead(A3);

   • analogRead() lee valores de una entrada analógica (en este caso, el pin A3).
   • Se usa cuando tenemos sensores como potenciómetros (como el que se ve en la imagen).
   • En este código, la lectura no se almacena en ninguna variable ni se usa después, por lo que no tiene efecto.

6. digitalWrite(LED_BUILTIN, HIGH);

   • digitalWrite() cambia el estado de un pin digital.
   • HIGH significa encender el LED.

7. delay(1000);

   • delay() pausa la ejecución del código durante un tiempo determinado en milisegundos.
   • 1000 significa que el programa se detiene por 1 segundo antes de continuar.

8. digitalWrite(LED_BUILTIN, LOW);

   • LOW significa apagar el LED.

9. delay(1000);

   • Se espera otro segundo antes de volver a repetir el ciclo.

---

¿Qué DEBE HACER este programa?

1. Lee el sensor en A3 (aunque no usa el valor leído).
2. Enciende el LED interno.
3. Espera 1 segundo.
4. Apaga el LED interno.
5. Espera otro segundo.
6. Repite el proceso una y otra vez.

Si quieres que el valor del sensor se muestre en la computadora a través del Monitor Serial, puedes modificar el código agregando lo siguiente:

void loop() {
    valor = analogRead(A3); // Leer el sensor y almacenar el valor en "valor"
    Serial.println(valor); // Enviar el valor al Monitor Serial
    digitalWrite(LED_BUILTIN, HIGH);
    delay(1000);
    digitalWrite(LED_BUILTIN, LOW);
    delay(1000);
}

Y en el setup(), agrega Serial.begin(9600); para habilitar la comunicación:

void setup() {
    Serial.begin(9600); // Iniciar la comunicación con el PC
    pinMode(LED_BUILTIN, OUTPUT);
}

Así, podrás ver en la pantalla cómo cambia el valor del sensor en tiempo real.

ACTIVIDAD 2