Manufaturação industrial
Internet das coisas industrial | Materiais industriais | Manutenção e reparo de equipamentos | Programação industrial |
home  MfgRobots >> Manufaturação industrial >  >> Manufacturing Technology >> Processo de manufatura

SMART CUBE:uma nova maneira de controlar sua casa

Componentes e suprimentos

Arduino 101
× 1
LED (genérico)
1 azul - 1 amarelo - 1 verde - 2 vermelhos
× 5
Resistor 221 ohm
× 5
Breadboard (genérico)
Não obrigatório
× 1
Escudo básico visto V2
× 1
Vered Grove LCD RGB Backlight
× 1
Sensor de som Grove visto
× 1
Seeed Grove Buzzer
× 1
Sensor de temperatura Grove visto
× 1
Teclado
× 1
Fios de jumpers (genérico)
× 1
Bateria de 9 V (genérica)
× 1
Clipe de bateria 9V
× 1
Fibra de densidade média (MDF) 20x30 cm
MDF de 3 mm ou outro material para corte a laser
× 1

Ferramentas e máquinas necessárias

Cortador a laser (genérico)
Ferro de soldar (genérico)

Aplicativos e serviços online

Arduino IDE
Nordic Semiconductor nRF Connect SDK
Não obrigatório

Sobre este projeto





O que é SMART CUBE?


Smart Cube é um controlador para seus dispositivos Smart Home.

Hoje em dia, gerenciar de forma mais inteligente todos os dispositivos de nossas casas está se tornando uma exigência . Precisamos de algo simples e intuitivo usar. Cubo Inteligente poderia ser uma solução:é um dispositivo portátil que contém um Arduino 101 placa e alguns sensores que se comunicam com os aparelhos e os atuadores em sua casa inteligente.

A inovação deste controle remoto está relacionada com a inovação da placa Arduino 101. Ele usa Bluetooth (BLE) para controlar as luzes, a temperatura e sua tv e você também pode sincronizá-la com seu smartphone . Mas a principal inovação é a maneira como você interage com o Smart Cube com o seu gesto usando o giroscópio e o acelerômetro. O cubo tem 6 faces e cada uma controla uma função particular . A função que você deseja usar é detectada graças ao giroscópio que reconhece a face superior. Por exemplo, você pode abrir as luzes da sala em que está apenas posicionando o cubo com a "face da luz" na posição superior . Se você quiser desligar a luz, você só precisa sacudir o cubo.

Se um rosto estiver PARA CIMA e não se move por mais de 2 segundos, é ativada a função relacionada. Este atraso é feito para que você possa ter tempo para girar e interagir com o cubo para encontrar a face de que precisa sem ativar acidentalmente outras funções. Quando você agita o cubo por mais de 2 segundos, a última função ativada é fechada.

Este projeto tem como objetivo ajudá-lo a construir um controlador inteligente . Este dispositivo precisa de um receptor (central inteligente na imagem) que interpretam os dados e gerenciar as funções de sua casa inteligente. A principal saída do cubo é um sinal BLE que pode ser usado de várias maneiras:por exemplo, você pode conectar o cubo com um aplicativo de smartphone (ou fazer o seu próprio), ou você pode construir uma estação com outro Arduino que coletam os dados BLE e controlam diretamente os eletrodomésticos da sua casa. Devido à variedade de casos, esta parte depende de sua necessidade. Neste guia, veremos como construir um cubo inteligente e você aprenderá como personalizá-lo.





Funções:


A estrutura do código é fácil de personalizar (analisamos o código mais tarde) para que você possa decidir quais funções controlar. Estas são as funções que decidi controlar:

LUZES :Este rosto em PARA CIMA abra as luzes da sala em que você está. Se você sacudir o cubo, as luzes se apagam e um led amarelo nesta face é ativado para que você possa encontrar o cubo na escuridão. A comunicação com suas lâmpadas é feito pelo BLE da 101 placa.

TEMPERATURA :Este rosto PARA CIMA ativar (via BLE) o ar condicionado se estiver quente ou aquecimento se estiver frio. Ele detecta a temperatura usando um sensor térmico e abra um led azul se o condicionador estiver ligado (flocos de neve) ou vermelho um se o aquecimento estiver ativado (sol).

TEMPORIZADOR :Este rosto PARA CIMA inicie um cronômetro que você pode ver no visor LCD. Existe uma campainha que funciona como um alarme quando a contagem regressiva terminar. Se você sacudir, parará o cronômetro e poderá ver o tempo restante. Quando a contagem regressiva termina, a cor do LCD muda de azul para vermelho e a campainha faz três sons.

TV :Este rosto PARA CIMA abra a TV. O cubo se torna um controlador remoto para sua TV. Existe um painel de botões com números que são ativados apenas se este rosto estiver PARA CIMA para evitar toques acidentais. O número que você empurra é enviado via BLE para o controlador central que está conectado à sua TV. Sacudindo o cubo, você fecha a TV.

SOM :Este rosto PARA CIMA ativar um led cujo brilho é baseado no nível de ruído da sala. O ruído é detectado graças a um sensor de som. Se você sacudir o cubo, fecha esta função. (Se quiser, pode ativar a sua função pessoal batendo palmas).

DESLIGADO face:Se você não sacudir o cubo, esta face é como uma posição neutra em que nada é alterado. Se você deseja fechar tudo posicione o cubo com a face OFF PARA CIMA e sacuda-o. Esse gesto é como o botão home do smartphone que você pressiona se quiser sair rapidamente. Há um led vermelho para que você possa encontrar o cubo se estiver escuro.





Diferenças do conceito:


O plano original era usar também comunicação IR para conectar sua TV diretamente ao cubo. Como o Arduino 101 não suporta (por enquanto) a biblioteca que gerencia os sinais IR, decidi enviar as informações via BLE para uma estação que pode gerenciar esta biblioteca (como o Arduino UNO). Por causa desse problema, removi a função de rádio (muito semelhante à face da TV), substituindo-a por uma face com sensor de som. Este rosto pode ser usado para reconhecer um ruído alto (como palmas) para ativar algo. A maior mudança está no material do cubo. Inicialmente pensei em construí-lo com uma impressora 3D mas então decidi usar um cortador a laser . Desta forma, é mais fácil de substituir um rosto se quiser alterar uma função. Por exemplo, você pode remover o mostrador do cronômetro e trocá-lo por um mostrador que enche automaticamente a tigela do seu gato. Sendo modular você não precisa reconstruir toda a estrutura!





Vamos construir:


Siga estas instruções para construir seu próprio cubo inteligente. Começaremos com o hardware , montando os eletrônicos componentes primeiro e, em seguida, o corpo cortado a laser do cubo feito de MDF. Após esta operação, explicarei como o código funciona e como você pode personalizá-lo . Depois de fazer o upload do código em seu Arduino 101, você pode fazer o download do aplicativo para ver a saída BLE do cubo ou conecte-o diretamente com sua casa inteligente!





Hardware - eletrônicos:


Vamos começar a formar seu Arduino 101. Este é o fritzing esquema a seguir:

Monte a blindagem de base Grove em sua placa e comece com as conexões.

Teclado :você tem que conectar os fios para os pinos:10, 8, 7, 6, 5, 4, 2.

conexões de LED :

Em primeiro lugar, temos que preparar os leds:

- conecte a perna longa do led (ânodo) a uma resistência de 220 ohm e, em seguida, a um fio vermelho (este é o cabo para conectar ao pino)

- conecte a perna curta (cátodo) a um fio branco (isso irá para o gnd)

- soldar as peças e cobri-las com fita isolante

- conecte todos os cabos brancos a um único cabo branco (isso irá para o gnd) e solde-os todos juntos

Agora conecte os fios vermelhos ao seu Arduino:LED VERDE para o pino 9, LED AMARELO para o pino 11, LED VERMELHO para o pino 12, LED AZUL para o pino 13 e o último LED VERMELHO para o pino A2.



Sensores Grove :

Conecte os sensores do bosque ao escudo (veja o esquema nos acessórios).

Buzzer para D3, LCD RGB para I2C, sensor de temperatura para A0, sensor de som para A1.

Ok, agora conectamos todos os aparelhos elétricos partes. Agora você precisa do caso .





Hardware - caixa


Você pode baixar o esboço do cubo para cortar com laser. As linhas vermelhas no esboço são os símbolos das faces, basta gravar eles. As linhas pretas devem ser cortadas . A dimensão interna do cubo é 9 cm . O esboço está ok se você usar um material de 3 mm , se você usar uma espessura diferente, você deve modificá-la (você pode usar este site:http://www.makercase.com/).

O material que escolhi é MDF (Fibra de densidade média), mas você pode usar o que quiser.

Aqui estão algumas fotos do corte a laser :





Agora temos que montá-lo .

Eu colei alguns pedaços de papelão para dar espessura ao led. Desta forma, eles serão alinhados com a superfície .

Agora montamos o teclado . Insira-o no orifício e remova o filme adesivo, depois reconecte os pinos.

Agora, o LCD RGB . Isso se encaixou perfeitamente no buraco.

Vamos preparar o conector da bateria :

Cortei um antigo plugue do transformador e o conectei a um clipe de bateria. Desta forma, economizamos espaço dentro da caixa.

Neste ponto, é isso que você deve ter:

Agora você só precisa conectar a bateria , faça upload do código e feche o cubo !

DICA:fixe a placa e a bateria com o case para que ao sacudir o cubo fiquem estáveis.





Código


Você pode encontrar o código nos anexos . Faça upload em sua placa com o Arduino IDE (lembre-se de atualizar seu software para compatibilidade com o Arduino 101).

Eu comentei quase todas as linhas do código para torná-lo mais compreensível que eu possa. Não tenha medo das mais de 500 linhas, a estrutura não é tão complicada.

No início estão as bibliotecas e todas as variáveis ​​ declaração .

Nesta parte também há a definição de serviços de BLE e característica . Usei o Automation IO serviço. Eu usei o Digital característica para luzes e temperatura (isto usa 2 bits, então 4 casos possíveis para codificar) e o Analógico para TV (para enviar todos os códigos do teclado).

Em seguida, a configuração . Este pat é executado apenas uma vez no inicio. Aqui, inicializamos os componentes como entradas ou saídas e inicializamos o BLE e o giroscópio da placa 101.

A parte principal é o loop . Está dividido em quatro partes:
  • 1 A primeira parte é copiada do tutorial do site do Arduino:(https://www.arduino.cc/en/Tutorial/Genuino101CurieIMUAccelerometerOrientation) esta parte é constantemente executada e retorna a orientação do tabuleiro.
  • 2 Na segunda parte, ativamos um rosto apenas se estiver na posição para cima por mais de dois segundos . Usamos o millis função para contar o tempo. Quando a posição muda ela memoriza o valor em milis e se a orientação permanece a mesma, após um intervalo (2 segundos), entramos em uma zona se onde a face selecionada tornou-se verdadeira (para a 4ª parte).
  • 3 A terceira parte é ativada apenas se o cubo for sacudido com uma certa intensidade e por mais de 2 segundos. O último ativado a função do rosto está fechada e o rosto é definido como falso . Se a face for falsa não pode entrar na 4ª parte.
  • 4 A quarta parte é apenas para verdadeiro rostos. Aqui está o núcleo das funções do cubo inteligente. Nesta parte são executados constantemente apenas as faces que são verdadeiras no loop.

Você pode modificar o rosto funciona com algumas modificações do código. A estrutura principal deve ser conforme descrito. Você pode alterar a parte dentro das condições if de cada rosto.
  if (face2 ==true) {// TEMPERATURE face // COMECE A ALTERAR AQUI digitalWrite (LEDOFF, LOW); // se esta face for verdadeira, o led da face OFF é BAIXO if (central.connected () ==true) {// se o cubo está conectado por BLE // lê o valor da temperatura int val =analogRead (pinTemp); // obtém o valor analógico resistência =(float) (1023-val) * 10000 / val; // obtém a temperatura da resistência =1 / (log (resistência / 10000) /B+1/298.15) -273,15; // calcula a temperatura // condições de ativação if (temperature> tooHot) {// ativa o ar condicionado digitalWrite (LEDhot, LOW); // fecha o led de aquecimento digitalWrite (LEDcold, HIGH); // condicionador de ar aberto led termoChar.setValue (1); // define via BLE a condição 1 =frio ligado - quente desligado} if (temperatura  tooCold &&temperature  

Você deve codificar a parte "verdadeira" (como no código anterior) e também a parte "falsa" quando o cubo é sacudido:
  // Desativação da TEMPERATURA if (lastFUNCTION ==2) {// Face da TEMPERATURA // COMECE A ALTERAR AQUI // se uma central estiver conectada ao periférico:if (central.connected () ==true) {digitalWrite (LEDhot, LOW); // LED vermelho de temperatura de fechamento digitalWrite (LEDcold, LOW); // led azul de temperatura de fechamento termoChar.setValue (0); // sinal BLE de temperatura:0 =frio desligado - quente desligado // END HERE} Serial.println ("TEMPERATURE false - CLOSE"); face2 =falso; // O rosto de TEMPERATURE tornou-se falso}  

Lembre-se de definir o rosto como falso quando você agita.





App:


Para ver as saídas BLE do cubo, você pode fazer download este aplicativo: nRF Connect

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

Ao abri-lo, basta pesquisar para dispositivos e conectar com "smartcubesketch". Em seguida, você verá três guias "Automação de E / S", clique nelas e empurre o coletor de dados contínuo.

É importante conectar o cubo porque algumas funções (luz, temperatura e tv) são executadas somente se o cubo estiver conectado.





Como funciona:VÍDEO


Faça upload do código, insira a bateria, feche a caixa e ...

... agora você tem um SMART CUBE!

Fiz um vídeo para mostrar todas as funções do cubo e como usá-lo.





Conclusões


Este projeto é apenas a primeira etapa para uma casa inteligente. Meu objetivo era usar o Arduino 101 potencialidade do conselho para criar algo novo . Eu acho que o acelerômetro e giroscópio dar ao conselho novas oportunidades em termos de mobilidade. Com o BLE, além de ser portátil, também é fácil de conectar .

É a primeira vez que concretizo concretamente um dos meus projetos (quer dizer, com um protótipo funcional). Foi difícil e houve algumas dificuldades na estrada, mas no final aprendi muito e estou contente com o resultado. Espero que também todos os que lerem este guia possam aprender algo com meu trabalho e também modificar este projeto de acordo com suas necessidades . Sinto muito pelo meu péssimo inglês, mas espero que as imagens possam te ajudar.

No futuro deste projeto, espero criar a centraline isso é como a ponte entre o cubo inteligente e os atuadores (luzes, temperatura, tv ...). Esta centraline receberá o sinal BLE do cubo e usará essa informação para fazer coisas inteligentes em sua casa.

Estou muito feliz por ter a oportunidade de usar o Arduino 101 e o kit Grove (o kit é muito simples e rápido para prototipagem).

Espero que usar o quadro desta forma possa ser uma inspiração para o seu projeto. Você pode personalizá-lo como quiser : Estou curioso para ver quais funções você criará e em que contexto diferente você as usará!

Talvez isso não seja uma revolução, mas é uma nova maneira de interagir com sua casa .

Espero que você goste deste tutorial.

Agora é sua vez :coloque suas mãos no cubo e hackear!


Código

  • SMART CUBE - código completo com comentários
SMART CUBE - código completo com comentários Arduino
Este é o código para fazer upload em seu Arduino 101. Você pode usar esse código como está ou personalizá-lo com base em suas necessidades. Siga os comentários para entender como funciona.
 // Bibliotecas # include "CurieIMU.h" // Acelerômetro e giroscópio # include  // Bluetooth Low Energy # include  #include "rgb_lcd .h "// LCD # include  // Keypadrgb_lcd lcd; // Inicialização do LCD // Inicialização do Bluetooth:BLEPeripheral blePeripheral; // Dispositivo periférico BLE (a placa que você está programando) // BLE ServicesBLEService lightsService ("1815"); // BLE Automation IO (1815) - ilumina informationsBLEService termoService ("1815"); // BLE Automation IO - informações de temperaturaBLEService TVService ("1815"); // BLE Automation IO - tv informations // BLE featureBLEUnsignedCharCharacteristic lightsChar ("2A56", // BLE característica Digital (2A56) - luzes BLERead | BLENotify); BLEUnsignedCharCharacteristic termoChar ("2A56", // BLE característica Digital - temperatura BLERead | BLENotify) ); BLEUnsignedCharCharacteristic TVChar ("2A58", // BLE característica Analógico (2A58) - tv BLERead | BLENotify); // Declaração de constantes e variáveis:// Orientação facial e funções de vibração:int lastOrientation =- 1; // orientação anterior (para comparação) unsigned long previousMillis =0; // última vez updateunsigned long interval =2000; // tempo de espera na posição para cima antes da ativação do rostounsigned long SHAKEpreviousMillis =0; // última vez updateunsigned long SHAKEinterval =2000; // tempo de espera durante a agitação para a desativação do rostoboolean keep =false; // isso é usado para contar apenas uma vez que a orientação da face changeint lastFUNCTION =-1; // isto é usado para saber qual é a orientação anterior // Faces de inicialização:no início, cada face é falsa booleana face0 =false; boolean face1 =false; boolean face2 =false; boolean face3 =false; boolean face4 =false; boolean face5 =false; // LIGHTS faceconst int LEDlights =11; // pino 11:led amarelo // faceconst de TEMPERATURA int pinTemp =A0; // pino A0:sensor de temperaturaconst int LEDhot =12; // pino 12:ledconst vermelho int LEDcold =13; // pino 13:temperatura do ledfloat azul; // memorização do valor da temperaturaint B =3975; // valor B da resistência de flutuação do termistor; // memorização do valor da resistênciafloat tooHot =26.0; // temperatura na qual o ar condicionado é ativado [SET] float tooCold =23.0; // temperatura na qual o aquecedor é ativado [SET] // TIMER faceint BUZZER =3; // pino 3:buzzerboolean KEEPtime =false; // é usado para contar apenas uma vez a mudança de orientação da face (não reiniciar durante a contagem) int TIMERmillis =0; // o seguinte é para a determinação da contagem regressivaint prevSHOWsecond =0; int CountdownInMillis =0; int SHOWmillis =0; // cálculo do valor em milis resultint SHOWminute =0; // valor dos minutos a ser mostrado no monitor para a contagem regressiva. 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  

Peças personalizadas e gabinetes

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

Processo de manufatura

  1. Por que os painéis solares são um investimento inteligente para sua casa
  2. Ganhe grande ou vá para casa com seu novo design de produto
  3. Aplicações de automação residencial
  4. Construindo uma rede de sensores sem fio em sua casa
  5. Monitore a temperatura de sua casa usando o Raspberry Pi
  6. A lacuna de habilidades da casa inteligente
  7. Fique esperto:O futuro da sua casa
  8. Segurança inteligente:Como proteger seus dispositivos domésticos inteligentes de hackers
  9. Maneiras de melhorar a segurança de sua casa inteligente
  10. Planta inteligente IoT