Medidor de distancias de seguridad

Hola a todos y a todas, Hoy os voy a enseñar a hacer un aparato que nos ayudará a guardar las distancias durante el periodo del COVID-19 para poder combatirlo. Para ello, voy a hacer uso de algunos de los proyectos que he hecho recientemente. Consiste en un aparato que mide la distancia entre personas, detectando un aparato incorporado en las mascarillas. Este dispositivo tiene un sensor de distancia ultrasónico, tres LEDs (verde, amarillo, rojo) que nos indicarán cómo de cerca estamos y un medidor que haremos con un servomotor. Todo esto además de una placa arduino, una placa de pruebas, resistencias de 330 omnios y cables.

Este aparato estaría posicionado en la mascarilla, y detecta a la distancia a la que están otros dispositivos iguales. La distancia de seguridad mínima son dos metros, si se está a esa distancia, una luz verde de nuestro dispositivo estará encendida y el indicador marcará un "Ok" o "Distancia Correcta" nosotros podremos ver el brillo del LED y otras personas podrán ver nuestro indicador. Si estamos a poco más de 2 metros de distancia, se encenderá un LED amarillo y la aguja del indicador cambiará y nos advertirá que debemos tener cuidado, pues es probable que nos acerquemos demasiado a alguien. Si se detecta a otra persona a menos de 2 metros, un LED rojo se encenderá y en el indicador podremos ver señalado un mensaje cómo "Demasiado cerca" o "Distancia mínima sobrepasada".
Gracias a este dispositivo, reduciremos el número de contagios.


El montaje de este proyecto es ligeramente más complicado que los anteriores, pues es la combinación de varios trabajos.

El código de bloques también es algo largo, pero no demasiado complejo.

Para la programación por bloques, sólo tenemos que hacer lo mismo que hicimos a la hora de hacer un sensor de ultrasonidos pero, añadiendo la orden que hace que el servomotor se mueva en las diferentes situaciones. 
Sensor de ultrasonidos: https://tecnoesocity.blogspot.com/2020/04/practica-304-sensor-de-ultrasonidos.html



Para que veáis cómo funciona, aquí os dejo un vídeo.

Y este es el final de la presentación de este proyecto, espero que os haya gustado y, cómo aún no tenemos este dispositivo, debéis cuidar vosotros las distancias.

¡Hasta pronto!

Pulsador y servomotor (practica 3.07)

Hola a todos y a todas, hoy vamos a ver cómo utilizar los pulsadores y los servomotores en Tinkercad. 

El primer proyecto que vamos a hacer, va a ser un servomotor que simulará una barrera, y, al pulsar un pulsador, se levanta durante 4 segundos y luego baja.


Vamos a necesitar un microservomotor, un pulsador, una placa arduino, una placa de pruebas, una resistencia de 1000 omnios y cables. Los elementos se disponen de esta forma:

Para la programación, colocamos los bloques así:

Lo primero que he hecho, ha sido asignar a A el valor del pulsador (1,0).
Luego, he dicho que, si A es 1 (pulsado), el servo gira a 90 grados y espera 4 segundos.
Para terminar, si no ocurre eso, el servo vuelve a 0 º.

Aquí os dejo un vídeo para que veáis cómo funciona:

Ahora vamos a hacer un segundo proyecto; vamos a hacer un servomotor regulable con un potenciómetro.
Vamos a necesitar un potenciómetro, un microservomotor, una placa arduino, una placa de pruebas y cables. Los elementos se disponen de esta forma:

Para la programación, colocamos los bloques así:

Lo que estamos haciendo, es asignar al pasador del servomotor, un dato que obtenemos tras dividir el numero obtenido por el potenciómetro, entre 5'689 (la relación 

 entre los valores del potenciómetro y el servo, que se consigue al dividir 1024 entre 180º)


Para que veáis cómo funciona, aquí os dejo un vídeo:

Espero que os haya gustado los proyectos de hoy. ¡Hasta pronto!

Prácrica 3.06 LED RGB controlado por potenciómetros

Hola a todos y a todas, hoy os voy a enseñar a hacer en Tinkercad un LED RGB controlada por potenciómetros.

Es un proyecto mucho más fácil de lo que parece que nos sirve para controlar el color de un LED.

Vamos a utilizar 3 potenciómetros, cada uno de ellos controlará la intensidad de un color (Rojo, Verde y Azul o Red Green Blue; los tres colores primarios) y, de esta forma, podremos crear prácticamente cualquier color del espectro visible.

Para ello, necesitamos colocar los elementos en esta disposición:

Las resistencias del LED RGB son de 220 omnios.

Como ya he dicho antes, este es un proyecto muy fácil de hacer, y, eso se refleja en la sencillez de los bloques que usamos para programarlo, donde tan solo necesitamos estos de aquí.

