Monitorizacion de liquidos via wifi desde su smartphone


Utilizando la placa WiFi NodeMCU-12E v3 ESP8266  y 2 sondas ultrasónicas de tipo HC-SR04 a prueba de agua , se  puede  medir el volumen de agua en 2 tanques de agua y ofrecer esa información  de un modo gráfico  y en tiempo real.

El  sonar suena por la parte superior del agua, obteniendo la distancia en cm,calculando la profundidad del agua en cm y luego extrapolando  el volumen de agua a litros.   Toda la información se pasa por WiFi en la WLAN al servidor local (RPi3) que ejecuta el servidor local Blynk. Finalmente la información está disponible en un teléfono usando la aplicación Blynk registrada en el servidor local.

Es importante destacar que el el mapeo de los pines es diferente en estas placa frente a lo s pines de un Arduino ( los números de pin son generalmente números de GPIO)

Es  este proyecto se usaran los típicos sensores ultrasónicos HC-SR04 estándar  sensores que transmiten   y reciben  señales  ultrasónicas ,  que en este caso deberán o bien  impermeabilizarse para ser resistentes al agua e impermeables ( el aspecto es muy similar a las mismas unidades que se usan en los vehículos para detectar colisiones al aparcar ) o bien comprarlos  ya  estancos espaciales  para ambientes húmedos, ( como en la foto).

sesnor

Concretamente este sensor se alimenta de  DC 5 V( consumo  30mA) usando  e emisión de frecuencia: 40 khz  con  una detección  máxima distancia de 4.5 m y resolución  cerca de 0.5 cm

Sus conexiones son 4:

  • VCC+ 5 V (fuente de alimentación positiva)
  • Trig (lado de control) RX
  • eco (lado receptor) TX
  • GND (negativo)

El uso de la ubicación disparador del IO TRIG puerto, pone el alto nivel de la señal de al menos 10us; el módulo automáticamente envía 8 trens de  40 KHz  con detección automática si  hay vuelta de señal.Una señal de vuelta se marca como  un alto nivel de salida a través del puerto IO de ECO. El tiempo de duración de alto nivel   ultrasónica es el del lanzamiento de volver.

La formula  para calcular la  distancia es la siguiente:

D(m) = tiempo de alto nivel * velocidad del sonido (los 340 M/S)) /2 

Como vemos este módulo utiliza el método sencillo, un puerto de control con un 10US por encima de alto nivel,  esperando un alto nivel de salida en el puerto de recepción. Una salida puede conducir el temporizador, de modo que cuando este puerto se pone la señal  bajo puede leer el valor del temporizador, y  esta vez para la ubicación del tiempo, se puede calcular la distancia de modo que así  constantemente hay un ciclo de  medicino

Estos sensores HCSR04 los conectamos  a una placa WiFi ESP8266 NodeMCU y yna pequeña placa para la alimenticio  de 3.3v  del ESP8200

El esquema es bastante sencillo como podemos ver en  la siguiente imagen:

Imagen de Primeros pasos con el banco para las pruebas iniciales

El  total de compontes    en resumen son los siguintes :

Para fines de prueba se puede  usar  un  PC para alimentar el circuito ,pero con la idea de que cuando este ya programado  funcione independiente , lo mejor es   utilizar un pequeño conversor  DC-DC de 3 v3  y asi usar cualquier fuente de alimentación de  220v/ 12v para alimentar el circuito (usando el coneversor como adptador de tension) 

 Tenga en cuenta que estas placas ESP12E funcionan con 3,3 voltios pero tienen un pin de suministro de entrada de 5v (VIN) y también funcionan con el suministro de USB cuando están conectados a su PC. No suministre más de 5 voltios al pin VIN si lo usa.

La conexiones  a usar son las siguientes :

  • Sensoring a Arduino GPIO5 (D1)
  • Sensor1 echo a Arduino GPIO4 (D2)
  • Sensor2 ping a Arduino GPIO14 (D5)
  • Sensor2 echo a Arduino GPIO12 (D6)

Estos sensores funcionan también a 3.3 voltios   y dan un  buen nivel de salida asi que no es necesario  convertidores de salida .Conecte ambos VCC a los sensores Arduino 3v3 y conecte ambos sensores GND a Arduino GND.

Puede usar un  LED  pero como se encenderá   solo de 50mS cada 2 segundos,  no merece la pena conectar una resistencia limitadora de corriente, (pero se puede agregar una resistencia 1 / 4W 470R si lo desea.). ElÁnodo del led  (pata larga) ira al Arduino GPIO13 (D7) y el Cátodo a Arduino GND

Tenga en cuenta   que los cables de los sensores  tienen cables coaxiales de 2 m de longitud., si necesita extender estoso pues usar un viejo cable coaxial que tenga , asegúrandose  de cubrir todas las uniones soldadas con termofluente.

 

 Instalando el Software

Este monitor de nivel de agua usa su tarjeta ESP8266 en su teléfono a través de sus servidores.

El servidor de Blynk en la nube sirve su aplicación con la información en los widgets en el teléfono. Al registrarte con Blynk, recibe 2000 puntos de energía de modo que con estos puntos se usan para ‘comprar’ widgets para su programa ( 2000 puntos son suficientes para construir esta aplicación de monitor de agua).

Otra opción es usar un servidor local ejecutándose en una Raspberry Pi, lo cual  permite puntos ilimitados y una mejor seguridad y no usando el servidor Blynk en absoluto,(es completamente independiente). La instalación y configuración de un servidor local está más allá del alcance de este post  sobre todo porque hay muchas instrucciones y tutoriales en la red para hacer esto comenzando con el sitio web de Blynk.

La versión final  utiliza  OTA para recibir actualizacion en el aire desde el wifi sin necesidad de  sacar todo para actualizar el software ( veremos  los cambios y métodos del software OTA más adelante).

 

Lo primero que necesitará es el Arduino IDE si aún no lo tiene.

Descargue la biblioteca Blynk aquí Biblioteca Blynk , la descarga se encuentra en la parte inferior de la página. Siga las instrucciones en esa página para instalar la biblioteca.Obtenga  tambien  la aplicación del teléfono aquí Blynk App .Se puede crear una cuenta para Blynk si desea usar la aplicación. Recuerde la dirección de correo electrónico de inicio de sesión que utiliza, la necesitará más adelante. Probablemente sea mejor usar su cuenta de correo electrónico todos los días.

También necesitará esta biblioteca:NewPing Esta es una excelente biblioteca para usar sus dispositivos. No hay necesidad de perder el tiempo con milisegundos, etc.

Estas instrucciones son para el software ESP8266:

  • Comenzando con 1.6.4, Arduino permite la instalación de paquetes de plataforma de terceros usando Boards Manager. Tenemos paquetes disponibles para Windows, Mac OS y Linux (32 y 64 bits).
  • Inicie Arduino y abra la ventana Archivo> Preferencias.
  • Ingrese “ `http: // arduino.esp8266.com / stable / package_esp8266com_index.json“` en el campo * Additional Board Manager URLs *. Puede agregar varias URL, separándolas con comas.
  • Abra el Administrador de tableros desde Herramientas> Menú de la placa e instale la plataforma * esp8266 * (y no olvide seleccionar su placa ‘NodeMCU 1.0 (Módulo ESP-12E)’ desde Herramientas> Menú de la placa después de la instalación).
  • En el menú, seleccione Boceto> Incluir biblioteca> Administrar bibliotecas.Permitir que termine la descarga. Debería ver las bibliotecas de Blynk instaladas.
  • Para que su PC se comunique con el software USB to Serial de las placas Arduino debe instalar el controlador USB-UART CH341SER_win. Esto es necesario para todas las comunicaciones Arduino a través de USB. Obtengalo aqui

 

 Código de prueba para la placa ESP8266

Comenzaremos con dos sensores que informan la información al monitor serie integrado en el IDE de Arduino. Aún no se informa al servidor Blynk, OTA o WiFi.

Haga doble clic en el archivo ‘water_code_1.in’ a continuación, después de que Arduino IDE comience vaya a Archivo> ‘guardar como’ y guárdelo en su carpeta de bocetos.Se creará una carpeta con el archivo dentro.Confirme que tiene la placa correcta seleccionada, haga clic en el botón ‘verificar’ (botón muy a la izquierda en el IDE). Debe compilar sin error. Conecte su placa al cable USB, desde el menú IDE Herramientas> Puerto> COM n.

El puerto de comunicación correcto se puede encontrar simplemente desenchufando la placa y viendo qué puerto desaparece.Haga clic en el botón ‘Subir’ en IDE Arduino y permita que termine de compilar y cargar.En el IDE seleccione Herramientas> Monitor en serie

El LED debe parpadear cada 2 segundos y el monitor debe informar la distancia, la profundidad y los litros de agua de cada tanque durante 2 segundos, de forma similar a la imagen mostrada.

Imagen del código de prueba para el tablero ESP8266e Estos sensores tienen un rango d aproximadamente 3 mtrs. de modo que están configurados a 3 mtrs en el software de todos modos.

Pruebe cada sensor moviéndolo dentro y fuera de un objeto sólido como la pared, debería ver las figuras cambiar en la ventana del monitor. A medida que la distancia aumenta, simula un nivel de agua más bajo.

Este es  el codigo  final :

#include
#include

#define SONAR_NUM 2 // Number of sensors. Change to suit your requirements.
#define PI 3.1415926535897932384626433832795

//** CHANGE TO SUIT TANK DIMENSIONS
const int MAX_DISTANCE = 300; //max distance to measure
const int Diameter1 = 276; //internal Diameter of tank 1 cm
const int Diameter2 = 276; //internal Diameter of tank 2 cm
const int Depth1 = 265; //total depth of tank 1 cm , from sensor to base inside
const int Depth2 = 265; //total depth of tank 2 cm, from sensor to base inside

const unsigned int Period = 2000; //period between pings, in milliseconds. i.e 1 munute = 60,000. max 65535. Want longer? use unsigned long

//** SENSOR PINS

const int PingPin1 = 5; // GPIO5, D1
const int EchoPin1 = 4; // GPIO4, D2
const int PingPin2 = 14; // GPIO14, D5
const int EchoPin2 = 12; // GPIO12, D6

const int Area1 = PI * ((Diameter1 / 2) * (Diameter1 / 2)); //area of base of tank 1
const int Area2 = PI * ((Diameter2 / 2) * (Diameter2 / 2)); //area of base of tank 2

// Global variables
int Litres1, Litres2, Distance1, Distance2, WaterDepth1, WaterDepth2;

BlynkTimer timer; //config timer

NewPing sonar[SONAR_NUM] = { // Sensor object array.
NewPing(PingPin1, EchoPin1, MAX_DISTANCE), // Each sensor’s trigger pin, echo pin, and max distance to ping.
NewPing(PingPin2, EchoPin2, MAX_DISTANCE)
};

void sendSensorReadings()
{
//***********Readings Tank 1
Distance1 = sonar[0].ping_cm(); //get distance to the top of the water tank 1
if (Distance1 >= Depth1 || Distance1 == 0 ) Distance1 = Depth1; //check it does not go negative
WaterDepth1 = Depth1 – Distance1; //calculate the depth of the water
Litres1 = (Area1 * WaterDepth1) / 1000; //calculate the volume of the water as litres
delay(50);

//************Readings Tank 2
Distance2 = sonar[1].ping_cm(); //get distance to the top of the water tank 2
if (Distance2 >= Depth2 || Distance2 == 0) Distance2 = Depth2; //check it does not go negative
WaterDepth2 = Depth2 – Distance2; //calculate the depth of the water
Litres2 = (Area2 * WaterDepth2) / 1000; //calculate the volume of the water as liters

digitalWrite(13, HIGH); //flash the LED on D7, just to let us know it’s running
delay(50);
digitalWrite(13, LOW);

//************************* can be commented out, test use only
Serial.println();
Serial.println();
Serial.println(“Tank 1 water distance: ” + String(Distance1)); //print depth
Serial.println(“Tank 1 water depth: ” + String(WaterDepth1)); //print depth
Serial.println(“Tank 1 Litres: ” + String(Litres1)); //print litres

Serial.println();
Serial.println(“Tank 2 water distance: ” + String(Distance2)); //print depth
Serial.println(“Tank 2 water depth: ” + String(WaterDepth2)); //print depth
Serial.println(“Tank 2 Litres: ” + String(Litres2)); //print litres
//***********************************************

}

