ACTIVIDAD FINAL DEL MODULO



PARTE 1 : SIMULACION

Enunciado

Diseñar un circuito con Arduino que mida la temperatura usando un sensor TMP36 y controle un servomotor, moviéndolo 55 grados cuando la temperatura supere un umbral predefinido.




---

Instrucciones para armar el circuito

1. Materiales necesarios

Arduino Uno

Sensor de temperatura TMP36

Servomotor SG90

Cables de conexión

Protoboard


2. Conexión del sensor TMP36

VCC (pin 1 del TMP36) → 5V de Arduino

GND (pin 3 del TMP36) → GND de Arduino

VOUT (pin 2 del TMP36) → A0 de Arduino


3. Conexión del servomotor SG90

Cable Rojo → 5V de Arduino

Cable Marrón/Negro → GND de Arduino

Cable Naranja/Blanco → Pin 9 de Arduino




---

Funcionamiento del circuito

1. Arduino mide la temperatura con el TMP36 cada segundo.


2. Si la temperatura supera 30°C, el servomotor se moverá 55 grados.


3. Si la temperatura baja del umbral, el servomotor regresará a 0 grados.


4. La temperatura medida se mostrará en el Monitor Serial.




---

Código explicado

#include <Servo.h> // Librería para el servomotor

Servo servoMotor; // Crear objeto para el servomotor
const int pinTMP36 = A0; // Pin analógico donde está conectado el TMP36
const int pinServo = 9; // Pin donde está conectado el servomotor
const float umbralTemperatura = 30.0; // Temperatura límite en grados Celsius

void setup() {
  Serial.begin(9600); // Iniciar comunicación serie
  servoMotor.attach(pinServo); // Asignar el servomotor al pin 9
  servoMotor.write(0); // Posición inicial del servomotor en 0 grados
}

void loop() {
  int lectura = analogRead(pinTMP36); // Leer el valor del sensor TMP36
  float voltaje = lectura * (5.0 / 1023.0); // Convertir lectura a voltaje
  float temperatura = (voltaje - 0.5) * 100.0;  
  // Convertir voltaje a temperatura en °C
  Serial.print("Temperatura: ");
  Serial.print(temperatura);
  Serial.println(" °C");

  if (temperatura > umbralTemperatura) {  
    // Si la temperatura supera el umbral, mover el servo 55 grados
    servoMotor.write(55);  
    Serial.println("Servo movido a 55 grados");
  } else {  
    // Si la temperatura es menor, regresar a 0 grados
    servoMotor.write(0);  
    Serial.println("Servo en posición inicial");
  }

  delay(1000); // Esperar 1 segundo antes de la siguiente medición
}


---

Forma de probar el circuito

1. Subir el código a la placa Arduino Uno.


2. Abrir el Monitor Serial en Arduino IDE para ver la temperatura medida.


3. Calentar el sensor TMP36 (puedes usar la mano o un encendedor a distancia).


4. Si la temperatura supera 30°C, el servomotor debe moverse 55 grados.


5. Si la temperatura baja, el servomotor debe regresar a 0 grados.


PARTE 2 PRÁCTICO 

Enunciado

Diseñar un circuito con Arduino que mida la temperatura usando un sensor TMP36 y controle un LED. El LED se encenderá cuando la temperatura supere los 30°C y se apagarán cuando la temperatura sea inferior a este valor. El circuito también mostrará la temperatura medida en el Monitor Serial.

PROGRAMACION PARA GUIARTE

Aquí está el código modificado para que el LED reemplace al servomotor. Ahora, el LED se enciende cuando la temperatura supera 30°C y se apaga cuando baja de ese valor.


---

Conexión del circuito

1. TMP36

VCC (pin 1) → 5V de Arduino

GND (pin 3) → GND de Arduino

VOUT (pin 2) → A0 de Arduino



2. LED (con resistencia de 220Ω en serie)

Ánodo (+) → Pin 7 de Arduino

Cátodo (-) → GND de Arduino





---

Código

const int pinTMP36 = A0; // Pin del sensor de temperatura TMP36
const int pinLED = 7; // Pin donde está conectado el LED
const float umbralTemperatura = 30.0; // Temperatura límite en grados Celsius

void setup() {
  Serial.begin(9600); // Iniciar comunicación serie
  pinMode(pinLED, OUTPUT); // Configurar el LED como salida
  digitalWrite(pinLED, LOW); // Asegurar que el LED empieza apagado
}

