Sorteo

KY-011: Módulo Led THT 5mm Bi-Color

Descripción:
Posee un led THT de 5mm de dos colores (Rojo-Verde) de Cátodo común, necesitamos agregarle 2 resistencias en serie a cada color, en Arduino de 330Ω y en Raspberry Pi de 150Ω. Su Tensión de trabajo ronda entre los 2V-2.5V.

Conexión Arduino:

Código Arduino:

int Led_Red = 11; 
int Led_Green = 10;
   void setup ()
 {      
pinMode (Led_Red, OUTPUT);
pinMode (Led_Green, OUTPUT);
 }
   void loop ()
      {
        digitalWrite (Led_Red, HIGH);
        digitalWrite (Led_Green, LOW);
        delay (3000);
        digitalWrite (Led_Red, LOW);
        digitalWrite (Led_Green, HIGH);
        delay (3000); 
      }

Conexión Raspberry Pi:

Código Raspberry Pi:

import RPi.GPIO as GPIO
import time

GPIO.setmode(GPIO.BCM)

LED_Red = 16
LED_Green = 18
GPIO.setup(LED_Red, GPIO.OUT, initial= GPIO.LOW)
GPIO.setup(LED_Green, GPIO.OUT, initial= GPIO.LOW)

print ("LED-Test [press ctrl+c to end the test]")

try:
while True:
print("LED Rojo se enciende por 3 segundos")
GPIO.output(LED_Red,GPIO.HIGH) 
GPIO.output(LED_Green,GPIO.LOW) 
time.sleep(3) 
print("LED Verde se enciende por tres segundos") 
GPIO.output(LED_Red,GPIO.LOW) 
GPIO.output(LED_Green,GPIO.HIGH) 
time.sleep(3) 

except KeyboardInterrupt:
GPIO.cleanup()

Para correr el programa abrimos terminal y tecleamos:

  • sudo python ky-011.py

KY-012: Módulo Buzzer Activo


Descripción:
Este módulo crea un sonido a una frecuencia de 2.5KHz.

Conexión Arduino:


Código Arduino:

int Buzzer = 8;
 
void setup ()
{
  pinMode (Buzzer, OUTPUT); 
}
 
void loop () 
{
  digitalWrite (Buzzer, HIGH); 
  delay (4000); 
  digitalWrite (Buzzer, LOW); 
  delay (2000); 
}

Conexión Raspberry Pi:

Código Raspberry Pi:

import RPi.GPIO as GPIO
import time
    
GPIO.setmode(GPIO.BCM)
   .
Buzzer_PIN = 18
GPIO.setup(Buzzer_PIN, GPIO.OUT, initial= GPIO.LOW)
    
print ("Buzzer-test [press ctrl+c to end the test]")
   
try:
        while True:
            print("Buzzer sonara por 4 segundos")
            GPIO.output(Buzzer_PIN,GPIO.HIGH) 
            time.sleep(4) 
            print("Buzzer no suena por 4 segundos") 
            GPIO.output(Buzzer_PIN,GPIO.LOW) 
            time.sleep(4) 
    
except KeyboardInterrupt:
        GPIO.cleanup()

Para correr el programa abrimos terminal y tecleamos:

  • sudo python ky-012.py

KY-013: Módulo Análogo Sensor de Temperatura

Descripción:
Este módulo es un termistor NTC Coeficiente Negativo de Temperatura) Al aumentar su temperatura varían considerablemente su resistencia, mayor temperatura menor resistencia.
Un termistor es un elemento de detección de temperatura compuesto por material semiconductor sinterizado que presenta un gran cambio en la resistencia en proporción a un cambio pequeño en la temperatura. En general, los termistores tienen coeficientes de temperatura negativos, lo que significa que la resistencia del termistor disminuye a medida que aumenta la temperatura.

Los termistores se fabrican con una mezcla de metales y materiales de óxido metálico. Una vez mezclados, los materiales se conforman y se hornean en la forma requerida. Los termistores pueden utilizarse tal cual, como termistores tipo disco, o seguir dándoles forma y montándolos con cables conductores y revestimientos para formar termistores tipo perla.

Rango de temperatura -55°C a +125°C

En cuánto a Raspberry Pi, nos enfrentamos a una pequeña barrera, ya que es un sensor análogo y no poseemos Pines análogos como en Arduino, por esto nos encontramos en la necesidad de utilizar un Convertidor Análogico-Digital que nos permita leer las medidas brindadas por el termistor. En este caso en particular utilizaremos el Convertidor ADS1115 de Adafruit o mejor conocido como KY-053.


Conexión Arduino:


Código Arduino:

#include <math.h> //Incluimos math para realizar las cuentas matematicas
 