void setup() {

pinMode(13, OUTPUT); //LED GPIO13 D7

timer.setInterval(Period, sendSensorReadings); // Setup a function to be called every ‘n’ seconds
delay(10);

//** can be commented out, test only
Serial.begin(115200); // Open serial console.
Serial.println();
//*******************************

delay(20);
}

void loop() {

Blynk.run();
timer.run();

}

 

Código  Final con WiFi y Blynk

Ahora vamos a conectarnos al servidor de Blynk. Descargue y abre el water_code_2.ino

En el IDE de Arduino, seleccione Archivo> “guardar como” en su carpeta de bocetos.

Abra la aplicación Blynk, inicie sesión. Cree un nuevo proyecto,  dispositivo = ESP8266, tipo de conexión = WiFi, configure el tema que prefiera.presione el botón Crear.Se enviará un token de autoridad a su cuenta de correo electrónico designada.Presione OK  y vaya a su correo electrónico , copie el token de autoridad, péguelo en su programa arduino donde dice ‘char auth [] = “YourAuthToken

También ingrese su SSID y su contraseña.Ahora cárgalo en su ESP.

Ahora  terminaremos el proyecto Blynk viendo como configurar la aplicación.

Configuración del programa de aplicación Blynk

Imagen de la configuración del programa de la aplicación Blynk

 

Entre en su app movil  Blync e introduzca sus credenciales de acceso. Siga los siguientes pasos para configurar la aplicación para la medición de los niveles de dos tanques

  • Presione + en la parte superior de la pantalla en la aplicación, desplázese hacia abajo y presiona Value Display. Haga esto 4 veces
  • Presione + en la parte superior de la pantalla en la aplicación, desplázese hacia abajo y presiona NivelV. Haga esto dos veces
  • Presione + en la parte superior de la pantalla en la aplicación, desplázesee hacia abajo y presiona SuperChart.
  • Diseñe los widgets como en la imagen. Una pulsación larga en el widget le da identificadores para redimensionarlos.
  • Colócalos como mejor le parezca.
  • Presione la primera Pantalla de valor (arriba a la izquierda), asígnele el nombre Profundidad 1, seleccione V1, 0 a 300 y PULSE
  • Presione la segunda pantalla de valores, nombre Profundidad 2, seleccione V4, 0 a 300 y PUSH
  • Presione la tercera pantalla de valores (2 abajo a la izquierda), nombre Liters 1, seleccione V2, 0 a 9999 y PUSH
  • Presione la cuarta pantalla de valores, nombre Liters 2, seleccione V5, 0 a 9999 y PUSH
  • Presione el nivel vertical izquierdo, nómbrelo Nivel 1, seleccione V3, 0 a 1600, APAGADO y EMPUJE
  • Presione el nivel Vertical derecho, nómbrelo Nivel 2, seleccione V6, 0 a 1600, APAGADO y PULSE
  • Presione SuperChart, Litros 1 y Litros 2.
  • Presione el ícono (flujo de datos) al lado de Nombre, PIN = V3, interruptor deslizante = VALORES, minn = 0, máximo = 1600
  • Presione el ícono (secuencia de datos) al lado del segundo nombre, PIN = V6, interruptor deslizante = VALORES, min = 0, máximo = 1600

Puede jugar con las otras configuraciones para adaptarlas a sus preferencias. Para eliminar un widget, arrástrelo a la derecha de la pantalla.

Si todo se ve bien, presione la esquina superior derecha de la pantalla. Si su Arduino se está ejecutando, debería ver los mismos números (excepto la distancia) que en el monitor de serie.

Como se puede ver en la imagen anterior de la app movil  de Blync   debe tener en cuenta que debe ajustar el valor real de  Profundidad1 y Profundidad2  en la app  , pero también deberá reflejar los  valores correspondientes en el codigo de Arduino  para calcular el volumen par lo cual es importante  no olvidar este detalle.

En el ejemplo los depósitos son circulares de modo que hay especificar tanto el diámetro como la profundidad:

 

Imagen de Mount the Sensors en los tanques

También  debe señalar que estos sensores tienen un rango mínimo de 20 cm, lo cual se debe a que el transmisor y el receptor comparten la misma distancia.

 

Configurar la  actualización por  OTA

Imagen de la configuración de la actualización de OTA

OTA o ‘Over The Air‘ es una característica realmente útil, especialmente en este caso donde ESP está dentro de una caja y afuera.

Este es un proceso bastante simple:

  1.  El cargador de arranque OTA se carga primero en la placa.
  2.  La placa se reinicia presionando el botón de reinicio en la placa.
  3.  Su nuevo código para el proyecto de tanque de agua que contiene las adiciones de OTA a su placa por USB.

Las cargas futuras se logran seleccionando el puerto WiFi en Herramientas> Puerto.

Vaya a Archivo> Ejemplos> ArduinoOTA> BasicOTA

El programa se cargará, ingrese su nombre de red y contraseña en el código.Suba esto a su placa. Ahora presione el botón de reinicio en el tablero.

Regrese a su programa de tanque de agua y vea los 3 lugares que se muestran en las imágenes, estos son necesarios para la carga de OTA.

Suba esto a su placa , usando  USB serial.

Si mira en Herramientas> Puerto en IDE Arduino, verá un nuevo puerto.Tendrá ‘esp8266’, la ID de la placa y la dirección IP de la placa.

Para una carga futura, use este puerto, sin necesidad de una conexión serial USB.

La placa ahora puede ser cargada por otros medios , es decir por wifi  sin tener que llevar el pc  y conectarlo por USB.

Montaje  final

Imagen de Monte las tablas en la caja

Puede montar  el ESP8266, tanto las placas ultrasónicas como el convertidor DC-DC en la caja con clasificación IP66, ya que estará   expuesto a los elementos. Si usa conectores de cable hembra-hembra, mucho mejor. Es interesante montar el convertidor CC-CC en una posición donde el conector de alimentación pueda enchufarse desde el exterior. 

También se deben tome todas las conexiones de alimentación y tierra a esta placa para evitar los bucles de tierra usando se 3.3 voltios para todo.

Es interesante hacer un agujero para el LED, e intentar ajustarlo para que no se necesite adhesivo.

Conecte todo y asegúrese de que todo sea resistente a la intemperie

Verifique todo, especialmente el cableado de alimentación.Enchufe la alimentación y conéctelo a la caja, conecte los sensores y enciéndalo.No verá nada en el monitor de serie, pero consulte la aplicación de su teléfono mediante la aplicación Blynk 

Mueva los sensores alrededor, las figuras deberían cambiar en la aplicación. Recuerde que una transmisión de ping e información solo se realiza cada 2 segundos.

Si sus tanques están a una distancia mayor, deberá  usar un extensor WiFi.

.

 

Fuente  Instructables.com

 

Anuncios

Cerradura RFID conArduino


RFID o identificación por radiofrecuencia (del inglés Radio Frequency Identification) es un sistema de almacenamiento y recuperación de datos remoto que usa  transpondedores RFID con el  propósito de transmitir la identidad de un ente  mediante ondas de radio. Las tecnologías RFID se agrupan dentro de las denominadas Auto ID (automatic identification, o identificación automática).

Las etiquetas RFID  son  dispositivos pequeños, similares a una pegatina que contienen antenas para permitirles recibir y responder a peticiones por radiofrecuencia desde un emisor-receptor RFID.

Una de las grandes ventajas de esta tecnología   es que las etiquetas   son pasivas ,no necesitando por  tanto  alimentación eléctrica   así como tampoco  requieren visión directa entre emisor y receptor.

En el post de  hoy  vamos    a ver como se implementa  establecer un pestillo de puerta que puede abrirse mediante una tarjeta  RFID  programando  una lista de las tarjetas ‘claves’ aceptables que podrían  abrir  la puerta durante un período determinado de tiempo.

Este es proyecto es  sencillo  pero requiere que alterar la  jamba de la puerta lo cual requiere mucha pericia   pero como podemos  en el siguiente vídeo  el resultado  es muy espectacular.

 

 Electrónica necesaria

Estas son las partes recomendadas para este proyecto. Puede usar otro relé de variante, Arduino, o etiqueta RFID compatibles, pero se recomienda el escudo RFIDuino para que el código que veremos funcione sin problemas.

 

Note que usando un solenoide de cierre de puerta recta necesita energía para abrir la puerta. Si pierde energía, usted se eficazmente bloqueará hacia fuera y no se puede abrir la puerta hasta que la energía se devuelve al sistema pero si usa una  placa electrónica , todavía puede utilizar su clave normal para abrir la puerta en el caso de un apagón.

Obtener sus datos de etiqueta RFID

  1. Conecte su RFIDuino como se muestra en la imagen teniendo en cuenta que el escudo RFdui9no deberá colocarlo encima de su Arduino en la posición exacta en que coinciden ambas placas .De la placa no olvide que ira la antena  RFID  al exterior y  por su puesto su Arduino ira conectado  por usb a su pc para poer  instalarle el firmware
  2. Abra su tablero. Usted puede encontrar este bosquejo bajo RFIDuino_helloworld
    File>Examples>RFIDuino>RFIDuino_helloworld
  3. Usted necesitará asegurarse de que el código se ajusta para el hardware del RFIduino.
    v1.2 escudos (2 pin antena, ‘REV 1.2’ impreso en el tablero) se necesita el siguiente código escudos v1.1 (antena de 4 pines, ningún número de versión impresa en la placa) tendrá el siguiente código

    RFIDuino myRFIDuino(1.2);     //initialize an RFIDuino object for hardware version 1.2
    RFIDuino myRFIDuino(1.1);     //initialize an RFIDuino object for hardware version 1.1

    Ambas líneas de código están disponibles en el dibujo, simplemente quite el comentario de que no necesita.RFIDuino_helloworld

    Si tiene aún dudas sobre qué hardware está usando, vea esta página

  4. Conecte un cable micro del USB de su ordenador  a su Geekduino
  5. Cargue  RFIDuino_helloworld3  en su tarjeta usando el botón de carga en el IDE de Arduino.
  6. Una vez cargado, puede dejar la placa conectada al ordenador  pues  necesita esta conexión para alimentar el tablero y para comunicarse con la computadora
  7. Abra al Monitor serie.
    Tools -> Serial Monitor

    El serial monitor debe ajustarse a los valores predeterminados (‘Fin a No Line’, 9600 baudios)

  8. Pase una etiqueta por la antena de RFIDuino. La luz verde se iluminará y el zumbador hará un ruido.
  9. El Serial Monitor mostrará 5 números. Estos números representan el ID de la etiqueta.
  10. Copie abajo estos números para uso futuro. Puede ser útil escribir el ID en una nota adhesiva y se adhiere a la etiqueta. Nota: se necesita el ID por al menos una etiqueta para el siguiente paso.

 Cableado y programación

  1. Conecte sus componentes como se muestra en le imagen  de arriba  donde como  se puede apreciar se ha añadido una placa de rele  en cuya salida conectaremos un solenoide que alimentaremos con una tensión exterior  y el alimentador  dedicado para suministrar energía  a la placa   Arduino y el Escudo .
  2. Abierta sobre su tablero. Usted puede encontrar este bosquejo bajo RFIDuino_demo3_lockbox_multi
    File>Examples>RFIDuino>RFIDuino_demo3_lockbox_multi
  3. Usted necesitará asegurarse de que el código se ajusta para el hardware del RFIduino.
    v1.2 escudos (2 pin antena, ‘REV 1.2’ impreso en el tablero) se necesita el siguiente código escudos v1.1 (antena de 4 pines, ningún número de versión impresa en la placa) tendrá el siguiente código

    RFIDuino myRFIDuino(1.2);     //initialize an RFIDuino object for hardware version 1.2
    RFIDuino myRFIDuino(1.1);     //initialize an RFIDuino object for hardware version 1.1

    Ambas líneas de código están disponibles en el dibujo, simplemente quite el comentario de que no necesita.RFIDuino_demo3_lockbox_multi

     

  4. Modifique el código para el número de tarjetas que desee por línea edición 58. Por ejemplo, si tienes tres tarjetas, utilice el código
    #define   NUMBER_OF_CARDS 3     //total numer of key cards that the system will respond to.
  5. También necesitará modificar el bosquejo para incluir los identificadores de las etiquetas que desea incluir. Estos identificadores pueden encontrarse usando el bosquejo. Encontrar el bloque de código a partir de en línea 62 – se parece a esto. Ahora inserte el ID para sus etiquetas. Si tenemos tres etiquetas clave, nuestro código podría ser algo así como Hello World
    byte keyTag[NUMBER_OF_CARDS][5] ={
    {0,0,0,0,0},  //Tag 1 //commenting each tag with a description can help you keep track of them
    {0,0,0,0,0},  //Tag 2
    {0,0,0,0,0}, //Tag 3
    {0,0,0,0,0},//Tag 4
    };
    byte keyTag[NUMBER_OF_CARDS][5] ={
    {77,0,44,22,242},  //Tag 1 //commenting each tag with a description can help you keep track of them
    {200,1,4,98,236},  //Tag 2
    {23,64,4,25,1}, //Tag 3
    };
  6. Conecte un cable micro del USB de su ordenador  a su Geekduino
  7. Cargar en su tarjeta usando el int del botón de subir el IDE de Arduino. RFIDuino_demo3_lockbox_multi
  8. Una vez cargado, desconecte el cable USB del ordenador…
  9. Ninguna de las etiquetas ‘clave’ pase por la antena de RFIDuino. La luz verde se iluminará y el zumbador tocar tres notas diferentes. Además, el solenoide se dispara.
  10. Pase cualquier etiqueta que no es la etiqueta de ‘clave’ a través de la antena de RFIDuino. La luz roja se iluminará y el zumbador tocar tres notas monótonos. El solenoide no reaccionará.

 Montaje final

 Una vez que este seguro que lo tiene programado y el seguro libera cuando usted pase la correcta etiqueta de RFID, ya puede montarlo en el marco de una  puerta. En el video  de hecho podemos ver en una puerta de marco de metal con ventanas de cristal, por lo que es mas sencillo instalar  el lector de RFID tras el cristal.
