PROYECTO DE UN CENTRO LOGÍSTICO INTELIGENTE CON ARDUINO
Figura 1: Vista del acceso al centro
Queremos diseñar un centro de almacenamiento controlado por arduino. El proyecto consta de una barrera de acceso al centro que se abre y se cierra de manera automática ante la presencia de un vehículo, y de tres silos de almacenamiento de mercancía en los que un led se enciende o se apaga de forma automática cuando en dichos silos hay almacenada una carga.
Se trata de un proyecto adecuado para realizar con alumnos de 4º de E.S.O.
AUTORES
José Miguel Morales Alonso.
César Sánchez García.
Julián Alaejos Casado.
Dentro de la asignatura Innovación Docente en la especialidad de Tecnología perteneciente al Máster de Profesorado de Educación Secundaria Obligatoria y Bachillerato, Formación Profesional y Enseñanza de Idiomas. Curso 2017/2018.
COMPONENTES ELECTRÓNICOS
Figura 2: Soldador de estaño
Figura 3: Protoboard
Figura 4: Leds
Figura 5: Placa de arduino
Figura 6: Cables de conexión
Figura 7: Resistencias
Figura 8: Sensor de luz
Figura 9: Servo motor
COMPONENTES Y HERRAMIENTAS PARA REALIZAR LA MAQUETA
Figura 10: Palos de helado
Figura 11: Cartulinas
Figura 12: Celo
Figura 13: Cutter
Figura 14: Poliestireno expandido (porexpan)
Figura 15: Pegamento
Figura 16: Palillos de madera
Figura 17: Papel de aluminio
Figura 18: Cartón pluma
PROCESO DE EJECUCIÓN DE LA MAQUETA
Figura 19
Figura 20
Figura 21
Figura 22
Figura 23
Figura 24
Figura 25
Figura 26
Figura 27
ESQUEMA CON FRITZING
Figura 28: Esquema de conexionado de sensores capacitivos
Figura 29: Esquema de conexionado del servo
CÓDIGO
Sensores
Capacitivos.
// Se incluye la librería necesaria para el
uso del sensor capacitivo.
#include <CapacitiveSensor.h>
// Se establece que en los sensores capacitivos,
los pines 2, 4 y 6 manden una señal eléctrica y los pines 3, 5 y 7 perciban variaciones
en la capacidad.
CapacitiveSensor capSensor1 = CapacitiveSensor(2, 3);
CapacitiveSensor capSensor2 = CapacitiveSensor(4, 5);
CapacitiveSensor capSensor3 = CapacitiveSensor(6, 7);
// Se establecen los umbrales para activar los
sensores capacitivos.
int threshold = 25;
int threshold2 = 200;
// Definimos las salidas digitales que se
corresponderán con las luces LED que se encenderán o apagarán en función de lo
que detecte el sensor capacitivo.
const int ledPin1 = 10;
const int ledPin2 = 11;
const int ledPin3 = 12;
// Comenzamos el programa. Con la función
SETUP() establecemos las condiciones de partida, es
decir, configuramos Arduino. Se invoca una
sola vez al iniciar el programa.
void setup()
{
// Encendemos el puerto Serie a 9600 baudios
para ver por pantalla los valores que nos puedan
resultar ser interesantes.
Serial.begin(9600);
// Definimos los pines digitales 1, 2 y 3 como
salidas.
pinMode(ledPin1, OUTPUT);
pinMode(ledPin2, OUTPUT);
pinMode(ledPin3,
OUTPUT);
// Escribimos aquí el código de instalación para
ejecutarlo una vez.
void loop() {
// Primero almacenamos los valores leídos por los
sensores capacitivos en una variable "sensorValue".
long sensorValue1 = capSensor1.capacitiveSensor(300);
long sensorValue2 = capSensor2.capacitiveSensor(300);
long sensorValue3
= capSensor3.capacitiveSensor(300);
// Imprimimos en el puerto serie los valores
leídos por los sensores capacitivos para poder percibir
posibles irregularidades.
Serial.print("sensor Value1: ");
Serial.println(sensorValue1);
Serial.print("sensor Value2: ");
Serial.println(sensorValue2);
Serial.print("sensor Value3: ");
Serial.println(sensorValue3);
// Si el valor del sensor 1 es superior al
umbral.
if (sensorValue1 >
threshold) {
// Se
enciende el LED 1.
digitalWrite(ledPin1, HIGH);
}
// Y si el valor del sensor 1 es inferior al
umbral.
else {
// El LED 1 se apaga.
digitalWrite(ledPin1, LOW);
}
// Si el valor del sensor 2 es superior al
umbral.
if (sensorValue2 >
threshold) {
// Se
enciende el LED 2.
digitalWrite(ledPin2, HIGH);
}
// Y si el valor del sensor 2 es inferior al
umbral.
else {
// El LED 2 se apaga.
digitalWrite(ledPin2, LOW);
}
// Si el valor del sensor 3 es superior al
umbral.
if (sensorValue3>
threshold) {
// Se
enciende el LED 3.
digitalWrite(ledPin3, HIGH);
}
// Y si el valor del sensor 3 es inferior al
umbral.
else {
// El LED 3 se apaga.
digitalWrite(ledPin3, LOW);
}
// Se mantiene a la espera medio segundo.
delay(500);
}
Motor
Servo.
//Incluimos librería y variables del servo.
#include <Servo.h>
// Creamos un objeto servo.
Servo myServo;
//Definimos las variables para los sensores de
luz 1 y 2.
int sensorValue1;
int sensorValue2;
// Variables para calibrar los valores bajos.
int sensorLow1 = 1023;
int sensorLow2 = 1023;
// Variables para calibrar los valores altos.
int sensorHigh1 = 0;
int sensorHigh2 = 0;
// Variable para definir el estado (carretilla
fuera).
int dentro = 0;
// Variable para definir el estado (carretilla
dentro).
int dentro = 1;
// Para
iniciar las variables, establecer el estado de los pins, etc, utilizamos la
función setup() que se establece cuando se inicia un programa -sketch. Esta
función se ejecutará una única vez después de que se conecte la placa Arduino a
la fuente de alimentación, o cuando se pulse el botón de reinicio de la placa.
void setup()
{
// conecta el servo en el pin 8.
myServo.attach(8);
// Iniciamos el modo monitor serie para ver los valores que recogemos con los sensores.
Serial.begin(9600);
// conecta el servo en el pin 8.
myServo.attach(8);
// Iniciamos el modo monitor serie para ver los valores que recogemos con los sensores.
Serial.begin(9600);
// Realizamos la calibración de los sensore de
luz que se llevara a cabo durante los 5 primeros segundos (5000 milisegundos)
desde que arranca el programa. Leerá de A1 y A2 (entradas analógicas) los datos
procedentes del exterior y asignara el valor más alto de luz a sensorHigh y el
valor más bajo a sensorLow.
while (millis() < 5000) {
sensorValue1 = analogRead(A1);
sensorValue2 = analogRead(A2);
if
(sensorValue1 > sensorHigh1) {
sensorHigh1 = sensorValue1;
}
if (sensorValue1 < sensorLow1) {
sensorLow1 = sensorValue1;
}
if (sensorValue2 > sensorHigh2) {
sensorHigh2 = sensorValue2;
}
if (sensorValue2 < sensorLow2) {
sensorLow2 = sensorValue2;
}
}
}
// La función loop se corresponde con un bucle
infinito.
void loop()
{
//Escribimos en el puerto serial los valores
leídos.
Serial.print("sensor1: ");
Serial.println(sensorValue1);
Serial.print("sensor2: ");
Serial.println(sensorValue2);
Serial.print("dentro:
");
Serial.println(dentro);
// Si la carretilla está fuera asignamos a las
variables sensorValue1 y sensorValue2 los valores de las entradas A1 y A2.
if(dentro==0){
sensorValue1 = analogRead(A1);
sensorValue2 = analogRead(A2);
// Si el valor del sensor 1 es menor a 500 la
posición del servo será 2 grados (barrera abierta).
if (sensorValue1 < 500) {
myServo.write(2);
// Se mantiene a la espera 5 segundos.
delay(5000);
// Si el valor del sensor 2 es menor a 500 la
posición del servo será 90 (barrera cerrada) grados y se establece el estado
“dentro=1” (carretilla dentro).
if (sensorValue2 < 500) {
myServo.write(90);
dentro =
1;
// Se mantiene a la espera 5 segundos.
delay(5000);
//Escribimos en el puerto serial los valores
leídos.
Serial.print("dentro: ");
Serial.println(dentro);
}
}
// Si la carretilla está dentro asignamos a
las variables sensorValue1 y sensorValue2 los valores de las entradas A1 y A2.
if (dentro==1){
sensorValue1 = analogRead(A1);
sensorValue2 = analogRead(A2);
// Si el valor del sensor 2 es menor a 500 la
posición del servo será 2 grados (barrera abierta).
if (sensorValue2 < 500) {
myServo.write(2);
// Se mantiene a la espera 5 segundos.
delay(5000);
// Si el valor del sensor 1 es menor a 500 la
posición del servo será 90 grados (barrera cerrada) y se establece el estado
“dentro=0” (carretilla fuera).
if (sensorValue1 < 500){
myServo.write(90);
dentro
= 0;
// Se mantiene a la espera 5 segundos.
delay(5000);
//Escribimos en el puerto serial los valores
leídos.
Serial.print("dentro: ");
Serial.println(dentro);
}
}
// Se mantiene a la espera 100 milisegundos.
delay(100);
}
VÍDEO DEMOSTRATIVO DEL FUNCIONAMIENTO