int sensorPin = A0;
 
double Thermistor(int RawADC)
{
    double Temp;
    Temp = log(10000.0 * ((1024.0 / RawADC - 1)));
    Temp = 1 / (0.001129148 + (0.000234125 + (0.0000000876741 * Temp * Temp )) * Temp );
    Temp = Temp - 273.15;            // conversion de grados Kelvin a Celsius
    return Temp;
}
 
void setup()
{
    Serial.begin(9600);
}
 
void loop()
{
    int readVal = analogRead(sensorPin);
    double temp =  Thermistor(readVal);
 
    Serial.print("La temperatura es:");
    Serial.print(temp); 
        Serial.print(char(186)); //Muestra el simbolo<°>.
    Serial.println("C");
    Serial.println("---------------------------------------");
 
    delay(500);
}

Conexión Raspberry Pi:

Código Raspberry Pi:

Pre-Requisito:

Librería I2C ADS1x5 de Adafruit
https://github.com/adafruit/Adafruit-Raspberry-Pi-Python-Code

from Adafruit_ADS1x15 import ADS1x15
from time import sleep

import math, signal, sys, os
import RPi.GPIO as GPIO
GPIO.setmode(GPIO.BCM)
GPIO.setwarnings(False)
 
delayTime = 0.5 
 
ADS1015 = 0x00  # 12-bit ADC
ADS1115 = 0x01  # 16-bit
 
# choosing the amplifing gain
gain = 4096  # +/- 4.096V
# gain = 2048  # +/- 2.048V
# gain = 1024  # +/- 1.024V
# gain = 512   # +/- 0.512V
# gain = 256   # +/- 0.256V
 
# Elegimmos el radio de muestreo
# sps = 8     # 8 Samples per second
# sps = 16    # 16 Samples per second
# sps = 32    # 32 Samples per second
sps = 64   # 64 Samples per second
# sps = 128  # 128 Samples per second
# sps = 250  # 250 Samples per second
# sps = 475  # 475 Samples per second
# sps = 860  # 860 Samples per second
 
# Asignacion de canales del conversor analogico digital (1-4)
adc_channel_0 = 0    # Channel 0
adc_channel_1 = 1    # Channel 1
adc_channel_2 = 2    # Channel 2
adc_channel_3 = 3    # Channel 3
 
# Iniciamos el convesor
adc = ADS1x15(ic=ADS1115)
 
# Funcion para calcular la temperatura a traves de la tension
def calcTemp(voltage):
        temperature = math.log((10000/voltage)*(3300-voltage))
        temperature = 1 / (0.001129148 + (0.000234125 + (0.0000000876741 * temperature * temperature)) * temperature);
        temperature = temperature - 273.15;
        return temperature
  
try:
        while True:
                #Lee la tension y calcula la temperatura
                temp0 = round(calcTemp(adc.readADCSingleEnded(adc_channel_0, gain, sps)), 2)
                temp1 = round(calcTemp(adc.readADCSingleEnded(adc_channel_1, gain, sps)), 2)
                temp2 = round(calcTemp(adc.readADCSingleEnded(adc_channel_2, gain, sps)), 2)
                temp3 = round(calcTemp(adc.readADCSingleEnded(adc_channel_3, gain, sps)), 2)
 
 
                print ("Channel 0:", temp0, "C")
                print ("Channel 1:", temp1, "C")
                print ("Channel 2:", temp2, "C")
                print ("Channel 3:", temp3, "C")
                print ("---------------------------------------")
 
                sleep(delayTime)
 
 except KeyboardInterrupt:
        GPIO.cleanup()

Para correr el programa abrimos terminal y tecleamos:

  • sudo python ky-013.py

KY-015 Módulo Combinado Sensor de Temperatura y Humedad

Descripción:
La principal ventaja de éste módulo es que podemos medir humedad y temperatura, por otro lado, solo podemos tomar mediciones cada 2 segundos.

  • Chipset: DHT11
  • Protocolo de comunicación: 1-wire
  • Rango de medición de humedad:20-90%RH
  • Rango de medición de temperatura: 0-50°C

Conexión Arduino:


Código Arduino:

Pre-Requisitos:

1. Librerías “DHT sensor library by Adafruit“, “Adafruit Unified Sensor by Adafruit“.
2. Para esto abrimos Arduino IDE, vamos al menú “Programa” -> “Incluír librerías…” -> “Gestionar librerías“.
3. En el cuadro de busqueda escribimos “DHT” y seleccionamos “Instalar” en la opción “DHT sensor library by Adafruit“. Luego escribimos en el campo de busqueda “Unified“, bajamos hasta el final de los resultados y seleccionamos “Instalar” en la opción “Adafruit Unified Sensor by Adafruit“.
Ahora en el IDE vamos al menú “Archivos” -> “Ejemplos” -> “DHT Sensor library” -> “DHT Tester“.
Compilamos y cargamos el sketch al Arduino, veremos lecturas de Temperatura y Humedad.
Luego creamos un nuevo Sketch nombrandolo como nos apetezca, si el código será hecho desde cero debemos importar la librería “DHT Sensor by Adafruit“.