void loop() {
  int lectura = analogRead(pinTMP36); // Leer el valor del sensor TMP36
  float voltaje = lectura * (5.0 / 1023.0); // Convertir lectura a voltaje
  float temperatura = (voltaje - 0.5) * 100.0;  
  // Convertir voltaje a temperatura en °C
  
  Serial.print("Temperatura: ");
  Serial.print(temperatura);
  Serial.println(" °C");

  // Control del LED  
  if (temperatura > umbralTemperatura) {  
    digitalWrite(pinLED, HIGH); // Encender el LED
    Serial.println("LED ENCENDIDO: Temperatura alta");
  } else {  
    digitalWrite(pinLED, LOW); // Apagar el LED
  }

  delay(1000); // Esperar 1 segundo antes de la siguiente medición
}


---

Cómo probar el circuito

1. Sube el código a Arduino Uno.


2. Abre el Monitor Serial para ver la temperatura medida.


3. Calienta el TMP36 (con la mano o un encendedor a distancia).


4. Comportamiento esperado:

A más de 30°C, el LED se enciende.

A menos de 30°C, el LED se apaga.











10 SERVOMOTOR

 

Servomotor con Arduino tutorial de programación paso a paso

click


¿ QUE ES UN SERVOMOTOR ?
Un servomotor esta constituido por un pequeño motor de corriente contínua y unas ruedas dentadas que hacen de reductora, lo que le da una potencia considerable. Además de esto cuenta con una pequeña tarjeta electrónica que es necesaria para su control.
El servomotor tiene un ángulo de giro de 0º a 180º, a no ser que se modifique su estructura interna para que este pueda girar 360º.



Funcionamiento del servomotor:

La tensión de alimentación de los servos esta comprendida entre los 4 y los 8 voltios. El control del servo simplemente consiste en indicarle la posición en la que se debe situar, mediante una señal cuadrada TTL modulada con PWM.
La duración de nivel alto de la señal indica la posición donde pondremos el eje del motor.
En la siguiente imagen podemos ver la posición del servo(ángulo) en función de la duración del pulso, estos margenes son genéricos, ya que cada servo tiene sus rangos de operación. 
El rango de operación corresponde con el ancho de pulso mínimo(0º) y el máximo(180º) , que el servo entiende. Por lo general estos rangos van desde 0,3ms hasta 2,1ms.


En el ejemplo de la imagen se aprecia que la posición inicial(0º) se encuentra en 0,3 ms, la posición central(90º) en 1,5ms y la posición máxima(180º) en 2,1 ms. Si se sobrepasan los límites de movimiento del servo, este comenzará a vibrar o emitir un zumbido, pidiendo el cambio en la anchura del pulso.

El periodo que se suele utilizar suele estar entre 10ms y 30ms, aunque lo habitual es 20 ms, trabajando a una frecuencia de 50Hz. Si el periodo es menor al mínimo, esto puede interferir en la temporización interna del servo, causando zumbido y vibración. En caso contrario si fuera mayor que el máximo pasará a estado dormido entre pulsos provocando que se mueva en pequeños intervalos.

Ademas de todo esto, el servo para que mantenga la misma posición , es necesario enviarle contínuamente pulsos de anchura constante. De esta forma, el servo mantendrá su posición a pesar de que exista alguna fuerza externa que intente mover su posición.

Terminales del servo

El servo motor cuenta con tres terminales de conexión.
  • Vcc: corresponde al cable de alimentación, de color rojo.
  • Gnd: es el cable de masa, puede ser negro o marrón.
  • Señal: es por donde se aplica la entrada de pulsos(Pwm). Puede ser de color amarillo,blanco o naranja.

¿Qué significa "crear un objeto"?

En programación, un objeto es una "cosa" que podemos controlar con comandos. En este caso, el objeto Servo representa un servomotor y nos permite ordenarle que gire a ciertos ángulos.

Piensa en un objeto en la vida real, como un control remoto de TV:

  • El control remoto (el objeto) tiene botones (funciones).
  • Puedes usar esos botones para cambiar de canal, subir volumen, apagar, etc.

En el código de Arduino, cuando escribimos esto:

Servo miServo;

Estamos diciendo:
"Voy a usar un servomotor, y lo llamaré miServo para darle órdenes después."


