Sistema de reconocimiento de colores para personas con discapacidades visuales


ColorDec  es un interesantismo  proyecto  que representará  al colegio Lope de Vega de 3ª de el ESO  para el concurso RetoTech que organiza ENDESA    creado por   Esther Scott, Irene Yebra, Irene Jimenez,Lucia Gomez y Paula  Vidal  ,  con el propósito de   ayudar  a  personas con discapacidad  visual para  mejorar su percepción de los colores,  gracias  a un hardware de bajo coste basado en Arduino   y una aplicación móvil  que ellas mismas han escrito usando el Mit App Inventor, una herramienta de la que por cierto hemos hablado en numerosas ocasiones en este blog .

El proyecto  tiene  pues su base  en un Arduino Nano, al que le han acoplado  un modulo bluetooth  para el envío de datos a  un smartphone  mediante los pines 9 (Rxd)  , 8(Txd)  para los datos  vía serie,   así como  VCC y gnd para la alimentación desde Arduino al  propio modulo  Bluetooth.

Para el reconocimiento de colores cuenta con un sensor especializado como es  el GY33 ( unos 15€ en Amazon)  el cual conectan al propio Arduino via I2C  por los pines A4,A5  alimentándose desde el propio Arduino  desde los pines  5v y GND.

El  GY-33 es un modulo  de reconocimiento de color de bajo costo que puede alimentarse  entre  3-5 V, con bajo consumo de energía, de  tamaño pequeño y facilidad de instalación.
Su principio de funcionamiento radica en que la iluminación de la irradiación de luz LED debe medirse  hacia el objeto de modo que la  luz de retorno es  detectada por los filtros de valores RGB y el propio modulo identifica los colores según los valores RGB.
Este módulo, soporta dos maneras de envió de  datos:

  • Via serie,  es decir mediante UART en serie (nivel TTL) configurando la conexión a 9600bps y 115200bps  siendo la velocidad en baudios del puerto en serie  configurable.
  • I2C (mediante 2 líneas) que es el que han empleado en este circuito mediante  lso pnes A4 y A5 .

El modulo puede hacer  un reconocimiento simple de 7 colores y no es necesario calcular el valor RGB o se puede gestionar  el dato de una manera compleja como vamos a ver.

Se complementa  el circuito   final con un pulsador(pin2)  con su respectiva resistencia para evitar rebotes    y la alimentación de  todo el conjunto  por un pila de 9v desde los pines VIN y GND de Arduino.

El diagrama   final  lo  podemos ver en  la imagen de mas abajo:

 

esquema

 

El dispositivo esta pensado para ser portátil de modo que sujetándolo con una mano se apoya en el objeto del que se  desea conocer el color , se pulsa el botón para que este lo transmita (tras convertirlo de RBG a HSV) por bluetooth al teléfono móvil del usuario, desde donde una APP   lo  reproduce hablando en inglés o castellano.

En cuanto al software para este  proyecto ha sido realizado utilizando el IDE de Arduino para programar un Arduino Nano, al que se le ha conectado un módulo Bluetooth, un Pulsador y un módulo GY-33 para el reconocimiento de color  lo cual es tarea del firmware de Arduino gestionarlo

El programa del Arduino, en su inicialización realiza un balance de blanco, y después espera a que se pulse el pulsador para leer el color, convertirlo a HSV y enviarlo por Bluetooth al móvil.

El código provisional para el firmware de Arduino que aun esta es proceso de mejora  nos lo comparten en estas lineas:

 

Colorview4-ino_1.png

Colorview4-ino_2.png

Colorview4-ino_3

Ya desde el teléfono, se conecta al Arduino por Bluetooth, se cargan dos arrays con los datos de dos ficheros CSV, uno con los códigos RGB de los colores y otro con los nombre de esos colores .

Se busca el color en el array y si se encuentra ese será el que el teléfono lea en voz alta.

Sino se encuentra entre los más de 600 códigos RGB, se usa el código en HVS para construir una frase que describe como es el color y se envía al sistema de síntesis de voz del teléfono.

La conversión a HVS han tenido que hacerla al no poder ordenar los códigos RGB para poder situarse sobre el color más cercano al leído.

Amablemente nos han compartido sin código escrito con el MIt App Inventor  para desplegarlo en un terminal Android

 

App-Inventor-Blocks 2-page.png

 

Es sin duda  un sistema  de mínimo coste  que puede ser de muchísima ayuda para  identificar  los colores para personas con deficiencias visuales,  así que le deseamos desde este blog  toda la suerte posible . El premio es una plaza para cada una de las cinco en un campamento de verano donde seguirán aprendiendo robótica y programación , así que queridos lectores porfavor  si os parece interesante  todo el esfuerzo de esta   chicas y  merece vuestra confianza, esta es la dirección para  votar   su proyecto:

https://pr.easypromosapp.com/voteme/826101/630232517

Personalmente  ya he votado porque me ha parecido impresionante el trabajo realizado , así que desde esta lineas  les deseamos toda la suerte en este concurso  y ojala puedan seguir aprendiendo  y perfeccionando sus conocimientos  tecnicos de modo que puedan seguir ayudando a construir un mundo mucho mejor gracias al uso de la tecnología y su ingenio

Anuncios

Controle su Roomba con Arduino y Android


 

iRobot Roomba Create2 es una a  plataforma grande y muy asequible para el desarrollo de la robótica, costando alrededor de US$ 200 permitiendo  una variedad de métodos de programación. Como  comienzo mjrovi usó  un Arduino y una aplicación Android para mover el robot  por puerto serie  consiguiendo asi controlar  sus motores, LEDS y sonido.

Como uno de los ganadores de 2016 del concurso de robótica   en Instructables, mjrovi recibió como premio un iRobot Roomba Create2.

 

 

La Roomba es un robot de impulsión diferenciada, con 2 ruedas motrices y una rueda  central  guía. Su velocidad va hasta 500 mm/s y puede ser mandado a ir hacia arriba o hacia atrás.
Para señalización, contamos con cuatro 7 segmentos display y 5 LEDs :

  • Limpiar
  • Punto
  • Muelle
  • ADVERTENCIA/Check
  • Suciedad/escombros

Como sensores internos, tenemos entre otros:

  • Detector de acantilado (4 en el frente)
  • Detectores Bump (frente 2)
  • Codificadores de rueda

