Industriële fabricage
Industrieel internet der dingen | Industriële materialen | Onderhoud en reparatie van apparatuur | Industriële programmering |
home  MfgRobots >> Industriële fabricage >  >> Manufacturing Technology >> Productieproces

SMART CUBE:een nieuwe manier om je huis te bedienen

Componenten en benodigdheden

Arduino 101
× 1
LED (generiek)
1 blauw - 1 geel - 1 groen - 2 rood
× 5
Weerstand 221 ohm
× 5
Broodplank (algemeen)
Niet verplicht
× 1
Seeed Base Shield V2
× 1
Seeed Grove LCD RGB-achtergrondverlichting
× 1
Seeed Grove-geluidssensor
× 1
Seeed Grove Buzzer
× 1
Seeed Grove-temperatuursensor
× 1
Toetsenblok
× 1
Jumperdraden (algemeen)
× 1
9V-batterij (algemeen)
× 1
9V batterijclip
× 1
Vezel met gemiddelde dichtheid (MDF) 20x30 cm
3 mm MDF of ander materiaal voor lasersnijden
× 1

Benodigde gereedschappen en machines

Lasersnijder (algemeen)
Soldeerbout (algemeen)

Apps en online services

Arduino IDE
Nordic Semiconductor nRF Connect SDK
Niet verplicht

Over dit project

Wat is SMART CUBE?

Smart Cube is een controller voor je Smart Home-apparaten.

Tegenwoordig wordt het slimmer beheren van alle apparaten in onze huizen een noodzaak . We hebben iets eenvoudigs nodig en intuïtief gebruiken. Slimme kubus zou een oplossing kunnen zijn:het is een draagbaar apparaat met een Arduino 101 bord en enkele sensoren die communiceren met de apparaten en de actuatoren in je Smart Home.

De innovatie van deze afstandsbediening is gerelateerd aan de innovatie van Arduino 101 board. Het maakt gebruik van Bluetooth (BLE) om verlichting, temperatuur en je tv te bedienen en je kunt het ook synchroniseren met je smartphone . Maar de belangrijkste innovatie is de manier waarop u interageert met Smart Cube met uw gebaar met behulp van de gyroscoop en de versnellingsmeter. De kubus heeft 6 vlakken en elk bestuurt een bepaalde functie . De functie die je wilt gebruiken wordt gedetecteerd dankzij de gyroscoop die de bovenzijde herkent. U kunt bijvoorbeeld de lichten van de kamer waarin u zich bevindt openen door de kubus met het "lichtvlak" in de bovenste positie te plaatsen . Als je het licht wilt uitschakelen, hoef je alleen maar met de kubus te schudden.

Als een gezicht UP is en het beweegt niet langer dan 2 seconden, het wordt de gerelateerde functie geactiveerd. Deze vertraging is zo gemaakt dat je de tijd hebt om de kubus te draaien en ermee te werken om het gezicht te vinden dat je nodig hebt zonder per ongeluk andere functies te activeren. Wanneer u de kubus langer dan 2 seconden schudt, wordt de laatst geactiveerde functie gesloten.

Dit project is bedoeld om u te helpen bij het bouwen van een slimme controller . Dit apparaat heeft een ontvanger nodig (slimme centrale lijn in de afbeelding) die de gegevens interpreteren en de functies beheren van uw slimme huis. De belangrijkste uitvoer van de kubus is een BLE-signaal dat op veel manieren kan worden gebruikt:u kunt de kubus bijvoorbeeld verbinden met een smartphone-app (of maak er zelf een), of je kunt een station bouwen met een andere Arduino die de BLE-gegevens verzamelen en rechtstreeks de apparaten van uw huis aansturen. Vanwege de verscheidenheid aan gevallen is dit onderdeel afhankelijk van uw behoefte. In deze gids zullen we zien hoe u een slimme kubus kunt bouwen en leert u hoe u deze kunt personaliseren.

Functies:

De structuur van de code is eenvoudig personaliseren (we analyseren de code later) zodat u kunt beslissen welke functies u wilt bedienen. Dit zijn de functies die ik besloot te bedienen:

LICHTEN :Dit gezicht in UP positie open de lichten van de kamer waarin u zich bevindt. Als je de kubus schudt, gaan de lichten uit en een gele led in dit gezicht wordt geactiveerd zodat je de kubus in het donker kunt vinden. De communicatie met je lampen wordt gemaakt door de BLE van het 101-bord.

