Como supeditar el encendido de una TV al de un descodificador,Blueray u otros dispositivos ( parte 1)


Puede parecer  extraño , pero cada vez tenemos dispositivos  conectados a nuestro TV  que  suelen ser  el origen de  vídeo  por defecto  como pueden ser dispositivos Android   TV, reproductores blueray, etc.  o   sobre todo descodificadores de TV  

En este sentido  podría ser interesante  supeditar  automáticamente el  encendido  de la TV  al de la fuente de vídeo ( normalmente un descodificador de TV) , para lo cual   vamos a intentar implementar una solución que lo automatice

Pensando en una solución , una aproximación  podría ser basarse en  las señales de infrarrojos entre el TV  y la fuente de vídeo ,pero esto conlleva mucha complejidad pues en el mercado existe una infinidad de marcas  y modelos de  dispositivos diferentes , que haría  muy difícil  contemplar un método practico para resolverlo , así  que debemos pensar en otra solución …

Pensando  en la variación del consumo de un dispositivo  ,una solución puede pasar por detectar  esa variación  de consumo   y con ello  sabremos si debemos o no activar la TV , para lo cual nos puede basta el sensor   ACS712    , un  Modulo Sensor de corriente para Arduino con un rango de medida máximo de 5 Amperios ( suficiente para la mayoría de los dispositivos  que conectaremos al TV) 

Este sensor esta basado  en efecto Hall   que detecta el campo magnético que se produce por inducción de la corriente que circula por la línea que se está midiendo , por lo que no hay disipación de potencia a través de este como ocurriría  con soluciones clásicas  que  usarían una resistencia de valor bajo  en serie  para medir la corriente que circula por ella  y el circuito (pero  con el consiguiente disipación  de potencia en esta )

Concretamente  en las pruebas  junto a un Arduino UNO , usaremos el  chip sensor  ACS712ELC-05A  alimentado  con  5V a través del propio Arduino ( lleva un led a bordo como e indicador de energia) 


El modulo puede medir los positivos y negativos de máximo 5 amperios, correspondiente a la salida analógica 185mV / A   entregando una salida de voltaje proporcional a la corriente, Dependiendo la aplicación podemos usar otros módulos  como el ACS712-05A, ACS712-20A o el ACS712-30A, para rangos de 5, 20 o 30 amperios respectivamente

El  ACS712  podemos encontrarlo en módulos, los cuales nos facilitan sus conexiones, Este modulo  trae una bornera para conectar la línea que queremos medir ( el descodificador)  y 3 pines por el otro extremo: dos para conectar la alimentación y un pin para la salida analógica.

Para las conexiones en el módulo debe  guiarse por los nombres de los pines, en algunos modelos vienen en diferente orden pero marcados en la serigrafia como Gnd,Out  y Vcc . En nuestro caso Vcc ira al pin +5V de Arduino, GND al GND del Arduino y  Out lo conectaremos al pin analógico de Arduino  A0 

En los terminales opuestos del  ACS712  conectaremos  en serie la alimentación del Descodificador ,o dispositivo que  vaya a controlar  la TV . Para medir la corriente se  debe conectar en serie con el dispositivo o carga, nunca conectar en paralelo a la fuente de voltaje.

 

 

El rango de corriente que podemos medir y sensibilidad varían dependiendo del modelo del integrado, existen tres modelos los cuales detallamos a continuación:

Modelo Rango Sensibilidad
ACS712ELCTR-05B-T -5 a 5 A 185 mV/A
ACS712ELCTR-20A-T -20 a 20 A 100 mV/A
ACS712ELCTR-30A-T -30 a 30 A 66 mV/A

El sensor  ACS712  nos entrega un valor de 2.5 voltios para una corriente de 0A y a partir de allí incrementa proporcionalmente de acuerdo a la sensibilidad, teniendo una relación lineal entre la salida de voltaje del sensor y la corriente. Dicha relación es una línea recta en una gráfica Voltaje vs Corriente donde la pendiente es la sensibilidad y la intersección en el eje Y es 2.5 voltios. La ecuación de la recta seria la siguiente

ecuacion V vs I en ACS712

Donde la pendiente es m y equivale a la Sensibilidad

Despejando tendremos la ecuación para hallar la corriente a partir de la lectura del sensor:

ecuacion para la corriente ACS712

 

Para realizar la lectura de corriente simplemente se necesita leer la entrada analógica y con la formula antes expuesta obtener la corriente.

A continuación se muestra el código para un realizar la lectura de corriente:

float Sensibilidad=0.185; 
//sensibilidad en Voltios
/Amperio para sensor de 5A void setup()
{    Serial.begin(9600); }
void loop()
{    float voltajeSensor= analogRead(A0)*(5.0 / 1023.0);
//lectura del sensor   
 float I=(voltajeSensor-2.5)/Sensibilidad;
//Ecuación  para obtener la corriente
 Serial.print("Corriente: ");
 Serial.println(I,3);
 delay(200);     
}

En nuestro caso estamos trabajando con un sensor de 5A ( ACS712  )  por eso usamos el valor de sensibilidad de 0.185V/A que es el equivalente 185mV/A que nos da el fabricante, si están trabajando con el sensor de 20A, reemplazar el valor de la sensibilidad por 0.100 V/A.

 

Existen varios tipos de filtros, que dependiendo de la complejidad pueden consumir recursos en la programación de nuestro Arduino, en nuestro caso  simplemente usaremos la media aritmética de varias lecturas consecutivas, implementar el promedio de las lecturas en Arduino es sencillo y fácil de entender, simplemente hay que sumar las lecturas y dividirlas en un  número de muestras suficiente.
La cantidad de muestras para calcular el promedio depende del nivel de ruido que tengan .En nuestro ejemplo con 200.000 son un valor lo suficiente bueno  para que nos de un resultado bastante preciso

El programa mejorado  seria el siguiente:

float Sensibilidad=0.185; 
//sensibilidad en Voltios/Amperio para sensor de 5A void setup()
{    Serial.begin(9600);
}
void loop()
{
 float I=get_corriente(200000);//obtenemos la corriente promedio de 200.00 muestras
 Serial.print("Corriente: ");
 Serial.println(I,3);
 delay(100);     
}
float get_corriente(int n_muestras)
{
 float voltajeSensor;
 float corriente=0;
 for(int i=0;i<n_muestras;i++)
 {    voltajeSensor = analogRead(A0) * (5.0 / 1023.0);
////lectura del sensor   
 corriente=corriente+(voltajeSensor-2.5)/Sensibilidad;
//Ecuación  para obtener la corriente  
}
 corriente=corriente/n_muestras;
 return(corriente);
}

 

 

Como  el error que obtenemos  aun con el numero tan elevado de muestras es grande, debemos de recalibrar y hallar los valores reales puesto que los valores que nos da el fabricante no son exactos.

Recordemos la ecuación que usamos para hallar la corriente:

ecuacion para la corriente ACS712

En esta ecuación solo tenemos dos constantes: los 2.5 que es el voltaje del sensor cuando la corriente es 0V y la sensibilidad, que equivale a la pendiente de la recta Voltaje Vs Corriente; tenemos que calcular los valores reales de estas dos constantes. Al ser una recta, basta con obtener dos puntos y con estos podemos calcular constantes.

Para esto necesitamos un polimetro en la escala de Intensidad   ( debe ser de buena precisión, ya que este será la herramienta para calibrar)  . El polimetro, el ACS712  y la carga deben de conectarse en serie. 

Después de conectar el aparato de medida y el  sensor, debemos de tomar lecturas de voltaje del sensor, esto se hace con el siguiente programa.

void setup() 
{  
 Serial.begin(9600);
} void loop()
{  
float voltajeSensor =get_voltage(10000);
//obtenemos voltaje del sensor(10000 muestras)
 Serial.print("Voltaje del sensor: ");
 Serial.println(voltajeSensor ,3);
     }
float get_voltage(int n_muestras)
{  float voltage=0;  
 for(int i=0;i<n_muestras;i++)
 {    
voltage =voltage+analogRead(A0) * (5.0 / 1023.0);    
 }  voltage=voltage/n_muestras;  return(voltage);
}

El primer punto que debemos medir es para una corriente de 0 amperios: esta es una de las constantes, en nuestro caso 2.527, que corresponde al punto P1(2.527,0)

Para hallar la segunda constante necesitamos una segunda medida, se recomienda que no sea cercano al valor de la primera medida, en nuestro caso usaremos una carga cuya corriente es superior a 1 amperio.Como se observa en el sensor  un voltaje de 2.687, y en el amperímetro medimos 1.155A, este sería nuestro segundo punto P2(2.687,1.155) ,

Para calcular la sensibilidad simplemente calculamos la pendiente.

Teniendo estos dos valores la ecuación para calcular la corriente es:

ecuacion de sensibilidad

Donde sensibilidad=0.139 V/A

Con estos nuevos valores debemos trabajar los ejemplos anteriores

Tener en cuenta que cada sensor tiene su propia característica

Otra forma puede ser en tomar varios puntos y al final aplicar regresión y hallara la ecuación de la recta.

 

 

Con estos dos valores  contemplados en el programa, toca  ejecutar el programa  y observar la salida  del monitor serie    en función de cuando activamos el descodificador  y lo apaguemos . En nuestro caso , las lecturas son inferiores a 0.207 cuando esta en stand-bye    , superando este valor  cuando esta encendido

Estos valores   son precisamente  los que podemos usar como umbral  para activar o desactivar un pin de salida  por ejemplo para activar/desactivar  un rele que  a su vez alimente  al TV

Con todos estos cambios , el código final del programa que detecta  si se enciende o no el descodificador es el siguiente:

 

 

const int sensorPin = A0; // seleccionar la entrada para el sensor
int sensorValue; // variable que almacena el valor raw (0 a 1023)
float value;
float Sensibilidad=0.185; //sensibilidad en Voltios/Amperio para sensor de 5A