Para la programación, el documento: iRobot® Create® 2 abierto interfaz (OI) debe ser utilizado.El Roomba puede ser programado en 3 modos:

  1. Modo pasivo:Al enviar el comando de Start o cualquiera de los comandos de modo de limpieza (por ejemplo, punto limpio, muelle buscar), la OI entra en modo pasivo. Cuando la OI está en modo pasivo, puede solicitar y recibir datos de los sensores usando cualquiera de los comandos del sensor, pero no puede cambiar los parámetros de comando actuales para los actuadores (motores, altavoces, luces, controladores de lado de baja, salidas digitales) a otra cosa.
  2. Modo seguro :Le da un control completo de Roomba, con excepción de las siguientes condiciones relacionadas con la seguridad:
    Cargador conectado y alimentado:detección de una caída de rueda (en cualquier rueda),detección de un acantilado mientras se mueve hacia adelante (o hacia atrás con un pequeño radio de torneado, menos de un radio de robot) o si ocurre una de las condiciones relacionadas con la seguridad mientras que el OI es en modo seguro, Roomba detiene todos los motores y vuelve al modo pasivo.
  3. Modo completo:Le da un control completo sobre Roomba, todos de sus actuadores y todas las condiciones relacionadas con la seguridad que están restringidas cuando la OI en modo seguro, como el modo completo se apaga el acantilado, caída de rueda y características de seguridad cargador interno.

Comunicaciones

Para  programar la Romba  la lista de  materiales  usada es la siguiente:

  • iRobot Create2
  • Arduino UNO
  • Módulo Bluetooth HC-06
  • Pulsador

Para la comunicación entre la Roomba y Arduino, se utilizará el puerto Serial. Por defecto, Roomba comunica a 115.200 baudios, pero para comunicarse con Arduino, se cambiará a 19.200.

Hay 2 formas de establecer la tasa de baudios de Roomba:

  1. Mientras que apagar Roomba, continúan mantenga pulsado el botón de encendido o limpiar después de que la luz se ha apagado. Después de unos 10 segundos, Roomba juega una melodía descendente de las echadas. Roomba se comunicará a 19.200 baudios hasta que el procesador pierde energía de la batería o la tasa de baudios se modifica explícitamente a través de la OI.
  2. Utilizar el pin de cambio de tasa de baudios (pin 5 del conector mini-DIN) para cambiar la velocidad en baudios de Roomba. Después de encender la Roomba, esperar 2 segundos y luego pulso el cambio de la tasa de baudios baja tres veces. Cada impulso debe durar entre 50 y 500 milisegundos. Roomba se comunicará a 19200 baudios hasta que el procesador pierde energía de la batería o la tasa de baudios se modifica explícitamente a través de la OI.

 

El diagrama de arriba muestra cómo la Arduino debe conectarse al conector mini-DIN de Roomba

 

 

Lo primero creo que debe hacerse cuando un Roomba de programación es “Despertar” el robot y  Definir el modo (segura o completa)

Nosotros podemos  hacer  un “wake-up”, enviar un poco de pulso al pin mini-DIN 5 (detección de dispositivo de entrada) como se muestra en la siguiente función:
void wakeUp (void)
{
setWarningLED(ON);
digitalWrite(ddPin, HIGH);
delay(100);
digitalWrite(ddPin, LOW);
delay(500);
digitalWrite(ddPin, HIGH);
delay(2000);
}

Para empezar a Roomba deberán enviarse 2 códigos de siempre: «START» [128] y el modo, en nuestro caso “Modo seguro” [131]. Si usted quiere un “modo completo”, debe enviarse en su lugar el código [132].
void startSafe()
{
Roomba.write(128); //Start
Roomba.write(131); //Safe mode
delay(1000);
}

 

Como se describe en la introducción, el Roomba tiene 5 LEDs:

  • Energía/limpiar (bicolor rojo/verde e intensidad controladas)
  • Punto (verde, intensidad fija)
  • Muelle (verde, intensidad fija)
  • ADVERTENCIA/Check (naranja, intensidad fija)
  • Suciedad/escombros (azul, fija la intensidad)

 

Control de leds

Todos los LEDs pueden ser ordenados mediante código [139]
Para controlar el LED de encendido, debe enviar dos bytes de datos a Roomba: “color” y la “intensidad”.
Color:

  • Verde = 0
  • Naranja = 128
  • rojo = 255

Intensidad:

  • Bajo = 0
  • Max = 255

La función setPowerLED (colores bytes, setIntensity bytes) lo hace:

void setPowerLED(byte setColor, byte setIntensity)
{
color = setColor;
intensity = setIntensity;
Roomba.write(139);
Roomba.write((byte)0x00);
Roomba.write((byte)color);
Roomba.write((byte)intensity);
}

Por ejemplo, para encender el LED de POWER de color naranja en la mitad de su intensidad, usted puede llamar a la función como bramido:setPowerLED (128, 128);

Encender los 4 LEDs restantes, deberán utilizarse las siguientes funciones:
setDebrisLED(ON);
setDockLED(ON);
setSpotLED(ON);
setWarningLED(ON);

Todas las funciones anteriores tiene un código similar a este:
void setDebrisLED(bool enable)
{
debrisLED = enable;
Roomba.write(139);
Roomba.write((debrisLED ? 1 : 0) + (spotLED ? 2 : 0) + (dockLED ? 4 : 0) + (warningLED ? 8 : 0));
Roomba.write((byte)color);
Roomba.write((byte)intensity);
}

Básicamente, la diferencia será la línea: debrisLED = habilitar;  debe modificarse permitiendo a cada uno de los otros LEDs (spotLED, dockLED, warningLED).

 

Envío de mensajes

Roomba tiene cuatro 4 displays de 7 segmentos que puede utilizar para enviar mensajes de dos maneras::
[163] código: Dígitos LED crudo (numérico)
[164] código: Dígitos LED de ASCII (aproximación de letras y códigos especiales)
Para mostrar números  debe enviar el código [163], siguiendo las 4 digitas a mostrar. La función: setDigitLEDs (bytes digit1 digit2 bytes, digit3 bytes, digit4 bytes) lo hace para usted:

void setDigitLEDs(byte digit1, byte digit2, byte digit3, byte digit4)
{
Roomba.write(163);
Roomba.write(digit1);
Roomba.write(digit2);
Roomba.write(digit3);
Roomba.write(digit4);
}

Por ejemplo, para mostrar “1, 2, 3, 4”, debe llamar a la función: setDigitLEDs (1, 2, 3, 4);

Con el código [164], es posible enviar aproximación de ASCII.

La función setDigitLEDFromASCII (dígitos de byte, char letra) hace esto para nosotros:
void setDigitLEDFromASCII(byte digit, char letter)
{
switch (digit){
case 1:
digit1 = letter;
break;
case 2:
digit2 = letter;
break;
case 3:
digit3 = letter;
break;
case 4:
digit4 = letter;
break;
}
Roomba.write(164);
Roomba.write(digit1);
Roomba.write(digit2);
Roomba.write(digit3);
Roomba.write(digit4);
}

