Manufactura industrial
Internet industrial de las cosas | Materiales industriales | Mantenimiento y reparación de equipos | Programación industrial |
home  MfgRobots >> Manufactura industrial >  >> Manufacturing Technology >> Proceso de manufactura

SMART CUBE:Una nueva forma de controlar su hogar

Componentes y suministros

Arduino 101
× 1
LED (genérico)
1 azul - 1 amarillo - 1 verde - 2 rojo
× 5
Resistencia de 221 ohmios
× 5
Breadboard (genérico)
No obligatorio
× 1
Seeed Base Shield V2
× 1
Luz de fondo RGB LCD Seeed Grove
× 1
Sensor de sonido Seeed Grove
× 1
Seeed Grove Buzzer
× 1
Sensor de temperatura Seeed Grove
× 1
Teclado
× 1
Cables de puente (genéricos)
× 1
batería de 9V (genérica)
× 1
Clip de batería de 9V
× 1
Fibra de densidad media (MDF) 20x30 cm
MDF de 3 mm u otro material para corte con láser
× 1

Herramientas y máquinas necesarias

Cortadora láser (genérica)
Soldador (genérico)

Aplicaciones y servicios en línea

Arduino IDE
Nordic Semiconductor nRF Connect SDK
No obligatorio

Acerca de este proyecto

¿Qué es SMART CUBE?

Smart Cube es un controlador para sus dispositivos Smart Home.

Hoy en día gestionar de forma más inteligente todos los dispositivos de nuestros hogares se está convirtiendo en una exigencia . Necesitamos algo simple e intuitivo usar. Smart Cube podría ser una solución:es un dispositivo portátil que contiene un Arduino 101 placa y algunos sensores que se comunican con los electrodomésticos y los actuadores de su Smart Home.

La innovación de este control remoto está relacionada con la innovación de la placa Arduino 101. Utiliza Bluetooth (BLE) para controlar las luces, la temperatura y su televisor y también puede sincronizarlo con su teléfono inteligente . Pero la principal innovación es la forma en que interactúas con Smart Cube con su gesto usando el giroscopio y el acelerómetro. El cubo tiene 6 caras y cada una controla una función particular . La función que quieres utilizar se detecta gracias al giroscopio que reconoce la cara superior. Por ejemplo, puedes abrir las luces de la habitación en la que te encuentras simplemente colocando el cubo con la "cara clara" en la posición superior . Si desea apagar la luz, solo necesita agitar el cubo.

Si una cara está ARRIBA y no se mueve por más de 2 segundos se activa la función relacionada. Este retraso está hecho para que puedas tener tiempo para rotar e interactuar con el cubo para encontrar la cara que necesitas sin activar accidentalmente otras funciones. Cuando agita el cubo durante más de 2 segundos, se cierra la última función activada.

Este proyecto tiene como objetivo ayudarlo a construir un controlador inteligente . Este dispositivo necesita un receptor (centralina inteligente en la imagen) que interpreta los datos y administrar las funciones de tu casa inteligente. La salida principal del cubo es una señal BLE que podría usarse de muchas maneras:por ejemplo, puede conectar el cubo con una aplicación de teléfono inteligente (o haz el tuyo propio), o puedes construir una estación con otro Arduino que recopilan los datos BLE y controlan directamente los electrodomésticos de su hogar. Debido a la variedad de casos, esta parte depende de su exigencia. En esta guía veremos cómo construir un cubo inteligente y aprenderá a personalizarlo.

Funciones:

La estructura del código es fácil de personalizar . (analizamos el código más adelante) para que pueda decidir qué funciones controlar. Estas son las funciones que decidí controlar:

LUCES :Esta cara en UP posición abre las luces de la habitación en la que te encuentras. Si sacudes el cubo, las luces se apagan y un led amarillo en esta cara se activa para que puedas encontrar el cubo en la oscuridad. La comunicación con sus lámparas está hecho por el BLE del tablero 101.

TEMPERATURA :Esta cara ARRIBA activar (a través de BLE) el aire acondicionado si hace calor o la calefacción si hace frío. Detecta la temperatura mediante un sensor térmico y abra un led azul si el acondicionador está encendido (copos de nieve) o un rojo uno si la calefacción está activada (sol).

TEMPORIZADOR :Esta cara ARRIBA inicie un temporizador que pueda ver en la pantalla LCD. Hay un timbre que funciona como alarma cuando termine la cuenta atrás. Si agita, detiene el temporizador y puede ver el tiempo restante. Cuando finaliza la cuenta atrás, el color de la pantalla LCD cambia de azul a rojo y el zumbador emite tres sonidos.

TV :Esta cara ARRIBA abre el televisor. El cubo se convierte en un control remoto para tu TV. Hay un panel de botones con números que se activa solo si esta cara está ARRIBA para evitar toques accidentales. El número que presiona se envía a través de BLE al controlador central que está conectado a su televisor. Sacudiendo el cubo cierras el televisor.

SONIDO :Esta cara ARRIBA activar un led cuyo brillo se basa en el nivel de ruido de la habitación. El ruido se detecta gracias a un sensor de sonido. Si agitas el cubo cierras esta función. (Si lo desea, puede activar su función personal aplaudiendo).

DESACTIVADO cara:si no sacudes el cubo, esta cara es como una posición neutral en el que nada cambia. Si desea cerrar todo coloque el cubo con el APAGADO hacia ARRIBA y agítelo. Este gesto es como el botón de inicio de su teléfono inteligente que presiona si desea salir rápidamente. Hay un led rojo para que puedas encontrar el cubo si está oscuro.

Diferencias con el concepto:

El plan original era utilizar también comunicación por infrarrojos para conectar su televisor directamente al cubo. Debido a que Arduino 101 no es compatible (por ahora) con la biblioteca que administra las señales de infrarrojos, decidí enviar la información a través de BLE a una estación que pueda administrar esta biblioteca (como Arduino UNO). Debido a este problema, eliminé la función de radio (muy similar a la carátula del televisor), reemplazándola por una carátula con sensor de sonido. Esta cara podría usarse para reconocer un ruido fuerte (como aplausos) para activar algo. El mayor cambio está en el material del cubo. Inicialmente pensé en construirlo con una impresora 3D pero luego decidí usar una cortadora láser . De esta forma es más fácil sustituir una cara si desea cambiar una función. Por ejemplo, puede quitar la carátula del temporizador y cambiarla por una carátula que llene automáticamente el cuenco de su gato. Ser modular ¡no necesitas reconstruir toda la estructura!

Vamos a construirlo:

Siga estas instrucciones para construir su propio cubo inteligente. Empezaremos por el hardware , ensamblando la electrónica componentes primero y luego el cuerpo cortado con láser del cubo hecho de MDF. Después de esta operación, explicaré cómo funciona el código y cómo puede personalizarlo . Una vez que haya cargado el código en su Arduino 101, puede descargar la aplicación para ver la salida BLE del cubo o conectarlo directamente con su hogar inteligente.

Hardware - electrónica:

Comencemos con tu Arduino 101. Este es el fritzing esquema a seguir:

Monte el escudo base Grove en su tablero y comience con las conexiones.

Teclado :tienes que conectar los cables en orden a los pines:10, 8, 7, 6, 5, 4, 2.

Conexiones de LED :

Antes que nada tenemos que preparar los leds:

- conecte la pata larga del led (ánodo) a una resistencia de 220 ohmios y luego a un cable rojo (este es el cable para conectar al pin)

- conecte la pata corta (cátodo) a un cable blanco (este irá a la tierra)

- soldar las piezas y cubrirlas con cinta aislante

- conecte todos los cables blancos a un solo cable blanco (este irá a la tierra) y suéltelos todos juntos

Ahora conecte los cables rojos a su Arduino:el LED VERDE al pin 9, el LED AMARILLO al pin 11, el LED ROJO al pin 12, el LED AZUL al pin 13 y el último ROJO al pin A2.

Sensores Grove :

Conecte los sensores de la arboleda al blindaje (vea el esquema en los accesorios).

Zumbador a D3, LCD RGB a I2C, sensor de temperatura a A0, sensor de sonido a A1.

Ok, ahora hemos conectado todos los eléctricos partes. Ahora necesitas el estuche .

Hardware - caja