Ejemplo con Comparación

Si quisiéramos usar un auto de juguete en un programa, podríamos hacer algo así:

Auto miAuto;  // Creamos un objeto "miAuto"

miAuto.avanzar();  // Le decimos que avance
miAuto.frenar();   // Le decimos que frene

En el caso del servomotor, hacemos lo mismo:

Servo miServo;   // Creamos el objeto "miServo"
miServo.write(90);  // Le decimos que gire a 90°

Resumen Sencillo

  • Un objeto es algo que podemos controlar en programación.
  • En Arduino, Servo miServo; crea un objeto que representa un servomotor.
  • Luego, usamos miServo.write(90); para moverlo, como si fuera un control remoto.

Funcionamiento del servomotor.

Un servomotor o servo. Es un motor eléctrico pero con dos características especiales.

Servomotor con Arduino



Por un lado, nos permite mantener una posición que indiquemos, siempre que esté dentro del rango de operación del propio dispositivo. Por otro lado nos permite controlar la velocidad de giro, podemos hacer que antes de que se mueva a la siguiente posición espere un tiempo.El ejemplo más típico es un coche teledirigido, esos que utilizan los niños y no tan niños. Estos juguetes suelen tener un mando a distancia donde podemos controlar la velocidad y el giro del coche. Precisamente el giro se suele hacer con un servomotor donde indicamos, en cada momento, la posición o el ángulo de giro que queremos que tenga en un preciso momento.

Características técnicas de un servomotor con Arduino

Hay varios modelos de servomotor con Arduino. En este caso vamos a utilizar un Micro Servo 9g SG90 de Tower Pro. Como siempre digo, hay que mirar la ficha técnica del producto. Todos tienen un funcionamiento muy parecido y la programación puede variar muy poco.

servomotor-arduino

Cosas a tener en cuenta con este dispositivo. Lo primero, el ángulo de giro, en este caso nos permite hacer un barrido entre -90º y 90º. Lo que viene a ser un ángulo de giro de 180º.

Aunque el servo puede moverse con una resolución de más de 1 grado, este es el máximo de resolución que vamos a conseguir debido a la limitación de la señal PWM que es capaz de generar Arduino UNO.

Estos motores funcionan con una señal PWM, con un pulso de trabajo entre 1 ms y 2 ms y con un periodo de 20 ms (50 Hz). ¿Qué quiere decir todo esto? Este dato nos indica la velocidad máxima a la que podemos mover el servomotor con Arduino. Solo podremos cambiar de posición cada 20 ms. Esto dependerá del tipo y marca de nuestro servo.

El elegir una salida PWM u otra da lo mismo, todas las salidas de este tipo funcionan igual.

Conexionado con Arduino

Las conexiones dependerán del tipo de servomotor con Arduino que estemos utilizando.

Conexion servomotor con Arduino

Todos deben tener 3 cables. Uno irá a tierra, otro a la alimentación de 5 Voltios y el tercero a un pin PWM. También puedes utilizar un shield para controlar servomotores, como el de Adafruit.

¿Cómo programar un servo desde el entorno de Arduino?

Ahora vamos a ir a lo interesante, la programación. Para ello tenemos que hacer uso de una librería externa para poder controlar el servo desde Arduino. Para incorporar la librería tenemos que ir a Programa/Include Library/Servo.

Importar libreria servomotor Arduino

El código para girar el motor de 0º a 180º

Esta acción ya nos ha hecho un include en nuestro código que nos permite controlar el servo. Os dejo a continuación un código básico para posicionar el servo en los ángulos 0º, 90º y 180º.

De la librería Servo.h hemos declarado un objeto o variable servoMotor y hacemos uso de dos métodos. Por un lado el attach, que nos permite indicar en que pin tenemos conectado nuestro servo, y por otro lado el write, donde indicamos en qué ángulo queremos posicionar nuestro servomotor.

Girando grado a grado el servomotor

Vamos a realizar otro ejemplo un poco más complicado, en este caso queremos que el servo haga un barrido desde el 0 al 180º y luego en sentido contrario. Vamos a utilizar los mismos métodos pero incorporamos dos bucles for, uno para cada sentido.

Actividad Sumativa 3: 

Aquí tienes un código para usar un sensor DHT11 junto con un servomotor en Arduino.