Con estos bloques, lo que estamos haciendo, es ordenar que cada pin asignado al LED, lleve a este la energía regulada por cada uno de las resistencias de los potenciómetros.

Para que veáis cómo funciona, aquí tenéis un vídeo:

Esto ha sido todo el proyecto de el LED RGB, muy útil para decoración luminosa o señales de color.

Espero que os haya gustado y servido mucho

¡¡nos vemos pronto!!

Practica 3.05 Sensor de inclinación

Hola a todos y a todas, hoy voy a enseñaros cómo funciona un sensor de inclinación.

Este sensor permite detectar si hay un cambio en la posición de un objeto. Normalmente un sólo sensor no me permite hacer muchas cosas, pero si combino varios sensores de inclinación puedo detectar con detalle la inclinación de un objeto e incluso medir ángulos.

Este tipo de sensores funciona con unas pequeñas bolas metálicas en su interior o una pequeña gota de mercurio, que al moverse en función de la inclinación, abre o o cierra el contacto.

Voy ha hacer un proyecto en Tinkercad utilizando dos de estos sensores, uno de ellos representa la inclinación hacia la izquierda y otro hacia la derecha. Al inclinarse hacia la izquierda, se enciende un LED verde, y hacia la derecha uno rojo. Se puede regular la inclinación de los sensores desde Tinkercad. Si cada uno de los sensores apunta hacia un lado diferente, no se enciende ningún LED.


Para empezar, he dispuesto los componentes de esta manera:

Estos son los bloques de código:

Primero, he creado dos variables; izquierda y derecha, a las que he asignado el valor de los pines 4 y 2.
Como solo puede estar inclinado hacia la izquierda o hacia la derecha, y en Tinkercad existe la opción de apuntar los dos sensores hacia lados diferentes, he tenido que ordenar que, cuando apuntan hacia lados diferentes (las variables obtienen el mismo valor), se apaguen los LEDs.
Si eso no ocurre, llegamos a la parte en la que solo hay derecha o izquierda. Si el sensor correspondiente a derecha se inclina, deja de emitir señal, y, gracias a la forma en la que he programado esta parte, se enciende el LED rojo, si no, no se enciende. 
Para la parte de izquierda, la programación es prácticamente la misma.


Este es el código de programación:



int izquierda = 0;

int derecha = 0;

void setup()
{
  pinMode(4, INPUT);
  pinMode(2, INPUT);
  pinMode(12, OUTPUT);
  pinMode(13, OUTPUT);
}

void loop()
{
  derecha = digitalRead(4);
  izquierda = digitalRead(2);
  if (izquierda == derecha) {
    digitalWrite(12, LOW);
    digitalWrite(13, LOW);
  } else {
    if (derecha == 0) {
      digitalWrite(12, HIGH);
    } else {
      digitalWrite(12, LOW);
    }
    if (izquierda == 0) {
      digitalWrite(13, HIGH);
    } else {
      digitalWrite(13, LOW);
    }
  }
  delay(10); // Delay a little bit to improve simulation performance

}




Para finalizar, aquí os dejo un vídeo para que veáis cómo funciona:

Y esto ha sido todo por hoy, ¡un saludo y hasta la próxima!😁

Practica 3.04 Sensor de ultrasonidos

Hola a todos y a todas, bienvenidos a mi blog, hoy vamos a hacer un sensor de proximidad.

Para ello vamos a usar un sensor de ultrasonidos, que es un dispositivo para medir distancias. Su funcionamiento se base en el envío de un pulso de alta frecuencia, que el ser humano no es capaz de oír. Este pulso rebota en los objetos cercanos y es reflejado hacia el sensor, que dispone de un micrófono adecuado para esa frecuencia.

Hay tres niveles de proximidad, cada uno indicado con un LED.

La conexión del circuito es esta:

Los bloques de programación son estos:

Primero, he anclado una variable a los valores que recibe el sensor de ultrasonidos. Luego, he programado el aviso de alta proximidad, que se manifiesta al encenderse un LED rojo, para hacer esto, he ordenado que si los valores de la variable son menores que 50 (cm) se ejecute la acción (que se encienda el LED). Después, he hecho lo mismo con los otros dos LEDS, de aviso medio (naranja), y bajo (amarillo), ordenando que se encienda si el valor de la variable está entre dos números. Como resultado, si un objeto está a menos de 50 cm, se enciende el rojo, si está entre 50 y 100 cm, el naranja, y si está entre 100 y 150 cm, el amarillo.

Este es el código de programación del proyecto:


int distancia = 0;

long readUltrasonicDistance(int triggerPin, int echoPin)
{
  pinMode(triggerPin, OUTPUT);  // Clear the trigger
  digitalWrite(triggerPin, LOW);
  delayMicroseconds(2);
  // Sets the trigger pin to HIGH state for 10 microseconds
  digitalWrite(triggerPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(triggerPin, LOW);
  pinMode(echoPin, INPUT);
  // Reads the echo pin, and returns the sound wave travel time in microseconds
  return pulseIn(echoPin, HIGH);
}

void setup()
{
  pinMode(4, OUTPUT);
  pinMode(7, OUTPUT);
  pinMode(12, OUTPUT);
}

void loop()
{
  distancia = 0.01723 * readUltrasonicDistance(3, 2);
  if (distancia < 50) {
    digitalWrite(4, HIGH);
  } else {
    digitalWrite(4, LOW);
  }
  if (distancia > 50 && distancia < 100) {
    digitalWrite(7, HIGH);
  } else {
    digitalWrite(7, LOW);
  }
  if (distancia > 100 && distancia < 150) {
    digitalWrite(12, HIGH);
  } else {
    digitalWrite(12, LOW);
  }
  delay(10); // Delay a little bit to improve simulation performance
}



Aquí os dejo un vídeo para que veais cómo funciona:

En la situación actual, este proyecto sería muy útil para prevenir el acercamiento excesivo entre personas y evitar el contagio del virus que actualmente asola nuestra sociedad.


¡¡Esto ha sido todo por hoy y nos vemos en la siguiente entrada!!

Práctica 3.03.1 (sensor de movimiento)

Hola a todos y a todas, hoy voy a enseñaros como hacer un sencillo detector de movimiento.
Voy a hacerlo enfocado a una alarma de seguridad, con un LED a modo de aviso.

He utilizado una placa Arduino, un sensor PIR (sensor infrarrojo pasivo) un LED y una resistencia, además de algunos cables.
todo esto lo he colocado así:

En la programación de bloques, se lee la información del PIR, si el sensor detecta algo, el LED parpadea.

Para que veáis cómo funciona, aqui hay un vídeo:

Esto ha sido todo por hoy, un saludo y hasta pronto.

Práctica 3.03 Tinkercad

Hola a todos y a todas, hoy vamos a hacer un pequeño proyecto de sensor de luz en tinkercad, en la parte de "circuitos".

Para empezar, tenemos que hacer este montaje:

Luego, en el apartado de "bloques" construimos esto:

1. Hay una variable "luz". La variable "luz" toma el valor que lee la LDR.
2. Sale en pantalla el valor de la variable. El monitor serie se puede activar abajo.
3. Si el valor de la variable es menor que 500 se enciende el led (pin 7).
4. En caso contrario, se apaga.

Al final, le damos a "iniciar simulación", y, ahí podemos variar la luz que recibe la LDR.
Abajo vemos los valores que está recibiendo la LDR.

¡Y esto es todo por hoy, muchas gracias y nos vemos pronto!

Sensor infrarrojo.1 (práctica)

Hola a todos y a todas, en la práctica de hoy vamos a hacer un sensor, que al detectar una superficie oscura, un LED se encienda, y que al detectar una superficie clara,el LED se apague.



Como ya sabréis, un sensor infrarrojo emite una onda de luz que está por debajo del rojo, y, por lo tanto, no es visible por el ojo humano.

Tiene tres conexiones:
OUT: pin digital
GND: toma de tierra
Vcc :energía: 5V

La onda que emite su parte "emisora" rebota en una superficie y le vuelve a llegar a la parte "receptora", cuanto mas clara y lisa sea la superficie, mejor llega de vuelta.

Estos son los elementos necesarios que se conectan a la placa de Arduino UNO.

-LED
-Sensor infrarrojo

Para empezar, he creado una variable a la que he llamado "A".

Posteriormente, en "Instrucciones iniciales (Setup)" he colocado el código "Serial.begin(9600); " que ya expliqué anteriormente para que sirve.

En la sección de " Bucle principal (Loop) ", he declarado la variable el valor que reciva el sebsor infrarrojo (0-1). Tras el bloque de  "Serial.println(A);" , he ordenado que si el valor de la variable es 0 (el sensor está sobre una superficie negra), se encienda el LED. Si por el contrario, el sensor está sobre una superficie clara, el valor que recivirá dicho sensor será igual a 1. De este modo el LED estará apagado.

 Para terminar, aquí os dejo el código de este programa.

/***   Included libraries  ***/




/***   Global variables and function definition  ***/
const int sensor_infrarrojos = 7;
const int led = 13;

/*
LMP_16
*/
float A = 0;



/***   Setup  ***/
void setup() {
    pinMode(sensor_infrarrojos, INPUT);
    pinMode(led, OUTPUT);

    Serial.begin(9600);

}


/***   Loop  ***/
void loop() {
    A = digitalRead(sensor_infrarrojos);
    Serial.println(A);

    if (A == 0) {
        digitalWrite(led, HIGH);
    } else {
        digitalWrite(led, LOW);
    }
}

Muchas gracias, y adiós. 😁

Breve introducción a los sensores de arduino

Los sensores son aparatos que se utilizan para detectar diferentes cosas.
Estos son algunos ejemplos:

Sensor de luz:
Detecta cambios de luminosidad y cantidad de luz.

Ejemplos de uso:

Estos componentes eléctricos se pueden usar como activador de las farolas de la calle; el LDR está recibiendo luz durante el día, pero, por la noche (o cuando se nuble) deja de recibir luz y disminuyen los omnios, lo que hace que se encienda la bombilla.

Sensor de presión de fuerza:

sirve para detectar una fuerza aplicada en la membrana. Básicamente, al detectar una flexión en la membrana el sensor cambia su resistencia interna.

Ejemplos de uso:
Estos sensores se pueden usar en básculas y otros aparatos cuya función sea medir la masa.

Sensor de movimiento:

Un detector de movimiento, o sensor de presencia, es un dispositivo electrónico equipado de sensores que responden a un movimiento físico.

Ejemplos de uso:

Estos sensores son usados en mecanismos de seguridad o en circuitos cerrados de televisión. Yo personalmente tengo la idea de usar un sensor de movimiento para que me salude cuando entre en mi habitación.

Sensor de metano:

Un detector de gas es un aparato que detecta la presencia de gas en el aire y que, a una determinada concentración, emite una señal.

Ejemplos de uso:

Se pueden usar en minas para detectar tipos de gases peligrosos. También se puede hacer un detector de flatulencias, eso es algo muy curioso.

Muchas gracias y hasta pronto.

Sensor de Luz V2 (definitivo)

Hola, hoy os voy a presentar la versión definitiva de mi sensor de luz V2.
Como recordareis, anteriormente hice y publiqué el prototipo de la versión número 2, en la cual explicaba los fundamentos de mi proyecto, he hecho algunos cambios y ahora funciona perfectamente; cuanta más luz reciba, menos luz recibe el LED, y viceversa.


Para este proyecto he usado:

.Una placa arduino uno

.Una placa "Protoboard"

.Un LED

.Un LDR

.2 resistencias; una de 220Ω y otra de 1000Ω

.5 cables arduino

-Para programarlo, he usado el programa "Bitbloq". Aquí esta la conexión:

El LED está conectado al pin 〜9, y la LDR al A1.



-El software de bloques que he usado es el siguiente:

Lo primero que he hecho ha sido declarar una variante a la que he llamado luminos en el apartado de "Variables globales y funciones".

En el apartado de "Instrucciones iniciales (Setup)", he añadido este Serial.begin(9600), para poder ver en el monitor los valores que está midiendo la LDR.

Este es el apartado de "Bucle principal (Loop)", donde está lo más interesante.

 -Para empezar, he ordenado que la variante sea el valor del sensor de luz, y he añadido un Serial.print(luminos) que tiene la misma utilidad que el Serial.begin(9600).

 -Después, mediante operaciones matemáticas, he encontrado la relación entre el pin digital y el pin analógico, que he declarado a la variable y posteriormente lo he invertido.

 -Tras esperar 10 ms, el valor de la variable se escribe en el LED. De esta manera, cuanta menos luz reciba el sensor, más se enciende la luz de forma progresiva.

 -Como quería que en algún momento el LED estuviese completamente encendido o apagado, declaré dos umbrales, uno para encenderlo a su máximo y otro para apagarlo; para conseguirlo usé los bloques de control "si" y "en cambio".

Este es el código de programación:

/***   Included libraries  ***/




/***   Global variables and function definition  ***/
const int led = 9;
const int sensor_de_luz = A1;

/*
LMP_16
*/
float luminos = 0;



/***   Setup  ***/
void setup() {
    pinMode(led, OUTPUT);
    pinMode(sensor_de_luz, INPUT);

    Serial.begin(9600);

}


/***   Loop  ***/
void loop() {
    luminos = analogRead(sensor_de_luz);
    Serial.println(luminos);

    luminos = luminos * 255 / 1024;
    luminos = 255 - luminos;
    delay(10);
    analogWrite(9, luminos);
    if (luminos > 200) {
        digitalWrite(led, HIGH);
    } else if (luminos < 30) {
        digitalWrite(led, LOW);
    }
}

Aquí podéis ver el montaje en "Fritzing":

Por último, os dejo un vídeo para que podáis comprobar lo bien que funciona.

Lo más interesante de mi proyecto es que la luminosidad del LED, aumenta de manera totalmente progresiva, y, de este modo no se percibe ningún cambio brusco de luz.

¡Muchas gracias y hasta la siguiente entrada!😁