Para simplificar, crear una nueva función para enviar los 4 dígitos al mismo tiempo:
void writeLEDs (char a, char b, char c, char d)
{
setDigitLEDFromASCII(1, a);
setDigitLEDFromASCII(2, b);
setDigitLEDFromASCII(3, c);
setDigitLEDFromASCII(4, d);
}

Por ejemplo, para mostrar “STOP”, usted debe llamar a la función: writeLEDs (‘s’, ‘ t ‘, ‘ o ‘, ‘p’);

Mover la  Roomba

Para la movilidad, Roomba tiene 2 motores independientes que pueden programarse para ejecutar 500mm/s. Hay varios comandos que pueden utilizarse para controlar el robot. Los principales son:

  • Código [137]: Unidad == > debe enviar +-velocidad en mm/s y +-radio en mm
  • Codigo [145] de código: Impulsión directa == > debe enviar izquierda velocidad en mm/s (+ para adelante y para atrás)
  • Código [146]: Unidad PWM == > debe enviar +-datos PWM para la izquierda y derecha las ruedas

 

A continuación el código para estas 3 opciones:

void drive(int velocity, int radius)
{
clamp(velocity, -500, 500); //def max and min velocity in mm/s
clamp(radius, -2000, 2000); //def max and min radius in mm

Roomba.write(137);
Roomba.write(velocity >> 8);
Roomba.write(velocity);
Roomba.write(radius >> 8);
Roomba.write(radius);
}

//—————————————————————

void driveWheels(int right, int left)
{
clamp(right, -500, 500);
clamp(left, -500, 500);

Roomba.write(145);
Roomba.write(right >> 8);
Roomba.write(right);
Roomba.write(left >> 8);
Roomba.write(left);
}

//—————————————————————
void driveWheelsPWM(int rightPWM, int leftPWM)
{
clamp(rightPWM, -255, 255);
clamp(leftPWM, -255, 255);

Roomba.write(146);
Roomba.write(rightPWM >> 8);
Roomba.write(rightPWM);
Roomba.write(leftPWM >> 8);
Roomba.write(leftPWM);
}

Tenga en cuenta que la función de “fijar” define los valores máximos y mínimos que se permitieron la entrada. Esta función se define en el archivo rombaDefines.h:

#define abrazadera (valor, min, max) (valor < min? min: valor > max? max: valor)
Utilizando el código anterior, se pueden crear funciones más simples para Roomba alrededor de:
/—————————————————————
void turnCW(unsigned short velocity, unsigned short degrees)
{
drive(velocity, -1);
clamp(velocity, 0, 500);
delay(6600);
drive(0,0);
}

//—————————————————————
void turnCCW(unsigned short velocity, unsigned short degrees)
{
drive(velocity, 1);
clamp(velocity, 0, 500);
delay(6600);
drive(0,0);
}

//—————————————————————
void driveStop(void)
{
drive(0,0);
}

//—————————————————————
void driveLeft(int left)
{
driveWheels(left, 0);
}

//—————————————————————
void driveRight(int right)
{
driveWheels(0, right);
}

Tenga en cuenta que para girar en ángulo, debe calcularse el argumento de “retraso” específicamente para una velocidad dada

A continuación algunos ejemplos que pueden utilizar para probar los motores:

turnCW (40, 180); girar 180 grados hacia la derecha y parada
driveWheels (20, -20); vuelta
driveLeft(20); girar a la izquierda

Para las pruebas de los motores, es bueno añadir un pulsador externo (en mi caso conectado al Arduino pin 12), para que puedan descargar el código de Arduino, a partir de la Roomba, pero parando la ejecución hasta que se pulsa la tecla. Generalmente, para los motores de prueba lo puedes hacer en la parte de configuración del código.

Como ejemplo, consulte el código de Arduino simple abajo (nota que el código usa funciones y definiciones desarrollaron antes):

#include “roombaDefines.h”
#include

// Roomba Create2 connection
int rxPin=10;
int txPin=11;
SoftwareSerial Roomba(rxPin,txPin);

//———————————————
void setup()
{
Roomba.begin(19200);

pinMode(ddPin, OUTPUT);
pinMode(buttonPin, INPUT_PULLUP); // connected to Arduino pin 12 and used for “starting”

delay(2000);

wakeUp (); // Wake-up Roomba
startSafe(); // Start Roomba in Safe Mode

while (digitalRead(buttonPin)) { } // wait button to be pressed to continous run code

turnCW (40, 180); //test Roomba spin clock-wise 180 degrees and stop
}

//———————————————
void loop()
{

}

 

Controlar la Roomba a través de Bluetooth

Para controlar  Roomba de modo inalambrico   vamos a instalar un módulo Bluetooth (HC-06) a nuestro Arduino. El diagrama de arriba muestra cómo hacerlo. Suele ser el HC-06 settle up de fábrica con una velocidad de 9.600. Es importante cambiarlo a 19.200 para ser compatible con la velocidad de la comunicación de Arduino-Roomba. Usted puede hacer que el envío un comando AT para el módulo (AT + BAUD5 donde “5” es el código de 19.200).

Para controlar la Roomba, utilizaremos una aplicación genérica que fue desarrollada por jrovai   para el control de robots móviles, con el MIT AppInventor 2: “MJRoBot BT Remote Control”. La aplicación puede descargarse gratuitamente de la tienda de Google a través del enlace: aplicación: MJRoBot BT Remote Control.

La aplicación tiene una interfaz sencilla, lo que le permite enviar comandos al módulo de BT en ambos, modo de texto o directamente a través de botones preprogramados (cada vez que se pulsa un botón, un carácter se envía):

  • w: hacia adeñante
  • S: hacia atras
  • d: derecho
  • a: izquierda
  • f: parada
  • p: ON / OFF (no usado en esta primera parte)
  • m: manual / automático (se utiliza para reiniciar Roomba si un obstáculo como un acantilado se encuentra en modo seguro)
  • +: Velocidad +
  • -: Velocidad –

También puede enviar otros comandos como texto si es necesario. También hay una ventana de texto para los mensajes recibidos desde el módulo de BT. Esta característica es muy importante durante la fase de prueba, puede ser utilizado en la misma forma que el “Serial Monitor”.

El loop() parte del código será “escuchando” el dispositivo bluetooth y dependiendo del comando recibido, tomar una acción:

void loop()
{
checkBTcmd(); // verify if a comand is received from BT remote control
manualCmd ();
}
La función checkBTcmd() se muestra a continuación:

void checkBTcmd() // verify if a command is received from BT remote control
{
if (BT1.available())
{
command = BT1.read();
BT1.flush();
}
}
Una vez que se recibe un comando, la función manualCmd() tomará la acción apropiada:
void manualCmd()
{
switch (command)
{

case ‘m’:
startSafe();
Serial.print(“Roomba in Safe mode”);
BT1.print(“Roomba BT Ctrl OK – Safe mode”);
BT1.println(‘\n’);
command = ‘f’;
playSound (3);
break;

case ‘f’:
driveStop(); //turn off both motors
writeLEDs (‘s’, ‘t’, ‘o’, ‘p’);
state = command;
break;

case ‘w’:
drive (motorSpeed, 0);
writeLEDs (‘ ‘, ‘g’, ‘o’, ‘ ‘);
state = command;
break;

case ‘d’:
driveRight(motorSpeed);
writeLEDs (‘r’, ‘i’, ‘g’, ‘h’);
break;

case ‘a’:
driveLeft(motorSpeed);
writeLEDs (‘l’, ‘e’, ‘f’, ‘t’);
break;

case ‘s’:
drive (-motorSpeed, 0);
writeLEDs (‘b’, ‘a’, ‘c’, ‘k’);
state = command;
break;

case ‘+’:
if (state == ‘w’)
{
motorSpeed = motorSpeed + 10;
if (motorSpeed > MAX_SPEED)
{
motorSpeed = MAX_SPEED;
}
command = ‘w’;
} else {command = state;}
break;

case ‘-‘:

if (state == ‘w’)
{
motorSpeed = motorSpeed – 10;
}
if (motorSpeed < MIN_SPEED )

{ motorSpeed = MIN_SPEED; }

Serial.println(motorSpeed); command = state; break; } }

 

 

 

El código de Arduino completo utilizado en documentos aquí relacionados se puede encontrar en GITHUB en https://github.com/Mjrovai/Roomba_BT_Ctrl

Varias de las funciones que   el autor  ha creado en su  programa se basaron en la biblioteca de crear 2 desarrollada por Dom Amato. Puede descargar la librería completa en‎: https://github.com/brinnLabs/Create2.

Ayuda robotica


Tercera Mano Robótica  es un kit de fuente abierta cuyas piezas se pueden  imprimir  en una impresora 3D y que se puede  usar en el antebrazo utilizando  un Trinket Pro como cerebro

Trinket es una versión reducida de un Arduino con un ATmega328 y de coste reducido, pero obviamente puede usarse cualquier  placa que sea compatible con Arduino

Cuando se le solicite, puede entregarle una herramienta que tenga, liberándolo de buscarlo o perderlo  todo ello pulsando un único pulsador que Tim (su creador) ha colocado estratégicamente en un dedo gracias a una pieza  similar a un anillo  impresa también en  3d

 

En realidad  son pocos componentes los usados en este proyecto:

  • 1x9g servo hobby barato
  • Trinket Pro 5V
  • Cargador de batería de litio de celda única (3.7V)  alimentado a 5V
  • Batería de  300mAH celda única LiPO
  •  imanes – 5/16 “de diámetro, 1.8” de espesor
  • 13 × 2-56 tornillos
  • 1 × piezas impresas en 3D
  • Banda de cintura elástica ancha 1 × 1 “

Después de reunir todos los elementos en la lista de componentes e imprimir sus piezas, ¡es hora de comenzar el ensamblaje y conectarlo todo!

 

Aquí está el diagrama de conexión:

 

Es bastante simple  pues se limita a conectar la placa a  un servo controlado por el puerto digital nº8   y que ira alimentando a la salida del cargador a 5v DC   y  un pulsador que conectaremos  al pin 3   y masa .

El resto es simplemente  la parte de carga de la batería que se conectará  por un lado a la batería   y por otro lado tanto al servo  como a  la placa de control  .

Puesto que la alimentación es suministrada por la batería se recomienda colocar un interruptor en la batería para impedir su descarga  cuando no se esta usando.

Aquí está el código para hacer su movimiento robótico de tercera mano:

// ThirdHand test script
// by Tim Giles <www.wildcircuits.com>

//servo is on Pin8
//button is on Pin3 and has the pullup enabled

#include 

Servo ServoA;

int Angle = 10;
int AngleClosed = 10;
int AngleOpen = 120;

void setup()
{
  ServoA.attach(8);
  pinMode(3,INPUT_PULLUP);
}

void loop()
{
  //update the servo position
  ServoA.write(Angle);
  delay(1);
  
  //check if the button is pushed
  if (digitalRead(3) == 0)
  {
    //debounce
    while (digitalRead(3) == 0){
      delay(1);
    }
    //set the servo to it's open position
    Angle = AngleOpen;
    ServoA.write(Angle);
    //hold the servo in this position to give the user time
    //to grab the screwdriver
    delay(2000);
    //set the servo to it's closed position
    Angle = AngleClosed;
    ServoA.write(Angle);
  }
}

Durante la programación se  recomienda desconectar la batería pues de lo contrario, el suministro de refuerzo de 5 V volverá a alimentar su ordenador y puede generar efectos negativos

Si su cable USB que está programando es demasiado largo / demasiado débil, es posible que tenga un comportamiento extraño cuando termine la programación y el servo intente moverse:esto se debe a una caída de voltaje excesiva en el cable USB que hace que el Trinket Pro se reinicie cuando el servo intenta moverse.

 

PIEZAS  IMPRESAS EN 3D

robotic

La base  , el bazo articulado  así como el anillo para el pulsador   se han realizado impresas en 3D

Los ficheros están disponibles como no en el repositorio Thingiverse  en la  url   https://www.thingiverse.com/thing:618811

Mientras ensambla las piezas impresas en 3D, notará que todos los orificios de los tornillos son ligeramente más pequeños o de mayor tamaño.

Los tornillos 2-56 se ensartarán automáticamente en los orificios de menor tamaño y girarán libremente en los orificios de mayor tamaño, lo cual  permite que el tornillo sujete firmemente la bandeja del destornillador mientras que el brazo que acciona la bandeja del destornillador se puede mover libremente.Si sus piezas no van juntas así, entonces necesitará ajustar su impresora o ajustar el tamaño de los orificios de los tornillos.

 

Fuente hackaday.io

Que es CheapDuino


 cheapduino.PNG

CheapDuino es una  placa  compatible con Arduino  de un tamaño muy reducido pero no hace honor actualmente a su origen (cheap , es decir barato ) pues  si bien el precio es aceptable (1/5 precio del Arduino UNO R3)   una de sus mejores puntos es su reducido espacio  proporcionando un procesador de  relativo bajo costo para  estudiantes y los aficionados al desarrollo profesional adecuado para  proyecto personalizados de bricolaje, taller, regalos para amigos, E-Textiles y uso educativo.

Pretendía esta placa ser una opción para aquellos estudiantes de países del segundo o tercer mundo que no pueden pagar el precio del Arduino oficial( entre 25 a 30€) ,  intentando abrir una puerta al mundo físico (unos 10€ por placa), pero   no debemos olvidar que existen clones de Arduino de un precio similar  o incluso mas bajo, así que su gran bazas es su  potencia en tamaño compacto pues  tiene una dimensión de solo 2 cm x 2 cm..