TEMPERATUUR :Dit gezicht UP activeer (via BLE) de airconditioning als het warm is of de verwarming als het koud is. Het detecteert de temperatuur met behulp van een thermische sensor en open een blauwe led als de conditioner aan staat (sneeuwvlok) of een rood één als de verwarming is geactiveerd (zon).

TIMER :Dit gezicht UP start een timer die u kunt zien op het LCD-scherm. Er is een zoemer die werkt als een alarm wanneer het aftellen is voltooid. Als je schudt stop je de timer en zie je de resterende tijd. Wanneer het aftellen eindigt, verandert de kleur van het LCD-scherm van blauw in rood en maakt de zoemer drie geluiden.

TV :Dit gezicht UP de televisie openen. De kubus wordt een afstandsbediening voor uw televisie. Er is een knoppenpaneel met cijfers die alleen wordt geactiveerd als dit gezicht OMHOOG is, om onbedoelde aanrakingen te voorkomen. Het nummer dat je indrukt, wordt via BLE naar de centrale controller gestuurd die op je tv is aangesloten. Door de kubus te schudden sluit je de tv.

GELUID :Dit gezicht UP activeer een led waarvan de helderheid is gebaseerd op het geluidsniveau van de kamer. Het geluid wordt gedetecteerd dankzij een geluidssensor. Als je de kubus schudt sluit je deze functie. (Als je wilt, kun je je persoonlijke functie activeren door in je handen te klappen).

UIT gezicht:als je de kubus niet schudt, is dit gezicht als een neutrale positie waarin niets verandert. Als u wilt sluiten alles positioneer de kubus met de UIT naar boven gericht en schud hem. Dit gebaar is vergelijkbaar met de startknop op je smartphone die je indrukt als je snel wilt afsluiten. Er is een rode led zodat je de kubus kunt vinden als het donker is.

Verschillen met het concept:

Het oorspronkelijke plan was om ook IR-communicatie te gebruiken om uw tv rechtstreeks op de kubus aan te sluiten. Omdat de Arduino 101 (voorlopig) de bibliotheek die de IR-signalen beheert niet ondersteunt, heb ik besloten om de informatie via BLE naar een station te sturen dat deze bibliotheek kan beheren (zoals Arduino UNO). Vanwege dit probleem heb ik de radiofunctie verwijderd (zeer vergelijkbaar met het gezicht van de tv), vervangen door een gezicht met een geluidssensor. Dit gezicht kan worden gebruikt om een ​​hard geluid te herkennen (zoals handgeklap) om iets te activeren. De grootste verandering zit in het materiaal van de kubus. Aanvankelijk dacht ik het te bouwen met een 3D-printer maar toen besloot ik een lasercutter te gebruiken . Op deze manier is het gemakkelijker te vervangen een gezicht als u een functie wilt wijzigen. U kunt bijvoorbeeld het timergezicht verwijderen en vervangen door een gezicht dat automatisch de kom van uw kat vult. modulair zijn je hoeft niet de hele structuur opnieuw op te bouwen!

Laten we het bouwen:

Volg deze instructies om je eigen slimme kubus te bouwen. We beginnen met de hardware , het monteren van de elektronica componenten eerst en dan het lasergesneden lichaam van de kubus gemaakt van MDF. Na deze operatie zal ik uitleggen hoe de code werkt en hoe je het kunt personaliseren . Nadat je de code op je Arduino 101 hebt geüpload kun je de app downloaden om de BLE-uitgang van de kubus te zien of rechtstreeks te verbinden met je slimme huis!

Hardware - elektronica:

Laten we beginnen met je Arduino 101. Dit is de fritzing te volgen schema:

Monteer het Grove basisschild op je bord en begin met de aansluitingen.

Toetsenblok :je moet de draden aansluiten op de pinnen:10, 8, 7, 6, 5, 4, 2.

LED-aansluitingen :

Allereerst moeten we de leds voorbereiden:

- sluit het lange been van de led (anode) aan op een weerstand van 220 ohm en vervolgens op een rode draad (dit is de kabel om op de pin aan te sluiten)

- sluit het korte been (kathode) aan op een witte draad (deze gaat naar de gnd)

- soldeer de onderdelen en bedek ze met isolatietape