// Incluímos la librería Adafruit_DHT
#include “DHT.h”
// Declaramos el Pin de entrada
#define DHTPIN 8
// Inicializamos el sensor
#define DHTTYPE DHT11 //DHT11
DHT dht(DHTPIN, DHTTYPE);
void setup()
{
Serial.begin(9600);
Serial.println(“KY-015 test:”);
// Comenzamos la medición
dht.begin();
}
void loop() {
// Pausa de 2 segundos entre medición
delay(2000);
// Medición de humedad
float h = dht.readHumidity();
// Medición de temperatura
float t = dht.readTemperature();
// Se probarán errores de mediciones
// Si un error es detectado se muestra un mensaje de error
if(isnan(h)||isnan(t)) {
Serial.println(“Error mientras leía el sensor”);
return;
}
// Salida por Monitor Serie
Serial.println(“———————————————————–“);
Serial.print(“Humedad: “);
Serial.print(h);
Serial.print(” %\t”);
Serial.print(“Temperatura: “);
Serial.print(t);
Serial.print(char(186)); // Salida <°> simbolo grado
Serial.println(“C “);
Serial.println(“———————————————————–“);
Serial.println(” “);
}

Conexión Raspberry Pi:

Código Raspberry Pi:
1.Necesitamos asegurarnos que nuestro sistema tenga las extensiones de Python disponibles para compilar y git para descargar la librería.

sudo apt-get install build-essential python-dev python-openssl git

2.Descargamos la libreria de adafruit:

git clone https://github.com/adafruit/Adafruit_Python_DHT.git

3.Nos movemos a la nueva carpeta:

cd Adafruit_Python_DHT

4.Instalamos la libreria con:

sudo python setup.py install

5.Para que Raspberry se comunique a traves de i2c con el sensor, debemos activar la función en config.txt:

sudo leafpad /boot/config.txt

6.Dónde debemos descomentar la linea:

dtparam=i2c_arm=on

7.Guardamos y descargamos algunas herramientas i2c necesarias:

sudo apt-get install python-smbus i2c-tools -y

8.Reiniciamos la Raspberry Pi:

sudo reboot
#!/usr/bin/python
# coding=utf-8
# Importamos los modulos necesarios
import Rpi.GPIO as GPIO
import Adafruit_DHT
import time
# configuramos una pausa de 2 segundos
sleeptime = 2
# El sensor debe ser configurado como Adafruit_DHT.DHT11,
# Adafruit_DHT.DHT22, o Adafruit_DHT.AM2302.
DHTSensor = Adafruit_DHT.DHT11
# Declaramos a que Pin lo hemos conectado
GPIO_Pin = 23
print(“KY-015 prueba de Temperatura y humedad”)
try:
while(1):
# La medicion sera escrita en las variables humid temper
humid, temper = Adafruit_DHT.read_retry(DHTSensor, GPIO_Pin)
print(“—————————————————————–“)
if humid is not None and temper is not None:
# El resultado se muestra en consola
print(“temperature = {0:0.1f}°C | rel. humidity = {1:0.1f}%’.format(temper, humid)”)
# A causa del sistema Linux, la Raspberry Pi tiene problemas para obtener
#mediciones en tiempo real.
# Esto es por, problemas de sincronización, lo que causa fallas de #comunicación.
# En ese caso, un mensaje de error se mostrará – el resultado se mostrará #en el próximo intento.
else:
print(“Error al leer, por favor reintentalo!”)
print(“—————————————————————–“)
print(“”)
time.sleep(sleeptime)
# Limpiamos los estados de GPIO
except KeyboardInterrupt:
GPIO.cleanup()

Para correr el programa abrimos terminal y tecleamos:

  • sudo python ky-15.py

Gracias por leer Ditecno Makers!!! Si quieres ver más módulos haz click en los siguientes enlaces

PARTE 1

PARTE 2

views
63

ElectroMercado

    0 Comentarios

    Contesta

    CONTACTANOS

    Esta es su red social de tecnología para compartir tus ideas y proyectos .Puedes enviarnos un correo si tienes dudas.Nos vemos

    Enviando

    Inicia Sesión con tu Usuario y Contraseña

    o    

    ¿Olvidó sus datos?

    Create Account