La placa tiene  integrado con un microcontrolador ATmega8 y Arduino NG.  Se  puede  programar directamente con Arduino IDE a través del programador FTDI o el adaptador de serie USB.3

(Cuando conecte el cable de programación fpc al programador DFRobot FPC y al dispositivo CheapDuino, por favor, el lado azul hacia arriba).

A nivel de hardware el procesador tiene 3 pines digitales pwm, 3 pines analógicos e interfaz de fuente de alimentación con almohadillas hexagonales alrededor de la placa, lo que hace que sea muy fácil de soldar para los principiantes.

Por supuesto, la interfaz I2C y el puerto serie también están disponibles para extender los dispositivos periféricos de 2 cables directamente. La adopción del conector micro FPC ahorra espacio adicional en comparación con la interfaz USB Arduino normal.

CheapDuino1.png

Especificaciones

  • Voltaje de funcionamiento: 3 ~ 5 voltios
  • Fuente de alimentación recomendada: 5v
  • Microctonroller: Atmel AVR ATmega8
  • gestor de arranque (opción de placa en Arduino IDE): Arduino NG / w ATmega8
  • 3 pines digitales, 3 pines analógicos con almohadillas hexagonales fáciles de soldar
  • Integra 3 pines pwm, interfaz I2C e interfaz UART
  • Adecuado para talleres, uso educativo y proyectos personalizados de bricolaje
  • Controlador compatible con Arduino de bajo costo
  • Diseñado para los estudiantes y DIYers
  • Dimensiones: 2cm x 2cm x 0.2cm

 

 

 

CheapDuino se puede comprar  en la página dee DFRobot o también en Amazon

 

Como leer el pulso cardiaco


La esencia de estos circuitos es un sensor integrado de circuito de amplificación óptica y con un circuito de eliminación de ruido de la frecuencia cardíaca  todo ello alimentado  con una tensión de alimentación: 3.3V ~ 5 V

Lo ideal  para medir el pulso  es  poner  el sensor de pulso en el dedo o lóbulo de la oreja, directamente  o bien  mediante algún sistema mecánico que lo deje fijo como por ejemplo   alguno de los sistemas que mostramos a continuación:

 

soportes sensores.PNG

 

Estos sensores cuentan con una salida analógica   que se puede conectar por ejemplo a una entrada analógica de un  Arduino, para probar la frecuencia cardíaca

Estudiantes, artistas, deportistas, creadores, desarrolladore3s de juegos, o terminales móviles puedan desarrollar software o interactivos relacionado con el ritmo cardíaco, pero no obstante también existe  una aplicación de código abierto para la visualización en tiempo real de la gráfica de la frecuencia cardíaca en https://github.com/WorldFamousElectronics/PulseSensor_Amped_Arduino/.

 

 

El sensor de pulso cardiaco es esencialmente un fotopletismógrafo, que es un dispositivo médico conocido que se usa para controlar la frecuencia cardíaca de forma no invasiva. Asimismo  los fotopletismógrafos miden los niveles de oxígeno en la sangre (SpO2) pero no siempre lo soportan.

La señal de pulso cardíaco que sale de un fotopletismograma es una fluctuación analógica de voltaje, y tiene una forma de onda predecible, tal como estamos acostumbrados a ver ( la representación de la onda de pulso se denomina fotopletismograma o PPG).

El Sensor de pulso  amplifica la señal bruta del Sensor de pulso anterior y normaliza la onda de pulso alrededor de V / 2 (punto medio en voltaje) respondiendo a los cambios relativos en la intensidad de la luz

Tal y como esta construido ,veremos que  la luz  interna del LED verde del sensor  se refleja de nuevo en el sensor cambiando durante cada impulso, ocurriendo las siguintes casuiticas:.

  • Si la cantidad de luz incidente en el sensor permanece constante, el valor de la señal permanecerá en (o cerca de) 512 (punto medio del rango de ADC).
  •  Más luz y la señal aumentará.
  • Menos luz, todo lo contrario: el valor de la señal analógica dismuniira

El objetivo es encontrar momentos sucesivos de latido instantáneo del corazón y medir el tiempo transcurrido entre ellos, llamado intervalo Inter Beat (IBI)  pues al seguir la forma y el patrón predecibles de la onda PPG, podemos hacer exactamente eso.

Cuando el corazón bombea sangre por el cuerpo, con cada latido hay una onda de pulso (una especie de onda de choque) que viaja a lo largo de todas las arterias hasta las mismas extremidades del tejido capilar donde está conectado el sensor de pulso. La sangre real circula en el cuerpo mucho más lentamente de lo que viaja la onda de pulso.

 

Figura 1

 

Sigamos los eventos a medida que progresan desde el punto ‘T’ en el PPG a continuación. Se produce un aumento rápido en el valor de la señal a medida que la onda de pulso pasa por debajo del sensor, luego la señal vuelve a descender hacia el punto normal. A veces, la muesca dicroica (pico descendente) es más pronunciada que otras, pero, en general, la señal se establece en el ruido de fondo antes de que la siguiente onda de pulso se filtre. 

Como la onda se repite y es predecible, podríamos elegir casi cualquier característica reconocible como punto de referencia, por ejemplo, el pico, y medir la frecuencia cardíaca haciendo cálculos matemáticos sobre el tiempo entre cada pico,pero sin embargo, esto puede dar lugar a lecturas falsas desde la muesca dicroica, si está presente, y puede también ser susceptible a la imprecisión con respecto al ruido de línea base.