- sluit alle witte kabels aan op een enkele witte kabel (deze gaat naar de gnd) en soldeer ze allemaal aan elkaar

Sluit nu de rode draden aan op je Arduino:GROENE led op pin 9, GELE led op pin 11, RODE led op pin 12, BLAUWE led op pin 13 en de laatste RODE op pin A2.

Grove-sensoren :

Sluit de grove sensoren aan op het schild (zie schema op bijlagen).

Zoemer naar D3, LCD RGB naar I2C, Temperatuursensor naar A0, Geluidssensor naar A1.

Ok, nu hebben we alle elektrische aangesloten onderdelen. Nu heb je de case nodig .

Hardware - doos

Je kunt de schets downloaden van de kubus te snijden met laser. De rode lijnen in de schets zijn de symbolen van de gezichten, gewoon graveren hen. De zwarte lijnen moeten geknipt worden. De interne afmeting van de kubus is 9 cm . De schets is in orde als je een 3 mm materiaal gebruikt , als u een andere dikte gebruikt, moet u deze aanpassen (u kunt deze website gebruiken:http://www.makercase.com/).

Het materiaal dat ik kies is MDF (Vezel met gemiddelde dichtheid) maar je kunt gebruiken wat je wilt.

Hier zijn enkele foto's van de lasercut :

Nu moeten we het in elkaar zetten .

Ik gelijmd enkele stukjes karton om de led dik te maken. Op deze manier worden ze uitgelijnd met het oppervlak .

Nu bevestigen we het toetsenbord . Steek het in het gat en verwijder de zelfklevende film, sluit dan de pinnen weer aan.

Nu de RGB LCD . Dit paste perfect in het gat.

Laten we de batterijconnector voorbereiden :

Ik heb een oude transformatorstekker doorgeknipt en aangesloten op een batterijclip. Op deze manier besparen we ruimte in de doos.

Op dit punt is dat wat u zou moeten hebben:

Nu hoef je alleen nog maar de batterij aan te sluiten , upload de code en sluit de kubus !

TIP:bevestig het bord en de batterij met de behuizing zodat ze stabiel zijn als je de kubus schudt.

Code

Je vindt de code in de bijlagen . Upload het in je bord met de Arduino IDE (Vergeet niet om uw software bij te werken voor Arduino 101-compatibiliteit).

Ik heb opmerking gegeven bijna elke regel van de code om het begrijpelijker te maken dat ik kan. Wees niet bang voor de 500+ lijnen, de structuur is niet zo ingewikkeld.

Aan het begin zijn er de bibliotheken en alle variabelen declaratie .

In dit deel is er ook de definitie van BLE diensten en karakteristiek . Ik gebruikte Automation IO dienst. Ik gebruikte de Digitale kenmerk voor licht en temperatuur (dit gebruik 2 bit , dus 4 mogelijke gevallen om te coderen) en de Analoge voor TV (om alle codes van het toetsenbord te verzenden).

Dan de setup . Deze klop wordt slechts één keer uitgevoerd in het begin. Hier initialiseren we de componenten als inputs of outputs en initialiseren we de BLE en de gyro van het 101-bord.

Het hoofdgedeelte is de loop . Het is verdeeld in vier delen:

  • 1 Het eerste deel is gekopieerd van de Arduino-website-tutorial:(https://www.arduino.cc/en/Tutorial/Genuino101CurieIMUAccelerometerOrientation) dit deel wordt constant uitgevoerd en het geeft de oriëntatie . terug van het bord.
  • 2 In het tweede deel activeren we een gezicht alleen als deze langer dan twee seconden in de positie staat . We gebruiken de millis functie om de tijd te tellen. Wanneer de positie verandert, onthoudt het de millis-waarde en als de oriëntatie hetzelfde blijft, komen we na een interval (2 sec) in een if-zone waar het geselecteerde gezicht waar werd (voor het 4e deel).
  • 3 Het derde deel wordt alleen geactiveerd als de kubus wordt geschud met een bepaalde intensiteit en langer dan 2 seconden. De laatst geactiveerde gezichtsfunctie is gesloten en het gezicht is ingesteld als false . Als het gezicht vals is, kan het 4e deel niet worden ingevoerd.
  • 4 Het vierde deel is alleen voor true gezichten. Hier is de kern van de functies van de slimme kubus. In dit deel worden constant alleen de vlakken uitgevoerd die waar zijn in een lus.

U kunt wijzigen het gezicht functioneert met enkele aanpassingen van de code. De hoofdstructuur moet zijn zoals beschreven. U kunt het deel in de if-voorwaarden . wijzigen van elk gezicht.

if (face2 ==true) { // TEMPERATURE face // START HIER WIJZIGEN digitalWrite (LEDUIT, LAAG); // als dit gezicht waar is, is de UIT-gezichtsled LAAG als (central.connected () ==true) {// als de kubus BLE is aangesloten // lees temperatuurwaarde int val =analogRead (pinTemp); // krijg analoge waarde weerstand =(float) (1023-val) * 10000/val; // krijg weerstandstemperatuur=1/(log(weerstand/10000)/B+1/298.15)-273.15; // bereken temperatuur // voorwaarden van activering als (temperatuur> tooHot) { // activeer airconditioning digitalWrite (LEDhot, LOW); // close verwarming led digitalWrite (LEDcold, HIGH); // open airconditioner led termoChar.setValue(1); // stel via BLE de voorwaarde in 1 =koud aan - heet uit} if (temperatuur  tooCold &&temperatuur  

Je moet het "true" deel coderen (zoals in de vorige code) en ook het "false" deel wanneer de kubus wordt geschud:

// TEMPERATUUR deactivering if (lastFUNCTION ==2) { // TEMPERATUUR gezicht // START HIER WIJZIGEN // als een centrale is aangesloten op randapparatuur:if (central.connected() ==true) { digitalWrite (LEDhot, LAAG); // close temperatuur rode led digitalWrite (LEDcold, LOW); // close temperatuur blauwe led termoChar.setValue (0); // temperatuur BLE-signaal:0 =koud uit - heet uit // END HERE} Serial.println ("TEMPERATURE false - CLOSE"); gezicht2 =onwaar; // TEMPERATUUR gezicht werd onwaar } 

Vergeet niet om het gezicht in te stellen als onwaar wanneer je het schudt.

App:

Om de kubus-BLE-uitgangen te zien, kunt u downloaden deze app:nRF Connect

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

Wanneer u het opent, hoeft u alleen maar te zoeken voor apparaten en verbinden met "smartcubesketch". Vervolgens ziet u drie "Automation IO"-tabbladen, klik erop en druk op de continue gegevensverzamelaar.

Het is belangrijk om de kubus aan te sluiten omdat sommige functies (verlichting, temperatuur en tv) alleen worden uitgevoerd als de kubus is aangesloten.

Hoe het werkt:VIDEO

Upload de code, plaats de batterij, sluit de doos en...

...nu heb je een SMART CUBE!

Ik heb een video gemaakt om je alle functies van de kubus te laten zien en hoe je hem kunt gebruiken.

Conclusies

Dit project is slechts de eerste stap naar een slimme woning. Mijn doel was om de Arduino 101 . te gebruiken board potentie om iets nieuws te creëren . Ik denk dat de versnellingsmeter en gyroscoop geef het bestuur nieuwe kansen op het gebied van mobiliteit. Met de BLE, is niet alleen draagbaar, maar ook gemakkelijk teaan te sluiten .

Dit is de eerste keer dat ik concreet een van mijn projecten realiseer (ik bedoel met een werkend prototype). Het was moeilijk en er waren wat moeilijkheden tijdens de weg, maar uiteindelijk heb ik veel geleerd en ben ik blij met het resultaat. Ik hoop dat ook iedereen die deze gids leest iets van mijn werk kan leren en ook dit project kan aanpassen aan hun behoeften . Het spijt me voor mijn slechte Engels, maar ik hoop dat de afbeeldingen je kunnen helpen.

In de toekomst van dit project verwacht ik de centrale dat is als de brug tussen de smart cube en de actuatoren (verlichting, temperatuur, tv...). Deze centrale ontvangt het BLE-signaal van de kubus en gebruikt deze informatie om slimme dingen in huis te doen.

Ik ben erg blij dat ik de mogelijkheid heb om Arduino 101 te gebruiken en de Grove-kit (de kit is heel eenvoudig en snel voor prototyping).

Ik hoop dat het op deze manier gebruiken van het bord een inspiratie kan zijn voor uw project. Je kunt het personaliseren zoals je wilt :Ik ben benieuwd welke functies je gaat maken en in welke andere context je deze gaat gebruiken!

Misschien is dit geen revolutie, maar het is een nieuwe manier om met je huis om te gaan .

Ik hoop dat je deze tutorial leuk vindt.

Nu is het jij aan de beurt :leg je handen op de kubus en hack hem!

Code

  • SMART CUBE - volledige code met opmerkingen
SMART CUBE - complete code met opmerkingenArduino
Dit is de code die u op uw Arduino 101 moet uploaden. U kunt deze code gebruiken zoals deze is of aanpassen op basis van uw behoeften. Volg de opmerkingen om te begrijpen hoe het werkt.
// Libraries#include "CurieIMU.h" // Acelerometer &Gyroscope#include  // Bluetooth Low Energy#include #include "rgb_lcd .h" // LCD#include  // Keypadrgb_lcd lcd; // LCD-initialisatie// Bluetooth-initialisatie:BLEPeripheral blePeripheral; // BLE Peripheral Device (het bord dat u programmeert)// BLE ServicesBLEService lightsService ("1815"); // BLE Automation IO (1815) - lichtinformatie BLEService termoService ("1815"); // BLE Automation IO - temperatuurinformatie BLEService TVService ("1815"); // BLE Automation IO - tv-informatie// BLE-karakteristiekBLEUnsignedCharacteristic lightsChar("2A56", // BLE-karakteristiek Digital (2A56) - lichten BLERead | BLENotify);BLEUnsignedCharacteristic termoChar("2A56", // BLE-karakteristiek Digitaal - temperatuur BLERead | BLENotify );BLEUnsignedCharacteristic TVChar("2A58", // BLE-karakteristiek Analoog (2A58) - tv BLERead | BLENotify);// Declaratie van constante en variabelen:// Gezichtsoriëntatie en schudfuncties:int lastOrientation =- 1; // vorige oriëntatie (ter vergelijking) unsigned long previousMillis =0; // laatste keer update unsigned lange interval =2000; // tijd om in opwaartse positie te wachten voordat het gezicht wordt geactiveerd unsigned long SHAKEpreviousMillis =0; // laatste keer update unsigned lang SHAKEinterval =2000; // tijd om te wachten tijdens het schudden voor gezichtsdeactivatieboolean keep =false; // dit wordt gebruikt om slechts één keer te tellen dat de gezichtsoriëntatie verandert in lastFUNCTION =-1; // dit wordt gebruikt om te weten wat de vorige rientation is// Gezichtsinitialisatie:aan het begin is elk gezicht falseboolean face0 =false;boolean face1 =false;boolean face2 =false;boolean face3 =false;boolean face4 =false;boolean face5 =false;// LIGHTS faceconst int LEDlights =11; // pin 11:gele led// TEMPERATUUR faceconst int pinTemp =A0; // pin A0:temperatuursensorconst int LEDhot =12; // pin 12:rode ledconst int LEDcold =13; // pin 13:blauwe ledfloat temperatuur; // memorisatie temperatuurwaardeint B=3975; // B-waarde van de thermistorfloat-weerstand; // weerstandswaarde onthouden float tooHot =26,0; // temperatuur waarbij de airconditioner wordt geactiveerd [SET]float tooCold =23.0; // temperatuur waarbij de verwarming wordt geactiveerd [SET]// TIMER faceint BUZZER =3; // pin 3:buzzerboolean KEEPtime =false; // dit wordt gebruikt om slechts één keer te tellen dat de gezichtsoriëntatie verandert (niet opnieuw starten tijdens het tellen) 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); Serieel.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.wissen(); // 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   

Aangepaste onderdelen en behuizingen

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

Schema's

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

Productieproces

  1. Waarom zonnepanelen een slimme investering zijn voor uw huis
  2. Ga groot of ga naar huis met je nieuwe productontwerp
  3. Toepassingen van domotica
  4. Een draadloos sensornetwerk in uw huis bouwen
  5. Bewaak je huistemperatuur met je Raspberry Pi
  6. De kloof tussen slimme thuisvaardigheden
  7. Wees slim:de toekomst van je huis
  8. Slimme beveiliging:hoe u uw smarthome-apparaten kunt beschermen tegen hackers
  9. Manieren om de beveiliging van uw Smart Home te verbeteren
  10. Smart Plant IoT
  11. Schakel Alexa Control in op je plafondventilator