Funcionamiento

  • El DHT11 mide la temperatura.
  • Si la temperatura supera 25°C, el servomotor gira a 90°.
  • Si la temperatura baja de 25°C, el servomotor regresa a .

Código Arduino

#include <Servo.h>       // Librería para el servomotor
#include <DHT.h>         // Librería para el sensor DHT11

#define DHTPIN 2         // Pin donde está conectado el DHT11
#define DHTTYPE DHT11    // Tipo de sensor (DHT11)

DHT dht(DHTPIN, DHTTYPE); // Crear objeto DHT
Servo miServo;           // Crear objeto Servo

void setup() {
    Serial.begin(9600);   // Iniciar monitor serie
    dht.begin();          // Iniciar sensor DHT11
    miServo.attach(9);    // Conectar servomotor al pin 9
}

void loop() {
    float temperatura = dht.readTemperature(); // Leer temperatura en °C

    Serial.print("Temperatura: ");
    Serial.print(temperatura);
    Serial.println(" °C");

    if (temperatura > 25) {
        miServo.write(90);  // Si la temperatura es mayor a 25°C, mueve el servo a 90°
    } else {
        miServo.write(0);   // Si es menor o igual a 25°C, vuelve a 0°
    }

    delay(2000); // Esperar 2 segundos antes de medir otra vez
}

Conexión del DHT11 y Servomotor


Explicación del Código

  1. Incluimos las librerías Servo.h y DHT.h.
  2. Definimos el pin del DHT11 y el tipo de sensor.
  3. Creamos los objetos dht (para el sensor) y miServo (para el motor).
  4. En setup():
    • Iniciamos el monitor serie.
    • Activamos el sensor DHT11 y el servomotor.
  5. En loop():
    • Leemos la temperatura del DHT11.
    • Si la temperatura es mayor a 25°C, el servomotor gira a 90°.
    • Si es menor o igual a 25°C, vuelve a .
    • Esperamos 2 segundos y repetimos el proceso.

Prueba el código en Tinkercad o en un Arduino real. Si necesitas ajustes, dime.

Conclusión

Controlar un servo desde Arduino es una tarea muy sencilla gracias al uso de la librería Servo.h. Te recomiendo que sigas practicando con esta librería.

9 Sensores Análogos de Arduino

Sensor de sonido KY-037


Módulo que detecta sonidos .mediante un micrófono electret y entrega señales analógicas y digitales. Tiene dos potenciómetros para ajustar la sensibilidad del micrófono y el umbral de detección del canal digital.0


¿Qué es un micrófono electret?

Un micrófono electret es un tipo de micrófono de condensador que usa un material electret (un dieléctrico con carga eléctrica permanente) para detectar sonidos y convertirlos en señales eléctricas.

Funcionamiento del micrófono electret

  1. Captación del sonido:
    • Una membrana delgada vibra con las ondas sonoras.
  2. Variación de la capacitancia:
    • La membrana está cerca de una placa fija, formando un condensador.
    • Cuando la membrana vibra, la capacitancia cambia, generando variaciones de voltaje.
  3. Amplificación con FET interno:
    • Un pequeño transistor de efecto de campo (FET) amplifica la señal, ya que el micrófono genera una corriente muy débil.
  4. Salida de la señal:
    • La señal amplificada puede ser procesada por un circuito externo, como un sensor de sonido KY-037 o una tarjeta de sonido en dispositivos de grabación.

Ejemplo de aplicación KY 037

  • En el KY-037, el micrófono electret detecta sonidos y genera una señal analógica proporcional a la intensidad del sonido, que se puede leer con Arduino.
  • También se usa en micrófonos de celulares, audífonos, cámaras y equipos de grabación por su pequeño tamaño y bajo consumo.


Características principales del sensor

  • Salida digital (D0): Se activa cuando el sonido supera el umbral ajustado.
  • Salida analógica (A0): Proporciona un voltaje proporcional a la intensidad del sonido.
  • Tensión de operación: 3.3V - 5V (compatible con Arduino).

Actividad de Simulación de KY-037 con Potenciómetro

Objetivo: En esta actividad se simulará el comportamiento del micrófono KY-037 utilizando un potenciómetro para generar una señal variable que se leerá a través del puerto serial de un Arduino. El propósito es emular el comportamiento de un micrófono sin necesidad de capturar sonido real, solo variando el valor de voltaje como lo haría un micrófono al captar diferentes intensidades sonoras.