También se  puede montar la antena en una caja resistente a la intemperie para la accesibilidad y mantener el Arduino y otros aparatos electrónicos en el interior por seguridad.

Hay instrucciones con la placa electrónica de apertura que puede ayudar en el montaje  Se recomienda mantener la placa tan al ras como puedas a la pared se monta en y tener cuidado al pasar los cables a través de una pared.

Fuente : instructables.com

 

Futurista ambientador


Es  reconfortante tener una fragante casa floral de primavera para senirse como si estuviera en medio de un jardín de lavanda en lugar de una vivienda tradicional  donde probablemente viva, de heho eso es es que precisamente por esto, muchas de las diferentes empresas han creado para los amantes del aire  una multitud de aromas.

Hay muchos ambientadores en el mercado: desde los antiguos aerosoles manuales hasta los disparados por temporizador pero los últimos, aunque son automáticas, son bastante tontas pues seguirán rociando incluso si no estás cerca para  sentir el olor, desperdiciando esas recargas de fragancia no tan baratas.

¿No sería agradable si su refrescante de aire fuera capaz de comunicarse con otros dispositivos y disparar solo cuando realmente lo necesite ?

En este proyecto IgorF2 diseñó   un ambientador  conectado , usando algunas impresiones 3D, NodeMCU, IFTTT y Adafruit.IO.

!

¡Siempre tenga en cuenta que este es un prototipo experimental y podría usarse con precaución!

Paso 1: herramientas y materiales