Puedes descargar el boceto del cubo para cortar con láser. Las líneas rojas en el boceto son los símbolos de las caras, solo grabar ellos. Las líneas negras deben cortar. La dimensión interna del cubo es 9 cm . El boceto está bien si usa un material de 3 mm , si usa un grosor diferente, debe modificarlo (puede usar este sitio web:http://www.makercase.com/).

El material que elijo es MDF (Fibra de densidad media) pero puede usar lo que quiera.

Aquí hay algunas imágenes del corte con láser :

Ahora tenemos que ensamblarlo .

Yo pegado unos trozos de cartulina para hacer espesores para el led. De esta forma estarán alineados con la superficie .

Ahora montamos el teclado . Insértelo en el orificio y retire la película adhesiva, luego vuelva a conectar los pasadores.

Ahora la LCD RGB . Esto encaja perfectamente en el agujero.

Preparemos el conector de la batería :

Corté un viejo enchufe de transformador y lo conecté a un clip de batería. De esta forma ahorramos espacio dentro de la caja.

En este punto, eso es lo que debería tener:

Ahora solo necesita conectar la batería , sube el código y cerrar el cubo !

SUGERENCIA:fije la placa y la batería con el estuche para que cuando agite el cubo estén estables.

Código

Puede encontrar el código en los archivos adjuntos . Súbela a tu placa con el Arduino IDE (recuerde actualizar su software para compatibilidad con Arduino 101).

He comentado casi todas las líneas del código para hacerlo más comprensible que pueda. No tenga miedo de las más de 500 líneas, la estructura no es tan complicada.

Al principio están las bibliotecas y todas las variables declaración .

En esta parte también está la definición de servicios BLE y característica . Usé Automation IO Servicio. Usé el Digital característica para luces y temperatura (esto usa 2 bits, por lo que 4 casos posibles para codificar) y el Analógico para TV (para enviar todos los códigos del teclado).

Luego, la configuración . Esta palmada se ejecuta solo una vez al principio. Aquí inicializamos los componentes como entradas o salidas e inicializamos el BLE y el giroscopio de la placa 101.

La parte principal es el bucle . . Está dividido en cuatro partes:

  • 1 La primera parte se copia del tutorial del sitio web de Arduino:(https://www.arduino.cc/en/Tutorial/Genuino101CurieIMUAccelerometerOrientation) esta parte se se ejecuta constantemente y devuelve la orientación del tablero.
  • 2 La segunda parte activamos una cara solo si está en la posición hacia arriba durante más de dos segundos . Usamos millis función para contar el tiempo. Cuando la posición cambia se memoriza el valor de milis y si la orientación permanece igual, luego de un intervalo (2 seg), ingresamos en una zona if donde la cara seleccionada se volvió verdadera (para la 4ta parte).
  • 3 La tercera parte se activa solo si el cubo está agitado con cierta intensidad y durante más de 2 segundos. El último activado la función facial está cerrada y el rostro se establece como falso . Si la cara es falsa no puede ingresar en la cuarta parte.
  • 4 La cuarta parte es solo para verdadero caras. Aquí está el núcleo de las funciones del cubo inteligente. En esta parte se ejecutan constantemente solo las caras que son verdaderas en bucle.

Puedes modificar la cara funciona con algunas modificaciones del código. La estructura principal debe ser como se describe. Puede cambiar la parte dentro de las condiciones if de cada rostro.

  if (face2 ==true) {// TEMPERATURA face // COMIENZA A CAMBIAR AQUÍ digitalWrite (LEDOFF, LOW); // si esta cara es verdadera, el LED de la cara APAGADA es BAJO if (central.connected () ==true) {// si el cubo está conectado BLE // lee el valor de temperatura int val =analogRead (pinTemp); // obtener el valor analógico resistencia =(float) (1023-val) * 10000 / val; // obtener temperatura de resistencia =1 / (log (resistencia / 10000) /B+1/298.15) -273.15; // calcular la temperatura // condiciones de activación if (temperature> tooHot) {// activar el aire acondicionado digitalWrite (LEDhot, LOW); // cerrar calefacción led digitalWrite (LEDcold, HIGH); // acondicionador de aire abierto led termoChar.setValue (1); // establece a través de BLE la condición 1 =frío encendido - caliente apagado} if (temperatura  tooCold &&temperature  

Tienes que codificar la parte "verdadera" (como en el código anterior) y también la parte "falsa" cuando se agita el cubo:

  // Desactivación de TEMPERATURA if (lastFUNCTION ==2) {// TEMPERATURE face // EMPEZAR A CAMBIAR AQUÍ // si una central está conectada al periférico:if (central.connected () ==true) {digitalWrite (LEDhot, BAJO); // temperatura de cierre led rojo digitalWrite (LEDcold, LOW); // temperatura de cierre led azul termoChar.setValue (0); // señal de temperatura BLE:0 =frío apagado - caliente apagado // FIN AQUÍ} Serial.println ("TEMPERATURA falso - CERRAR"); face2 =falso; // La cara de TEMPERATURA se volvió falsa}  

Recuerde establecer la cara como falsa cuando lo sacudes.

Aplicación:

Para ver las salidas del cubo BLE, puede descargar esta aplicación: nRF Connect

https://play.google.com/store/apps/details?id=no.nordicsemi.android.mcp&hl=it

Cuando lo abra, simplemente buscar para dispositivos y conectar con "smartcubesketch". Luego verá tres pestañas "Automation IO", haga clic en ellas y presione el recopilador de datos continuo.

Es importante conectar el cubo porque algunas funciones (luces, temperatura y tv) se ejecutan solo si el cubo está conectado.

Cómo funciona:VIDEO

Sube el código, inserta la batería, cierra la caja y ...

... ahora tienes un CUBO INTELIGENTE!

Hice un video para mostrarte todas las funciones del cubo y cómo usarlo.

Conclusiones

Este proyecto es solo el primer paso a una casa inteligente. Mi propósito era usar Arduino 101 potencialidad de la junta para crear algo nuevo . Creo que el acelerómetro y giroscopio dar a la junta nuevas oportunidades en términos de movilidad . Con el BLE, además de ser portátil, también es fácil de conectar .

Esta es la primera vez que realizo concretamente uno de mis proyectos (me refiero a un prototipo funcional). Ha sido duro y ha habido algunas dificultades durante la ruta, pero al final he aprendido mucho y estoy contento con el resultado. Espero que también todos los que lean esta guía puedan aprender algo de mi trabajo y también modificar este proyecto según sus necesidades . Lamento mi mal inglés, pero espero que las imágenes puedan ayudarte.

En el futuro de este proyecto espero crear la centraline que es como el puente entre el cubo inteligente y los actuadores (luces, temperatura, tv ...). Esta centralina recibirá la señal BLE del cubo y usará esta información para hacer cosas inteligentes en su hogar.

Estoy muy feliz de tener la oportunidad de usar Arduino 101 y el kit Grove (el kit es muy simple y rápido para la creación de prototipos).

Espero que usar el tablero de esta manera pueda ser una inspiración para su proyecto. Puedes personalizarlo como quieras : ¡Tengo curiosidad por ver qué funciones creará y en qué contexto diferente las usará!

Quizás esto no sea una revolución, pero es una nueva forma de interactuar con su hogar .

Espero que les guste este tutorial.

Ahora es tu turno :pon tus manos en el cubo y ¡piratea!

Código

  • CUBO INTELIGENTE:código completo con comentarios
SMART CUBE:código completo con comentarios Arduino
Este es el código para cargar en su Arduino 101. Puede usar este código tal cual o personalizarlo según sus necesidades. Siga los comentarios para entender cómo funciona.
 // Bibliotecas # incluyen "CurieIMU.h" // Acelerómetro y giroscopio # incluyen  // Bluetooth Low Energy # incluyen  #include "rgb_lcd .h "// LCD # incluye  // Keypadrgb_lcd lcd; // Inicialización de LCD // Inicialización de Bluetooth:BLEPeripheral blePeripheral; // Dispositivo periférico BLE (la placa que está programando) // BLE ServicesBLEService lightsService ("1815"); // BLE Automation IO (1815) - información de luces BLEService termoService ("1815"); // BLE Automation IO - información de temperaturaBLEService TVService ("1815"); // BLE Automation IO - información de tv // BLE featureBLEUnsignedCharCharacteristic lightsChar ("2A56", // BLE feature Digital (2A56) - lights BLERead | BLENotify); BLEUnsignedCharCharacteristic termoChar ("2A56", // BLE feature Digital - temperatura BLERead | BLENotify ); BLEUnsignedCharCharacteristic TVChar ("2A58", // BLE feature Analog (2A58) - tv BLERead | BLENotify); // Declaración de constantes y variables:// Funciones de orientación y movimiento de la cara:int lastOrientation =- 1; // orientación anterior (para comparación) unsigned long previousMillis =0; // la última vez que se actualizó el intervalo largo sin firmar =2000; // tiempo para esperar en posición arriba antes de la activación de la cara unsigned long SHAKEpreviousMillis =0; // última actualización sin firmar largo SHAKEinterval =2000; // tiempo de espera durante el temblor para la desactivación de la cara boolean keep =false; // esto se usa para contar solo una vez el cambio de orientación de la cara en lastFUNCTION =-1; // esto se usa para saber cuál es la orientación anterior // Iniciación de caras:al principio cada cara es falsa boolean face0 =false; boolean face1 =false; boolean face2 =false; boolean face3 =false; boolean face4 =false; boolean face5 =falso; // LUCES faceconst int LEDlights =11; // pin 11:led amarillo // TEMPERATURA faceconst int pinTemp =A0; // pin A0:sensor de temperaturaconst int LEDhot =12; // pin 12:ledconst rojo int LEDcold =13; // pin 13:temperatura del flotador del led azul; // memorización del valor de temperaturaint B =3975; // Valor B de la resistencia de flotación del termistor; // valor de resistencia memorizationfloat tooHot =26.0; // temperatura a la que se activa el aire acondicionado [SET] float tooCold =23.0; // temperatura a la que se activa el calentador [SET] // TIMER faceint BUZZER =3; // pin 3:buzzerboolean KEEPtime =false; // this is used to count only one time the face orientation change (not restart while counting)int TIMERmillis =0; // the following are for the countdown determinationint prevSHOWsecond =0;int CountdownInMillis =0;int SHOWmillis =0; // millis value calculation resultint SHOWminute =0; // minutes value to show in the monitor for the countdownint SHOWseconds =0; // seconds value to show in the monitor for the countdownconst int SETminute =2; // set 2 minute timer [SET]const int SETsecond =30; // set 30 seconds timer [SET]// SOUND faceconst int soundLED =9; // pin 9:green led const int soundSENSOR =A1; // pin A0:sound sensorint brightness =0; // green led brightness initialization// TV faceconst byte ROWS =4; // four rows keypadconst byte COLS =3; // three columns keypadchar keys[ROWS][COLS] ={ {'1','2','3'}, {'4','5','6'}, {'7','8','9'}, {'*','0','#'}}; // keypad button valuesbyte rowPins[ROWS] ={10,8,7,6}; // pin 10,8,7,6:connect to the row pinouts of the keypadbyte colPins[COLS] ={5,4,2}; // pin 5,4,2:connect to the column pinouts of the keypadKeypad keypad =Keypad( makeKeymap(keys), rowPins, colPins, ROWS, COLS ); // keypad initialization// OFF faceconst int LEDOFF =A2; // pin A2:red ledvoid setup() { pinMode(LEDlights, OUTPUT); // every led is set as an output pinMode(LEDhot, OUTPUT); pinMode(LEDcold, OUTPUT); pinMode(soundLED,OUTPUT); pinMode(LEDOFF, OUTPUT); Serial.begin (9600); // initialize Serial communication CountdownInMillis =(SETminute*60 + SETsecond)*1000; // this calculates the corrispondent value in millis from the minutes and seconds setting lcd.begin(16, 2); // LCD initialization lcd.setRGB(0, 0, 0); // LCD RGB is OFF at the beginning // initialize device Serial.println("Initializing IMU device..."); CurieIMU.begin (); // Set the accelerometer range to 2G CurieIMU.setAccelerometerRange(2); // Enable Shock Detection CurieIMU.setDetectionThreshold(CURIE_IMU_SHOCK, 7000); // 7.0g =7000 mg (this value set the intensity of the shock) CurieIMU.setDetectionDuration(CURIE_IMU_SHOCK, 2000); // 2000ms (this value set the duration of the shock) CurieIMU.interrupts(CURIE_IMU_SHOCK); // BLE setup initialization blePeripheral.setLocalName("SmartCubeSketch"); // the name of the project blePeripheral.setAdvertisedServiceUuid(lightsService.uuid()); // add the lights service UUID blePeripheral.addAttribute(lightsService); // add the BLE lights service blePeripheral.addAttribute(lightsChar); // add the BLE lights characteristic lightsChar.setValue(3); // initial value for this characteristic =3 //BLE lights value meaning:0 =lights off, 1 =lights on, 3 =initial state, 4 =not used blePeripheral.setAdvertisedServiceUuid(termoService.uuid()); // add the temperature service UUID blePeripheral.addAttribute(termoService); // add the BLE temperature service blePeripheral.addAttribute(termoChar); // add the BLE temperature characteristic termoChar.setValue(0); // initial value is 0:cold off - hot off //BLE termo value meaning:0 =cold off - hot off, 1 =cold on - hot off, 2 =cold off - hot on, 3 =not used blePeripheral.setAdvertisedServiceUuid(TVService.uuid()); // add the tv service UUID blePeripheral.addAttribute(TVService); // add the BLE tv service blePeripheral.addAttribute(TVChar); // add the tv characteristic TVChar.setValue('x'); // initial value for this characteristic (x means nothing) //BLE TV value meaning:#number corrispond to the pressed button, C:close TV, O:open TV, x:initial state blePeripheral.begin(); Serial.println("Bluetooth device active, waiting for connections..."); } // setup endvoid loop() { BLECentral central =blePeripheral.central(); // BLE connection unsigned long currentMillis =millis(); // current value of time in milliseconds // the following code comes from www.arduino.cc/en/Tutorial/Genuino101CurieIMUccelerometerOrientation // it is used to detect the orientation of the board int orientation =- 1; // the board's orientation String orientationString; // string for printing description of orientation // read accelerometer:int x =CurieIMU.readAccelerometer(X_AXIS); int y =CurieIMU.readAccelerometer(Y_AXIS); int z =CurieIMU.readAccelerometer(Z_AXIS); // calculate the absolute values, to determine the largest int absX =abs(x); int absY =abs(y); int absZ =abs(z); if ( (absZ> absX) &&(absZ> absY)) { // base orientation on Z if (z> 0) { orientationString ="up"; orientation =0; } else { orientationString ="down"; orientation =1; } } else if ( (absY> absX) &&(absY> absZ)) { // base orientation on Y if (y> 0) { orientationString ="digital pins up"; orientation =2; } else { orientationString ="analog pins up"; orientation =3; } } else { // base orientation on X if (x <0) { orientationString ="connector up"; orientation =4; } else { orientationString ="connector down"; orientation =5; } } // end of the tutorial code. // at this point you have the orientation value of the board constantly updated:/* The orientations of the board:0:flat, processor facing up (TIMER) 1:flat, processor facing down (TV) 2:landscape, analog pins down (TEMPERATURE) 3:landscape, analog pins up (OFF) 4:portrait, USB connector up (LIGHTS) 5:portrait, USB connector down (SOUND) */ // for this project you need to know if the face has changed from the previous face function [lastFUNCTION !=orientation] // but this information is printed only if the face is in the UP position for more than [interval] time // and only for one time [keep] (you don't nedd to constantly activate the face, you just need it one time) // because the orientation value is constantly updated you need to start counting time when the orientation change [orientation !=lastOrientation] if (orientation !=lastOrientation) { // if the orientation has changed, start to count time lastOrientation =orientation; // memorize the current orientation of the face previousMillis =currentMillis; // memorize the time when the face has changed keep =false; } else if (currentMillis - previousMillis> interval &&keep ==false &&lastFUNCTION !=orientation) { //this condition print the orientation only if the face is up for an interval //and only for one time (keep) //and only if the face is different from the previous loop Serial.println(orientationString); // print the orientation // the current face [orientation] is set as true (that means that the face function is set as activated) if (orientation ==1) { // TV face face1 =true; // TV face becomes true lastFUNCTION =orientation; // memorize this activation in [lastFUNCTION] Serial.println("TV true"); // print the activated face TVChar.setValue('O'); // O:open the tv signal (BLE):tv is open only one time } if (orientation ==4) { // LIGHTS face face4 =true; lastFUNCTION =orientation; Serial.println("LIGHTS true"); } if (orientation ==3) { // OFF face face3 =true; lastFUNCTION =orientation; Serial.println("OFF true"); } if (orientation ==5) { // SOUND face face5 =true; lastFUNCTION =orientation; Serial.println("SOUND true"); } if (orientation ==2) { // TEMPERATURE face face2 =true; lastFUNCTION =orientation; Serial.println("TEMPERATURE true"); } if (orientation ==0) { // TIMER face face0 =true; lastFUNCTION =orientation; Serial.println("TIMER true"); if (KEEPtime ==false) { // timer is activated only if it is the 1st cycle or has been stopped TIMERmillis =currentMillis; // start counting time } } keep =true; // [keep] change value so that, in the next loop, you can't enter in this condition if the face don't change (avoid to activate another time the same face) } // this condition is for the shake function:if you shake for more than [SHAKEinterval] time, the face is deactivated if (CurieIMU.getInterruptStatus(CURIE_IMU_SHOCK) &¤tMillis - SHAKEpreviousMillis> SHAKEinterval) { Serial.println("SHAKE"); // print "SHAKE" if shake is detected // the last activated face [lastFUNCTION] is set as false (that means that the face function is deactivated) //TV deactivation if (lastFUNCTION ==1) { // TV face TVChar.setValue('C'); // C:close the tv BLE signal Serial.println("TV false - CLOSE"); // print the closed face face1 =false; // TV face becomes false } //LIGHTS deactivation if (lastFUNCTION ==4) { // LIGHTS face if (central.connected() ==true) { // if a central is connected to peripheral:lightsChar.setValue(0); // lights OFF BLE signal digitalWrite (LEDlights, HIGH); // open the yellow led to see the cube in the dark } Serial.println("LIGHTS false - CLOSE"); face4 =false; // LIGHTS face become false } // OFF if (lastFUNCTION ==3) { // OFF face // OFF face shaked:everything is closed and red led OFF is open digitalWrite (LEDOFF, HIGH); // red led OFF is on when cube is closed // now close all the activated functions:// CLOSE TV TVChar.setValue('C'); // C:close the tv BLE signal Serial.println("TV false - CLOSE"); face1 =false; // CLOSE LIGHTS Serial.println("LIGHTS false - CLOSE"); if (central.connected() ==true) { lightsChar.setValue(0); digitalWrite (LEDlights, LOW); // lights led is closed if OFF face is shaked } face4 =false; // CLOSE SOUND analogWrite(soundLED, LOW); // close the sound led Serial.println("SOUND false - CLOSE"); face5 =false; //CLOSE TEMPERATURE if (central.connected() ==true) { digitalWrite(LEDhot, LOW); digitalWrite(LEDcold, LOW); termoChar.setValue(0); // temperature BLE signal:0 =cold off - hot off } Serial.println("TEMPERATURE false - CLOSE"); face2 =false; // CLOSE TIMER Serial.println("TIMER false - CLOSE"); lcd.setRGB(0, 0, 0); // the LCD RGB is closed lcd.clear(); KEEPtime =false; face0 =false; // The cube is inactive, only OFF led is active Serial.println("OFF false - CLOSE"); face3 =false; // OFF face becomes false } // SOUND deactivation if (lastFUNCTION ==5) { // SOUND face analogWrite(soundLED, LOW); // close the sound led Serial.println("SOUND false - CLOSE"); face5 =false; // SOUND face becomes false } // TEMPERATURE deactivation if (lastFUNCTION ==2) { // TEMPERATURE face // if a central is connected to peripheral:if (central.connected() ==true) { digitalWrite(LEDhot, LOW); // close temperature red led digitalWrite(LEDcold, LOW); // close temperature blue led termoChar.setValue(0); // temperature BLE signal:0 =cold off - hot off } Serial.println("TEMPERATURE false - CLOSE"); face2 =false; // TEMPERATURE face became false } // TIMER deactivation if (lastFUNCTION ==0) { // TIMER face Serial.println("TIMER false - CLOSE"); face0 =false; // TIMER face became false // if you shake the cube when the time is running, the LCD became red and show the remaining time to countdown lcd.setRGB(180, 40, 0); // the RGB backlight become red lcd.clear(); // lcd is cleared lcd.setCursor(0, 0); lcd.print("STOP AT "); lcd.setCursor(8, 0); lcd.print(SHOWminute); // indicates the minutes when you shake the cube lcd.setCursor(9, 0); lcd.print(":"); lcd.setCursor(10, 0); lcd.print(SHOWseconds); // indicates the seconds when you shake the cube tone(BUZZER,1000,1000); // it make a short sound delay(2000); lcd.clear (); // clear the LCD lcd.setRGB(0, 0, 0); // LCD RGB backlight is closed KEEPtime =false; // TIMER face became false } SHAKEpreviousMillis =currentMillis; // memorize the value for the [SHAKEinterval] calculation } // the following instructions are executed in loop only if the face is activated if (face1 ==true) { // TV face digitalWrite (LEDOFF, LOW); // if this face is true the OFF face led is LOW if (central.connected() ==true) { // if the cube is BLE connected char key =keypad.getKey(); // read the value from the keypad if (key &&orientation ==1){ // if something is pressed and only when the tv face is up (avoid involuntary keypad pression) if (key =='0') { // if the pressed key is 0 TVChar.setValue(key); // send the [key] value via BLE Serial.println(key); // print the pressed button (comment if you don't want to show this information) } if (key =='1'){ TVChar.setValue(key); Serial.println(key); } if (key =='2'){ TVChar.setValue(key); Serial.println(key); } if (key =='3'){ TVChar.setValue(key); Serial.println(key); } if (key =='4'){ TVChar.setValue(key); Serial.println(key); } if (key =='5'){ TVChar.setValue(key); Serial.println(key); } if (key =='6'){ TVChar.setValue(key); Serial.println(key); } if (key =='7'){ TVChar.setValue(key); Serial.println(key); } if (key =='8'){ TVChar.setValue(key); Serial.println(key); } if (key =='9'){ TVChar.setValue(key); Serial.println(key); } if (key =='*'){ TVChar.setValue(key); Serial.println(key); } if (key =='#'){ TVChar.setValue(key); Serial.println(key); } } } } if (face4 ==true) { // LIGHTS face digitalWrite (LEDOFF, LOW); // if this face is true the OFF face led is LOW if (central.connected() ==true) { // if a central is connected to peripheral:lightsChar.setValue(1); // LIGHTS activated BLE signal digitalWrite (LEDlights, LOW); // yellow led is closed because the home lights are on } } if (face3 ==true) { // OFF face // when OFF face is up nothing is done digitalWrite (LEDOFF, LOW); // led OFF is activated only when the cube is shaked, so now is LOW } if (face5 ==true) { // SOUND face digitalWrite (LEDOFF, LOW); // if this face is true the OFF face led is LOW // sound sensor is activated, led brightness regulated by the sond // this code comes from brightness regulation example long sum =0; for (int i=0; i<32; i++) { sum +=analogRead(soundSENSOR); } sum>>=5; brightness =(sum*255)/1024; // calculate the brightness value analogWrite(soundLED,brightness); // green led brightness intensity is regulated by the noise delay(50); //end brightness example } if (face2 ==true) { // TEMPERATURE face digitalWrite (LEDOFF, LOW); // if this face is true the OFF face led is LOW if (central.connected() ==true) { // if the cube is BLE connected // read temperature value int val =analogRead(pinTemp); // get analog value resistance=(float)(1023-val)*10000/val; // get resistance temperature=1/(log(resistance/10000)/B+1/298.15)-273.15; // calculate temperature //conditions of activation if (temperature> tooHot) { // activate air conditioning digitalWrite(LEDhot, LOW); // close heating led digitalWrite(LEDcold, HIGH); // open air conditioner led termoChar.setValue(1); // set via BLE the condition 1 =cold on - hot off } if (temperature  tooCold &&temperature   

Piezas y carcasas personalizadas

This is the file (.dxf) that you can upload on your laser cutter. I used a medium density fiberboard (MDF) of 3mm. Cut the black lines and engrave red lines. Important:if your material thickness is different you have to modify this sketch. smart_cube_8sVCflFmhM.dxfThe same file of the box but in a different format:.pdf

Esquemas

This is a .jpeg of the Fritzing scheme (yellow wires are connected to Grove components) This is a scheme of the connections in the Grove Shield _cI0IwUsPVZ.Base%20shield%20connections

Proceso de manufactura

  1. Por qué los paneles solares son una inversión inteligente para su hogar
  2. Vaya a lo grande o vaya a casa con su nuevo diseño de producto
  3. Aplicaciones de automatización del hogar
  4. Creación de una red de sensores inalámbricos en su hogar
  5. Controle la temperatura de su hogar usando su Raspberry Pi
  6. La brecha de habilidades para el hogar inteligente
  7. Sea inteligente:el futuro de su hogar
  8. Seguridad inteligente:cómo proteger sus dispositivos domésticos inteligentes de los piratas informáticos
  9. Formas de mejorar la seguridad de su hogar inteligente
  10. Smart Plant IoT
  11. Habilita el control de Alexa en tu ventilador de techo