---

Materiales:

1 Arduino (cualquier modelo con entrada analógica)

1 Potenciómetro (10kΩ recomendado)

2 Cables de conexión

1 Resistencia de 10kΩ (opcional, si se desea un divisor de voltaje más preciso)

1 Fuente de alimentación de 5V (como la que proporciona Arduino)

1 PC con el entorno de desarrollo de Arduino (IDE)



---

Esquema de conexión:

1. Conecta un extremo del potenciómetro a 5V (fuente de alimentación de Arduino).


2. Conecta el otro extremo del potenciómetro a GND (tierra).


3. Conecta el terminal central (wiper) del potenciómetro al pin analógico A0 del Arduino. Este será el punto de salida de la señal variable.


4. (Opcional) Usa una resistencia en serie si deseas ajustar mejor el rango de voltaje.




---

Código para Arduino:

int valorPot = 0; // Variable para almacenar el valor leído del potenciómetro

void setup() {
  Serial.begin(9600); // Iniciar la comunicación serie
}

void loop() {
  valorPot = analogRead(A0); // Leer el valor analógico de A0
  Serial.println(valorPot); // Imprimir el valor en el monitor serie
  delay(100); // Espera de 100 ms
}


---

Procedimiento:

1. Conectar los componentes: Realiza las conexiones como se indica en el esquema, asegurándote de que el potenciómetro esté correctamente conectado al pin A0 del Arduino.


2. Cargar el código en Arduino: Abre el IDE de Arduino y carga el código proporcionado. Esto permitirá que el Arduino lea continuamente el valor del potenciómetro conectado a A0.


3. Monitorear la salida serial: Una vez cargado el código, abre el Monitor Serial en el IDE de Arduino. El valor leído por el Arduino de la entrada analógica A0 (proveniente del potenciómetro) aparecerá en el monitor serial.




---

Explicación de los resultados:

El potenciómetro variará su resistencia interna conforme lo gires, lo que hará que el voltaje en el terminal central (wiper) cambie entre 0V y 5V.

El valor leído por el pin A0 del Arduino será un número entre 0 y 1023, que representa el voltaje que el potenciómetro está generando, mapeado en 10 bits (de 0 a 1023).

Al girar el potenciómetro:

Si lo giras hacia un extremo, el valor en el monitor serial será bajo (cerca de 0), representando un sonido muy débil o ausente.

Si lo giras al otro extremo, el valor será alto (cerca de 1023), emulando un sonido fuerte o intenso.



En resumen, lo que verás en el monitor serial es una señal de voltaje variable, similar a lo que un micrófono haría al captar sonidos de distintas intensidades. Aunque el potenciómetro no detecta sonido real, su variación de voltaje puede ser utilizada para emular el comportamiento de un micrófono en cuanto a la variabilidad de la señal en función de la "intensidad" del sonido.


---

Conclusión:

A través de este ejercicio, hemos simulado el comportamiento de un micrófono utilizando un potenciómetro como generador de señales analógicas. El monitor serial en Arduino muestra cómo el voltaje varía, emulando cómo un micrófono podría generar señales en respuesta a cambios en la intensidad del sonido. Esto te permite experimentar con la lectura de señales análogas sin necesidad de captar sonido real.

Sensor de nivel de agua

Definición del Sensor de Nivel de Agua

Este sensor es un sensor de nivel de agua que detecta la presencia o ausencia de líquido mediante la conductividad eléctrica entre sus pistas de cobre. Funciona como un divisor de voltaje y genera una señal analógica proporcional al nivel de agua que lo cubre.


---

Detalles Importantes del Sensor

1. Voltaje de operación: 3.3V - 5V


2. Salida: Señal analógica (proporcional a la cantidad de agua)


3. Interfaz: 3 pines (VCC, GND, y SIG)


4. Principio de funcionamiento: Al cubrirse con agua, la resistencia disminuye y el voltaje de salida aumenta.




---

Conexión con Arduino

Conectaremos el sensor al Arduino de la siguiente manera:

VCC → 5V en Arduino

GND → GND en Arduino

SIG → Entrada analógica A0 en Arduino


Para controlar un servomotor, conectaremos:

Cable rojo del servo → 5V en Arduino

Cable negro del servo → GND en Arduino

Cable amarillo/blanco del servo → Pin digital 9 en Arduino



---

Código para Leer el Sensor y Mostrar Datos en el Monitor Serial

#include <Servo.h> // Librería para controlar el servomotor

Servo miServo; // Crear un objeto para el servomotor
int pinSensor = A0; // Entrada analógica del sensor
int pinServo = 9; // Pin del servomotor

void setup() {
  Serial.begin(9600); // Iniciar comunicación serial
  miServo.attach(pinServo); // Asignar el servo al pin 9
  miServo.write(0); // Posicionar el servo en 0°
}

void loop() {
  int lectura = analogRead(pinSensor); // Leer el valor del sensor
  Serial.print("Nivel de Agua: ");      
  Serial.println(lectura); // Imprimir el valor en el Monitor Serial

  // Controlar el servomotor si el nivel de agua es alto
  if (lectura > 500) { 
    miServo.write(90); // Mover el servo a 90°
  } else {
    miServo.write(0); // Mantener en 0° si el nivel de agua es bajo
  }

  delay(500); // Pequeña pausa antes de la siguiente lectura
}


---

Explicación del Código

1. Importamos la librería Servo.h y creamos un objeto miServo.


2. Configuramos los pines en setup(), iniciando el servo en 0°.


3. En loop():

Leemos el sensor con analogRead(A0).

Mostramos el valor en el Monitor Serial con Serial.println(lectura).

Si el nivel de agua es alto (lectura > 500), el servomotor se mueve a 90°.

Si el nivel es bajo, el servo vuelve a 0°.

Esperamos 500 ms antes de la siguiente lectura.





---

Comportamiento en el Monitor Serial

Cuando se sumerge el sensor en agua, el Monitor Serial mostrará valores altos. Si el sensor está seco, los valores serán bajos.

Ejemplo de salida en el Monitor Serial:

Nivel de Agua: 120
Nivel de Agua: 650 <-- Se detectó agua
Nivel de Agua: 700
Nivel de Agua: 150 <-- Agua bajó

Cuando los valores sean mayores a 500, el servomotor se moverá a 90°, indicando la presencia de agua. Cuando sean menores, regresará a 0°.


---

Resumen de la Asociación con el Servomotor

Sin agua → Servo en 0°

Con agua → Servo en 90°


Este sistema puede usarse para activar válvulas o alarmas según el nivel de agua detectado.

Interpretación de los Valores en el Monitor Serial

Cuando conectamos el sensor a Arduino y abrimos el Monitor Serial, veremos una serie de valores numéricos que indican la lectura de voltaje del sensor. Estos valores pueden variar entre 0 y 1023, ya que Arduino usa una conversión analógica-digital (ADC) de 10 bits.


---

Ejemplo de Salida en el Monitor Serial

Si el sensor está seco (sin agua), la resistencia es alta y la lectura será cercana a 0:

Nivel de Agua: 20
Nivel de Agua: 15
Nivel de Agua: 10

Si el sensor empieza a mojarse, la resistencia disminuye y el valor aumenta:

Nivel de Agua: 300
Nivel de Agua: 450

Cuando el sensor está sumergido completamente, la lectura será alta (cercana a 1023 si está bien sumergido):

Nivel de Agua: 850
Nivel de Agua: 900
Nivel de Agua: 980


---

Cómo Interpretamos Estos Valores

0 - 100 → El sensor está seco o apenas hay agua.

100 - 500 → Hay algo de agua, pero el nivel es bajo.

500 - 800 → El sensor está moderadamente sumergido.

800 - 1023 → El sensor está completamente sumergido en agua.



---

Relación con el Servomotor

Si el valor en el Monitor Serial es menor a 500, el servomotor se queda en 0°.

Si el valor es mayor a 500, el servomotor se mueve a 90°.


Ejemplo de Monitor Serial con el servo en acción:

Nivel de Agua: 120 → Servo en 0°
Nivel de Agua: 600 → Servo en 90°
Nivel de Agua: 750 → Servo en 90°
Nivel de Agua: 300 → Servo en 0°

Este comportamiento nos ayuda a interpretar la cantidad de agua detectada y a tomar decisiones, como activar una válvula o una bomba cuando el nivel es alto.




JIJIJIJIJI

ACTIVIDAD FINAL DEL MODULO

PARTE 1 : SIMULACION Enunciado Diseñar un circuito con Arduino que mida la temperatura usando un sensor TMP36 y controle un servomotor, movi...