Las siguientes herramientas y materiales fueron utilizados en este proyecto:

  • impresora 3d. En mi caso, utilicé Voolt3D, una impresora 3D basada en Grabber i3;
  • 1.75mm PLA de su color favorito;
  • Alambre de soldar. Tendrás que soldar algunos cables;
  • Destornillador. Lo necesitará para montar su caso;
  • Tornillos M2x6mm (x11) ;
  • Servomotor MG995
  • NodeMCU LoLin (- La versión NodeMCU LoLin tiene un pin UV, que está conectado al terminal USB 5V. De esta forma, es posible usar los 5 V de un cargador USB, pasando por la placa NodeMCU, para alimentar el servomotor. Otras versiones de NodeMCU no tienen este pin UV (tienen un pin reservado en su lugar). De esta forma, no podrá alimentar su servomotor directamente si usa una de esas otras versiones;
  • NeoPixel 16 x WS2812 5050 RGB LED
  • Botón pulsador de 12x12x12 mm
  • Cable MiniUSB , para la conexión entre NodeMCU y la computadora (para cargar el código);
  • Cargador USB 5V, 2A ( cargador de teléfono, por ejemplo) para alimentar el circuito;
  • 5 cables de puente hembra-hembra;
  • 3 cables de puente macho-hembra;
  • Recambio de aire fresco.

 

Paso 2: impresión en 3D

Imagen de impresión 3D

El modelo 3d se diseñó utilizando Fusion 360.

El modelo se compone de cinco partes diferentes:

  • Frente: cuerpo principal del gadget. Aquí es donde algunos de los componentes electrónicos (anillo LED y botón pulsador) y el servomotor se unirán;
  • Funda trasera: se usa para cerrar el cuerpo de la caja. Aquí es donde se instalarán NodeMCU y el recambio de renovación;
  • Botón : esta parte está conectada al botón;
  • Tapa: esta parte se enrosca en la parte posterior de la caja y permite reemplazar la recarga
  • Soporte: esta parte se utiliza para bloquear el anillo LED y el botón en su posición.

Puede descargar todos los archivos stl en https://www.thingiverse.com/thing:2613327

Este es un prototipo experimental. Tenga en cuenta que fue diseñado para un modelo determinado de recarga de renovación de aire (una Glade, cuyas dimensiones en milímetros puede encontrar en las imágenes). Si desea utilizar un modelo diferente, envíe un comentario y puedo ver si es posible cambiar las dimensiones del modelo para adaptarlo a sus necesidades.

Si no tiene una impresora 3D, aquí hay algunas cosas que puede hacer:

  • Pídale a un amigo que lo imprima para usted;
  • Encuentre un espacio para hackers / fabricantes cerca. Las piezas utilizadas en este modelo se pueden imprimir rápidamente (alrededor de 9 horas).Algunos espacios de hackers / fabricantes solo le cobrarán por los materiales utilizados;
  • ¡Improvisar! Puede intentar ensamblar una estructura sin partes impresas en 3D;

Paso 3: Explicación del circuito

Imagen del circuito explicado

Para este proyecto se utiliza  el modulo  NodeMCU LoLin para controlar el gadget. NodeMCU es una plataforma de código abierto IoT, que se ejecuta en un SoC Wi-Fi ESP8266 de Espressif Systems. Su hardware se basa en el módulo ESP-12.

La placa de desarrollo conecta una red Wi-Fi determinada y recibe algunos comandos de Adafruit.io plafrom. Un anillo NeoPixel se utiliza para la indicación del estado (si la conexión Wi-Fi fue exitosa, o si se recibió un comando dado, por ejemplo). El tablero de control también acciona un servomotor, que actuará en una recarga de renovación de aire. Un botón pulsador se usa para comandos locales.

Se utilizó un cargador USB de 5 V y 2 A para alimentar la placa de control y todos los periféricos. Es importante observar que cuando se activa el servo, se toma una corriente máxima considerable de la fuente de alimentación. De esta forma, no use el puerto USB de una computadora (o cualquier otro dispositivo) para alimentar su circuito. Podría reiniciarse o incluso dañarse.

Las figuras ilustran cómo se conectaron los componentes.

Paso 4: Prepare la electrónica

Imagen de Prepare the Electronics

Algunos de los componentes utilizados en este proyecto deben soldarse primero. En este paso, mostraré cómo se prepararon para una conexión más fácil de los componentes.

1. Terminales Solder NeoPixel

Los anillos NeoPixel generalmente vienen sin cables conectados a sus terminales. Esto significa que tuve que soldar algunos cables para la conexión de los LED al microcontrolador.

Para eso use tres puentes femeninos y femeninos. Corte un lado del puente y suelde sus cables en los terminales de anillo NeoPixel. El otro extremo de cada jumper estará con un terminal hembra, que se conectará más adelante en los pines NodeMCU.

  • Cable rojo = 5V
  • Cable negro = GND
  • Cable amarillo = entrada de datos

2. Terminales de botón de soldadura

Para conectar el botón pulsador al NodeMCU, primero tuve que soldar algunos cables de puente en dos terminales del botón.

Use dos jumpers femeninos y femeninos. Cortar un lado del jumper y suelde sus hilos al botón.

  • Cable verde = entrada de datos
  • Cable negro = GND

3. Servomotor MG995

Los servomotores generalmente tienen un terminal hembra de tres pines, pero desafortunadamente no se puede conectarse directamente al NodeMCU debido a la posición de los pines. Para conectar esos componentes usé un cable de puente macho-hembra.

Paso 5: Ensamblar los componentes

Imagen de Montar los Componentes

En este paso, veremos cómo ensamblar los componentes dentro de la estructura impresa en 3D. Si no desea imprimir el caso por algún motivo, puede saltar al siguiente paso y ver cómo está conectado el circuito.
Una vez que se imprime su estructura, ensamblar el circuito es bastante simple:

  1. Coloque el anillo de LED dentro de la caja frontal ;
  2. Coloque el botón impreso en 3D dentro del anillo;
  3. Coloque el botón pulsador en el medio del soporte impreso en 3D;
  4. Monte el soporte dentro de la caja frontal con cuatro pernos M2x6mm;
  5. Monte el servomotor dentro de la carcasa delantera con cuatro tornillos (los que generalmente vienen con el servo);
  6. Coloque la bocina del servo de acuerdo con la imagen y bloquee su posición con un perno. Cuando el servo está a 90 grados, la retención debe ser horizontal;
  7. Fije NodeMCU dentro de la caja trasera usando cuatro pernos M2x6mm;
  8. Inserte el relleno de renovación de aire dentro de la cámara;
  9. Thead la tapa, cerrando la cámara;
  10. Conecte el circuito (en el siguiente paso le mostraré cómo hacerlo);
  11. Cierre la caja con tres tornillos M2x6mm.

Después de eso, estará listo para subir el código.

Paso 6: Cableado del circuito

Imagen de Wire Up the Circuit

Una vez que los componentes se colocaron dentro de la caja, conecte los cables de acuerdo con los esquemas.

  • NeoPixel 5V (cable rojo) => NodeMcu 3V3
  • NeoPixel GND (cable negro) => NodeMcu GND
  • Entrada de datos NeoPixel (cable amarillo) => NodeMcu GPIO 15 (pin D8)
  • Botón pulsador 1 (cable verde) => NodeMcu GPIO 14 (pin D5)
  • Pulsador 2 (cable negro) => NodeMcu GND
  • MG995 servo 5V (cable rojo) => NodeMcu VU pin
  • MG995 servo GNG (cable marrón) => NodeMcu GND
  • Servo señal MG995 (cable naranja) => NodeMcu GPIO 12 (pin D6)

Paso 7: Configurar NodeMCU en Arduino IDE

Imagen de Setup NodeMCU en Arduino IDE

Para este proyecto se utiliza  Arduino IDE para programar  el NodeMcu. Es la forma más fácil si ya has usado un Arduino antes, y no necesitarás aprender un nuevo lenguaje de programación, como Python o Lua, por ejemplo.

Si nunca has hecho esto antes, primero tendrá que agregar el soporte de la placa ESP8266 al software Arduino.

1. Descargue e instale la última versión de Arduino IDE

Puede encontrar la última versión para Windows, Linux o MAC OSX en el sitio web de Arduino: https://www.arduino.cc/en/main/software

Descárguelo gratis, instálelo en su computadora y ejecútelo.

2. Agregar el tablero ESP8266

Arduino IDE ya viene con soporte para muchas placas diferentes: Arduino Nano, Mine, Uno, Mega, Yún, etc. Desafortunadamente ESP8266 no está por defecto entre esas placas de desarrollo soportadas. Por lo tanto, para subir sus códigos a una placa base ESP8266, primero deberá agregar sus propiedades al software de Arduino.

  • Navegue a Archivo> Preferencias (Ctrl +, en el sistema operativo Windows);
  • Agregue la siguiente URL al cuadro de texto Gestor de tableros adicionales (el que está en la parte inferior de la ventana de Preferencias):

http://arduino.esp8266.com/stable/package_esp8266com_index.json

  • Si el cuadro de texto no estaba en blanco, significa que ya había agregado otras placas antes en Arduino IDE. Agregue una coma al final de la URL anterior y la anterior.
  • Presiona el botón “Aceptar” y cierra la ventana de Preferencias.
  • Navegue hacia Herramientas> Tablero> Administrador de tableros para agregar su placa ESP8266.
  • Escriba “ESP8266” en el cuadro de texto de búsqueda, seleccione “esp8266 por ESP8266 Community” e instálelo.

Ahora su IDE de Arduino estará listo para trabajar con muchas placas de desarrollo basadas en ESP8266, como el ESP8266 genérico, NodeMcu (que utilicé en este tutorial), Adafruit Huzzah, Sparkfun Thing, WeMos, etc.

3. Agregar las bibliotecas

Las siguientes bibliotecas se usarán para nuestro código Arduino. Descargue las siguientes bibliotecas:

Navegue a Boceto-> Incluir biblioteca-> Administrar bibliotecas … en tu IDE de Arduino y agrega las bibliotecas de arriba.¡Ahora que su entorno de desarrollo está listo, pasemos al siguiente paso!

Paso 8: Configuración de Adafruit.IO

Imagen de la configuración de Adafruit.IO

Hay muchos servicios de registro de datos disponibles para comunicar un microcontrolador a la web. Con esos servicios, puede cargar / descargar datos desde / hacia la nube y hacer muchas cosas interesantes.
Adafruit.IO es uno de esos servicios gratuitos. ¡Es realmente fácil de usar y promete traer Internet de las cosas a todos!

Crear Adafruit IO Web Feed

  • Regístrese en https://io.adafruit.com/
  • En Feeds> Crear un nuevo feed, agregue un nuevo feed denominado “IoT air freshner command”. Creará una base de datos, y la usaremos para almacenar los comandos recibidos por el gadget.

En el siguiente paso, veremos cómo configurar IFTTT, otra plataforma utilizada  en este proyecto. La idea aquí es simple: IFTTT tendrá configurados algunos desencadenantes y enviará algunos datos a la plataforma Adafruit.IO cuando una lógica dada sea verdadera. El gadget podrá leer los datos almacenados en un feed determinado en Adafruit.IO, ejecutar un poco de lógica y realizar algunas acciones.

También es un buen momento para copiar su clave Adafruit.IO, que luego será utilizada para permitir que su dispositivo acceda a la base de datos. Navega por Configuración> Ver clave AIO y copia el código de tecla activa. Lo necesitará para su código Arduino (NodeMCU) en los próximos pasos.

Paso 9: Configuración IFTTT

Imagen de la configuración IFTTT

IFTTT es una plataforma gratuita que ayuda a conectar aplicaciones y dispositivos. Puede usarlo para conectar su teléfono inteligente con otros dispositivos, o para compartir datos entre sus servicios web favoritos (como Google, Facebook, Twitter, Instragram, etc.) y otros dispositivos físicos, por ejemplo. ¡Y la mejor parte es que es realmente fácil de usar!

IFTTT usa una lógica “si esto, luego eso”, donde “esto” representa un servicio que activará una acción determinada dada por “eso”. De esta forma, creará pequeños applets que conectan los servicios y dispositivos web. Para el proyecto descrito en este tutorial, hay varias manzanas que se te ocurren. Por ejemplo, los siguientes ejemplos podrían usarse para activar su dispositivo (“esto”):

  • se hace clic en un botón virtual en un teléfono;
  • todos los días en un momento dado;
  • un teléfono inteligente (GPS) llega a una ubicación determinada;
  • se recibe una notificación por correo electrónico.

En nuestros ejemplos, “ese” valor siempre será un enlace a Adafruit.IO, donde los comandos (resultado de un desencadenante dado) se almacenarán, y más tarde serán leídos por el NodeMCU.

Primero tendrá que iniciar sesión en:https://ifttt.com/

Luego instale la aplicación IFTTT en su teléfono inteligente. Puedes encontrarlo en Google Play Store:https://play.google.com/store/apps/details?id=com.ifttt.ifttt

En el sitio web, vaya a Nuevo applet (haga clic en el botón de flecha al lado de su inicio de sesión para acceder al menú).

Paso 10: Applet # 1 – The Lazy Boy

Imagen de Applet # 1 - The Lazy Boy

Para este applet crearemos un botón virtual que activará su gadget IoT. ¡En nuestro caso, significa que no tendrá que levantarse y encender su refrescante de aire! Haga clic en un botón, aguarde y respire profundamente.

Crear el applet en el sitio web:

  • Haga clic en + Esto;
  • Escriba “botón” en el cuadro de texto del servicio Seach y seleccione Botón widget> Presione botón . Tal como se describe en el sitio web de IFTTT, creará un activador que se activará cada vez que presione el botón;
  • Ahora elija + Eso ;
  • Escriba “adafruit” y seleccione Adafruit> Enviar datos a Adafruit IO . Esto enviará datos a un canal de información en su cuenta IO de Adafruit siempre que el activador que configuró previamente ( + Esto ) esté activado;
  • Configure el nombre del feed como “IoT air freshner command” y Data para guardar como “botón”.
  • Termina tu applet y enciéndelo.

Crea un botón virtual en dispositivos Android:

  • Mantenga presionado el fondo. Y elige Widgets ;
  • Búsqueda de IFTTT Small 1 x 1;
  • Ahora elija Enviar datos a IoT air freshner command feed;
  • Se creará un botón con el ícono de Adafruit.

Pruebas:

  • Haga clic en el botón que acaba de crear;
  • En https://io.adafruit.com/, vaya a su feed de comandos de renovación de aire IoT y verifique si se recibió el comando. Mostrará la última vez que se recibió la acción si funciona correctamente.

En pasos adicionales, le mostraré cómo crear el código para su ESP8266 para realizar una acción cuando se recibe el comando.

Paso 11: Applet # 2 – IIIIIIII es Tiiiiiime!

Imagen de Applet # 2 - IIIIIIIIt es Tiiiiiime!

Para este applet, crearemos un disparador de temporizador para su gadget de IoT, que se activará en determinados momentos. Reloj de alarma perfumado listo para despertarte!

Crea el applet en el sitio web:

  • Haga clic en + Esto ;
  • Escriba “Fecha” en el cuadro de texto del servicio Seach y seleccione el widget Fecha y hora> Todos los días a las . Tal como se describe en el sitio web de IFTTT, creará un disparador que se dispara todos los días en un momento determinado;
  • Haga clic en + Eso ;
  • Escriba “adafruit” y seleccione Adafruit> Enviar datos a Adafruit IO. Esto enviará datos a un feed en su cuenta IO de Adafruit siempre que el activador que configuró previamente (+ Esto) esté activado;
  • Configure el nombre del feed como “IoT air freshner command” y Data para guardar como “time”;
  • Termina tu applet y enciéndelo.

Pruebas:

  • Para probar si está funcionando, configure el tiempo de activación por un minuto después de su hora actual. Y espéralo;
  • En https://io.adafruit.com/ , vaya a su feed de comandos de renovación de aire IoT y verifique si se recibió el comando. Mostrará la última vez que se recibió la acción si funciona correctamente.

Paso 12: Applet # 3 – ¡Hogar, dulce hogar!

Imagen de Applet # 3 - Home, Sweet Home!

Para este applet, crearemos un activador de ubicación para su gadget IoT, que se activará cada vez que ingrese a un área específica (su hogar, por ejemplo).Utilizará el servicio de Localización de su teléfono (posición de GPS) para determinar si se acerca a una ubicación específica.

Crear el applet en el sitio web:

  • Haga clic en + Esto ;
  • Escriba “ubicación” en el cuadro de texto del servicio Seach y seleccione widget de ubicación> Ingrese un área . Tal como se describe en el sitio web de IFTTT, creará un activador que se activará cada vez que ingrese a una ubicación específica;
  • Especifique la dirección de su ubicación;
  • Haga clic en + Eso ;
  • Escriba “adafruit” y seleccione Adafruit> Enviar datos a Adafruit IO . Esto enviará datos a un feed en su cuenta IO de Adafruit siempre que el activador que configuró previamente (+ Esto) esté activado;
  • Configure el nombre del feed como “comando IoT air freshner” y datos para guardar como “ubicación”;
  • Termina tu applet y enciéndelo.

Pruebas:

Para probar si funciona, ¡tendrá que caminar un poco! Tienes que salir de la ubicación que especificaste y volver allí. :RE

Paso 13: Applet # 4 – ¡Tiene correo!

Imagen de Applet # 4 - ¡Tienes correo!

Para este applet, crearemos un activador de notificación para su gadget IoT, que se activará cada vez que se reciba un correo electrónico en su cuenta de gmail. Si un tono de llamada y una notificación de vibración no fueran suficientes, ¡ahora puede agregar una notificación de olor para los mensajes entrantes!

Crea el applet en el sitio web:

  • Haga clic en + Esto ;
  • Escriba “gmail” en el cuadro de texto del servicio Seach y seleccione widget de Gmail> Cualquier correo electrónico nuevo en la bandeja de entrada . Tal como se describe en el sitio web de IFTTT, creará un activador que se activará cada vez que llegue un nuevo mensaje a Gmail.
  • Haga clic en + Eso ;
  • Escriba “adafruit” y seleccione Adafruit> Enviar datos a Adafruit IO . Esto enviará datos a un feed en su cuenta IO de Adafruit siempre que el activador que configuró previamente (+ Esto) esté activado;
  • Configure el nombre del feed como “comando IoT air freshner” y datos para guardar como “correo”;
  • Termine su applet y enciéndelo.

Pruebas

  • Para probar si funciona, envíelo y envíe un correo electrónico;
  • En https://io.adafruit.com/ , vaya a su feed de comando de renovación de aire IoT y verifique si se recibió el comando. Mostrará la última vez que se recibió la acción si funciona correctamente.

Paso 14: Código ESP8266

Imagen del código ESP8266

Ahora que sus activadores están configurados, trabajemos en su código ESP8266.

Básicamente, su gadget se conectará a una red wi-fi y esperará hasta que se reciba un nuevo comando en Arduino.IO. Cada vez que se recibe un mensaje, el renovador de aire IoT realizará sus acciones (mover un servo motor para liberar un poco de perfume, cambiar los colores del LED) y regresar para el estado inactivo. El circuito también usará un botón como entrada.

Para cargar su código, seleccione NodeMCU 0.9 (Módulo ESP-12) (si está utilizando un NodeMCU) con una velocidad de carga de 11520 kbps.Desconecte el servomotor del NodeMCU, conecte NodeMCU al puerto USB de su computadora y cargue el código.

Llevará un tiempo (mucho más que completar y cargar un boceto para un Arduino … tenga paciencia …). ¡Ahora es un buen momento para que le des un mecano de instrucciones mientras esperas! :RE

Después de completar la carga, desenchufe el cable USB, conecte el servomotor y alimente su circuito desde un cargador USB.

Código explicado:

Para la configuración de IO de Adafruit, deberá reemplazar el nombre de usuario ( XXXXXXXXXX ) y la tecla io ( YYYYYYYYY ).

Visite adafruit.io, inicie sesión en su cuenta y copie la clave io (tal como se describió en los pasos anteriores).

/************************ Adafruit IO Configuration *******************************/
// visit io.adafruit.com if you need to create an account, or if you need your Adafruit IO key.
#define IO_USERNAME “XXXXXXXXXX”
#define IO_KEY “YYYYYYYYY”

También deberá especificar el SSID y la contraseña de su enrutador Wi-Fi.Reemplace WWWWWWWWWW y ZZZZZZZZZZ para configurar su conexión Wi-Fi.

/******************************* Configuración de WIFI ***************** ********************* /
#define WIFI_SSID “WWWWWWWWWW”
#define WIFI_PASS “ZZZZZZZZZZ”
#include “AdafruitIO_WiFi.h”
AdafruitIO_WiFi io (IO_USERNAME, IO_KEY, WIFI_SSID, WIFI_PASS);

 

Se usarán las siguientes bibliotecas (como se describe en los pasos anteriores).Deberá agregarlos en el ide de Arduino antes de compilar el código.

/ ************************ El programa principal comienza aquí ********************* ********* /

#include <ESP6266WiFi.h>
#include <AdafruitIO.h>
#include <AdafruitMQTT.h>
#include <ArduinoHttpClient.h>
#include “Servo.h”

 
Varias cosas (pines y parámetros de LED) se definen antes de la configuración:
#define SERV1 12 // Pin conectado al Servomotor
Servo s1;
#define BUTTON_PIN 14 // Pin conectado al pulsador
#define PIXELS_PIN 15 // Pin conectado a la entrada de datos NeoPixel
#define NUM_LEDS 16 // Número de NeoPixels
#define BRILLO 30
#define PIXEL_TYPE NEO_GRB + NEO_KHZ800 // Tipo de NeoPixels (vea el ejemplo de strandtest).
Anillo Adafruit_NeoPixel = Adafruit_NeoPixel (NUM_LEDS, PIXELS_PIN, PIXEL_TYPE); // + NEO_KHZ800);
AdafruitIO_Feed * command = io.feed (“iot-air-freshner-command”); // configura el feed ‘comando’
Durante la configuración, el NodeMCU inicializará los LED (apague y encienda), inicie el puerto de comunicación en serie y conéctese a Adafruit.io. Se mostrará una animación mientras intenta conectarse.

Las entradas (pulsador) y las salidas (servomotor) también se configuran durante la configuración.

void setup () {
ring.setBrightness (BRILLO);
ring.begin ();
ring.show (); // Inicializa todos los píxeles a ‘off’
// inicia la conexión en serie </ p> Serial.begin (115200);
// conectarse a io.adafruit.com
Serial.print (“Conectando a Adafruit IO”);
io.connect ();

// configuramos un manejador de mensajes para el feed ‘comando’.
// la función handleMessage (definida a continuación)
// se llamará cada vez que se envíe un mensaje
// recibido de adafruit io.
command-> onMessage (handleMessage);
// espera una conexión
int i = NUM_LEDS – 1;
int color = 255;
// anima los LED mientras espera la conexión
while (io.status () <AIO_CONNECTED) {
Serial.print (“.”);
ring.setPixelColor (i, 0, 0, color);
ring.show ();
i = i – 1;
if (i <0)

{ if (color == 255) {

color = 0; }

else

{ color = 255;

}

i = NUM_LEDS – 1;

} delay (50); }

lightPixels (ring.Color (0, 0, 0, 0)); // restablecer todos los píxeles a apagado cuando está conectado

// Estamos conectados

Serial.println ();

Serial.println (io.statusText ());

// mover el servomotor a la posición neutral s1.attach (SERV1);

s1.write (90); retraso (500);

s1.detach (); // establecer el pin del botón como entrada pinMode (BUTTON_PIN, INPUT_PULLUP);

}

El ciclo principal es bastante corto. Verifica si hay datos entrantes de Adafruit.io, y verifica si se presionó el botón. Si uno presiona el botón, envía datos a Adafruit.io.

 

void loop ()

{ // io.run (); es requerido para todos los bocetos.

// siempre debe estar presente en la parte superior de tu ciclo // función. mantiene al cliente conectado a

// io.adafruit.com, y procesa cualquier información entrante.

io.run ();

if(digitalRead(BUTTON_PIN) == LOW) {
command->save(“button”);
}

}

 

Cada vez que se recibe un mensaje, se llama a la función handleMessage .Esta función lee los últimos datos recibidos en una fuente dada en Adafruit.io, y verifica si se recibió una de las cadenas de comandos conocidas (‘botón’, ‘temporizador’, ‘ubicación’ o ‘correo’).

Según el comando recibido, los LED parpadearán con diferentes colores y el servomotor se activará.
// esta función se invoca cada vez que se recibe un mensaje
// de Adafruit IO. estaba adjunto a
// la alimentación en la función setup () arriba.

void handleMessage (AdafruitIO_Data * data) {

lightPixels (ring.Color (0, 0, 0, 0)); // restablecer todos los píxeles a apagado cuando se recibe nueva información
String commandStr = data-> toString (); // almacena los comandos entrantes en una cadena

Serial.print (“recibido <-“);
Serial.println (commandStr);

// Estas declaraciones if comparan la variable meteorológica entrante con las condiciones almacenadas, y controlan las NeoPixels en consecuencia.

// si se presionó el botón virtual
if (commandStr.equalsIgnoreCase (“button”)) {
Serial.println (“Botón virtual”);
rotatingPixels (ring.Color (255, 255, 0, 0)); // mostrar animación
lightPixels (ring.Color (255, 255, 0, 0)); // mostrar animación
launch (1);
lightPixels (ring.Color (0, 0, 0, 0)); // restablecer todos los píxeles a apagado cuando se recibe nueva información
}

// si es hora
if (commandStr.equalsIgnoreCase (“timer”)) {
Serial.println (“es hora”);
rotatingPixels (ring.Color (0, 0, 255, 0)); // mostrar animación
lightPixels (ring.Color (0, 0, 255, 0)); // mostrar animación
launch (2);
lightPixels (ring.Color (0, 0, 0, 0)); // restablecer todos los píxeles a apagado cuando se recibe nueva información
}

// si se alcanzó la ubicación
if (commandStr.equalsIgnoreCase (“ubicación”)) {
Serial.println (“Bienvenido a casa!”);
rotatingPixels (ring.Color (0, 255, 0, 0)); // mostrar animación
lightPixels (ring.Color (0, 255, 0, 0)); // mostrar animación
launch (2);
lightPixels (ring.Color (0, 0, 0, 0)); // restablecer todos los píxeles a apagado cuando se recibe nueva información
}

// si tiene correo
if (commandStr.equalsIgnoreCase (“mail”)) {
Serial.println (“¡tienes correo!”);
rotatingPixels (ring.Color (255, 0, 0, 0)); // mostrar animación
lightPixels (ring.Color (255, 0, 0, 0)); // mostrar animación
launch (1);
lightPixels (ring.Color (0, 0, 0, 0)); // restablecer todos los píxeles a apagado cuando se recibe nueva información
}
}

//La función auxiliar rotatingPixels fue desarrollada para mostrar una animación.El color se recibe como una entrada para esta variable.
// Rotación completa de Funcion NeoPixels 

void rotatingPixels (uint32_t color) {
for (int j = 0; j <3; j ++) { for (int i = NUM_LEDS-1; i> = 0; i–) {
ring.setPixelColor (i, color);
ring.show ();
delay (50);
ring.setPixelColor (i, 0, 0, 0);
ring.show ();
}
}
}

//la función de inicio se usa para controlar el servomotor. Ciclos su posición de //90 ° a 175 ° una cantidad determinada de veces.
// Actúa el servomotor
void launch (int number) {
s1.attach (SERV1);
para (int i = 0; i <number; i ++) {
s1.write (175);
delay (1000);
s1.write (90);
delay (1000);
}
s1.detach ();
}

 

Código completo Arduino  aqui; iot-air-freshner-code.inoiot-air-freshner-code.ino

 

Desde luego es un proyecto realmente muy interesante  no solo por su posible utilidad sino  porque no enseña la potencia de la herramientas o servios  web disponibles hoy en dia para ayudarnos en nuestros proyectos

¡Siempre tenga en cuenta que este es un prototipo experimental y podría usarse con precaución!

 

 

Fuente  ; instructables.com

Montaje de una impresora 3D paso a paso


Construir una  impresora  3d requiere una cierta cantidad de destreza física, sentido común y una comprensión profunda de lo que está haciendo.

Asi mismo la construcción y operación implica tensiones , por lo que deben tomarse todas las precauciones necesarias . No obstante las impresoras 3D,  funcionan con una fuente de 12V  DC  suministrados por una fuente de alimentación certificada, por lo que no debería haber peligro a tener que involucrarse con solo 12V, pero, tenga en cuenta que todavía puede haber altas corrientes involucradas ! incluso 12V no deberían tomarse a la ligera!.

Además,también las altas temperaturas están involucradas con la impresión 3D, ya que la boquilla de extrusión del extremo caliente puede funcionar alrededor de 230 ° C, la cama calentada corre a 110 ° C y el plástico fundido extrudido saldrá inicialmente alrededor de 200 ° C, por lo que debe prestarse especial cuidado y atención cuando se manejan estas partes de la impresora durante el funcionamiento.

Si esta pensando en adquirir una impresora 3d en Kit  en este post veremos paso a paso como se construye una  Iprusa I3 Max, una de las impresoras mas populares y económicas sobre todo cuando se compra en kit ( entre 100 y 200€)

Si en efecto adquiere un kit , desembale el equipo y compruebe que todas las piezas están en la caja revisando el estado de cada pieza, pues puede haber habido algún tipo de daño durante el envío. Para ayudarle con esto, suele haber una lista de componentes (BOM ) en la caja y cada bolsa de piezas suele estar etiquetadas .
Antes de empezar, con el fin de ahorrar tiempo, ordene especialmente los tornillos y tuercas y por supuesto !no los mezcle!.

Asegúrese de tener las habilidades necesarias para llevar a cabo el trabajo, o recurrir a la ayuda de alguien que lo haga.
Trabaje en una gran mesa o banco firme en un área limpia y bien iluminada.
Este tipo de kits contienen partes pequeñas asi que deberia mantenerlos fuera de los niños menores de 3 años.

1 Montar las varillas de un eje Y

Part ID Required quantity Required parts
NO.5 2 φ10 threaded rod
NO.W14 2 Y axis connect plate
NO.17 6 Spring washer
NO.8 8 M10 Washer
NO.12 8 M10  Nut

Enrosque las tuercas y las arandelas en las dos varillas roscadas M10 por separado.Es importante   respetar tanto el orden  como el numero de elementos ha insertar en la varilla roscada
El orden debe ser el siguiente:

1) Enrosque la placa de conexión del eje Y W14 en el centro.

2) Enroscar la arandela M10> Arandela elástica M10> Tuerca M10> Tuerca M10> Arandela M10 a la izquierda

3) Por la derecha enroscar la arandela M10

El aspecto de como debe quedar es el siguiente:

ejelargo.PNG

Puede ser buena ida para añadir los elementos auxiliarse de un par de gomas de borrar u otros elementos de poco espesor para apoyar ambos lados del eje

 

En el siguiente vídeo podemos ver paso a paso el montaje de este conjunto:

 Montar las 2 varillas lisas

Part ID Required quantity Required parts
NO.3 2 φ8 smooth rod
NO.32 3 LM8UU Linear bearings
NO.18 2 Screw locking ring
  1. Retirar la varilla de 410mm
  2. Deslice 3 Rodamientos lineales sobre las varillas lisas, una varilla lisa con dos piezas y otra con una. Antes de deslizar los rodamientos, asegúrese de que estén limpios.
  3. Deslice el anillo de fijación del tornillo en el extremo de la varilla lisa.

El resultado debería ser similar al de la imagen:

 

barras

3 Montar las placas de soporte del eje Y

Part ID Required quantity Required parts
NO. W9、

W 10

2 Support plate of Y axis(front)
NO. W 11、

W 12

2 Support plate of Y axis(rear)
NO.8 4 M10 washer
NO.12 4 M10 nut
  • Paso 1. Inserte dos barras roscadas en las placas de soporte traseras separadamente a través del orificio de montaje inferior; tenga en cuenta la orden secuencial de dos placas de soporte (como debajo de la imagen)
  • Paso 2. Fije ligeramente las varillas roscadas y la placa de soporte trasera con tuerca M10 y arandela M10.
  • Paso 3.Inserte las barras lisas con el anillo de cerradura encendido en las placas de soporte posteriores a través del agujero de montaje superior; luego fijar ligeramente el anillo de bloqueo.
  • Paso 4. Inserte el otro extremo de las varillas lisas y las varillas roscadas en la parte superior e inferior de los orificios de montaje del soporte delantero.
  • Paso 5. Fije ligeramente las varillas roscadas y la placa de madera con tuerca M10 y arandela M10.

 

 

El resultado debería ser similar al de la imagen

cuerpo.PNG

Consejos: Trate de mantener paralelas las varillas de rosca y las cuatro piezas de madera paralelas. El eje Y debe ser un rectángulo, es decir, las varillas en ambos lados deben ser paralelas, por lo que es la placa frontal y trasera. De lo contrario, causará obstrucción para el cinturón más tarde. Puede usar un calibrador digital para medir.

En el siguiente vídeo podemos ver paso a paso el montaje de este conjunto:

4 Montaje del motor Y

Part ID Required quantity Required parts
NO. W13 1 Y motor fix plate
NO.58 1 Stepper motor
NO.39 1 Pulleys
NO.22 3 M3 x 10mm screw
NO.24 2 M3 x 16 mm screw
NO.15 2 M3 square nut
NO.7 5 M3 washer

Paso 1. Montar la polea en el eje del motor, uno de los tornillos debe ser atornillado en el lado plano del eje. Atorníllelo lo más firmemente posible.(Observe la dirección de la polea )

Paso 2. A continuación, atornille el motor en el soporte del motor Y con 3 tornillos M3 x 10 mm y arandelas M3.

Paso 3. Empuje la lengüeta de sujeción del motor Y en el orificio cuadrado de la placa posterior. A continuación, fije con 2 tornillos M3x16mm, arandelas M3 y tuercas cuadradas M3

El resultado debería ser similar al de la imagen:

motor.PNG

En el siguiente vídeo podemos ver paso a paso el montaje de este conjunto:

5 Construcción de  la plataforma de impresión

Part ID Required quantity Required parts
NO.W15 1 Y platform support
NO.W16 3 Y bearing block
NO.A17 1 Belt mount
NO.47 1 Belt bracket
NO.62 4 Zip ties
NO.23 3 M3 x 12 mm screw
NO.24 6 M3 x 16 mm screw
NO.10 8 M3 nut
NO.15 1 M3 square nut
NO.7 9 M3 washer
    En este paso veremos como montar la pieza horizontal   de grandes dimensiones  donde descansara la cama caliente  que ademas  estara dotada de movilidad. Los pasos  para su montaje son los siguintes:
  • Paso 1. Monte los 3 bloques de rodamientos sobre la placa de soporte de la plataforma con tornillos M3 x 16m y arandela M3 y luego fije los otros extremos con tuercas M3.
  • Paso 2.Instale el soporte de la correa en el soporte de la correa con 2 tornillos M3 x 12mm, arandela M3 y tuerca M3.
  • Paso 3. Monte el soporte de la correa en la placa de soporte de la plataforma con un tornillo M3 x 12mm, una arandela M3 y una tuerca cuadrada M3 del mismo lado con el bloque del rodamiento.(Observe la dirección: La dirección del bracket de la correa es igual que el bloque del cojinete)
  • Paso 4. Coloque el soporte de la plataforma de construcción en el soporte del eje Y y, a continuación, ciérrelo con los tres cojinetes lineales del eje Y juntos.(Observe la dirección: El soporte de la correa está en la línea con la polea del motor Y.)

El resultado debería ser similar al de la imagen:

camacaliente.PNG

En el siguiente vídeo podemos ver paso a paso el montaje de este conjunto:

6 Ensamblaje  del rodillo Y

Part ID Required quantity Required parts
NO.41 2 Ball bearing
NO.37 1 Driven wheel holder
NO.40 1 Driven wheel
NO.24 1 M3 x 16 mm screw
NO.14 1 M3 wing nut
NO.29 1 M4 x25 mm screw
NO.13 1 M4 Lock nut

En realidad este paso es muy sencillo  y lo veremos de forma muy parecido en otros pasos similares del montaje . Básicamente se realiza en  los tres siguientes pasos:

Paso 1. Enrosque el tornillo M3 x 16mm a través del soporte de la rueda impulsada.

Paso 2. Ponga la rueda impulsada con rodamiento de bolas en el soporte de la rueda impulsada; Enrosque el tornillo M4 x25mm a través de la rueda motriz. Bloquee el otro extremo con una contratuerca M4. Es posible que necesite un par de alicates para apretar la tuerca de bloqueo. No  atornille demasiado el eje e pues debe dejar suficiente sitio para que la rueda dé vueltas libremente.

Etapa 4. Monte el soporte del rodamiento montado en las placas de soporte delanteras desde el interior hasta el exterior. Y atornille éste  con una tuerca de mariposa.

El resultado debería ser similar al de la imagen:

rodamiento.PNG

En el siguiente vídeo podemos ver paso a paso el montaje de este conjunto:

7 Montaje del cinturón del eje Y

Part ID Required quantity Required parts
NO.35 1 Timing Belts

En este paso  se trata de darle movilidad al eje Y , dado que se supone ya montado el motor  y la base de la cama caliente

Los pasos son muy sencillos y los veremos repetidos de forma muy similar para el montaje de los otros dos ejes:

  • Paso 1. Inserte un extremo de la correa en el soporte de la ranura. Preste atención a la malla del diente de la correa y la ranura.
  • Paso 2. Enhebre el otro extremo del cinturón a través de la polea del motor Y.
  • Paso 3. Enhebre el cinturón a través de la rueda impulsada. Bloquee la tuerca de mariposa. No apriete demasiado en este paso.
  • Etapa 4. Tense la correa en el soporte del cinturón, tire fuertemente y confirme su longitud, luego corte la pieza de recambio. Inserte el extremo de la correa en el soporte de la ranura
  • Paso 5.Tire la tuerca de mariposa.Consejos: La polea, el soporte del cinturón y la rueda impulsada deben estar al ras para asegurar que la plataforma de impresión se mueva suavemente.

El resultado debería ser similar al de la imagen:

ejez.PNG

En el siguiente vídeo podemos ver paso a paso el montaje de este conjunto:

8 Montaje del fin de carrera del eje Y

Part ID Required quantity Required parts
NO.52 1 End stop
NO.20 2 M2.5 x 16 mm screw
NO.9 2 M2.5 Hex nut
NO.6 2 M2.5 washer

Dentro de los componentes electrónicos, se encuentra el final de carrera o sensor de contacto (también conocido como “interruptor de límite”). Son dispositivos eléctricos  situados al final del recorrido o de un elemento móvil ,( el ejemplo mas claro es una cinta transportadora) , con el objetivo de enviar señales que puedan modificar el estado de un circuito en este caso para cortar la alimentación de motor paso a paso.

Internamente los usados en esta impresora   contiene  interruptores normalmente abiertos (NA), de modo que  al actuar sobre ellos  en la palanquilla abriran el circuito al que estén conectados

En nuestro caso simplemente montaremos  el tope final en la placa de soporte trasera del eje Y , con un tornillo M2.5 x 16mm, arandela M2.5 y tuerca hexagonal M2.5.

 

El resultado debería ser similar al de la imagen:

findecarrera.PNG

 

En el siguiente vídeo podemos ver paso a paso el montaje de este conjunto:

9 Montaje del marco XZ y el panel lateral

Part ID Required quantity Required part
NO. W1-A 1 X-Z frame (up)
NO.W1-B 1 X-Z frame (bottom)
NO.W2 1 Left side frame
NO.W3 1 Right side frame
NO.24 6 M3 x 16 mm screw
NO.15 6 M3 square nut
NO.7 6 M3 washer

En   esta fase simplemente se trata de montar el esqueleto de la impresora siguiendo los siguientes pasos:

  • Paso 1. Atornille el marco X-Z (arriba) y el panel lateral con tornillos M3 x 16mm, arandela M3 y tuercas cuadradas M3.
  • Paso 2. Atornille el marco X-Z (arriba) y el panel lateral con tornillos M3 x 16mm; M3 y tuercas cuadradas M3.  Observe la dirección de los orificios de la perilla LCD. Está a la derecha.

El resultado debería ser similar al de la imagen:

 

esqueleto.PNG

En el siguiente vídeo podemos ver paso a paso el montaje de este conjunto:

10 Ensamblaje del soporte de los  2 Z motores

Part ID Required quantity Required parts
NO.W4 1 Z motor fix plate (left)
NO.W5 1 Z motor fix plate (right)
NO.W6 3 Z motor support plate
NO. W7 1 Z motor support plate
NO.24 10 M3 x 16 mm screw
NO.15 10 M3 square nut
NO.7 10 M3 washer

Para alojar los motores en este paso  vamos a dotar a la estructura anterior de dos pequeños soportes donde irán los otros dos motores :

  • Paso 1.Ensamble Z placa de soporte del motor W6, W7 con placa de fijación del motor Z (izquierda) junto con tornillos M3 x 16 mm, arandela M3 y tuercas cuadradas M3.
  • Paso 2.Ensamble 2 placas de soporte de motor Z W6 con placa de fijación de motor Z (derecha) junto con tornillos M3 x 16 mm, arandela M3 y tuercas cuadradas M3.NOTE EL PEQUEÑO AGUJERO
  • Paso 3. Enrosque los soportes de motor Z montados a la izquierda y las esquinas de rigidez del marco principal con tornillos M3 x 16mm y tuercas cuadradas M3.

El resultado debería ser similar al de la imagen:

soporte motoes.PNG

En el siguiente vídeo podemos ver paso a paso el montaje de este conjunto:

11 Montaje del ventilador

Part ID Required quantity Required parts
NO.49

NO.254M3 x20 mm screw

NO.104M3 nut

NO.74M3 washer

1

1

1

1

Fan

Fije el ventilador en la parte posterior izquierda del bastidor con 4 tornillos M3 x 20, arandela M3 y tuercas M3. Cuidado con la dirección del ventilador. (El lado con la etiqueta está hacia afuera.)

El resultado debería ser similar al de la imagen:

ventilador.PNG

En el siguiente vídeo podemos ver paso a paso el montaje de este conjunto:

12 Esamblaje ejes Y – Z

Part ID Required quantity Required parts
NO.24 6 M3 x 16 mm screw
NO.10 4 M3 nut
NO.15 2 M3 square nut
NO.7 6 M3 washer

En este paso se trata de montar por fin la estructura que soportara  la cama caliente  al resto de estructura de la impresora-

Los pasos  son los siguientes:

  • Paso 1. Coloque el eje Y entre el marco principal. W14 está en la parte delantera del marco.
  • Paso 2. Atornille la placa trasera del eje Y y el panel lateral con tornillos M3 x16mm, arandela M3 y tuercas cuadradas M3.
  • Paso 3. Atornille el bastidor principal a la placa de conexión del eje Y con 4 tornillos M3 x 16mm, arandela M3 y tuercas M3.
  • Paso  4. Atornille las tuercas M10 en el eje Y.)

El resultado debería ser similar al de la imagen:

ensamblaje.PNG

En el siguiente vídeo podemos ver paso a paso el montaje de este conjunto:

13 Montaje fin de carrera eje Z

Part ID Required quantity Required parts
NO.52 1 End stop
NO.20 2 M 2.5 x 16 mm screw
NO.9 2 M 2.5 nut
NO.6 2 M 2.5washer

En este paso se trata de montar el interruptor de fin de carrera del eje z

Monte el tope en la base del motor de eje Z (izquierda) con tornillo M2.5 x 16mm, arandela M2.5 y tuerca hexagonal M2.5.

El resultado debería ser similar al de la imagen:

fin2.PNG

En el siguiente vídeo podemos ver paso a paso el montaje de este conjunto:

14 Montaje de los  2 Z motores

Part ID Required quantity Required parts
NO.58 2 Stepper motor
NO.22 8 M3 x 10mm screw
NO.7 8 M3 washer
  • Paso 1. Enhebre los cables de los motores a través de los agujeros de la fama principal. A continuación, coloque el motor debajo de la base del motor.
  • Paso 2. Atornille los motores con 4 tornillos M3 x 10mm y arandela M3.

El resultado debería ser similar al de la imagen:

motor_ens.PNG

Haga lo mismo con el otro motor Z de acuerdo con los pasos anteriores.

En el siguiente vídeo podemos ver paso a paso el montaje de este conjunto:

15 Montaje de los acoplamientos

Part ID Required quantity Required parts
NO.38 2 Coupling

Se trata  ahora de añadir al motor un acoplador para poder después conectarle un eje  en forma de varilla roscada

Los pasos a seguir son los siguientes:

  •  Fijar los dos acoplamientos en ambos del eje del motor.Tenga en cuenta:La apertura de ambos extremos, uno es de 5mm, otro es de 8mm, conectar el orificio de 5mm al eje del motor.
  • Atornille firmemente el tornillo de la pieza de 5 mm en la parte superior del lado plano del eje del motor; puede ver el límite en el interior del acoplamiento.
  • Haga lo mismo con el acoplamiento del eje del motor derecho de acuerdo con los pasos anteriores.

El resultado debería ser similar al de la imagen:

acople.PNG

En el siguiente vídeo podemos ver paso a paso el montaje de este conjunto:

 

En el siguiente post veremos la finalización del montaje de una impresora 3d tipo  Priusa I3 Pro W

Construcción de un centro multimedia Android para nuestro coche


Mediante una placa Arduino Mega  Aykut Çelik, ha cambiado  de una forma muy elegante  la vieja radio integrada de serie de su Volkswagen Polo de 2014 que  solo cuenta con radio con lector de cd  y no tienen ninguna conectividad bluetooth con teléfonos inteligentes y  tampoco ninguna aplicación de navegación GPS.,  pero es manejada por mandos especiales  en el volante

El  cambo es radical pues la propuesta es reemplazar la radio original  ,por una potente  tableta  con  Android   , con todo lo que se puede instalar en una tableta de ese tipo como  Google Maps, Spotify, Yandex, radio FM o cualquier  aplicación de Android  que se puede imaginar   pero además  manteniendo  los controles de volumen o  de otras funciones del coche colocados en el volante para controlar el volumen de su tableta o otras funciones.

Las partes que se necesitan son:

 

  • Un amplificador a 12V, Aunque  la radio de un coche incluye un amplificador , esta ocupa el  espacio reservada  a la tableta  y  si queremos usar solo el amplificador al no conocer habría que modificarla así que lo mejor es optar por un amplificador de audio  de calidad  ya construido, pues ademas los modernos  cuentan con mando a distancia  para regular sus diferentes as funciones 

amplificador

  • Un escudo del canbus es necesario para  poder leer comandos de la línea del canbus pues algunas de las informaciones del coche. Utiliza  este escudo para detectar los comandos del botón de rueda como los botones Subir volumen, Mute y Bajar volumen. Detrás de la radio hay dos cables de bus. Uno de ellos es Canbus – HIGH y el otro es Canbus-LOW:estos cables deben estar conectados a enchufes verdes en el escudo del canbus SeeedStudioescudo canbus
  • Un Arduino Mega  pues es responsable de analizar los datos canbus y enviarlos a la tableta Android. El envío de datos a la tableta Android es un trabajo realmente complicado, porque al principio el autor decidío utilizar un escudo de host USB y de hecho  funcionaba  arduino megapero resulta que el escudo de USB Host y el escudo de Canbus no pueden funcionar al mismo tiempo via SPI para comunicarse con el Arduino sobre el mismo pin.                                                
  • Modulo  bluetooth ; El autor  intentó cambiar el pin que estaba utilizando por el escudo del anfitrión del USB pero no funciono, asi que entonces quito el escudo host usb y  utilizo un módulo del bluetooth para comunicar la tableta Android .
  • Un adaptador del panel preparado para cada  modelo de coche. Hay personas que optan por fabricárselo a medida  con una impresora 3D  , pero también están accesibles  en tiendas online  de modo que soportan una tableta android de unos 7″ en este adaptador  quedando  muy bien estéticamente y completamente integrada en el salpicadero del automóvil.(incluso en algunos modelos se puede sacar  esta)

 

adaptador de panel

  • Convertidor 12v /2v DC de al menos 1 amp  pues serviría  para alimentar la tableta  y el modulo de  Arduino

 

Después de reunir estos elementos el sistema final es así:

Sistema completo

Este sistema parece no complicado a nivel  eléctrico ( a nivel hardware  ),  pero como vamos  a ver, si lo a nivel de sw  que debe usarse para procesar la señales del volante y enviarla a la tableta

En el siguiente vídeo, podemos  ver  como funciona el reproductor multimedia.

 

 

Vamos a continuar con la parte de programación, donde  a mi juicio es  quizás la parte mas complicada.

Usando el escudo del canbus Seeed se puede recoger  los datos del canbus del coche. Can Bus es un sistema de comunicación que cada paquete tiene un id y su carga útil. Puede ser difícil encontrar la identificación relacionada con los clics del botón de la rueda por lo que lo norma es utilizar un analizador de com serie, pero el autor tubo suerte pues después de un par de intentos encontró  los ids necesarios relacionados con los clicks  de botón de rueda que era “0xbf”.

A continuación podemos ver una parte del código arduino para identificar clics de botón:

 

witch ( buf [ 0 ] ) {
                 case 16 :
                     buttonState = VolUp ;
                     break ;
                 case 17 :
                     buttonState = VolDown ;
                     break ;
                 case 22 :
                     buttonState = Back ;
                     break ;
                 case 21 :
                     buttonState = Forward ;
                     break ;
                 case 32 :
                     buttonState = Mute ;
                     break ;
                 case 25 :
                     buttonState = Voice ;
                     break ;
                 case 28 :
                     buttonState = Phone ;
                     break ;
                 case 7 :
                     buttonState = OK ;
                     break ;
                 case 4 :
                     buttonState = Up ;
                 case 5 :
                     buttonState = Down ;
                     break ;
                 default :
                     buttonState = Nothing ;
                     break ;
             }
Como vemos  con el codigo adjunto se pueden recoger al menos 11  eventos; Volumen ,Mute, ok, atras, ariba , abajo  , voz y teleefono
Puede encontrar el proyecto Arduino en github: https://github.com/clkasd/vwcardasharduino
La información que se obtiene de canbus transferido a Android tablet vía bluetooth por lo que  finalmente en la tableta Android hay una pequeña aplicación que se encarga, por ejemplo, de reducir el volumen cuando se hace clic en el botón de la rueda ( es decir recoger las ordenes por bluetooth   y procesarla en Androi).
Ademas la app cuenta con una actividad del menú para abrir otras aplicaciones.
Puede encontrar el proyecto Android desde aquí: https: // github. com / clkasd / vwCarDashAndroid

 

Es sin duda  un excelente trabajo  muy interesante para  incluso adaptarlo a cualquier otro tipo de vehículo pues ademas el autor ha compartido el código  fuente tanto de la aplicación de captura de códigos como el de la tableta para que los pueda recoger   y hacer que cumplan su cometido

Más información en su web.

Diseño de una embarcación autopilotada


Mucho antes que aparecieran los coches autónomos , por su simplicidad  destacar que ya existían múltiples soluciones para embarcaciones autónomas  que no dependen del ser humano para moverse por el mundo

Leo Megliola, estudiante de 8 grado  invirtió un año construyendo una embarcación  autónoma    con ayuda de la academia de  Berwick Academia y su mentor Jeff gum

El  kayak era la octava tentativa  de conseguir una embarcación autónoma así que buscaba  desapoderadamente una idea innovadora  para conseguir el objetivo de construir una embarcación autónoma

La  idea de usar el kayak vino en de forma accidental de un paseo con su padre donde miraban  a un isla que estaban  a unas seis millas de distancia de  ellos ,  y el padre le preguntó si tuviese que enviar algo a  esa isla como lo haría . En principio Leo  pensó en  un cohete de globo o  incluso un avión de ala fija, pero decidió que la manera  más eficiente sería por barco, así que decidió  intentar nuevamente si proyecto esta vez centrándose en usar un  kayak que debería viajar todo el camino a Shoals totalmente sin ayuda.

El autor eligió una trayectoria desde una boya en el mar  cerca Portsmouth a otro justo en frente de Appledore Island  constituyendo un viaje de poco más de  cinco millas

TRAVESIA

El diseño de piezas  utiliza la fusión  en una impresora 3d para crear un prototipo , probando cada subsistema individualmente para aprender cómo cada pieza trabaja antes de intentar instalarlos en ambos sistemas principales

Usa   obviamente electrónica tanto para el control  de dirección como para  la  propulsión ,  y la verdad que en el vídeo vemos como va adelante rápidamente dirigiéndose  a  su destino así que todos esos  tres sistemas son buenos y probados

Nos  cuenta que la primera vez que probó el  sistema  pudo  ver un controlador de motor paso a paso   lleno de humo , pero como llevaban  un Arduino de repuesto  realizó  la primera prueba sin dirección.

Después corregido el problema hizo más pruebas en  la paya pudiendo  navegar incluso con corriente y  viento, pero lamentablemente  empezaron los  problemas de  filtraciones de  agua  y lentamente se  llenaba  de agua peligrando  la electrónica

Corregidas  las filtraciones el siguiente intento  conseguir llegar alrededor de la  mitad del itinerario , pero el kayak funcionaba perfectamente ,aunque confundió  algunas cosas en el  código que ejecuta el arduino

Los componentes del kayak  son lo siguientes:

  • El sistema de propulsión del kayak lo  constituye    un motor eléctrico de tipo trolling del que  hemos hablado  en numerosas veces es este blogyilon
  • Usa  tambien una batería  marina AGM    de ciclo profundo proporcionando la energía  necesaria tanto a la electrónica como al sistema de propulsión51AO+9H+NTL
  • Un Arduino Uno
  • Un modulo  GPS
  • Dos controladores de motor paso a paso(*)
  • Dos relés de potencia consecutivos(**)

 

(*)  En principio pare el timon  al  llevar dos cables el autor ha debido usar  un motor conectado solidariaemnte a cada uno de ellos

(**) Debido a la potencia del motor probablemente el autor ha optado por conectar dos reles en paralelo en lugar de un único relé

Como era de esperar  , Arduino es  responsable de dirigir el barco y encender y apagar el motor, así como navegar  en función de las señales  NMEA  que proporciona el escudo GPS

Cuenta con dos motores paso a paso que van girando en un sentido o en otro  para mover el timón de la embarcación . El autor ha optado  para no estropear la embarcación, situando  los  motores para  controlar la  dirección a una distancia  adecuada para por medio de dos cables de acero  tirar  de cada extremo del timón  hacia estribor o babor y no dirigir la dirección del barco entero pues el uso de la palanca  ayuda  a minimizar el consumo del motor de dirección

En la electrónica,  el GPS es responsable para decirle al kayak qué dirección está viajando calculando el  por medio del microcontrolador Arduino  las ordenes a dar  al motor  PaP  en en función de  las  señales que está recibiendo   dado que  no cuenta con brújula electrónica

El algoritmo inicial  tenia   en cuenta donde estaba hace unos segundos y donde está en el momento actual de modo que podía  calcular  de que manera  se había movido  sabiendo qué camino estába viajando bien, así que fruto  de la experimentación  consiguió escribir  el  programa adecuado para ir corrigiendo constantemente el rumbo para llegar al destino

El autor tubo algunos  problema a la hora sobre todo de escribir el código principalmente  por  tres  motivos principales:

  • Primero el autor  falló en  simulación de scratch donde tuvo la pequeño barco y la isla y nosotros fundamentalmente los rudimentos de la código que escribimos en Arduino idioma y se movió mucho y luego terminó simplemente haciendo un círculo  una y otra vez para que ese total  falló y terminamos arreglando que reescribió completamente el código y tomó enfoque diferente  SCARTACH1.PNG
  • El segundo fracaso vino  que trataron de navegar en el coche  usando la misma electrónica pero a la que añadieron  cuatro LEDs que indicaba  de qué manera había que dar la vuelta si el circuito sabe de alguna corrección GPS , así como si se estaba dentro del rango para detener o no . Por el resultado comprobado empíricamente, el algoritmo estaba mal ,pues indicaba  que estaba completamente fuera de la distancia cuando en realidad  estában a unos cien metros de distancia  y  dijo que está en algún lugar en el rango de cinco mil metros de distancia..
  • El tercer fallo vino con una  de las revisiones de código cuando íba hacia el norte pues en el código estaba dividiendo por cero y perdía el control .Arreglo eso también tomando una nuevo enfoque completamente nuevo de modo que finalmente  consiguio solucionar  el problema   incluso en una corriente cruzada como  se  puede ver en el vídeo .

 

El autor ha utilizado componentes y tutoriales principalmente de Adafruit, incluyendo un Arduino, un sensor GPS, un relé y un controlador de motor paso a paso y para programarlo ha usado Scratch

De momento aquí os dejamos un vídeo en el que nos enseña su proyecto  aunque  lamentablemente no ha compartido el código de Arduino .

 

 

 

 

Nos  consta  que has seguido intentando mejorar  su proyecto  como demuestra el siguiente vídeo  donde el kayak de Leo adquiere y encuentra una boya de mar a 1,5 km de distancia (prueba de mar abierto)  siendo el rumbo inicial  de 120 grados respecto al objetivo.

 

 

Sencillo exobrazo


Puede parecer una banalidad , pero la idea detrás de este prototipo es muy interesante ya que  puede suponer una ayuda importante   a la movilidad,  pues esta  assietncia puede ser especialmente importante para los ancianos y otras personas que necesitan este tipo de ayuda en la vida cotidiana.

El sistema que sugieren sus creadores destaca por su simplicidad : una estructura de aluminio  para sujetar el brazo, un motor y una placa Arduino con su correspondiente escudo (cuyos detalles, por cierto, han publicado en hackaday.com) ,

Nos explican   que en la construcción del  exo-brazo buscaban  que fuese relativamente barato, sencillo y potente que permitiera  un uso fácil del mismo , por lo cual  construir su prototipo no deberia costar mas de 100$ ,  lo cual es un precio bastante razonable ,sobre todo si nos vamos a soluciones que se  estan desarrollando la industria.

El desarrollo de este proyecto comenzó centrándose más en el control del brazo y luego en el propio diseño, por lo que  tal vez el  objetivo número de sus creadores  es   hacer que el control de ExoArm sea tan barato y tan intuitivo como sea posible.

En el siguiente video podemos verlo en acción:

Como podemos  apreciar, hay una estructura articulada de aluminio  y precisamente en la articulación esta el motor (en el codo) , aunque  sugieren que en otros diseños futuros  también proveen implementar  un  actuador en el hombro( de hecho el shield empleado admite dos motores).

Este  exo-brazo tiene   tambien apoyo trasero, de modo que todo el peso se distribuye uniformemente a su cuerpo siendo la capacidad de elevación  alrededor de 10 kg máximo o 22 libras.

 

Electrónica

 

 

modulo.PNG

 

 

Ademas de la placa Arduino, un componente básico es el driver del motor VNH2SP30 ,el cual es esencialmente una versión en rampa del escudo de motor Ardumoto. Esta placa se presenta como un escudo que  se conecta encima de Arduino  y es de bajo coste ( unos 6,5€ en Amazon).

Para este  Shield se usa  un par de drivers de motor de puente completo VNH2SP30. También incluye los circuitos de soporte para que esta placa sea capaz de controlar  un par de motores de alta corriente ,  aunque para esta aplicacion solo se usa uno .

El VIN y el motor son lanzados para  terminales de tornillo de 5mm , lo que facilita la conexión de cables de mayor calibre.

Al utilizar este escudo en aplicaciones de alta demanda extrema puede ser necesario mejorar el rendimiento térmico con un disipador de calor o ventilador y soldar los cables directamente a la placa en lugar de usar un terminal de tornillo (tenga en cuenta la alta corriente de este) , aunque  cuando se utiliza el escudo en corrientes de hasta 6A los chips apenas llegarán a ser perceptiblemente calientes.

Resumidamente  esta son algunas de las características del escudo empleado:

  • Voltaje: max. 16V
  • Regimen de corriente: 30A maximo 
  • Corriente permanente: 14 A
  • Resistencia MOSFET (solo ida): 19 m & OHgr;
  • Frecuencia PWM: 20 kHz Max.
  • Tamano placa: 6 * 5,2 * 2cm / 2,4 * 2 * 0,8pulg
  • Peso : 23 g / 0,8 oz

Una vez resuelto el driver, respecto a Arduino , los pines que se requieren , en la aplicación  son los pines siguientes:

  • Pines 3 y 4  como salidas binarias para configurar el motor vía el driver del motor VNH2SP30
  • Pin 5  como salida analógica para escribir el dato en el el driver del motor VNH2SP30
  • Pin 2  como entrada analógica para el encoder solidario al eje del motor para saber la posición de la articulación
  • Pines 8 como entrada binaria para ordenar subir la articulación via el motor
  • Pines 9  como entrada binaria para ordenar bajar  la articulación vía el motor

 

 

Antes de ver el codigo  final ,  es interesante apreciar como el control del motor se hace fijando los pins 3  y 4 a un valor  y luego sacando un valor analogico en el pin 5, por ejemplo, parar mover  arriba el motor   se usa esta función:

void moveup(float writemotor){ /
writemotor = map(writemotor, 0, -80, 255, 0);
digitalWrite(3, HIGH);
digitalWrite(4, LOW);
analogWrite(5, writemotor);

Y de forma similar para mover hacia  abajo :

void movedown(float writemotor){ 

writemotor = map(writemotor, 0,-255, 0, 255);
digitalWrite(3, LOW);
digitalWrite(4, HIGH);
analogWrite(5, writemotor);
}

Simplemente para  parar el moto,r   sacamos un  valor cero  en el pin 5 usan esta otra función:

void stopmove(){ //parar el motor
digitalWrite(3, LOW);
digitalWrite(4, LOW);
analogWrite(5, 0);
}

 

Una función  muy importante  es conocer la posición de la articulación  gracias a que hay conectado un potenciómetro solidario al aje de modo  que  capturando  el valor  de la salida del potenciómetro podemos   conocer el angulo ,gracias  al  siguiente código:

float errorSum;
float Kp = 2;
float Ki = 0;

float computePID(int setpoint){    
angle = analogRead(2);
angle = map(angle, 0, 344, 0, 90); 

double time_elapsed = micros();
dtrate = (time_elapsed – last) / 1000.f;
last = time_elapsed;

float error = setpoint – angle;
errorSum += error * dtrate;
errorSum = constrain(errorSum, -255, 255);

return (Kp * error) + (Ki * errorSum);

}

Por ultimo,  en la función loop miramos continuamente  los valores binarios de los pines 8 y 9  ,y en función de su estado, llamaremos a alguna de las rutinas anteriores:

 

void loop()   //bucle principal de ejecución
{
int program_runtime = millis();

int readingUp = digitalRead(8);
int readingDown = digitalRead(9);

if(readingUp == 1 && readingDown == 0){
if(program_runtime – previousMillis > interval) {
previousMillis = program_runtime;
Step -= 5;
}

}
if(readingDown == 1 && readingUp == 0) {
if(program_runtime – previousMillis > interval) {
previousMillis = program_runtime;
Step += 5;
}

 

Código arduino

El procesamiento de control como decíamos se hace con un Arduino, por lo que el código es  bastante fácil de entender y modificar cuanto se quiera para mejorarlo o adaptarlo a cada necesidad:

 

#include <ArduinoTimer.h>
#include <CircularBuffer.h>
#include <CommandHandler.h>
#include <CommandProcessor.h>
#include <DataStore.h>
#include <DeviceAddress.h>
#include <EEPROMStore.h>
#include <Filter.h>
#include <MegunoLink.h>
#include <MessageHeaders.h>

#include “MegunoLink.h” /Funciones útiles para comunicarse con MegunoLink Pro.

#include “filter.h”
#include “Servo.h”

TimePlot plot;

int potVal;
int angle;
float dtrate;
double last;

ExponentialFilter FilteredMuscleValue(5, 20); / peso de la derecha, valor de inicio izquierdo

void moveup(float writemotor){ //mover  arriba el motor
writemotor = map(writemotor, 0, -80, 255, 0);
digitalWrite(3, HIGH);
digitalWrite(4, LOW);
analogWrite(5, writemotor);

}

void stopmove(){ //parar el motor
digitalWrite(3, LOW);
digitalWrite(4, LOW);
analogWrite(5, 0);
}

void movedown(float writemotor){ //mover hacia  abajo

writemotor = map(writemotor, 0,-255, 0, 255);
digitalWrite(3, LOW);
digitalWrite(4, HIGH);
analogWrite(5, writemotor);
}

float errorSum;
float Kp = 2;
float Ki = 0;

float computePID(int setpoint){    //función de  calculo de la posición del encoder
angle = analogRead(2);
angle = map(angle, 0, 344, 0, 90); // dejanski kot
Serial.print(angle);

double time_elapsed = micros();
dtrate = (time_elapsed – last) / 1000.f;
last = time_elapsed;

float error = setpoint – angle;
errorSum += error * dtrate;
errorSum = constrain(errorSum, -255, 255);
//Serial.println(error);
return (Kp * error) + (Ki * errorSum);

// Serial.println(time_elapsed, 5);
}

int Step = 0;

void setup()     //inicializacion del brazo
{
pinMode(8, INPUT);
pinMode(9, INPUT);
pinMode(3, OUTPUT);
pinMode(4, OUTPUT);
pinMode(5, OUTPUT);
Serial.begin(9600);
Step = 0;
}

int k = 1;
int previousMillis = 0;
int interval = 50;

void loop()   //bucle principal de ejecución
{
int program_runtime = millis();

int readingUp = digitalRead(8);
int readingDown = digitalRead(9);

if(readingUp == 1 && readingDown == 0){
if(program_runtime – previousMillis > interval) {
previousMillis = program_runtime;
Step -= 5;
}

}
if(readingDown == 1 && readingUp == 0) {
if(program_runtime – previousMillis > interval) {
previousMillis = program_runtime;
Step += 5;
}

}
Step = constrain(Step, -150, 150);
if(readingDown == 0 && readingUp == 0) Step = 0;

//plot.SendData(“pid”, writemotor);
Serial.println(Step);
if(Step > 0) moveup(Step);
if(readingUp == 0 && readingDown == 0) stopmove();
if(Step < 0) movedown(Step);

}

Componentes necesarios

1 × calibrador de tensión con el amplificador de celda de carga
1 × Aluminio 4 x 30 x al menos 2000 mm
1 × Arduino Uno / Nano
1 × controlador de motor VNH2SP30
1 × Motor del limpiador del parabrisas del coche
1 × cables largos
1 × Potenciómetro
1 × Li-Po batería 3S 5500mAh
1 × Tornillos y tuercas. M4 y M6
1 × Cinta adhesiva
1 × Zipties
1 × Correas
1 × Placas de madera
1 × Tubo termorretráctil

 

 

En el siguiente vídeo el autor describe mas detalles de construcción   de este excelente  exo-brazo:

 

 

Mas información en https://hackaday.io/project/20663-assistive-exoskeleton-arm-exoarm#menu-description