Refuerzo Académico del 3er Parcial
Camila Ortiz
- Elabore una entrada en su blog donde resuma la investigación de los siguientes componentes:
DESCRIPCIÓN:
Es un sensor de temperatura que proporciona la salida de datos de manera digital sin alterar la lectura de estos. Sin embargo, este solamente logra leer enteros, es decir que si se necesita presicion de los datos, se tendrá mas dificultad. Cada dos segundos se obtienen los datos en cantidades mostrados como enteros.
CONEXIÓN:
PROGRAMA BÁSICO:
/**
GeekFactory - "Construye tu propia tecnologia"
Distribucion de materiales para el desarrollo e innovacion tecnologica
www.geekfactory.mx
EJEMPLO SENSOR DHT11 1
EJEMPLO PARA EL SENSOR DHT11 QUE PERMITE MEDIR HUMEDAD Y TEMPERATURA. ESTE SENSOR
ES MUY ECONÓMICO Y PODEMOS USARLO PARA DETECTAR LA HUMEDAD EN EL AMBIENTE EN ZONAS
COMO INVERNADEROS, LAVANDERIAS, FABRICAS Y BAÑOS. USAMOS LA LIBRERIA DHT DE ADAFRUIT
PARA COMUNICARSE CON EL DHT11 Y DHT22
*/
#include "DHT.h"
// CONSTRUCTOR DEL OBJETO DHT RECIBE EL PIN EN EL QUE SE CONECTA EL SENSOR
// Y TAMBIEN RECIBE EL TIPO DE SENSOR QUE VAMOS A CONECTAR
DHT dht(2, DHT11);
void setup() {
// PREPARAR LA COMUNICACION SERIAL
Serial.begin(9600);
Serial.println("Prueba del sensor DHT11");
// PREPARAR LA LIBRERIA PARA COMUNICARSE CON EL SENSOR
dht.begin();
}
void loop() {
// ESPERAR ENTRE MEDICIONES, NECESARIO PARA EL BUEN FUNCIONAMIENTO
delay(2000);
// LEER LA HUMEDAD USANDO EL METRODO READHUMIDITY
float h = dht.readHumidity();
// LEER LA TEMPERATURA USANDO EL METRODO READTEMPERATURE
float t = dht.readTemperature();
// REVISAR QUE LOS RESULTADOS SEAN VALORES NUMERICOS VALIDOS, INDICANDO QUE LA COMUNICACION ES CORRECTA
if (isnan(h) || isnan(t)) {
Serial.println("Falla al leer el sensor DHT11!");
return;
}
// IMPRIMIR RESULTADO AL MONITOR SERIAL
Serial.print("Humedad: ");
Serial.print(h);
Serial.print(" % ");
Serial.print("Temperatura: ");
Serial.print(t);
Serial.println(" *C");
}
FUNCIÓN QUE BRINDA AL PROYECTO:
Este sensor nos dará la temperatura requerida.
DESCRIPCIÓN:
Es un sensor electrónico utilizado como herramienta de medición de rayos de luz infrarrojos de un objeto a simple vista. Este dispositivo, al igual que muchos otros, no generan cualquier tipo de energía para su detección, por tanto son llamados pasivos.
CONEXIÓN:
PROGRAMA BÁSICO:
Para completar el funcionamiento de este sensor se debe leer la salida del PIR, y hacer parpadear el LED
mientras la señal esté activa.
El código que se utiliza es el siguiente:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
|
const int LEDPin= 13;
const int PIRPin= 2;
void setup()
{
pinMode(LEDPin, OUTPUT);
pinMode(PIRPin, INPUT);
}
void loop()
{
int value= digitalRead(PIRPin);
if (value == HIGH)
{
digitalWrite(LEDPin, HIGH);
delay(50);
digitalWrite(LEDPin, LOW);
delay(50);
}
else
{
digitalWrite(LEDPin, LOW);
}
}
|
Si el objetivo es ejecutar una acción una sola vez al detectar
movimiento, en lugar de todo el tiempo que la señal este activa, se debe usar el siguiente código:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
|
const int LEDPin = 13; // pin para el LED
const int PIRPin = 2; // pin de entrada (for PIR sensor)
int pirState = LOW; // de inicio no hay movimiento
int val = 0; // estado del pin
void setup()
{
pinMode(LEDPin, OUTPUT);
pinMode(PIRPin, INPUT);
Serial.begin(9600);
}
void loop()
{
val = digitalRead(PIRPin);
if (val == HIGH) //si está activado
{
digitalWrite(LEDPin, HIGH); //LED ON
if (pirState == LOW) //si previamente estaba apagado
{
Serial.println("Sensor activado");
pirState = HIGH;
}
}
else //si esta desactivado
{
digitalWrite(LEDPin, LOW); // LED OFF
if (pirState == HIGH) //si previamente estaba encendido
{
Serial.println("Sensor parado");
pirState = LOW;
}
}
}
|
FUNCIÓN QUE BRINDA AL PROYECTO:
Este detectara la luz y ayudara a equilibrarse.
DESCRIPCIÓN:
Este sensor utiliza como elemento unas ondas ultrasónicas para medir la distancia, tanto para la emisión como para la recepción de esta.
CONEXION:
PROGRAMA BÁSICO:
1. CON LIBRERIA:
#include <NewPing.h>
/*Aqui se configuran los pines donde debemos conectar el sensor*/
#define TRIGGER_PIN 12
#define ECHO_PIN 11
#define MAX_DISTANCE 200
/*Crear el objeto de la clase NewPing*/
NewPing sonar(TRIGGER_PIN, ECHO_PIN, MAX_DISTANCE);
void setup() {
Serial.begin(9600);
}
void loop() {
// Esperar 1 segundo entre mediciones
delay(1000);
// Obtener medicion de tiempo de viaje del sonido y guardar en variable uS
int uS = sonar.ping_median();
// Imprimir la distancia medida a la consola serial
Serial.print("Distancia: ");
// Calcular la distancia con base en una constante
Serial.print(uS / US_ROUNDTRIP_CM);
Serial.println("cm");
}
2. SIN LIBRERÍA:
/**
GeekFactory - "Construye tu propia tecnologia"
Distribucion de materiales para el desarrollo e innovacion tecnologica
www.geekfactory.mx
EJEMPLO SENSOR ULTRASONICO 1
REALIZA LA MEDICION DE DISTANCIA CON UN SENSOR ULTRASÓNICO HC-SR04 CONECTADO
AL ARDUINO. ESTE EJEMPLO NO UTILIZA LIBRERIAS ESPECIALES PARA EL SENSOR, SOLAMENTE
SE UTILIZA LA FUNCION "PULSEIN" PARA MEDIR LA LONGITUD DEL PULSO DE ECO.
*/
// DECLARACION DE VARIABLES PARA PINES
const int pinecho = 8;
const int pintrigger = 9;
const int pinled = 13;
// VARIABLES PARA CALCULOS
unsigned int tiempo, distancia;
void setup() {
// PREPARAR LA COMUNICACION SERIAL
Serial.begin(9600);
// CONFIGURAR PINES DE ENTRADA Y SALIDA
pinMode(pinecho, INPUT);
pinMode(pintrigger, OUTPUT);
pinMode(13, OUTPUT);
}
void loop() {
// ENVIAR PULSO DE DISPARO EN EL PIN "TRIGGER"
digitalWrite(pintrigger, LOW);
delayMicroseconds(2);
digitalWrite(pintrigger, HIGH);
// EL PULSO DURA AL MENOS 10 uS EN ESTADO ALTO
delayMicroseconds(10);
digitalWrite(pintrigger, LOW);
// MEDIR EL TIEMPO EN ESTADO ALTO DEL PIN "ECHO" EL PULSO ES PROPORCIONAL A LA DISTANCIA MEDIDA
tiempo = pulseIn(pinecho, HIGH);
// LA VELOCIDAD DEL SONIDO ES DE 340 M/S O 29 MICROSEGUNDOS POR CENTIMETRO
// DIVIDIMOS EL TIEMPO DEL PULSO ENTRE 58, TIEMPO QUE TARDA RECORRER IDA Y VUELTA UN CENTIMETRO LA ONDA SONORA
distancia = tiempo / 58;
// ENVIAR EL RESULTADO AL MONITOR SERIAL
Serial.print(distancia);
Serial.println(" cm");
delay(200);
// ENCENDER EL LED CUANDO SE CUMPLA CON CIERTA DISTANCIA
if (distancia <= 15) {
digitalWrite(13, HIGH);
delay(500);
} else {
digitalWrite(13, LOW);
}
}
FUNCIÓN QUE BRINDA AL PROYECTO:
Esto medirá la distancia mas cercana.
DESCRIPCIÓN:
La fotorresistencia tiene que ver y su funcion se desarrolla dependiendo de la exposición de la luz, es decir si es creciente o disminuyente. Dependiendo de esto, se regula el flujo de la electricidad. Su objetivo principal es mantener un rango de seguridad al dificultar y bloquear la corriente de electricidad a través de un circuito.
CONEXIÓN:
PROGRAMA BÁSICO:
*/
// Pin donde se conectan los leds
int pinLed1 = 2;
int pinLed2 = 3;
int pinLed3 = 4;
// Pin analogico de entrada para el LDR
int pinLDR = 0;
// Variable donde se almacena el valor del LDR
int valorLDR = 0;
void setup()
{
// Configuramos como salidas los pines donde se conectan los led
pinMode(pinLed1, OUTPUT);
pinMode(pinLed2, OUTPUT);
pinMode(pinLed3, OUTPUT);
// Configurar el puerto serial
Serial.begin(9600);
}
void loop()
{
// Apagar todos los leds siempre que se inicia el ciclo
digitalWrite(pinLed1, LOW);
digitalWrite(pinLed2, LOW);
digitalWrite(pinLed3, LOW);
// Guardamos el valor leido del ADC en una variable
// El valor leido por el ADC (voltaje) aumenta de manera directamente proporcional
// con respecto a la luz percibida por el LDR
valorLDR= analogRead(pinLDR);
// Devolver el valor leido a nuestro monitor serial en el IDE de Arduino
Serial.println(valorLDR);
// Encender los leds apropiados de acuerdo al valor de ADC
if(valorLDR > 256)
{
digitalWrite(pinLed1, HIGH);
}
if(valorLDR > 512)
{
digitalWrite(pinLed2, HIGH);
}
if(valorLDR > 768)
{
digitalWrite(pinLed3, HIGH);
}
// Esperar unos milisegundos antes de actualizar
delay(200);
}
FUNCIÓN QUE BRINDA AL PROYECTO:
Este dará seguridad en nuestra conexión.
DESCRIPCIÓN:
El servomotor es un dispositivo electrónico que sirve para tener una mejor presicion al momento de posicionar un objeto. Físicamente es una carcasa de plastifico conformada por un motor, varios engranes y una tarjeta de control.
CONEXIÓN:
PROGRAMA BÁSICO:
La frecuencia usada para mandar la secuencia de pulsos al servomotor es
de 50 Hz esto significa que cada ciclo dura 20 ms, Las duraciones de
cada pulso se interpretan como comandos de posicionamiento del motor,
mientras que los espacios entre cada pulso son despreciados.
CODIGO PARA LOGRAR GIRAR EL MOTOR DE 0º a 180º:
*/
// Incluímos la librería para poder controlar el servo
#include <Servo.h>
// Declaramos la variable para controlar el servo
Servo servoMotor;
void setup() {
// Iniciamos el monitor serie para mostrar el resultado
Serial.begin(9600);
// Iniciamos el servo para que empiece a trabajar con el pin 9
servoMotor.attach(9);
}
void loop() {
// Desplazamos a la posición 0º
servoMotor.write(0);
// Esperamos 1 segundo
delay(1000);
// Desplazamos a la posición 90º
servoMotor.write(90);
// Esperamos 1 segundo
delay(1000);
// Desplazamos a la posición 180º
servoMotor.write(180);
// Esperamos 1 segundo
delay(1000);
}
FUNCIÓN QUE BRINDA AL PROYECTO:
De acuerdo al ángulo de giro, se podría 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.
DESCRIPCIÓN:
El motorreductor sirve como un reductor de velocidad. Su tamaño es el adecuado, ya que es explícitamente para colocarlo fácilmente. Además de tener un mantenimiento simple. La sección del reductor de velocidad de un motorreductor está disponible con diferentes flechas y configuraciones de engranes.
CONEXIÓN:
PROGRAMA BÁSICO:
const int transistorPin = 9; // conectado a la base del transistor
void setup() {
pinMode(transistorPin, OUTPUT);
}
void loop() { // loop= repetir esto constantemente
digitalWrite(transistorPin, HIGH); // enciende el motor
delay(2000); // durante 2 segundos
digitalWrite(transistorPin, LOW); // apaga el motor
delay(2000); // durante 2 segundos
}
FUNCIÓN QUE BRINDA AL PROYECTO:
Tal como su nombre lo indica, la finalidad de este aparato es reducir la velocidad con un motor posteriormente conectado. Esto probablemente ayudara a controlar la ligereza del motor, facilitando su mantenimiento.
DESCRIPCIÓN:
CONEXIÓN:
PROGRAMA BÁSICO:
*/
char rxChar; // Variable para recibir datos del puerto serie
int ledpin = 13; // Pin donde se encuentra conectado el led (pin 13)
// Configurar el arduino
void setup()
{
// Pin 13 como salida
pinMode(ledpin, OUTPUT);
// Comunicación serie a 9600 baudios
Serial.begin(9600);
}
// Ciclo infinito, programa principal
void loop()
{
// Si hay datos disponibles en el buffer
if( Serial.available() )
{
// Leer un byte y colocarlo en variable
rxChar = Serial.read();
// Procesar comando de un solo byte
if( rxChar == 'A' )
{
digitalWrite(ledpin, HIGH);
Serial.println("ON");
}
else if ( rxChar == 'a' )
{
digitalWrite(ledpin, LOW);
Serial.println("OFF");
}
}
// Podemos hacer otras cosas aquí
delay(100);
}
FUNCION QUE BRINDA AL PROYECTO:
Nos ayudara dando enlaces punto a punto entre dos módulos y también teniendo un juego de comandos más completo