Existen otras buenas razones para no basar el algoritmo de detección de latidos en fenómenos de onda arbitrarios. Idealmente, queremos encontrar el momento instantáneo del latido del corazón. Esto es importante para el cálculo preciso de BPM, la variabilidad del ritmo cardíaco ( y mida la frecuencia cardíaca haciendo cálculos en el tiempo entre cada pico.

Sin embargo, esto puede dar lugar a lecturas falsas desde la muesca dicroica, si está presente, y puede también ser susceptible a la imprecisión con respecto al ruido de línea base.

.

 

Algunos investigadores del corazón dicen que es cuando la señal alcanza el 25% de la amplitud, algunos dicen que es el 50% de la amplitud, y algunos dicen que es el momento en que la pendiente es más pronunciada durante el evento ascendente.

 

El circuito que vamos  a ver es muy simple pues solo se precisa conectar  un buzzer y el sensor de pulsos cardíacos  .

Como podemos ver en el video  , el sensor de pulsos cardíacos  se conecta a la alimentación de +5V  entre el hilo rojo(+5v)   y el naranja (GND)   y del  hilo marrón obtenemos la salida analógica que conectaremos a la primera entrada analogica (A0) de cualquier placa que  soporte entradas analogicas como pueden ser Arduino o Netduino

 

arduino.PNG

Para complementar el circuito puede ser interesante reflejar el punto maximo de nivel qeu reproduciremos mediante un buzzer  conectado al pin 11 de salida binaria

 

A continuación  en este breve  ejemplo  para Arduino se puede mostrar un pulso de latido del corazón humano en directo ayudándonos por medio de “Serial Plotter” de arduino o  por ejemplo con una aplicacion móvil usando   un modulo bluetooth coenctado a nuestro arduino

 

En este pequeño programa para Arduino qeu vamos a ver , sonará un buzzer con cada latido de tu corazón al mismo tiempo que se envia el valor de la señal de forma serie (esta es la señal directa del sensor de pulso) el cual podemos visualizar en un ordenador  o si tenemos conectado un modulo bluettoth a nuestro arduino mediante un smarptphone usando una app .

 

//Programa para capturar el pulso cardiaco

// Variable para fijar el puerto donde conectaremos el buzzer 

int buzzer = 11;

// la variable pulso contiene los datos brutos entrantes pudiendo  variar entre 0-1024

int pulso;

 

// Determina qué señal “se contará como un latido” y qué señal ignorar.

int limite = 550;

 

void setup() {

//definimos donde conectamos el buzzer , que  sonará al ritmo de su corazón

pinMode(buzzer,OUTPUT);

 

// Configura la comunicación serial a 9600 dependiendo de su adaptador bluetooth como esté configurado

Serial.begin(9600);
}

void loop() {

// Lee el valor del pin analógico 0, y Asigna este valor a la variable “pulso”.
pulso = analogRead(A0);

 

//Este caracter lo filtra la aplicación en APP inventor

Serial.print(“*”);

// Envíe el valor de pulso al Plotter serial. Comentar si queremos visualizar en “serial ploter”
Serial.println(pulso);
if(pulso > limite){

// Si la señal es superior a “550”, entonces suena el buzzer.
digitalWrite(buzzer,HIGH);

}

else

{

// De lo contrario, deja de sonar el buzzer.
digitalWrite(buzzer,LOW);
}

//Retardo de 35ms
delay(35);
}

 

 

Desbloquear un Netduino inaccesible


La palabra “ladrillo” (bricked) ,se utiliza en referencia a la electrónica de consumo, describiendo como  un dispositivo electrónico tal omo un smartphone, videoconsola, router,tablet, o placa de desarrollo  debido a un severo daño físico, un grave error de configuración, corrupto firmware  o un problema de hardware , ya no funciona, por lo tanto, sólo puede ser útil  tecnológicamente como un ladrillo (y de ahí la sugerencia humoristica  de que el dispositivo  ya sólo puede funcionar como un objeto sin vida, tal como  un pisapapeles o tope de puerta).

Este término es comúnmente usado como verbo. Por ejemplo,  “bricked” mi reproductor de MP3 cuando trató de modificar su firmware y no le funciono. También puede ser utilizado como un sustantivo, por ejemplo, si queda corrupto y se aplica usando fastboot, el dispositivo es un “brick”(ladrillo).

En el uso común del término, “bricking” sugiere que el daño es tan grave que se inutilizó el dispositivo permanentemente.

Antiguamente para desbriquear placas Netduino teníamos la herramienta .NET Micro Framework Deploy Tool (MFDeploy) , herramienta que se instala con  el Framework .NET . Por  ejemplo, para la version 4.3    normalmente el ejecutable estará en  la ruta “C:\Program Files (x86)\Microsoft .NET Micro Framework\v4.3\Tools\MFDeploy.exe”. Esta antigua herramienta nos puede resolver el problema , pero adolece de un  serio inconveniente: no incluye el  firmware disponible ( que como sabemos dependiente de la placa  y  version ) , pero ademas, no siempre logra su objetivo sobra una placa bloqueada.

Asegurar que su Netduino tenga el firmware más reciente significa que será actualizado con la actual ejecución de Netduino específica de  .NET Micro Framework   .Además, a menos que su Netduino tenga el firmware más reciente, pueden tener problemas implementando su aplicación  en ese contexto, de modo   que merece la pena intentar cargar el ultimo firmware oficial.

Las instrucciones para  cargar el ultimo firmware  son diferentes  para el SO donde conectaremos nuestra placa Netduino ( Windows y  tambien Mac).

Desgraciadamente, por consideraciones tecnológicas, las placas soportadas  por esta nueva herramienta son sólo aquellas versiones superiores   a la version 2  ( es decir a partir de Netduino 2 en adelante).

Windows

  1. Descargue la aplicación Netduino Updater .
  2. Descomprimir  la aplicación Netduino Updater_4.3.2.3 en una ubicacion del disco de su ordenador .
  3. Ejecutar la aplicación Netduino Updater.exe .
  4. Incluso conectado su Netduino a su PC no debería aperecer nada   :                                              
  5. Mientras su Netduino está desenchufado de su pc mediante un cable USB, mantenga pulsado el pulsador interno de la placa y luego  al conectarlo suéltelo, para ponerlo en Modo Bootloader de DFU:                                                                                          
  6. Su Netduino debería aparecer en la lista de dispositivos de la lista. Si no apareciese, puede que el driver no este actualizado,  o simplemente que Windows tiene problemas para cargar el driver para ese puerto , por lo que recomendamos probar  conectando el cable a otro puerto USB disponible.
  7. Una vez aparezca su placa en la pantalla de Netduino Adapter, haga clic en la casilla de verificación junto a él y haga clic en el botón Upgrade (Actualizar)netduino.png
  8. Netduino updater instalará automáticamente la última versión de firmware:
  9. Cuando termine, se reiniciará el Netduino y así que debe ya no se mostrar nada en la lista de dispositivos.                              
  10. Existen tres opciones disponible en esta herramienta ademas de poder actualizar el firmware:
  • Cambiar el nombre de la placa desde la pestaña “General” . Observe que este dato se almacena en una zona de memoria no borrable por lo que su cambio no se puede asegurar hasta que lo repita unas cuantas veces ( al menos dos o mas)general.png
  • Cambiar la dirección MAC  de su placa Netduino  desde la pestaña “Network” .Observe que este dato se almacena en una zona de memoria no borrable por lo que su cambio no se puede asegurar hasta que lo repita unas cuantas veces ( al menos dos o mas)                                          mac.png
  • Borrar la ultima aplicación que haya desplegado en su placa Netduino desde la pestaña “Tools”                                                                         borrar.png

 

Mac

  1. Mientras su Netduino está desenchufado, mantenga pulsado el botón y luego conectarlo, para ponerlo en Modo Bootloader de DFU:
  2. Iniciar el Netduino Mac desplegar (disponible en la página de descargas ):
  3. Haga clic en el botón, debe instalar el firmware: Install Firmware

Instalación de Firmware de los archivos .hex o .s19

La herramienta de Mac Firmware también permite la implementación de firmware manual:

  1. Siga los pasos 1 y 2 anteriores.
  2. Haga clic en el botón y seleccionar la o y archivos: Choose.hex.s19ER_CONFIGER_FLASH
  3. Haga clic en y se deben desplegar el firmware: Deploy

Fuente   http://developer.wildernesslabs.co

Detector de movimiento inteligente


En este ejemplo    volveremos a  usar  un economico NodeMCU ,junto con un  sensor de movimiento PIR  y la plataforma de IoT  Carriots para  construir, usando el IDE de Arduino, un  detector de movimiento inteligente para comerciales y hogar.

El tema  gira en torno a la seguridad de un edificio o casa o una zona restringida detectando cualquier movimiento dentro de un rango específico con un sensor PIR . Gracias al  IoT, además de detectar objetos en movimientos podemos hacer  muchas más cosas como por ejemplo:

  • Encender un dispositivo mediante un relé (en el ejemplo es una luz durante unos 30 segundos).
  •  Al mismo tiempo enviar un correo electrónico al usuario, utilizando la IOT – plataforma Carriots sobre WIFI.
  • El relé se puede conectar a cualquier luz del dispositivo, alarma, cámara, sistema de seguridad…
  • Incluso el disparo puede ser SMS, llamar a las autoridades, llamando a otros servicios…

Node MCU es una plataforma para el desarrollo de proyectos IoT que integra el famoso chip ESP8266, el cual se ha extendido enormemente debido a su facilidad para desarrollar proyectos open source  a los que indudablemente se une su bajisimo precio comparado con otras opciones.
De este componente destaca  integra capacidades de comunicación via WiFi , conteniendo en su interior  microprocesador que puede ser programado fácilmente usando en conocido lenguaje de programación Lua o vía Arduino IDE.

¿Se pregunta cómo controlar  su económico ESP8266 de forma remota desde cualquier lugar del mundo?

En este post repasaremos precisamente el proceso, paso a paso, de cómo escribir código en el IDE de Arduino y programar su ESP8266 permitiendo  que el código  escrito para  el ESP8266 se comunique con la plataforma  de Iot   Carrriots,  la cual  nos va  permitir monitorear  y controlar el ESP8266.

Los pasos  a seguir   para conectar un ESP8266   a  Carriots   son los siguientes:

  •  Instalación del IDE de Arduino .Si aun no lo tiene instalado ,se puede hacer  desde aqui
  • Instalación  del paquete de la placa ESP8266 en Arduino IDE  siguiendo las instrucciones del sitio : https://github.com/esp8266/Arduino

esp

  • Instalación de los controladores USB

Es necesario instalar el controlador USB requerido en su ordenador  para que pueda programar el ESP8266.  Independientemente de la opción de firmware que elijamos, primero necesitamos comunicarnos con la placa de desarrollo ESP-12E utilizando la interfaz USB de la computadora.

El módulo USB a Serial UART incluido en la placa es Silicon Labs ‘CP2012, para lo cual generalmente necesitamos instalar los controladores de puerto COM virtual (VCP) fácilmente disponibles para su sistema operativo específico.Una vez instalado, debemos verificar que el CP2102 sea reconocido por su ordenador

Una vez que el controlador está instalado, podemos conectar el cable USB al puerto USB de la computadora y la placa. Después de hacerlo, deberíamos ver el mensaje: software del controlador del dispositivo instalado correctamente.

Además, podemos verificar manualmente que todo funcione correctamente siguiendo estos pasos:

Abra el Administrador de dispositivos (disponible a través del Panel de control → Sistema y seguridad → Administrador de dispositivos en la sección Sistema)
Debajo de la entrada Puertos (COM & LPT), debe haber un puerto abierto llamado USB-SERIAL CP2102 (COM) donde hay un número típicamente mayor o igual a 3.

Carriots es una Plataforma como Servicio (PaaS en sus siglas en inglés) diseñada para proyectos del Internet de las Cosas (IoT) y de Máquina a Máquina (M2M)

carriots

Carriots es una plataforma IoT creada en España  que  permite crear potentes productos y servicios IoT  haciendo posible conectar fácilmente “sus cosas” al Internet de las Cosas.

Se  pueden construya sus apps inteligentes con Carriots en pocos pasos.

  1. Conectar Dispositivos
  2. Recopilar Datos
  3. Gestionar Dispositivos y Datos
  4. Construir APPs

Principales ventajas

  • Listo para empezar a desarrollar.
  • Minimizar tiempo de desarrollo.
  • Gestión simplificada de múltiples proyectos: Arquitectura de 7 niveles
  • Amplia variedad de APIs y potente SDK: REST API y SDK
  • Escalabilidad inmediata
  • Inicio gratuito y pago por uso.
  • Alojamiento simplificado: Oferta PaaS para escalabilidad fiable.

Hardware

Ahora preparado el entorno , necesitamos el hw  que lo permita , el cual  como vamos a ver,  es muy simple reduciendose a la placa o NodeMCUuna placa de relé, el sensor PIR  y una fuente de 5V DC

Sensor PIR

El sensor PIR usado , es del tipo HC-SR501, de bajo coste   el cual es ampliamente utilizado en diversos equipos eléctricos de detección automática, productos para el control automático especialmente a batería.Tiene alta sensibilidad, alta fiabilidad, bajo consumo de energía, el modo de operación de bajo voltaje.

Especificaciones:

  •  Dimensiones: Cerca de 3,2 x 2,4 cm (L x W).
  •  Rango de tensión: 5V-20V DC.
  •  Corriente estática: < 50uA
  •  Voltaje de salida: 3,3 V (alto) / 0V (bajo)
  •  Modo del disparador: L (no se puede gatillo repetida), H gatillo repetida (Repetición predeterminado de disparo)
  •  El Tiempo de retardo: 0,3 seg 18 seg (ajustable)
  •  Temperatura De funcionamiento: -15 C a 70

 Placa de rele

Por  precio  es mucho mas asequible optar por una placa    de  2 reles    con salida de relé máxima: DC 30V / 10A, AC 250V / 10A. Es  importanet   que el interfaz de tarjeta de relé sea de 5v . En nuestro caso es de 2 canales y cada canal necesita 15-20mA actual controlador

Este tipo de placas es de fácil instalación por el microcontrolador como Arduino, 8051, AVR, PIC, DSP, BRAZO, MSP430, PLC, lógica TTL pues solo ha que conectar la alimentacion  y dos cables de datos en caso de necesitar los dos canales 

Resumiendo , estos son los componentes  necesarias:

  • Placa de desarrollo de NodeMcu Lua WIFI Internet de las cosas basado en ESP8266 – 1 (capacidad de MCU y WIFI)
  • Sensor PIR ( hemos hablado  en este blog )
  • 1 módulo de relé con opto aislamiento de  5V1
  • Fuente de alimentación conmutada  220V/5v ( nos sirve cuaqluier cargador de movil  con salida microusb)
  • Placa Protoboard

Diagrama del circuito:

El circuito   no incluye dificultad alguna ,pues se reduce a conectar el sensor PIR a +5V  y la salida binaria al pin D2, el módulo de rele a +5v   y al pin D2    y por  supuesto la alimentación del circuito que puede ser bien a baterías  o  bien por medio del  propio micro-usb   usado para programar el  NodeMcu

Resumiendo las conexiones con las siguientes:

  • NodeMCU (ESP8266 Dev Kit) D1—> INI del relé
  • NodeMCU (ESP8266 Dev Kit) D2—> Digital sensor PIR
  • NodeMCU (ESP8266 Dev Kit) VCC—> VCC (+) de la batería
  • NodeMCU (ESP8266 Dev Kit) GND—> GND (-) de la batería
  • Relé de VCC—> VCC (+) de la batería
  • Relé de tierra—> GND (-) de la batería
  • PIR Sensor VCC—> VCC (+) de la batería
  • PIR Sensor de tierra—> GND (-) de la batería

Software

Una vez el hardware  montado nos toca escribir el código  el código utilizando el IDE de Arduino para hacer que NodeMCU trabaje con un relé, sensor de movimiento PIR y utilizar IOT plataforma carriots sobre WIFI

El autor se  encontró con  algunos puntos problemas  en el diseño del programa  para ejecutar en la placa NodeMcu;

  • Compruebe que los pines de NodeMcu  están dando la entrada o salida correcta como se están asumiendo, por ejemplo, asegurándose  que usted no está tomando el pin 4 (GPIO) como un pin de entrada asi que por defecto que este pin debe leer…
  • Utilizar un método directo de get y post HTTP en lugar de utilizar una función de visualización por BLYNK o Thinger.io.
  • Observe  que el PIR da salida permanentemenet alta durante un par de envíos pero se necesita traer retraso para evitar el envío de múltiples correos electrónicos. Con algunos servicios como BLYNK este retraso causa un problema  asi que  es mejro a llamar a esa función una vez despues  de 6 o 7 seg.
  • Una vez satisfecha la condición de if loop, llamar a una función, en lugar de escribir todo con el bucle. Esto aporta claridad del código y ayuda en la resolución de problemas.
  • Se  puede  ajustar la sensibilidad del PIR para reducir el tiempo que permanece alta.

A continuación veamos el codigo completo del sw  que habrá que subir  a la placa desde el entorno  de Arduino:

#include “ESP8266WiFi.h”

const char * ssid = “NETGXXXXX”;   //red wifi a la que se conectara

const char * clave = “XXXXXXXXX”;  //clave red wifi para coenctarse

const char * servidor = “api.carriots.com”;

const String APIKEY = XXXXXXXXXX”; //Sustituir con su apikey de Carriots

 const  String DEVICE = “[email protected]”; //Reemplazar por el id_developer del dispositivo de  carriots

int ledpin = 4;

pirpin INT = 12;

int pirstate = LOW;

int val = 0;

void setup() {

Serial.Begin(115200);

Delay(10);

pinMode(ledpin,OUTPUT);

pinMode(pirpin,INPUT);

Serial.println(“calibrando”);

for (int i = 0; i < 20; i ++) {

Serial.Print(“.”);

Delay(1000);

}

//iniciar wifi

Serial.println();

Serial.println();

Serial.Print (“conectarse”);

Serial.println(SSID);

WiFi.begin (ssid, clave);

while  (WiFi.status()! = WL_CONNECTED) {

Delay(500);

Serial.Print(“.”);

}

Serial.println(“”);

Serial.println (“Wi-Fi conectado”);

Serial.println (“dirección IP:”);

Serial.println(WiFi.localIP());

}

//función para hablar con la plataforma Carriot

void sendStream()

{

String txt = “”; //Texto para enviar

if (pirstate == HIGH)

{/ / alarma

txt = “Detecta movimiento;”

} else {/ / alarma en

txt = “Algo mal”;

}

 

Serial.println(txt);

Serial.println(Val); / / para fines de depuración

Client WiFiClient;

const int httpPort = 80;

if  (client.connect (servidor, 80)) {/ / si hay una conexión exitosa

Serial.println(F(“Conectedo”));

//Construir el campo de datos

String json = “{\”protocol\”:\”v2\”,\”device\”:\””+DEVICE+”\”,\”at\”:\”now\”,\”data\”:{\”light\”:\””+txt+”\ “}}”;

//Realizar una solicitud HTTP

Client.println (“POST /streams HTTP/1.1”);

Client.println (“Host: api.carriots.com”);

Client.println (“Accept: aplicación/json”);

Client.println (“User-Agent: Arduino-Carriots”);

Client.println (“Content-Type: aplicación/json”);

Client.Print (“carriots.apikey:”);

Client.println(APIKEY);

Client.Print (“Content-Length:”);

int thisLength = json.length();

Client.println(thisLength);

Client.println (“conexión: cerrar”);

Client.println();

Client.println(JSON);

}

Else {}

//Si no tiene una conexión con el servidor:

Serial.println (F (“Conexión fallida”));

}

}

 

void loop() {}

Val = digitalRead(pirpin);

Serial.println(Val);

if(Val == HIGH) {}

digitalWrite(ledpin,HIGH);

if  (pirstate == LOW) {

Serial.println (“movimiento detectado”);

pirstate = HIGH;

Serial.println (F (“secuencia de enviar”));

sendStream();

Delay(30000);

}

/ * {while(client.available())}

String linea = client.readStringUntil(‘\r’);

Serial.Print(line);

Delay(30000);

} */

}

Else {}

digitalWrite(ledpin,LOW);

if(pirstate == HIGH) {}

Serial.println (“movimiento detectado correo enviado”);

pirstate = LOW;

}

}

}

Programación de disparadores de Carriots enviar Email:

Una vez   que  tenga desplegado el  sw en su  placa NodeMcu  ,la capacidad de activar un correo debe ser  programado o configurado en la plataforma de Internet para este producto que está utilizando (la plataforma Carriots IOT) . Si no sabe como hacerlo en el siguiente video podemso  ver  como  familiarizarse con las funciones y cómo utilizarlas:

 

Obviamente esto podría programarse para llamada, o un texto o una alarma a la policía o quien sea. !Como podemos adivinar   las posibilidades  son infinitas!.

Fuente