void setup() {

// Iniciamos comunicacion serie
Serial.begin(9600);
}


void loop() {

float I=get_corriente(200000);//obtenemos la corriente promedio de 500 muestras

if (I<0.207)
{Serial.print(“Apagado: “);  // aqui podemos desactivar un pin binario de salida  para deactivar  un rel
Serial.println(I,3);
delay(100);
}
else
{Serial.print(“Encendido: “);// aquí podemos activar un pin binario de salida  para activar  un relé
Serial.println(I,3);
delay(100);
}


}


float get_corriente(int n_muestras)
{
float voltajeSensor;
float corriente=0;
for(int i=0;i
{
voltajeSensor = analogRead(sensorPin) * (5.0 / 1023.0);////lectura del sensor
corriente=corriente+(voltajeSensor-2.5)/Sensibilidad; //Ecuación para obtener la corriente
}
corriente=corriente/n_muestras;
return(corriente);
}

// cambio de escala entre floats
float fmap(float x, float in_min, float in_max, float out_min, float out_max)
{
return (x – in_min) * (out_max – out_min) / (in_max – in_min) + out_min;
}

 

 

 

Anuncios

Como emular un mando con Arduino


A veces   puede ser  interesante emular del comportamiento  de un mando infrarrojo  con el fin de automatizar procesos  que de otra manera  seria mucho mas complejo . Como ejemplo típico de dispositivos que podemos controlar vía infrarojos, hablamos de  reproductores de cámaras, televisores, DVD, VCR, lectores de blueray, equipos de sonidos, descodificadores  y  un largo etcétera 

Aunque pueda parecer descabellado repetir las mismas señales desde una placa Arduino , lo cierto  es que no es descabellado querer emular este comportamiento , porque  podemos  hacer cosas  que seria muy dificultoso  sin la ayuda del procesamiento de señales de infrarojos como por ejemplo  encender automáticamente  el Aire Acondicionado  cuando la temperatura  suba un determinado valor , o se desconecte a una determinadas horas ,  se apague  cuando no haya movimiento  y un largo  etcétera 

Como paso previo  debemos analizar las señales infrarrojas emitidas por el mando usado para el control de ese dispositivo  por lo que deberemos averiguar  cómo recibir los códigos y luego una vez conocidas intentar ver como transmitirlas.

Para nuestra tarea necesitamos :

  • 1 x Arduino (cualquier versión sirve  siempre que pueda procesar señales  “PWM” )
  • 1 x LED IR   (usted puede conseguir éstos de cualquier TV remoto)
  • 1 x receptor IR (usted puede conseguir éstos de cualquier TV remoto)

 

Preparación para recibir señales

Para el análisis  de las señales infrarrojas  producidas por el mando del  dispositivo a controlar en primer lugar necesitaremos  un receptor de infrarrojos ,   que bien  puede proceder de   uno reciclado de cualquier viejo proyecto que ya no utilice  o bien adquirido específicamente  en el comercio

Una interesante opción son los famosos kits para Arduino que integran por unos 4€  todo los necesario para habilitar la comunicación en los dos sentidos  gracias a un led IRDa, un receptor IRDA  y un mando para pruebas.

Kit Modulo Receptor Infrarojo IR Protocolo Nec con Mando a Distancia Arduino

Como sugerencia  para captar el código correcto , deberíamos poner el receptor IR y el mando en una caja opaca  o algo que sea oscuro  lo cual  asegurará que habrá el mínimo de interferencias y  podremos tener el código más claro para que no tengamos que programar  nuestro  Arduino  muchas veces para una simple tarea. También, asegúrese de que estar alejados de personas viendo la televisión.

Realmente el circuito es bastante sencillo pues únicamente tendremos que alimentar con 5v DC  ( que podemos tomar directamente desde nuestro Arduino )   y luego conectar la salida del receptor digital al pin digital A2 de Arduino

 

Picture of Preparing to Receive Signals

Una vez montado el simple circuito del receptor de infrarrojo es hora de  subir el programa a su Arduino  para  poder descodificar la señal infrarroja .

El siguiente programa utiliza el Arduino y un PNA4602 para descifrar IR recibido lo cual se  puede utilizar para hacer un receptor de infrarrojos. (buscando un código en particular) o transmisor (pulsando un LED IR a ~ 38KHz para el duraciones detectadas,

Este código es de dominio público (visite http://www.ladyada.net y adafruit.com), pero en esta ocasión se ha traducido para que sea mas legible y fácil de entender:


// Necesitamos usar los métodos de lectura de pin ‘raw’  porque el tiempo es muy importante aquí y el digitalRead () es un  procedimiento s más lento!

#define IRpin_PIN PIND
#define IRpin 2

// el pulso máximo que escucharemos: 65 milisegundos es mucho tiempo
#define MAXPULSE 65000

// lo que debería ser nuestra resolución de tiempo, más grande es mejor ya que es más ‘preciso’ – pero demasiado grande y no se conseguirá  tiempo exacto
#define RESOLUTION 20

// almacenaremos hasta 100 pares de pulsos (esto son muchos )
uint16_t pulses[100][2]; // par es pulso alto  y bajo 
uint8_t currentpulse = 0; // indice para pulsos que estamos almacenando

void setup(void)

{
Serial.begin(9600);
Serial.println(“Ready to decode IR!”);
}

void loop(void)

{

// tiempo de almacenamiento temporal
uint16_t highpulse, lowpulse;

//empezar sin pulso 
highpulse = lowpulse = 0;

//esto es demasiado lento!
while (IRpin_PIN & (1 << IRpin)) {
// pin esta a nivel alto

// continúa otros microsegundos
highpulse++;
delayMicroseconds(RESOLUTION);

// Si el pulso es demasiado largo, ‘se agotó el tiempo’ – o bien nada / se recibió o el código está terminado, así que imprima lo que  hemos obtenido hasta ahora, y luego reiniciamos
if ((highpulse >= MAXPULSE) && (currentpulse != 0)) {
printpulses();
currentpulse=0;
return;
}
}
// no nos detuvimos, así que escondamos la lectura
pulses[currentpulse][0] = highpulse;

// lo mismo que arriba
while (! (IRpin_PIN & _BV(IRpin))) {
// pin esta aun bajo
lowpulse++;
delayMicroseconds(RESOLUTION);
if ((lowpulse >= MAXPULSE) && (currentpulse != 0)) {
printpulses();
currentpulse=0;
return;
}
}
pulses[currentpulse][1] = lowpulse;

// leemos un pulso alto-bajo con éxito, ¡continuamos!
currentpulse++;
}

void printpulses(void) {
Serial.println(“\n\r\n\rReceived: \n\rOFF \tON”);
for (uint8_t i = 0; i < currentpulse; i++) {
Serial.print(pulses[i][0] * RESOLUTION, DEC);
Serial.print(” usec, “);
Serial.print(pulses[i][1] * RESOLUTION, DEC);
Serial.println(” usec”);
}
}


Una vez que hemos subido el código anterior  y  todo está configurado correctamente, abrir el serial monitor haciendo clic en el botón en el programa de Arduino que es el botón de un círculo en la imagen y  ya estára en marcha así que ahora usted necesitará encontrar un control remoto que desee usar para controlar algo con Arduino

El proceso  esquemáticamente  a seguir es el siguiente :

  1. Encontrar el mando a distancia del dispositivo  que quiere controla
  2. Ejecutar el código del  receptor anteriormente citado
  3. Presione el botón del mando cuyo  código desea obtener 
  4. Ver el Monitor Serial
  5. Pegar el todo el código del monitor serie  en un editor de texto 
  6. Repetir los paso 3, 4 6  con todos los botones del mando que desee descodificar 

 Interpretando las señales

Una vez siga la secuencia de paso anteriores recibirá un montón de números seguidos por “usecs” o “usec”.
Asegúrese de que ha copiado la señal que se desea formateando la salida para más fácil referencia.

Se verá algo como esto:
500 usec, 300 usec
600 usec, usec 1200

Pero habrá números mucho más que eso.

Ahora en el programa emisor  verá esto bastantes veces:

delayMicroseconds();
pulseIR();

Es decir tenemos que  tomar el primer número y poner paréntesis en delayMicroseconds(“here”); el  valor obtenido en el monitor
y a su vez   tomar el segundo número de la misma línea como el de la delayMicroseconds()  valorar y poner en el paréntesis de pulseIR(); valor.

Veamos otro ejemplo .Si conseguimos esto en el monitor serial:

OFF ON
1660 usec, usec 580
1640 usec, usec 560

Ahroa para poner los  correspondiente valores en sus áreas correspondientes lo haremos asi :

delayMicroseconds(1660);
pulseIR(580);
delayMicroseconds(1640);
pulseIR(560);

Como puede apreciar ,la  tarea de transcripción  es muy fácil.

Una vez que tenga los códigos que desee, abra un nuevo  archivo IR_SEND.pde en el programa de Arduino y luego tendremos que  poner  los valores que tiene del monitor de serie entre paréntesis haciéndolo  del mismo modo  que hemos visto anteriormente .

Ahora, una vez que tenemos los códigos que desea y haya cargado el programa con la señal que desea enviar, todo lo que tiene que hacer es conectar el LED IR al pin 13 y luego a tierra  No necesita la resistencia si tiene un Duemilanove Arduino porque tiene una resistencia integrada para PIN 13, por lo que no tiene que preocuparse.


Como ejemplo veamos este código cuando se presiona el botón para subir el canal en un  control remoto de Comcast. . Aquí está el código de Serial Monitor: Recibido:

OFF  ON
36328 usec, 280 usec
820 usec, 300 usec
1580 usec, 320 usec
640 usec, 240 usec
2740 usec, 240 usec
1280 usec, 240 usec
1240 usec, 240 usec
1120 usec, 240 usec
2600 usec, 240 usec
12740 usec, 240 usec
840 usec, 240 usec
980 usec, 240 usec
700 usec, 240 usec
700 usec, 240 usec
720 usec, 240 usec
2460 usec, 260 usec
700 usec, 240 usec
700 usec, 240 usec
14904 usec, 260 usec
820 usec, 240 usec
1660 usec, 240 usec
700 usec, 260 usec
2740 usec, 240 usec
1240 usec, 240 usec
1260 usec, 240 usec
1100 usec, 240 usec
2620 usec, 240 usec
12720 usec, 260 usec
840 usec, 220 usec
2080 usec, 240 usec
1780 usec, 260 usec
700 usec, 240 usec
700 usec, 240 usec
2480 usec, 240 usec
700 usec, 240 usec
700 usec, 240 usec

Aquí está el código realizado a partir de los datos en bruto anteriores  pero no se  asociado al código  

En el siguiente  programa   se ha introducido  un detalla original ; Arduino cambiará el canal cada diez segundos para que se puedan hacer otras cosas , Por ejemplo mientras se ve televisión y esta haciendo otras cosa  así  no tendrá que cambiar el canal de modo que el sw  recorrerá los canales para que tenga las manos libres. (todos sabemos que presionar un botón es tan difícil, ¿por qué no hacerlo de forma automática?)

 

He aquí el programa realizado por Wally_Z:


int IRledPin =  13;    // LED conectado al pin digital 13

// El método setup () se ejecuta una vez, cuando comienza el boceto

void setup()   {               
  // initializa  el pin como salida :
  pinMode(IRledPin, OUTPUT);     

  Serial.begin(9600);
}

void loop()                    
{
  SendChannelUpCode();

  delay(20*1000);  // espera veinte segundos (20 segundos * 1000 milisegundos) Cambia este valor para diferentes intervalos.

}

// Este procedimiento envía un pulso de 38KHz al IRledPin  para un cierto  numero de microsegundos. Usaremos esto siempre que tengamos que enviar códigos.

void pulseIR(long microsecs)

{
  // contaremos desde la cantidad de microsegundos que se nos dice que esperemos

  cli();  // esto apaga cualquier interrupción de fond

  while (microsecs > 0) {
   // 38 kHz tiene aproximadamente 13 microsegundos de alto y 13 microsegundos de bajo
   digitalWrite(IRledPin, HIGH);  //Esto lleva alrededor de 3 microsegundos
   delayMicroseconds(10);         // esperar 10 microseconds
   digitalWrite(IRledPin, LOW);   // esto toma sobre 3 microseconds
   delayMicroseconds(10);         // esperar   10 microseconds

   // asi que  26 microseconds  todo junto
   microsecs -= 26;
  }

  sei();  // esto devuelve el control
}

void SendChannelUpCode()

{
  // Este es el código para CHANNEL + para TV COMCAST.
 
  delayMicroseconds(36328);      //Tiempo libre (columna IZQUIERDA)      
  pulseIR(280);                               //Tiempo en (columna DERECHA) <——- NO MEZCLAR ESTOS ARRIBA
  delayMicroseconds(820);
  pulseIR(300);
  delayMicroseconds(1580);
  pulseIR(320);
  delayMicroseconds(640);
  pulseIR(240);
  delayMicroseconds(1280);
  pulseIR(240);
  delayMicroseconds(1240);
  pulseIR(240);
  delayMicroseconds(1120);
  pulseIR(240);
  delayMicroseconds(2600);
  pulseIR(240);
  delayMicroseconds(12740);
  pulseIR(240);
  delayMicroseconds(840);
  pulseIR(240);
  delayMicroseconds(980);
  pulseIR(240);
  delayMicroseconds(700);
  pulseIR(240);
  delayMicroseconds(700);
  pulseIR(240);
  delayMicroseconds(720);
  pulseIR(240);
  delayMicroseconds(2460);
  pulseIR(240);
  delayMicroseconds(700);
  pulseIR(240);
  delayMicroseconds(700);
  pulseIR(240);
  delayMicroseconds(14904);
  pulseIR(240);
  delayMicroseconds(820);
  pulseIR(240);
  delayMicroseconds(1600);
  pulseIR(240);
  delayMicroseconds(700);
  pulseIR(260);
  delayMicroseconds(2740);
  pulseIR(240);
  delayMicroseconds(1240);
  pulseIR(240);
  delayMicroseconds(1260);
  pulseIR(240);
  delayMicroseconds(1100);
  pulseIR(240);
  delayMicroseconds(2620);
  pulseIR(240);
  delayMicroseconds(12720);
  pulseIR(260);
  delayMicroseconds(840);
  pulseIR(220);
  delayMicroseconds(2080);
  pulseIR(240);
  delayMicroseconds(1780);
  pulseIR(260);
  delayMicroseconds(700);
  pulseIR(240);
  delayMicroseconds(700);
  pulseIR(240);
  delayMicroseconds(2480);
  pulseIR(240);
  delayMicroseconds(700);
  pulseIR(240);
  delayMicroseconds(700);
  pulseIR(240);
}

 

Via Instrucables.com

 

 

 

Como controlar cualquier electrodoméstico con mando vía wifi


Modernamente están apareciendo muchos electrodomésticos convencionales como equipos de Aire  Acondicionado , Robots de limpieza , Persianas eléctricas , TV , etc con la opción de poderlos controlar  a distancia gracias  a la  conectividad  WIFI ,lo cual puede ser muy interesante  para configurarlos , programarlos o activarlos no solo desde casa, sino incluso fuera de esta  , y con ello mejorar nuestra calidad  de vida  . El punto  negativo es que en la mayoría de los casos   incrementa  sustancialmente el precio  desgraciadamente frente a los  equipos convencionales que no cuentan  con  dicho control y ademas  si contamos con equipos instalados operativos  pero sin esa funcionalidad de control por wifi   , no es una razón de peso para desechar estos¿no?. 

Asimismo ,como sin duda el lector conocerá, cada día  son mas frecuentes los asistentes de voz  como Alexa de Amazon , Google Home o el propio novedoso Aura de Movistar , todos ellos que poco podrán hacer sobre dichos  equipos  a controlar, si no disponen de los  módulos de control  correspondientes. Por ejemplo   con un Amazon Echo Dot o un Google Home Mini  si quiere enseñarle a encender el aparato de Aire Acondicionado  antes de llegar a casa o encender la TV   cuando olvida el mando a distancia lejos del sofá  no podrá hacerlo fácilmente   directamente  pues estos equipos no están preparados par ser controlados por dichos asistentes ,  pero no se alarme, porque   en efecto  no hace falta invertir una gran suma de dinero en cambiar dicho aparato , pues nos bastara ,  si este equipo es controlable   por infrarrojos o RF , de  instalar  un control remoto de luz infrarroja compatible con Alexa o Google Home  que haga las veces de “puente” entre ambos mundos.

Como opción interesante para controlar nuestros dispositivos en el salón destaca el Broadlink RM mini3, un pequeño dispositivo  que  puede controlar sin limitaciones  a  todos los dispositivos y dispositivos controlados con mandos a distancia por infrarrojos  o  que  emiten radiofrecuencia  en las frecuencias de 433 Mhz y 315 Mhz en toda la casa. ( excepto si el código es variable, Broadlink Rm Pro no puede admitirlo) 

 El BroadLink en cuestión tiene el tamaño de un vaso de chupito   contando con  varios leds de infrarojos  repartidos en la cabeza en forma 360° , que hacen que su área de actuación sea muy buena, por ejemplo  para encender el aire acondicionado antes de llegar a casa o para simular presencia encendiendo la tele  gracias a  una app específica para Europa (Intelligent Home Center For EU  , la cual se rige por el Reglamento General de Protección de Datos de la Unión Europea, famoso por ser estricto con el manejo de datos personales).

 

 Con este tipo de dispositivo podremos reemplazar  todos los controles remotos  por  su teléfono inteligente, pues cuenta con soporte para más de 80,000 dispositivos controlados por infrarrojos como aire acondicionado, TV, DVD, PVR, CD, SAT, aire acondicionado, persianas eléctricas, lámparas, purificadores, WiFi, reproductores BluRay, proyectores , Unidades de CA, salidas de RF, ventiladores y mucho más.

Aunque se ha comentado alguna  vez en este blog ,para saber si un mando es IR o RF, enfoque con la cámara del móvil a la punta del mando que controle ese dispositivo y pulse un botón: si en la pantalla del móvil  se ve un destello de  luz azul/blanca, es IR ( si no se ve nada, es de RF).

 

 

Los pasos a seguir para la instalación del el Broadlink RM mini3,  son realmente  muy sencillos:

  1. Instalar la app en el móvil ( esta disponible tanto para Android  como para  iOS)
  2. Enchufarle  una conexión de 5v  por el conector micro-USB ( no esta incluido el adaptador )                                                                                     ,
  3. Abriremos la   app   (esta disponible tanto para Android  como para  iOS)  y vincularemos el  Broadlink RM mini3,por  bluetooth a nuestro terminal                                                                       .
  4. Tendremos que conectar  el  Broadlink RM mini3 a nuestra red wifi añadiendo las credenciales  de nuestra red. Este modelo solo es compatible con redes de 2,4 GHz, pero no 5G  y la  contraseña de Wifi debe ser de  menos de 32 bytes, sin espacios y símbolos especiales, solo con alfabeto y número,
  5. Seguidamente añadiremos el  dispositivo a controlar  para lo cual elegiremos el  tipo de dispositivo, buscando  este modelo en la base de datos   que ofrece la propia aplicación  
  6. Probaremos  si funciona el control remoto desde la propia app , pero  si no funciona , cambiaremos  de modelo  hasta que reaccione)
  7. Si el control remoto no reconoce el dispositivo, puede copiar la señal del mando a distancia manualmente (pero los dispositivos que no están en la base de datos de BroadLink no son compatibles con los asistentes de voz)
  8. Repetiremos el proceso  para  todos los dispositivos controlados por infrarrojo que el BroadLink RM mini 3 tenga a su alcance  como puede ser los equipos de  aire acondicionado, televisores, equipos de música,lectores de dvd o blueray , descodificadores  de televisión de pago ,  barra de sonido, robot aspirador, reproductor multimedia, persianas eléctricas, etc..
  9. .El siguiente paso es configurar escenas que luego usaremos como comandos de Alexa o Google Home. Por  ejemplo para el televisor podemos tener varias  escenas para “encender la television”  o apagar la televisión  o incluso subir o bajar el volumen   o para el equipo de aire acondicionado  por ejemplo podemos tener una escena “calienta la casa” que sube la temperatura a 26 ºC y otra  escena “enfría la casa” que baja la temperatura a 18 ºC.
  10. El último paso es conectar la app de BroadLink con el altavoz inteligente. Hay un manual de instrucciones en el menú Más > Añadir servicio de voz, pero en resumen tenemos que abrir la aplicación Alexa o Google Home en el móvil e instalar la skill o servicio correspondiente. El asistente reconocerá automáticamente los nuevos dispositivos y sus comandos o escenas. Llegados a este punto  ya podrá decir “enciende el aire acondicionado”, “pon el aire acondicionado en modo calefacción” o “enfría la casa” para que el altavoz inteligente se comunique con el control remoto y este, a su vez, envíe la orden al aire acondicionado. También puedes decir “enciende la tele”, “silencia la tele” o “pon La Sexta” para que el control remoto envíe esas órdenes al televisor, aunque no sea una Smart TV ni nada parecido.
  11. Si puede  añadir un nivel de complejidad, creando rutinas desde las apps de Alexa y Google Home para encender las luces del salón de un color determinado cuando ponga el fútbol, conectar  la calefacción todos los días a una hora determinada o apagar el equipo de música cuando enciende la tele. 

 

Conclusiones 

Puede ser interesante para poder manejar la tele, aire acondicionado, bomba de calor y decodificador con el móvil pero sobre todo mediante un asistente de voz como  Google Home o Alexa 

Si nos remitimos al móvil , gracias a este dispositivo se pueden manejar multitud de aparatos sin problemas, configurarse  estos  fácilmente desde la aplicación y enseguida se pueden usar todos, desde casa o fuera de ella ( eso si sólo aquellos que usen infrarrojos  no Radiofrecuencia)

La app ademas permite poner temporizadores para que automáticamente la aplicación ejecute la función del aparato que se desee, en una hora o día concreto, o cada cierto tiempo. También existen los ambientes, que permiten ejecutar varios pasos automáticamente que nosotros indiquemos, de uno o varios aparatos, con un solo click. 

La pega viene con su compatibilidad con Google Home ya que no es del todo correcta. Para el RM Mini3 hay dos app, versión global y europea, que se usan igual para configurar los mandos, pero con la primera de ellas, Google Home no integra ni detecta los dispositivos, sólo los ambientes, y no los ejecuta bien. Con la otra, la europea, Google Home integra los dispositivos, pero solo las de tipo lámpara y tipo aire acondicionado, no las TV ni otros aparatos personalizados.

Respecto a Alexa , aunque la configuración a través de ambientes , escenas y rutinas se hace ardua y repetitiva una vez conseguida el funcionamiento es perfecto. Puedes controlar todo aparato que use infrarojos  que tenga en la misma habitación, y la función de aprendizaje de botones te facilita muchas tareas, así como las funciones pre-configuradas que otros usuarios ya han colgado en el servidor.  Es   un aparato imprescindible en dúo con Alexa.

En el siguiente video podemos ver un ejemplo de integración de Alexa con el Broadlink RM mini3,

Por cierto este  puente  de infrarrojos con wifi   se puede comprar  en Amazon por unos 24,99,   pero tenga cuidado porque hay otros modelos de Broadlink  algo mas económicos que no son controlables por asistentes de voz como Alexa o Google Home.Si necesita controlar aparatos que vayan por radiofrecuencia en lugar de infrarrojos necesitarás su hermano mayor…. El pro

 

Curso gratuito sobre impresión en 3D


En este blog nos intentamos hacer eco de todos los proyectos interesantes que surgen  respecto a la  impresión en 3D

Precisamente orientado  a todas aquellas personas que quieran profundizar en esta plataforma ,gracias a la plataforma de Miriadax   tenemos disponibles  en la red   un interesante  curso gratuito  online  sobre impresión en 3d   apoyado  por la UPM  (Universidad Politécnica de Madrid)

El curso esta organizado en formato MOOC, (el acrónimo en inglés de Massive Online Open Courses ) , es decir como  un curso online masivo y abierto donde toda la comunidad   colabora de forma interactiva a través de la plataforma  y el uso de redes sociales.

Si el 2018 ha sido un año donde la Impresión 3D ha sido un boom a nivel del gran público y prácticamente ya no queda nadie que no conozca de su existencia, este año 2019 va a ser un año de gran crecimiento a nivel profesional, presencia en PYMES y uso en la Industria.

Todo ello gracias al considerable abaratamiento de tecnologías como FDM o SLA, así como a la constante evolución de los materiales para impresión , lo que amplían el abanico de soluciones que podemos llegar a crear apoyándonos en la impresión 3D.

 

No hay comienzo de año que no esté lleno de buenos propósitos, así que desde el MOOC Imprimiendo en 3D desde la plataforma MiriadaX nos animan a todos los que nos interese el mundo de la impresión en 3d o queramos mejorar nuestros conocimientos a que incluyamos en esta tarea en nuestra lista de propósitos 😉 nos permitirá obtener un conocimiento global de este apasionante mundo y descubrir que áreas son más de nuestro interés.

“Imprimiendo en 3D” quiere acercar a los usuarios esta tecnología, en constante cambio, que está llamada a revolucionar el mundo productivo y las relaciones comerciales en un corto espacio de tiempo.

 

La liberalización de algunas patentes y el descenso del coste de las impresoras están acercando la impresión 3D a casi todas las personas.

Desde sus inicios en los años ochenta del siglo XX, la impresión 3D ha ido perfeccionando tanto la propia impresora como diversificando los materiales que pueden emplearse. Por esta razón, se propone este curso para conocer las herramientas básicas de este proceso aditivo de fabricación de objetos desde un soporte digital (dibujos realizados con algún software: Blender, SketchUp, etc.), animado con ejemplos para que los usuarios pueden llevarlos a cabo (piezas de drenes, etc.)

 

En próximos MOOCs ya más especializados nos prometen ir abordando y profundizando en temas similares que sean de nuestro interés como por ejemplo  “Construcción de drones apoyándose en impresión 3D”, “Diseño avanzado con softwares para impresión en 3D”, etc.).

Para los que ya esteis pensando en  comenzar este MOOC, ya hay un Foro https://miriadax.net/es/web/imprimiendo-3d-/foro en el que se pueden hacer llegar dudas y preguntas asi como debatir sobre todo lo relacionado la Impresión 3D

https://miriadax.net/es/web/imprimiendo-3d-/inicio .

 

Enchufe inteligente basado en Cayenne


Un enchufe inteligente puede ser el primer camino sencillo para empezar la automatización del hogar ,objetivo   que sin duda esta muy pronto por llegar (en cuanto bajen aun mas los precios del hardware , pero sobre todo se mejore el software respecto a la seguridad) . Como hemos visto en este blog en numerosas ocasiones, existen muchos tipos de enchufes inteligentes disponibles en el mercado , pero aunque su precio empieza a ser razonable, desgraciadamente son soluciones cerradas  y por tanto no son personalizables  estando unidos a una solución sw que es muy difícil de cambiar.

En general, un enchufe inteligente es un dispositivo compacto que se conecta a tomas de corriente tradicionales   pudiendo actualizarse   con control remoto (normalmente por wifi) y por programación mediante diversas aplicaciones a medida   ejecutadas desde un smartphone ( o desde un pagina web).

Hoy, día de año nuevo, vamos a ver lo sencillo que es construir un enchufe inteligente mediante la plataforma Cayenne y utilizando el económico módulo wifi ESP8266

Con esta solución se consiguen varios objetivos:

  • Control local y remoto – el dispositivo basado en Cayenne puede ser fácilmente encendido/apagado usando la aplicación para smartphone Cayenne o desde la página web de Cayenne.
  • Motion Control – puede automáticamente encender o apagar con su presencia así como activar o desactivar esta opción por medio de la propia app de Cayenne.
  • Control por voz – puede activar o apagado el enchufe usando el Asistente de voz de Alexa
  • Poder de programación – se puede crear fácilmente horarios de
    encendido/apagado para sus dispositivos .También fácilmente puede configurar el temporizador de Cayenne directamente desde la aplicación.
  • Protección térmica – gracias a un sensor de temperatura incorporado automáticamente se puede apagar aparatos por sobrecalentamiento y notificar esta condicion a través de SMS o correo electrónico.
  • Monitorización remota – Por medio de la aplicación de Cayenne se puede monitorear el voltaje, corriente, temperatura y estado del enchufe (o está activado o desactivado).
  • Estadísticas de uso de energía – se puede controlar el consumo de energía de los dispositivos conectados y obtener notificaciones.

 

 

 

 

El circuito

Para este proyecto se usa  la siguiente lista de componentes:

  1.  Módulo de ESP8266-12E
  2.  Adaptador  DC5V 
  3.  Regulador de 3.3V 
  4. Modulo sharp S108T02 
  5. .  Sensor de temperatura  (DS18B20)
  6.   Sensor Consumo  (ACS712)
  7.  Sensor de  presencia PIR HC-SR501 
  8.  Cables y placa de prototipos.

 

El circuito no es demasiado complejo pues básicamente consiste en conectar los    sensores al ESP8266 , sin olvidar la alimentación de 3.3v   obtenida a partir de una fuente standard conmutada de  5v DC  y un reductor de 5v y 3.3v DC .  Puede usar  un viejo cargador de teléfono móvil y realizar la conversión de 5V a 3.3V con un circuito regulador integrado como el  AMS1117 . También puede alimentar con 5v  el circuito  usando directamente un micro-usb. 

 

Usaremos el sensor digital de temperatura DS18B20 con bus de hilo de Maxim IC , componente muy usado por cierto en muchos proyectos de registro de datos y control de temperatura

Este chip envia  al bus I2C la información de la temperatura exterior en  grados C con precisión 9-12 bits, -55C a 125C (+/- 0.5C).a.

Cada sensor tiene un número de serie único de 64 bits grabado en él lo cual permite un gran número de sensores que se utilizarán en un bus de datos.

 

DS18B20

 

Para medir el interior temperatura del enchufe se  usa el sensor de temperatura DS18B20  que alimentaremos  con 5v DC  desde  el propio  ESP8266 .Respecto a la salida digital del sensor de temperatura lo conectaremos a la una entrada digital por el  pin 13.

 

Como vemos en el esquema anterior , el sensor de proximidad    lo conectaremos al  pin  4  digital  y también a la alimentación de 5v DC  de la placa.

Respecto al sensor de consumo , éste  esta  basado en el  AC712  el cual conectaremos  en derivación ( es decir en serie ) con  la carga  AC  y a su vez con el   modulo sharp S108T02  (que es un relé de estado solido ) que  a su vez   llevaremos al enchufe para conectar la carga que deseamos controlar.

El   modulo sharp S108T02  (que es un relé de estado solido ) lo comandaremos directamente  con una salida digital   por medio del pin 5  ( al pin+)  y  masa . No debemos confundir los pines de control  (+-)  con lo pines de la  carga AC controlar rotulados con el signo de ca .

Respecto al sensor de consumo eléctrico, nos basaremos en  el modulo  ACS712  , el  cual  asimismo también debe conectarse a la carga en serie   como ya comentábamos  . Para evitar precisamente problemas en las conexiones ,  el modulo  ACS712     cuenta con dos terminales  atornillables para conectar aquí la carga  en  serie  y justo en el lado opuesto tres pines donde conectaremos la alimentación  y el pin de datos (OUT) que soldaremos al pin analógico  (ADC) del ESP8266

 

El modulo  ACS712  puede medir hasta  30 amperios gracias a su tamaño compacto fácil  de usar   basándose  en el Chip IC de producto: ACS712ELC 30 A . Su tensión de alimentación es de 5V y la tensión de salida con corrientes de hasta 30A es de185 mV/A siendo el rango de temperatura de funcionamiento entre -40 °C a 85 °C

Rrefiriéndonos al sensor PIR  podemos conectar un sensor PIR HC-SR501   que alimentaremos a 5v DC

 

hcsr501.PNG

 

El  modelo HC-SR501HC-SR501 es  un Sensor infrarrojo de bajo coste (menos de 2€  por modulo en Amazon) con placa de circuito de control donde se pueden ajustar la sensibilidad y el tiempo de retención gracias a dos resistencias ajustables que dispone en un lateral.

La gama de voltaje de trabajo es  DC 5V-20V  con un consumo de corriente de  menos de 60uA. La salida  es binaria digital  siendo el voltaje de salida de  3,3 V para un nivel alto o “1” logico  y  0V para el cero lógico (no detección de movimiento).

Lo primero que hacemos es conocer el pinout del HC-SR501, pero rápidamente al ver la serigrafía  de la placa, queda perfectamente claro :GND  para la masa , VCC para la alimentación (que tomaremos desde la Orange Pi ) y un pin de salida (OUT) que será el que nos indique si ha detectado algún movimiento.

Luego lleva un par de resistencia variables o potenciómetros que nos permiten ajustar los parámetros de sensibilidad y duración de la señal, es decir, durante cuanto tiempo vamos a querer que en pin OUT tener la salida informada.

sensor

 

El primer potenciómetro hacia la derecha sirve para ajustar la distancia de modo que el , rango de detección aumenta (unos 7 metros), por el contrario, la gama de detección disminuye (unos 3 metros).El otro potenciómetro rotándolo a la derecha sirve para retrasar  el  retardo de sensor a  tiempos más largos (sobre 300s).Si se gira la contrario el retardo sera corto (sobre 5).

 

 

Plataforma Cayenne

Gracias  a la plataforma de Cayenne , de la que hemos hablado en este blog en numerosas  ocasiones es bastante sencillo monitorizar cualquier variable física  de un modo realmente sencillo  simplemente  haciendo drug &drop desde el panel de control de Cayenne utilizando internet sin tener conocimientos  de programación conseguiendo asi controlar o monitorizar una carga AC a  en tan solo unos minutos  .

En efecto, gracias  a un  framework  genérico desarrollado por  myDevices IO Project Builder llamado Cayenne , los desarrolladores , fabricantes y  también aficionados  pueden  construir rápidamente prototipos y proyectos que requieran controlar o monitorizar   cualquier cosa conectada a  una placa  con conectividad  , permitiendo con una sóla cuenta gratuita de Cayenne, crear un número ilimitado de proyectos  mediante una solución  muy sencilla  basada en arrastrar y soltar 

Obviamente el punto fuerte de Cayenne  son las  capacidades de  IO  para que pueda controlar de forma remota sensores, motores, actuadores, incluidas los puertos  de GPIO con almacenamiento ilimitado de datos recogidos por los componentes de hardware,   triggers y alertas,  que proporcionan las herramientas necesarias para la automatización y la capacidad de configurar alertas. Ademas también puede crear cuadros de mando personalizados para mostrar su proyecto con arrastrar y soltar widgets que también son totalmente personalizables.

Para  probar Cayenne  con el  ESP12E       necesitamos  programar su ESP-12E para conectarse a su punto de acceso wifi   (el código fuente a subir  se puede descargar desde https://codebender.cc/embed/sketch:398516)

Como hemos hablado en  muchas ocasiones de Cayenne  pues en realidad está concebido para  que su manejo sea realmente sencillo   de configurar,  de modo que nos iremos a  su   url :   https://cayenne.mydevices.com/  

Tras registrarnos nos iremos  al panel de control   ,pulsaremos en  Add new   y seleccionamos generic ESP8266

A continuación nos ofrece  la API key que deberemos añadir al sw del   ESP12E      y tras reiniciarlo  ya debería poderse  comunicar con el node de Cayenne

 

Ahora la placa  está configurada con el MQTT  ( username /pwd)     así como con conectividad  wifi ,  de modo que ya   debería  de  poder conectarse al framework de Cayenne   y podemos seguir hacia adelante añadiendo sensores que deberán estar de acuerdo con el sw instalado en el ESP12E

Para visualizar los datos y controlar el dispositivo basta con añadir el widget apropiado usando arrastrar y soltar el método por lo que en  primer lugar, es necesario determinar los parámetros que quieres monitorear.

Cayenne utilizar un canal separado para cada parámetro y necesita definir cuándo configurar  un widget para cada funcionalidad

 

Estos son algunos de los widges que podemos usar para este circuito   :

 

Como vemos ,en este caso , como se aprecia en la pantalla anterior se han añadido:

  • Dos valor pantalla Widgets para mostrar temperatura y corriente.
  • Un calibrador de pantalla Widget para mostrar el voltaje.
  • Un 2 Widget de pantalla de estado para monitorear el estado de la clavija
  • Tres botón controlador Widget para el torneado de encendido y apagado el enchufe, proximidad de activación/desactivación y activación/desactivación temporizador.
  • Un regulador controlador Widget para ajustar la hora.
  • Una línea gráfico pantalla Widget para mostrar el índice de consumo de energía.
  • Dos disparadores, uno por automático apagado si se sobrecalienta y otra para correo electrónico y notificación por SMS.

 

Básicamente  el código a subir al    ESP12E     usa 5 librerías:  tres de Cayenne donde  tendremos que definir el SSID y la pwd de la red wifi así como las credenciales de Cayenne    , una cuarta de temporización para enviar muestras a intervalos prefijados ( que obviamente podemos cambiar ) 

Es de destacar  la creación  de  dos puertos virtuales  para capturar  los valores  en tiempo real de la temperatura  y la humedad tomadas ambas  del DHTXX  , lo cual nos van a permitir comunicarnos con el API de Cayenne.

Este es un ejemplo muy sencillo de utilización:

#include "CayenneDefines.h"
#include "CayenneWiFi.h"
#include "CayenneWiFiClient.h"


#define CAYANNE_DEBUG
#define CAYANNE_PRINT Serial


// Cayenne authentication token. This should be obtained from the Cayenne Dashboard.
// Change the value of token, ssid, and pwd to yours
char token[] = "xxxxxx";
char ssid[] = "xxxxxx";
char pwd[] = "xxxxx";
DHT dht(DHTPIN, DHTTYPE);

void setup() {
// put your setup code here, to run once:
Serial.begin(115200);
Cayenne.begin(token, ssid, pwd);
dht.begin();
}

CAYENNE_OUT(V0)
{
float t = dht.readTemperature();
Cayenne.virtualWrite(V0, t); //virtual pin
}
......
......

void loop() {
Cayenne.run();
}
 
Como es obvio  necesitaremos actualizar  en el código anterior cambiando el valor de ssid, contraseña  configurándola para la red wifi de su hogar y  también no olvidar   registrar  el  token de Cayenne que previamente habrá solicitado  desde la propia web de cayenne.

Md Hairul ha compartido el código de su prototipo  mediante licencia GPL, código, el cual  para que sea mas legible hemos añadido  unos breves lineas explicatorias.

 

// usado para enviar datos a la nube Cayenne
#include "CayenneDefines.h"
#include "CayenneWiFi.h"
#include "CayenneWiFiClient.h"

// Incluye las bibliotecas para el sensor de temperatura DS18B20
#include <OneWire.h>
#include <DallasTemperature.h>

// Habilitando la voz de Alexa
include "WemoSwitch.h"
include "WemoManager.h"
include "CallbackFunction.h"

WemoManager wemoManager;
WemoSwitch *light = NULL;

// configurar la depuración de cayenne
define CAYENNE_PRINT Serial

// tipos de datos
define TYPE_DIGITAL_SENSOR "digital_sensor"
define TYPE_VOLTAGE "voltage"
define TYPE_CURRENT "current"

// tipos de unidades
define UNIT_DIGITAL "d"
define UNIT_VOLTS "v"
define UNIT_AMP "a"

// El pin e datos está conectado al puerto 2 del ESP8622
define ONE_WIRE_BUS 2

// Configurar una instancia de OneWire para comunicarse con cualquier dispositivo OneWire (no solo IC de temperatura Maxim / Dallas)
OneWire oneWire(ONE_WIRE_BUS);

// Pasar la referencia oneWire al sensor de temperatura.
DallasTemperature sensors(&oneWire);
define PLUG 5
define pirPin 4

//variables
int timer_flag = 0;
int timer_time = 120;
int pir_flag = 0;
long timer_millis = 0;
int calibrationTime = 30;
long unsigned int lowIn;
long unsigned int pause = 60000;
boolean lockLow = true;
boolean takeLowTime;
int PIRValue = 0;
unsigned long lastMillis = 0;
int mVperAmp = 185; // usar 100 para el modulo de 20A y 66 para el módulo
int RawValue= 0;
int ACSoffset = 500; //solo para el modulo esp8266
double Voltage = 0;
double current = 0;
float temp = 0;

// Información de la red WiFi que debe personalizarse con lso datos de su red.
const char ssid[] = "xxxxxxxx";
const char wifiPassword[] = "xxxxxxxxx";

// información de autentificación Cayenne que deben obtenerse desde el tablero de Cayenne.
const char username[] = "xxxxxxxxxxxxxxxxxxxxxx";
const char password[] = "xxxxxxxxxxxxxxxxxxxxxx";
const char clientID[] = "xxxxxxxxxxxxxxxxxxxxxx";

void setup() {
Serial.begin(9600);
pinMode(PLUG, OUTPUT);
pinMode(pirPin, INPUT);

//configurar cayenne
Cayenne.begin(username, password, clientID, ssid, wifiPassword);

// Poner en marcha la biblioteca de sensores de temperatura
sensors.begin();

// iniciar wemo library
wemoManager.begin();

// Formato: Alexa invocation name, local port no, on callback, off callback
light = new WemoSwitch("Smart Plug", 80, plugOn, plugOff);
wemoManager.addDevice(*light);
delay(100);
digitalWrite(PLUG, LOW);
}





void loop() //aquí comienza el bucle infinito de lecturas y envios
{
Cayenne.loop();
wemoManager.serverLoop();
if(timer_flag){
check_time();
}
if(pir_flag)
{
PIRSensor();
}
read_temperature();
int voltage = 220; // definir voltaje standard
read_current();
float energy = 0.7 * voltage * current * millis()/(1000 * 60);
//en kWh, asumiendo un factor de potencia de 0.7

if (millis() - lastMillis > 10000)
{
lastMillis = millis();

// Enviar datos a Cayenne desde aquí.
//Este ejemplo simplemente envía el tiempo de actividad actual en milisegundos.

Cayenne.virtualWrite(1, voltage, TYPE_VOLTAGE, UNIT_VOLTS);
Cayenne.virtualWrite(2, current, TYPE_CURRENT, UNIT_AMP);
Cayenne.virtualWrite(3, temp, TYPE_TEMPERATURE, UNIT_CELSIUS);
Cayenne.virtualWrite(4, energy, TYPE_ENERGY, UNIT_KW_PER_H);
}

}


CAYENNE_IN(5)
// recepción de datos del canal 5 (encendido / apagado)
{
int value = getValue.asInt(); //aceptar y convertir valor a entero
Serial.println(value);
digitalWrite(PLUG, value); //cambiar el estado de
Cayenne.virtualWrite(7, value, TYPE_DIGITAL_SENSOR, UNIT_DIGITAL);
}



CAYENNE_IN(6)
// recepción de datos del canal 6 (encendido / apagado)
{
int value = getValue.asInt(); //aceptar y convertir valor a entero
Serial.println(value);
timer_time = value;
}


CAYENNE_IN(8)
//Datos recibidos desde el canal 6 de proximidad on / off
{
int value = getValue.asInt(); //accept and convert value to Int
Serial.println(value);
pir_flag = value;
}
CAYENNE_IN(10)

// recepción de datos del temporizador de activación / desactivación del canal 6
{
int value = getValue.asInt();// aceptar y convertir valor a Int
 Serial.println(value);
timer_flag = value;
timer_millis = millis();
}

// Función predeterminada para procesar comandos del actuador desde el Tablero de Cayenne.
//También puede usar funciones para canales específicos, por ejemplo, CAYENNE_IN (1) para los comandos del canal 1.



CAYENNE_IN_DEFAULT()
{
CAYENNE_LOG("CAYENNE_IN_DEFAULT(%u) - %s, %s", request.channel, getValue.getId(), getValue.asString());
//Procesar mensaje aquí. Si hay un error, establezca un mensaje de error utilizando getValue.setError (),
//por ejemplo, getValue.setError ("Mensaje de error")
;
}

void read_temperature(){
// llamada a sensores.requestTemperaturas () para emitir una temperatura global // solicitud a todos los dispositivos en el bus
Serial.print("Recuperando temperaturas…");
sensors.requestTemperatures(); // Envía el comando para obtener temperaturas.
Serial.println("HECHO");
// Después de que tengamos las temperaturas, podemos imprimirlas aquí. // Usamos la función ByIndex, y como ejemplo obtenemos la temperatura solo del primer sensor.
Serial.print("Temperatura para el dispositivo 1 (indice 0) es: ");
temp = sensors.getTempCByIndex(0);
Serial.println(temp);
}


void read_current()
{
//1000 lecturas analógicas para promediar
for(int i = 0; i < 1000; i++)
{
RawValue = RawValue + analogRead(A0); // agregar cada lectura A / D a un total
}
Voltage = ((RawValue / 1000) / 1023.0) * 1000;
// Gets you mV, max is 1000mV
current = ((Voltage - ACSoffset) / mVperAmp);
}

void check_time()
{
if(((millis()-timer_millis)/60000) > timer_time)
{
digitalWrite(PLUG, !digitalRead(PLUG));
Cayenne.virtualWrite(7, !digitalRead(PLUG), TYPE_DIGITAL_SENSOR, UNIT_DIGITAL);
timer_flag = 0;
}
}


void PIRSensor()
{
if(digitalRead(pirPin) == HIGH)
{
if(lockLow)
{
PIRValue = 1;
lockLow = false;
Serial.println("Movimiento detectado.");
digitalWrite(PLUG, HIGH);
Cayenne.virtualWrite(7, 1, TYPE_DIGITAL_SENSOR, UNIT_DIGITAL);
delay(50);
}
takeLowTime = true;
}
if(digitalRead(pirPin) == LOW) {
if(takeLowTime){
lowIn = millis();takeLowTime = false;
}
if(!lockLow && millis() - lowIn > pause) {
PIRValue = 0;
lockLow = true;
Serial.println("Movimiento terminado.");
digitalWrite(PLUG, LOW);
Cayenne.virtualWrite(7, 0, TYPE_DIGITAL_SENSOR, UNIT_DIGITAL);
delay(50);
}
}
}

void plugOn()
{
Serial.print("Conmutar 1 a encendido …");
digitalWrite(PLUG, HIGH);
Cayenne.virtualWrite(7, 1, TYPE_DIGITAL_SENSOR, UNIT_DIGITAL);
}

void plugOff()
{
Serial.print("Conmutar 1 a apagado …");
digitalWrite(PLUG, LOW);
Cayenne.virtualWrite(7, 0, TYPE_DIGITAL_SENSOR, UNIT_DIGITAL);
}

En el siguiente vídeo podemos ver el resultado de este interesante proyecto

 

 

 

 

 

Fuente https://www.instructables.com/id/Smart-Plug/

Proyecto de navidad: construya un piano con teclas de frutas


No espere poder realizar una sonata para piano de Beethoven en este proyecto , pero  hoy vamos a cambiar de registro  en cuanto los contenidos que compartimos en este blog ,   enfocándonos en  un proyecto  muy sencillo  pensado sobre  para que los mas pequeños aprendan electrónica  y programación de un modo divertido   usando la excusa   del  las frutas para activar 8 notas  ¡y, no se preocupe si no tiene plátanos en este momento también  debería funcionar con cualquier fruta o verdura !.


El fundamento del circuito es a realmente  sencillo  pues basta  conectar a  cada fruta con una resistencia de 2,2 Mohmios ( o similar ) a una entrada analógica diferente y usar una referencia de GND como polo común    y con esto ya tenemos  junto con cualquier Arduino los fundamentos para hacer el piano frutal pues la electricidad  fluyera cuando toquemos la fruta para cerrar el circuito y, cuando lo haga, lo leeremos desde  una  Placa Arduino  pudiendo desencadenar un evento  que en este caso, sera  reproducir una nota  que sacáramos por un pin digital

Es decir cuando , usando un  pin digital de  Arduino configurado como entrada, si lo conectamos  a  un objeto con cierta resistencia , esto hará que la resistencia entre esta  y masa se desplace hacia GND (es decir a 0 V) porque el circuito está completo , el programa  leerá ese valor binario ( es decir un cero lógico)  y este evento provocara   que  Arduino reproduzca  una nota.

Para hacer el piano  de frutas  necesitará:

  • Una placa Arduino, puede usar Arduino  UNO pero también puede usar cualquier placa compatible  procedente del mercado oriental .
  • Ocho  resistencias de alto valor  de  2,2 Mega ohmios, aunque  debería funcionar con cualquier valor  entre 1 Mega-ohmios  y 10 Mega-ohmios . Si no tiene  estos valores también puede asociar varias en serie o en paralelo  hasta obtener  valores parecidos (al usar 8 entradas al menos necesitaremos pues 8 resistencias)
  • Una resistencia de 220 ohmios para no proteger  el altavoz ,( si es un altavoz de 1W  o mas puede  prescindir de esta).
  • Un altavoz de 8 ohmios.
  •  Idealmente una placa de prueba para  conectar fácilmente los cables y las resistencias al Arduino.
  • Cables rígidos  para las conexiones.
  • !Su fruta o verdura favorita!( cuanto mas agua tenga mejores resultados obtendremos)

En cuanto al circuito , vamos a usar un Arduino Uno  configurando los pines digitales 2,3,4,5,6,7 y 8, como entradas digitales  y el pin digital 12 como salida digital.  También se puede usar cualquier placa compatible  con Arduino  procedente del mercado oriental y por supuesto también   una placa  Netduino en  todas sus variantes ( tendra que adaptar el sw)

El circuito es  muy sencillo  pues  consintiendo básicamente   en   8  entradas      y una   salida.   A las entradas digitales conectaremos 8  resistencias de pull-up de 2,2 Meg Ohm entres estas y VCC(+5V), conexión esta ultima que obtendremos directamente de la propia placa de Arduino. Como se puede deducir,  estas  entradas digitales se conectan   a  una fruta  clavando el hilo en esta . Cuando tocamos esta  fruta ,al estar conectada  a  una entrada de Arduino , llevaremos  a nivel lógico BAJO etas   al conectar  a tierra cada fruta  que a su vez esta  conectada a cada entrada digital.

El circuito se complementa con una resistencia de  220 ohmios, conectada desde el pin 12 a un altavoz de 8 ohmios. Esta resistencia perfectamente se puede suprimir si conecta directamente un altavoz  y no un amplificador   

En cuanto al sketh o programa para nuestro Arduino vamos a usar el ejemplo de E.Ballew escrito en Junio de 2018 que toma prestados  las librerías de tono de Tom Igoe (puede ver mas  ejemplos  en http://arduino.cc/en/Tutorial/Tone ) utilizando  sus archivos pitches.h  con una  clausula  include     para las frecuencias de las notas.

Este código implementa una sola octava de un piano simple, es decir solo reproduce  8 sonidos diferentes .

En primer lugar en el bloque Setup  se definen los pines de entradas digitales  asi como sus correspondientes notas para lo cual se define una matriz  unidimensional llamada  digInput   

int digInput[] = { 2, 3, 4, 5, 6, 7, 8, 9 };

También se define  cual va a ser el pin digital que va a usarse como salida  para conectar el altavoz ( el pin 12)

int toneOut = 12;

Definida el array  de los pines digitales  que usaremos como entrada digital  y la variable para el pin digital de salida    simplemente  toca asignar esta como entradas   mediante la clausula  pinMode(xx INPUT )  recorriendo el array  con un  bucle for  . También para  terminar definiremos  la salida  con la clausula pinMode(yy, OUTPUT);  resultando el siguiente código:

void setup() { ;

 for (int i = 0; i < numKeys; i++)

{ pinMode(digInput[i], INPUT);

}

pinMode(toneOut, OUTPUT); }


En cuanto al   bucle principal  leemos  mediante bucle el estado de las 8 teclas de frutas mediante la instrucción sensorVal = digitalRead(digInput[j])    ,  de modo   que si detectamos un nivel bajo   reproducimos la nota asociadas a  esa tecla  mediante la instrucción  tone(toneOut, myNote[j]); 

Asimismo  debemos  evitar  falso sonidos  para lo cual  incrementaremos la variable kepressed ,que inicializamos a cero en cada pasada del bucle para  silenciar el altavoz en cuanto sepamos que no se ha pulsado ninguna fruta  

int keypressed = 0;

……

if (sensorVal == LOW)

{ ++keypressed;

// increment keypressed

digitalWrite(13, HIGH);

tone(toneOut, myNote[j]);

}

if (keypressed == 0) { noTone(toneOut); }


También  a  efectos de depuración   realizamos un retardo entre cada interacción de 250ms  mediante la clausula  delay(250);

Al  bucle principal  ademas   efectos de depuración se añade una salida a de monitor en serie (que deberemos configurar  a 9600  baudios   )  , para probar los 8 niveles lógicos correspondientes   a las 8 entradas binarias .


El código final resultante  de  todas las consideraciones anteriores es el siguiente:

#include "pitches.h"

int numKeys = 8;
int digInput[] = { 2, 3, 4, 5, 6, 7, 8, 9 };
int myNote[] = { NOTE_C4, NOTE_D4, NOTE_E4, NOTE_F4, NOTE_G4, NOTE_A4, NOTE_B4, NOTE_C5 };
int toneOut = 12;

void setup() {
  // arrnacar conexion serie
  Serial.begin(9600);
  // Configurar  pines  digitales como entrada 
  for (int i = 0; i < numKeys; i++) {
    pinMode(digInput[i], INPUT);
  }
  pinMode(toneOut, OUTPUT);
}

void loop() {
  
  int keypressed = 0;
  for (int j = 0; j < numKeys; j++) {
    int sensorVal = digitalRead(digInput[j]);
    String outStr = String("K");
      outStr = String(outStr + j);
      outStr = String(outStr + ": ");
      outStr = String(outStr + sensorVal);
    if (sensorVal == LOW) {
      ++keypressed;  // incrementar keypressed
      digitalWrite(13, HIGH);
      tone(toneOut, myNote[j]);
    }
    //outStr = String(outStr + ":");
    //outStr = String(outStr + keypressed);
    Serial.print(outStr);
    Serial.print("\t");
  }
  Serial.println("");
  if (keypressed == 0) {
    noTone(toneOut);
  }
  delay(250);
}






Fichero pitches.h

/*************************************************
* Public Constants
*************************************************/


#define NOTE_C4 262

#define NOTE_D4 294

#define NOTE_E4 330
#define NOTE_F4 349

#define NOTE_G4 392

#define NOTE_A4 440

#define NOTE_B4 494
#define NOTE_C5 523

Obviamente una vez hayamos depurado el circuito no necesitamos la salida por consola del estado de las entrada binarias , por lo que el programa puede quedar reducido las
siguientes lineas:


#include “pitches.h”

int numKeys = 8;
int digInput[] = { 2, 3, 4, 5, 6, 7, 8, 9 };
int myNote[] = { NOTE_C4, NOTE_D4, NOTE_E4, NOTE_F4, NOTE_G4, NOTE_A4, NOTE_B4, NOTE_C5 };
int toneOut = 12;

void setup() {
for (int i = 0; i < numKeys; i++) {
pinMode(digInput[i], INPUT);
}
pinMode(toneOut, OUTPUT);
}

void loop() {
int keypressed = 0;
for (int j = 0; j < numKeys; j++) {
int sensorVal = digitalRead(digInput[j]);
if (sensorVal == LOW) {
++keypressed; 
digitalWrite(13, HIGH);
tone(toneOut, myNote[j]);
}
}
if (keypressed == 0) {
noTone(toneOut);
}
delay(250);
}









Por cierto el concepto , aunque sirve para emular un mini órgano también puede servir para emular un miniteclado , un pulsador especial , o cualquir cosa que ncesiste ser activado mediante algo diferente

Como convertir una impresora 3D en una impresora Wifi


Geeetech es un fabricante chino fundada  en 2011, y que se ha dedicado a la I + D integrada, la producción y la distribución de EDB (placas de desarrollo integrada), MCU, así como a hardware de código abierto, destacando por sus desarrollos en impresión 3d. De hecho son una de las compañías más grandes de impresoras 3D en China, ya que han producido más de 100,000 impresoras, siendo ademas de las pocas compañías de impresoras 3D de código abierto en China.

Precisamente  dada su trayectoria no podían olvidar el desarrollo de un modulo que ofrezca  conectividad inalámbrica con el único objetivo de permitir que todos los aficionados a la impresión en 3D puedan controlar su impresora de forma inalámbrica. 

Dicho modulo inalámbrico   llamado 3D WiFi es ampliamente compatible con muchos tipos diferentes de impresoras 3D en el mercado: el único requisito es que el chip conversor de  USB a serie de su impresora pertenezca a uno de estos tres :CH340, FT232 y PL2303   y esté controlado por las instrucciones G.code, así que si cumple esto  dicho o Módulo 3D WiFi puede actualizar su máquina como Wi-Fi habilitada y hacerla comparable a otras impresoras 3D conectadas Wi-Fi prohibitivamente caras.

3D-wifi 10.jpg

El módulo  3D WiFi compone principalmente de dos partes: placa de control y módulo Wi-Fi  siendo de tamaño muy pequeño ( mas o menos como una caja de cerillas)  pero  lo suficientemente potente como para conectar su impresora 3D con el servidor en la nube de Geeetech, para  controla un dispositivo desde la aplicación EasyPrint 3D sin mas configuraciones dado que el módulo de WiFi en 3D está listo para usar de inmediato: solo necesita conectar su impresora 3D al puerto USB del este dispositivo y finalizar las configuraciones simples por medio de  la aplicación para Android EasyPrint 3D y a partir de ahí  ya puede  comenzar a controlar su impresora de forma inalámbrica.

 A través de la aplicación EasyPrint 3D, es extremadamente simple y conveniente controlar directamente su impresora en cualquier lugar y en cualquier momento pues solo necesitara conectar su impresora 3D al puerto USB del módulo 3D WiFi , completar configuraciones sencillas en la aplicación 3D EasyPrint ( que vamos a ver )  y ya luego puede controlar su dispositivo inalámbrico y comenzar a imprimir  .Además, se da a acceso a una gran galería en la nube( al estilo thinginverse ) , que cubre 9 categorías de modelos 3D para imprimir desde hobby, hogar, moda, arte a gadgets, herramientas, juguetes, educación y piezas de impresión en 3D. 

También se puede grabar y compartir  diseños desde  la aplicación EasyPrint 3D en segundos .

Quizás una de las facilidades mas interesantes es la de control remoto  su impresora 3d en tiempo real. Incluso puede configurar los parámetros de impresión relevantes y recibir notificaciones instantáneas durante su trabajo de impresión.

Ademas de ser compatible  3D WiFi  con todas las impresoras de Geetech, se ha probado con la siguientes impresoras:

Creality-CR-10.jpg
Anycubic-I3-Mega.jpg
Anet-A8.jpg
Monoprice2.jpg
Monoprice1.jpg


El módulo 3D WiFi   también es compatible con impresoras 3d controladas por las siguientes placas:

Arduino-Mega-R3.jpg
Iduino-Mega-R3.jpg
Rumba.jpg.

Carastericticas del 3D WiFi  

  • Alimentación: 5V DC
  • Corriente de trabajo: 150mA (en promedio), 500mA (pico)
  • USB 2.0 de velocidad completa
  • Soporte de tarjeta TF: SDSC, SDHC (<32G); CLASS2, CLASS4
  • WIFIFrecuencia: 2.4G ~ 2.5G (2400M ~ 2483.5M)
  • Potencia de transmisión: 802.11b: + 20 dBm / 802.11g: +17 dBm / 802.11n: +14 dBm
  • Sensibilidad de recepción: 802.11b: -91 dBm (11 Mbps) / 802.11g: -75 dBm (54 Mbps) / 802.11n: -72 dBm (MCS7)
  • Antena: antena PCB a bordo
  • Modo Wi-Fi: Estación / SoftAP 
  • Estándar WLAN: 802.11 b / g / n /
  • Mecanismo de seguridad: WPA / WPA2
  • Tipo de cifrado: WEP / TKIP / AES
  • Protocolo de red: IPv4 、 TCP / UDP / HTTP / FTP / MQTT
  • Tamaño: 49.37 * 25.87 * 16.5mm
  • Tamaño de empaquetado: 52.44 * 28.94 * 17 mm

 

Aplicación EasyPrint 3D

EasyPrint 3D se desarrolló como una aplicación de impresión 3D, estando orientada tanto para principiantes en impresión 3D como para profesionales experimentados, con el objetivo de llevar la tecnología de impresión 3D a nuestra vida diaria. Usa  un interfaz de usuario simple y elegante  proporcionando un flujo de operación fácil y una experiencia de usuario receptiva.

EasyPrint 3D viene con cuatro características principales:

  • Monitorizacion en tiempo real: con EasyPrint 3D, un colaborador considerado, le resultará conveniente monitorear el estado de su impresora y el progreso de la impresión en tiempo real cuando está ocupado completando su trabajo, haciendo footing, comprando o visitando amigos.
  • Control remoto: al conectar su impresora con EasyPrint 3D, puede dirigir el control remoto sobre el proceso general de impresión. Le permite elegir un modelo 3D favorito de la tarjeta SD y la galería de aplicaciones en la nube. Solo unos pocos clics en su teléfono para configurar su máquina, obtener una vista previa del archivo de modelo, calibrar y nivelar su impresora, modificar la temperatura de la extrusora y el semillero y la velocidad de impresión, y comenzar a imprimir. Durante la impresión, recibirá de inmediato una notificación cuando se corte la energía. En este caso emergente, la impresora se detendrá y guardará el estado de impresión en tiempo real de inmediato. Cuando encienda la impresora la próxima vez, aparecerá un mensaje emergente para que usted elija reanudar la impresión anterior o iniciar una nueva.
  • Cloud slicer: esta característica le permite transformar archivos .stl en comandos g.code en su palma de la mano. Eficiente y conveniente.
  • Una galería en la nube de modelos en 3D: esta galería en la nube cubre 9 categorías de modelos 3D GRATIS, que incluyen arte, moda, hogar, pasatiempos, educación, partes de impresoras 3D, dispositivos, juguetes y herramientas. El desarrollo de una galería de nubes de este tipo surge de nuestra idea: compartir y desarrollar. En la próxima versión, puede tener acceso a un gran volumen de modelos 3D gratuitos compartidos por aficionados a la impresión en 3D de todo el mundo.

Veamos a continuación los pasos para configurar el modulo 3D WiFi :

  • Descargue la aplicación EasyPrint 3D aquí e instálela siguiendo las instrucciones o también puede descargar la aplicación EasyPrint 3D en Google Play y App Store.
  • Abra la aplicación EasyPrint 3D. Haga clic en el botón [Iniciar sesión] en la interfaz [Me] para finalizar su registro.
Inicia sesión.jpg
  •  Para principiantes, haga clic en [Cuenta] para registrarse. Ingrese su propia información de cuenta.(Nota: no hay espacio en el nombre de usuario. Para usuarios extranjeros, seleccione “Inglés” para la dirección de su servidor).
15 register.jpg   16 register.jpg  17 register.jpg
  •  Haga clic en [Registrarse ahora] y aparecerá una interfaz emergente para que revise su correo electrónico.
20 register.jpg
  •  Haga clic en OK y revise su correo electrónico.
  •  Inicie sesión con la información de su cuenta.

Enlazar la impresora 3D a la aplicación EasyPrint 3D

  • Inicie sesión y enlace la impresora. En [Me] – [Mi impresora 3D], finalice el proceso de encuadernación siguiendo las instrucciones de la aplicación.
  •  Haga clic en [Mi impresora 3D].
13 Me.jpg
  • Haz clic en el botón “Comenzar para enlazar”.
21 empezar a bind.jpg
  • Haga clic en el botón en la imagen de abajo para ingresar el número de serie manualmente.
Image021.jpg   22 número de serie.jpg
  • Haga clic en “Siguiente” y aparecerá la siguiente imagen para informarle que el proceso de encuadernación es exitoso.
Image024.jpg
  • Luego verá la siguiente interfaz, que muestra que la impresora está fuera de línea.
Imagen026.jpg
  • !Ese es todo el proceso de unión.! 

En el siguiente punto, terminaremos las configuraciones de Wi-Fi paso a paso.

Configuración de Wi-Fi

Los procedimientos de configuración detallados son los siguientes:

  •  Conecte su impresora 3D al puerto USB del módulo WiFi 3D con su cable USB para la transmisión de datos. Use el cable de alimentación para conectar el módulo WiFi 3D con su adaptador para encenderlo.
33 (1) .png
  • Compruebe si los tres indicadores luminosos están encendidos: Wi-Fi, USB, fuente de alimentación de izquierda a derecha en orden. Inserte la tarjeta TF en la ranura.
11- (1) .png
  •  Presione prolongadamente el orificio etiquetado con “establecer” con un alfiler, hasta que la luz de Wi-Fi se apague y parpadee rápidamente. Afloje el pin y el Wi-Fi 3D entrará en el modo de configuración. Nota: Si no afloja el pin, la luz parpadeará lentamente para entrar en el modo de reinicio.
  • Abra la aplicación EasyPrint 3D y haga clic en “Imprimir”. En la página de la ventana emergente, haga clic en el ícono “Wi-Fi” para ingresar al modo de configuración de Wi-Fi, como se muestra en la imagen a continuación.
Image032.jpg Image034.jpg Imagen036.png
  • Haga clic en [Siguiente] para comenzar a detectar el Wi-Fi integrado en la impresora. Si se detecta la conexión Wi-Fi, podría ver la siguiente imagen.
Imagen038.png
  • Si no se detecta, aparecerá un mensaje emergente “La impresora no se detectó Wi-Fi”. Haga clic en [Aceptar] y nuevamente haga clic en [Siguiente] para volver a detectar.
Imagen040.jpg
  •  Después de detectar el Wi-Fi integrado en la impresora, haga clic en [Siguiente] y elija un punto de acceso Wi-Fi, como se muestra en la imagen a continuación.
  • Haz clic en [Siguiente]. Si el punto de acceso Wi-Fi necesita una contraseña, la interfaz mostrará el cuadro de entrada de la contraseña de Wi-Fi.Simplemente ingrese la contraseña correcta y luego haga clic en [OK], como se muestra en la imagen a continuación. (si no es necesario ingresar la contraseña, continúe con el siguiente paso).
Image044.png

 

  • Cuando logre conectar la red Wi-Fi, la interfaz mostrará que la configuración ha finalizado. Haga clic en [Aceptar] y la interfaz mostrará que la impresora está en línea.
Imagen046.png Image048.jpg


Hasta aquí, la configuración entre la aplicación y su impresora ha finalizado. Ahora puede imprimir y controlar la impresión a través de la aplicación EasyPrint 3D.

  •  Haga clic en [Siguiente] para comenzar a detectar el Wi-Fi integrado en la impresora. Si se detecta la conexión Wi-Fi, podría ver la interfaz de “Configuración” en su teléfono.
Imagen036.png Image051.png
  • Haga clic en el botón de Wi-Fi para conectar la zona activa “Geeetech-Printer”, como se muestra en la imagen.
Image053.png
  • Haga clic en el botón [Siguiente] en la imagen de abajo.
Image055.png
  •  Ingrese el nombre WLAN y la contraseña de su router. Haga clic en [Aceptar] para conectar su Wi-Fi.
Image057.png
  • Cuando logre conectar el Wi-Fi, la interfaz mostrará que la configuración ha finalizado, como se muestra en la imagen a continuación.
Imagen046.png
  • Haga clic en [Aceptar] y la interfaz mostrará que la impresora está en línea.
Image048.jpg


Hasta aquí, la configuración entre la aplicación y su impresora , de modo  que ya ha finalizado todos los ajustes oportunos. Ahora puede imprimir y controlar la impresión 3d con el modulo  3D WiFi  a través de la aplicación EasyPrint 3D.

 

Resumiendo en el siguiente vídeo podemos ver  todos los pasos de configuración de este modulo 3D WiFi    con la  aplicación easyprint3d: