Dankzij de snelle ontwikkeling van micro-elektronica, communicatiekanalen, internettechnologieën en kunstmatige intelligentie (AI) wordt het onderwerp slimme huizen steeds relevanter. De menselijke huisvesting heeft sinds de Steentijd ingrijpende veranderingen ondergaan en is in het tijdperk van de Industriële Revolutie 4.0 en het Internet of Things (IoT) comfortabel, functioneel en veilig geworden. Er komen oplossingen op de markt die een appartement of landhuis transformeren tot complexe informatiesystemen die overal ter wereld met een smartphone worden aangestuurd. Bovendien vereist de interactie tussen mens en machine geen kennis van programmeertalen meer: ​​dankzij spraakherkenning en synthese-algoritmen spreekt een mens in zijn moedertaal met een slim huis.

Sommige smart home-systemen die momenteel op de markt zijn, zijn een logische doorontwikkeling van videobewakingssystemen in de cloud. De ontwikkelaars realiseerden zich dat er behoefte was aan een totaaloplossing, niet alleen voor het bewaken, maar ook voor het beheren van afgelegen objecten.

We bieden u een reeks van drie artikelen aan, die u informeren over alle belangrijke componenten van het cloud smart home-systeem, dat de auteur zelf heeft ontwikkeld en in gebruik heeft genomen. Het eerste artikel is gewijd aan de apparatuur voor de eindgebruiker die in het smart home is geïnstalleerd, het tweede aan de architectuur van het cloudopslag- en gegevensverwerkingssysteem, en het derde aan de clientapplicatie voor het beheer van het systeem op mobiele en vaste apparaten.

Slimme huishoudelijke apparatuur

Laten we eerst eens kijken hoe je van een gewoon appartement, een datsja of een cottage een smart home kunt maken. Hiervoor moet je doorgaans de volgende apparatuur in je huis installeren:

1. sensoren die verschillende parameters van de externe omgeving meten;
2. actuatoren die op externe objecten inwerken;
3. een controller die berekeningen uitvoert op basis van sensormetingen en ingebouwde logica en opdrachten aan actuatoren geeft.

De volgende afbeelding toont een diagram van een slim huis met waterleksensoren (1) in de badkamer, temperatuursensoren (2) en verlichtingssensoren (3) in de slaapkamer, een slimme stekker (4) in de keuken en een CCTV-camera (5) in de gang.

Draadloze sensoren die werken op RF433, Z-Wave, ZigBee, Bluetooth en wifi worden momenteel veel gebruikt. Hun belangrijkste voordelen zijn eenvoudige installatie en gebruik, evenals lage kosten en betrouwbaarheid, omdat fabrikanten ernaar streven hun apparaten op de markt te brengen en beschikbaar te maken voor gewone gebruikers.

Sensoren en actuatoren worden doorgaans draadloos verbonden met een smart home controller (6) – een gespecialiseerde microcomputer die al deze apparaten in één netwerk verbindt en bestuurt.

Sommige oplossingen kunnen echter een sensor, actuator en controller tegelijkertijd combineren. Zo kan een slimme stekkerdoos geprogrammeerd worden om volgens een schema in of uit te schakelen, en kan een cloud-videobewakingscamera video opnemen op basis van een bewegingsdetectiesignaal. In de eenvoudigste gevallen kunt u zonder een aparte controller, maar om een ​​flexibel systeem met meerdere scenario's te creëren, is deze noodzakelijk.

Om de smart home controller met het wereldwijde netwerk te verbinden, kunt u een gewone internetrouter (7) gebruiken, die al lang een vertrouwd huishoudelijk apparaat is geworden. Nog een argument vóór de smart home controller: als de internetverbinding wegvalt, blijft het smart home in de normale modus werken dankzij het logische blok dat in de controller is opgeslagen, en niet in de cloud.

Slimme huiscontroller

De controller voor het in dit artikel besproken cloud smart home-systeem is ontwikkeld op basis van een single-board-microcomputer. Raspberry Pi 3 model B+, die in maart 2018 werd uitgebracht en over voldoende resources en prestaties beschikt voor smart home-taken. Hij is voorzien van een quad-core Cortex-A53-processor op een 64-bits ARMv8-A-architectuur met een kloksnelheid van 1.4 GHz, 1 GB RAM, wifi 802.11ac, Bluetooth 4.2 en een gigabit Ethernet-adapter die werkt via de USB 2.0-bus.

De controller is zeer eenvoudig te monteren: de microcomputer (1) is in een kunststof behuizing (2) geplaatst, waarna een 8 GB microSD-geheugenkaart met software (3) en een USB Z-Wave-netwerkcontroller (4) in de daarvoor bestemde slots worden geplaatst. De smarthomecontroller wordt via een 5V, 2.1A-stroomadapter (5) en een USB-micro-USB-kabel (6) op het elektriciteitsnet aangesloten. Elke controller heeft een uniek identificatienummer, dat bij de eerste keer opstarten in het configuratiebestand wordt geschreven en nodig is voor interactie met de clouddiensten voor smarthomes.

De software voor de smart home controller is ontwikkeld door de auteur van dit artikel op basis van het besturingssysteem Linux Raspbian-stretchHet bestaat uit de volgende hoofdsubsystemen:

• serverproces voor interactie met slimme apparaten voor thuisgebruik en de cloud;
• grafische gebruikersinterface voor het instellen van de configuratie- en bedrijfsparameters van de controller;
• databases voor het opslaan van de controllerconfiguratie.

databank smart home controller wordt geïmplementeerd op basis van een ingebedde DBMS SQLite en is een bestand op de SD-kaart met systeemsoftware. Het dient als opslag voor de controllerconfiguratie: informatie over de aangesloten apparatuur en de huidige status, een blok logische productieregels en informatie die geïndexeerd moet worden (bijvoorbeeld de namen van lokale videobestanden). Wanneer de controller opnieuw wordt opgestart, wordt deze informatie opgeslagen, waardoor de controller weer operationeel kan worden bij stroomuitval.

Grafische interface Slimme thuiscontroller ontwikkeld in PHP 7 met behulp van microframework SlimDe webserver is verantwoordelijk voor de werking van de applicatie. lighttpd, vaak gebruikt in embedded apparaten vanwege de goede prestaties en lage resourcevereisten.

(klik op de afbeelding om deze in hogere resolutie te openen)

De belangrijkste functie van de grafische interface is het verbinden van smarthomeapparatuur (IP-videobewakingscamera's en sensoren) met de controller. De webapplicatie leest de configuratie en huidige status van de controller en de aangesloten apparaten uit de SQLite-database. Om de controllerconfiguratie te wijzigen, verstuurt de applicatie besturingsopdrachten in JSON-formaat via de RESTful API-interface van het serverproces.

Serverproces

Serverproces — een sleutelcomponent die alle belangrijke taken uitvoert bij het automatiseren van de informatieprocessen die de basis vormen van een smart home: het ontvangen en verwerken van sensordata en het uitvoeren van besturingsacties op basis van de ingebouwde logica. Het serverproces is bedoeld om te communiceren met smart home-apparatuur, logische productieregels uit te voeren en opdrachten te ontvangen en te verwerken van de grafische interface en de cloud. Het serverproces in de betreffende smart home-controller is geïmplementeerd als een multithreaded applicatie, ontwikkeld in C++ en gelanceerd als een aparte service. systemd besturingssysteem Linux Raspbian.

De belangrijkste blokken van het serverproces zijn:

1. Berichtenbeheerder;
2. IP-camera server;
3. Z-Wave-apparaatserver;
4. Productie Logische Regels Server;
5. Database met controllerconfiguratie en logische regels;
6. RESTful API-server voor interactie met de grafische interface;
7. MQTT-client voor interactie met de cloud.

Serverprocesblokken worden geïmplementeerd als afzonderlijke threads, waarbij informatie tussen de threads wordt overgedragen in de vorm van berichten in JSON-formaat (of gegevensstructuren die dit formaat in het procesgeheugen representeren).

Het hoofdonderdeel van het serverproces is berichtenbeheerder, die berichten in JSON-formaat naar alle blokken van het serverproces routeert. De typen JSON-berichtinformatievelden en de waarden die ze kunnen aannemen, staan ​​in de tabel:

apparaattype
protocol
berichtType
apparaatstatus
commando

camera
ONVIF
sensorData
on
streaming (aan/uit)

sensor
Z-Wave
commando
korting
opname (aan/uit)

effector
MQTT
bedrijfsLogischeRegel
streaming (aan/uit)
evice(Toevoegen/Verwijderen)

bedrijfslogica
configuratiegegevens
opname (aan/uit)

Bluetooth
apparaatstatus
fout

wifi

rf

Een bericht van een camerabewegingsmelder ziet er bijvoorbeeld zo uit:

{
	"vendor": "*****",
	"version": "3.0.0",
	"timestampMs": "1566293475475",
	"clientType": "gateway",
	"deviceId": "1616453d-30cd-44b7-9bf0-************",
	"deviceType": "camera",
	"protocol": "onvif",
	"messageType": "sensorData",
	"sensorType": "camera",
	"label": "motionDetector",
	"sensorData": "on"
}

Productielogica

Om een ​​bericht van de dispatcher te ontvangen of te verzenden, abonneert het serverprocesblok zich op berichten van een bepaald type. Het abonnement is een productielogicaregel van het type "Als ..., dan ...", weergegeven in JSON-formaat, en een verwijzing naar de berichtenhandler in het serverprocesblok. Om bijvoorbeeld de IP-cameraserver opdrachten van de GUI en de cloud te laten ontvangen, moet u de volgende regel toevoegen:

{
	"if": {
	    "and": [{
		"equal": {
		    "deviceId": "1616453d-30cd-44b7-9bf0-************"
		}
	    },
	    {
		"equal": {
		    "messageType": "command"
		}
	    }
	    ]
	},
	"then": {
	    "result": "true"
	}
}

Indien aan de voorwaarden is voldaan zoals gespecificeerd in antecedent (linkerkant) van de regel is waar, dan wordt deze uitgevoerd Gevolg (rechterkant) van de regel, en de handler krijgt toegang tot de hoofdtekst van het JSON-bericht. Het antecedent ondersteunt logische operatoren die JSON-sleutel-waardeparen vergelijken:

1. gelijk aan "gelijk";
2. niet gelijk aan "niet_gelijk";
3. minder;
4. meer "groter";
5. kleiner dan of gelijk aan "kleiner_of_gelijk";
6. groter dan of gelijk aan "groter_of_gelijk".

De resultaten van de vergelijking kunnen met behulp van Booleaanse algebra-operatoren aan elkaar worden gekoppeld:

1. En "en";
2. OF "of";
3. NIET "niet".

Door operatoren en operanden in de Poolse notatie te schrijven, is het mogelijk om behoorlijk complexe voorwaarden met een groot aantal parameters te vormen.

Precies hetzelfde mechanisme, gebaseerd op JSON-berichten en productieregels in JSON-formaat, wordt gebruikt in het productielogica-serverblok om kennis weer te geven en logische gevolgtrekkingen uit te voeren met behulp van sensorgegevens van slimme thuissensoren.

Met behulp van een mobiele applicatie creëert de gebruiker scenario's op basis waarvan het slimme huis zou moeten functioneren. Bijvoorbeeld: "Als de sensor voor het openen van de voordeur wordt geactiveerd, doe dan het licht in de gang aan"De applicatie leest de identifiers van sensoren (openingssensor) en actuatoren (slimme stopcontacten of slimme lampen) uit de database en vormt een logische regel in JSON-formaat, die naar de smart home controller wordt verzonden. Dit mechanisme wordt uitgebreider besproken in het derde artikel van onze serie, waarin we de clientapplicatie voor smart home control bespreken.

Het hierboven besproken productielogicamechanisme wordt geïmplementeerd met behulp van de bibliotheek SnelleJSON — SAX-parser van JSON-formaat in C++. Sequentieel lezen en parsen van een reeks productieregels maakt het mogelijk om de functie voor datamatching binnen antecedenten eenvoudig te implementeren:

void CRuleEngine::Process(PProperties pFact)
{
    m_pActions->clear();

    rapidjson::Reader   reader;
    for(TStringMap::value_type& rRule : m_Rules)
    {
        std::string sRuleId   = rRule.first;
        std::string sRuleBody = rRule.second;

        CRuleHandler            ruleHandler(pFact);
        rapidjson::StringStream ruleStream(sRuleBody.c_str());
        rapidjson::ParseResult  parseResult = reader.Parse(ruleStream, ruleHandler);
        if(!parseResult)
        {
            m_Logger.LogMessage(
                        NLogger2::ePriorityLevelError,
                        std::string("JSON parse error"),
                        "CRuleEngine::Process()",
                        std::string("RuleId: ") + sRuleId);
        }

        PProperties pAction = ruleHandler.GetAction();
        if(pAction)
        {
            pAction->Set("ruleId", sRuleId);
            m_pActions->push_back(pAction);
        }
    }
}

Hier pFact — een structuur met sleutel-waardeparen uit een JSON-bericht, m_Regels — een stringarray met productieregels. Het inkomende bericht en de productieregel worden vergeleken in de functie lezer.Parse(ruleStream, ruleHandler)Waar regelHandler — is een object dat de logica van Booleaanse operatoren en vergelijkingsoperatoren bevat. sRegelID — een unieke regel-ID waarmee regels in de database van de smart home controller kunnen worden opgeslagen en bewerkt. m_pActies — een array met de resultaten van de logische gevolgtrekking: JSON-berichten met de gevolgen van de regelbasis en doorgestuurd naar de berichtendispatcher zodat abonneethreads deze kunnen verwerken.

De prestaties van RapidJSON zijn vergelijkbaar met die van de functie strlen(), en minimale systeemresourcevereisten maken het mogelijk om deze bibliotheek te gebruiken in embedded apparaten. Door berichten en logische regels in JSON-formaat te gebruiken, kan een flexibel informatie-uitwisselingssysteem worden geïmplementeerd tussen alle componenten van de smart home controller.

Z-Wave-sensoren en -actuatoren

Het belangrijkste voordeel van een smart home is dat het onafhankelijk verschillende parameters van de buitenomgeving kan meten en afhankelijk van de situatie nuttige functies kan uitvoeren. Hiervoor worden sensoren en actuatoren aangesloten op de smart home controller. In de huidige versie zijn dit draadloze apparaten die werken volgens het protocol Z-Wave op een speciaal toegewezen frequentie 869 MHz Voor Rusland. Voor hun werk zijn ze verenigd in een mesh-netwerk, met signaalrepeaters om het dekkingsgebied te vergroten. De apparaten hebben ook een speciale energiebesparende modus: ze staan ​​het grootste deel van de tijd in de slaapstand en sturen alleen informatie wanneer hun status verandert, wat de levensduur van de ingebouwde batterij aanzienlijk verlengt.

Er zijn momenteel een groot aantal verschillende Z-Wave-apparaten op de markt. Laten we er een paar als voorbeeld bekijken:

1. De Zipato PAN16 smart socket kan de volgende parameters meten: elektriciteitsverbruik (kWh), vermogen (W), spanning (V) en stroomsterkte (A) in het elektriciteitsnet. Hij heeft ook een ingebouwde schakelaar waarmee u het aangesloten elektrische apparaat kunt bedienen;
2. De Neo Coolcam-leksensor detecteert de aanwezigheid van gemorst vloeistof door de contacten van de externe sonde te sluiten;
3. De Zipato PH-PSG01 rookmelder wordt geactiveerd wanneer rookdeeltjes de gasanalysekamer binnendringen;
4. De Neo Coolcam-bewegingssensor analyseert infraroodstraling van het menselijk lichaam. Daarnaast is er een lichtsensor (Lx);
5. De Philio PST02-A multisensor meet temperatuur (°C), verlichting (%), deuropening en menselijke aanwezigheid in de kamer;
6. Z-Wave USB-stick ZME E UZB1 netwerkcontroller waarop sensoren worden aangesloten.

Het is erg belangrijk dat de apparaten en de controller op dezelfde frequentie werken, anders zien ze elkaar niet wanneer ze verbonden zijn. Er kunnen maximaal 232 apparaten worden aangesloten op één Z-Wave-netwerkcontroller, wat ruim voldoende is voor een appartement of een landhuis. Om het netwerkbereik binnenshuis uit te breiden, kan het slimme stopcontact worden gebruikt als signaalrepeater.

In het proces van de smart home controller-server dat in de vorige paragraaf werd besproken, is de Z-Wave-server verantwoordelijk voor de interactie met Z-Wave-apparaten. Deze gebruikt de bibliotheek om informatie van sensoren te ontvangen. OpenZWave in C++, dat een interface biedt voor interactie met de Z-Wave netwerk-USB-controller en werkt met diverse sensoren en actuatoren. De waarde van de externe omgevingsparameter die door de sensor wordt gemeten, wordt door de Z-Wave-server vastgelegd als een JSON-bericht:

{
	"vendor": "*****",
	"version": "3.0.0",
	"timestampMs": "1566479791290",
	"clientType": "gateway",
	"deviceId": "20873eb0-dd5e-4213-a175-************",
	"deviceType": "sensor",
	"protocol": "zwave",
	"messageType": "sensorData",
	"homeId": "0xefa0cfa7",
	"nodeId": "20",
	"sensorType": "METER",
	"label": "Voltage",
	"sensorData": "229.3",
	"units": "V"
}

Het wordt vervolgens naar de berichtendispatcher van het serverproces gestuurd, zodat de abonneethreads het kunnen ontvangen. De belangrijkste abonnee is de productielogicaserver, die de waarden van de berichtvelden koppelt aan de antecedenten van logische regels. De resultaten van de logische gevolgtrekking, met daarin besturingsopdrachten, worden teruggestuurd naar de berichtendispatcher en van daaruit naar de Z-Wave-server, die ze decodeert en naar de USB-controller van het Z-Wave-netwerk stuurt. Vervolgens gaan ze naar de actuator, die de status van objecten in de externe omgeving verandert, en zo verricht het slimme huis nuttig werk.

(klik op de afbeelding om deze in hogere resolutie te openen)

Z-Wave-apparaten worden aangesloten in de grafische interface van de smart home controller. Ga hiervoor naar de pagina met de lijst met apparaten en klik op de knop "Toevoegen". De toevoegingsopdracht via de RESTful API-interface gaat naar het serverproces en wordt vervolgens door de berichtenbeheerder naar de Z-Wave-server verzonden. Deze schakelt de Z-Wave-netwerk-USB-controller over naar een speciale modus voor het toevoegen van apparaten. Vervolgens moet u op het Z-Wave-apparaat een reeks korte drukken (3 keer binnen 1,5 seconde) op de serviceknop drukken. De USB-controller verbindt het apparaat met het netwerk en stuurt informatie hierover naar de Z-Wave-server. De server maakt op zijn beurt een nieuw item aan in de SQLite-database met de parameters van het nieuwe apparaat. Na een bepaald tijdsinterval keert de grafische interface terug naar de pagina met de Z-Wave-apparatenlijst, leest informatie uit de database en geeft het nieuwe apparaat weer in de lijst. Elk apparaat ontvangt een eigen unieke identificatiecode, die wordt gebruikt in de regels voor logische productie-inferentie en bij gebruik in de cloud. De werking van dit algoritme wordt weergegeven in het UML-diagram:

(klik op de afbeelding om deze in hogere resolutie te openen)

IP-camera's aansluiten

Het in dit artikel besproken cloud-smarthomesysteem is een upgrade van het cloud-videobewakingssysteem dat eveneens door de auteur is ontwikkeld, dat al enkele jaren op de markt is en in veel Rusland is geïnstalleerd.

Een van de meest prangende problemen bij cloudvideobewakingssystemen is de beperkte keuze aan apparatuur waarmee integratie mogelijk is. De software die verantwoordelijk is voor de verbinding met de cloud is in de videocamera geïnstalleerd, wat direct hoge eisen stelt aan de hardware: de processor en de hoeveelheid vrij geheugen. Dit is de belangrijkste reden waarom cloudvideobewakingscamera's duurder zijn dan reguliere IP-camera's. Bovendien zijn er lange onderhandelingen met fabrikanten van videobewakingscamera's nodig om toegang te krijgen tot het bestandssysteem van de camera en alle benodigde ontwikkeltools.

Aan de andere kant beschikken alle moderne IP-camera's over standaardprotocollen voor interactie met andere apparatuur (met name videorecorders). Het gebruik van een aparte controller die via een standaardprotocol verbinding maakt en videostreams van IP-camera's naar de cloud uitzendt, biedt daarom aanzienlijke concurrentievoordelen voor cloudvideobewakingssystemen. Bovendien, als de klant al een videobewakingssysteem heeft geïnstalleerd op basis van eenvoudige IP-camera's, bestaat de mogelijkheid om dit uit te breiden en om te vormen tot een volwaardig smart home in de cloud.

Het meest populaire protocol voor IP-videobewakingssystemen, dat momenteel zonder uitzondering door alle IP-camerafabrikanten wordt ondersteund, is ONVIF Profile S, waarvan de specificaties bestaan ​​in de Web Services Description Language wsdl. Hulpprogramma's uit de toolkit gebruiken gSOAP Het is mogelijk om de broncode te genereren van services die met IP-camera's werken:

$ wsdl2h -o onvif.h 
	https://www.onvif.org/ver10/device/wsdl/devicemgmt.wsdl 
	https://www.onvif.org/ver10/events/wsdl/event.wsdl 
	https://www.onvif.org/ver10/media/wsdl/media.wsdl 
	https://www.onvif.org/ver20/ptz/wsdl/ptz.wsdl

$ soapcpp2 -Cwvbj -c++11 -d cpp_files/onvif -i onvif.h

Het resultaat is een set headerbestanden "*.h" en bronbestanden "*.cpp" in C++, die direct in een applicatie of een aparte bibliotheek kunnen worden geplaatst en gecompileerd met de GCC-compiler. Door de vele functies is de code omvangrijk en vereist deze aanvullende optimalisatie. De Raspberry Pi 3 model B+ microcomputer heeft voldoende prestaties om deze code uit te voeren, maar als de code naar een ander platform moet worden geporteerd, is het noodzakelijk om de processorarchitectuur en systeembronnen correct te selecteren.

IP-camera's die de ONVIF-standaard ondersteunen, worden bij gebruik in een lokaal netwerk verbonden met een speciale multicastgroep met het adres 239.255.255.250Er is een protocol WS-Discovery, waarmee u het zoeken naar apparaten op het lokale netwerk kunt automatiseren.

De grafische interface van de smart home controller implementeert een zoekfunctie voor IP-camera's in PHP, wat erg handig is bij interactie met webservices via XML-berichten. Bij het selecteren van menu-items Apparaten > IP-camera's > Scannen Het zoekalgoritme voor IP-camera's wordt gestart en de resultaten worden weergegeven in de vorm van een tabel:

(klik op de afbeelding om deze in hogere resolutie te openen)

Wanneer u een camera aan de controller toevoegt, kunt u de instellingen opgeven voor de interactie met de cloud. In deze fase krijgt de camera automatisch een unieke apparaat-ID toegewezen, waarmee deze in de toekomst gemakkelijk in de cloud kan worden geïdentificeerd.

Vervolgens wordt een bericht in JSON-formaat gegenereerd met alle parameters van de toegevoegde camera. Dit bericht wordt via een RESTful API-opdracht verzonden naar het serverproces van de smart home controller. Daar worden de cameraparameters gedecodeerd en opgeslagen in een interne SQLite-database. Ze worden ook gebruikt om de volgende verwerkingsstromen te starten:

1. het tot stand brengen van een RTSP-verbinding om video- en audiostreams te ontvangen;
2. transcoderen van audio van G.711 mu-Law, G.711 A-Law, G.723, enz. formaten naar AAC-formaat;
3. transcoderen van videostreams in H.264-formaat en audio in AAC-formaat naar een FLV-container en deze via het RTMP-protocol naar de cloud verzenden;
4. het tot stand brengen van een verbinding met het eindpunt van de IP-camerabewegingsdetector via het ONVIF-protocol en het periodiek peilen ervan;
5. periodiek genereren van een miniatuurvoorbeeldafbeelding en deze via het MQTT-protocol naar de cloud verzenden;
6. Lokale opname van video- en audiostreams als afzonderlijke MP4-bestanden op de SD- of Flash-kaart van de smart home controller.

Om een ​​verbinding met camera's tot stand te brengen, videostreams te transcoderen, te verwerken en op te nemen in het serverproces, worden functies uit de bibliotheek gebruikt FFmpeg 4.1.0.

Bij het prestatie-testexperiment werden 3 camera's op de controller aangesloten:

1. HiWatch DS-I114W (resolutie - 720p, compressieformaat - H.264, bitsnelheid - 1 Mb/s, geluid G.711 mu-Law);
2. Microdigital MDC-M6290FTD-1 (resolutie - 1080p, compressieformaat - H.264, bitsnelheid - 1 Mb/s, zonder geluid);
3. Dahua DH-IPC-HDW4231EMP-AS-0360B (resolutie - 1080p, compressieformaat - H.264, bitsnelheid - 1.5 Mb/s, AAC-audio).

Alle drie de streams werden gelijktijdig naar de cloud uitgevoerd, audiotranscodering werd alleen vanaf één camera uitgevoerd en lokale archiefopname was uitgeschakeld. De CPU-belasting bedroeg ongeveer 5%, het RAM-gebruik was 32 MB (per proces), 56 MB (totaal inclusief besturingssysteem).

Zo kunnen er ongeveer 20-30 camera's (afhankelijk van de resolutie en bitrate) op een smart home controller worden aangesloten, wat voldoende is voor een videobewakingssysteem voor een huis met drie verdiepingen of een klein magazijn. Voor taken die hogere prestaties vereisen, kan een nettop met een multi-core Intel-processor en besturingssysteem worden gebruikt. Linux Debian Sergeant. De controller wordt momenteel getest en de prestatiegegevens zullen worden bijgewerkt.

Interactie met de cloud

Een smart home in de cloud slaat gebruikersgegevens (video- en sensormetingen) op in de cloud. De architectuur van de cloudopslag wordt in het volgende artikel in onze serie uitgebreider besproken. Laten we het nu hebben over de interface voor het verzenden van informatieberichten van de smart home-controller naar de cloud.

De toestanden van aangesloten apparaten en sensormetingen worden via het protocol verzonden MQTT, dat vaak wordt gebruikt in Internet of Things-projecten vanwege de eenvoud en energiezuinigheid. MQTT maakt gebruik van een client-servermodel, waarbij clients zich abonneren op specifieke onderwerpen binnen een broker en hun berichten publiceren. De broker verstuurt berichten naar alle abonnees volgens regels die zijn gedefinieerd door het QoS-niveau (Quality of Service):

• QoS 0 - maximaal eenmalig (geen leveringsgarantie);
• QoS 1 - minimaal één keer (met leveringsbevestiging);
• QoS 2 - precies één keer (met extra leveringsbevestiging).

In ons geval gebruiken we een MQTT-broker Eclipse MosquitoDe topicnaam is een unieke identificatie van de smarthomecontroller. De MQTT-client binnen het serverproces abonneert zich op dit topic en zendt JSON-berichten van de berichtenbeheerder ernaar uit. En omgekeerd worden berichten van de MQTT-broker door de client naar de berichtenbeheerder gestuurd, die ze vervolgens multiplext naar zijn abonnees binnen het serverproces.

Er wordt gebruikgemaakt van een opgeslagen berichtenmechanisme om berichten over de status van de smart home controller te verzenden. bewaarde berichten MQTT-protocol. Dit maakt het mogelijk om de herverbindingsmomenten tijdens stroomuitval goed te volgen.

De MQTT-client is ontwikkeld op basis van de bibliotheekimplementatie Verduistering Paho in de programmeertaal C++.

H.264 + AAC-mediastreams worden via het RTMP-protocol naar de cloud verzonden, waar een mediaservercluster verantwoordelijk is voor de verwerking en opslag ervan. Om de belasting in het cluster optimaal te verdelen en de minst belaste mediaserver te selecteren, doet de smarthomecontroller een voorlopige aanvraag bij de cloudloadbalancer en verstuurt pas daarna de mediastream.

Conclusie

Het artikel besprak een specifieke implementatie van een smart home controller gebaseerd op de Raspberry Pi 3 B+ microcomputer. Deze kan informatie ontvangen, verwerken en apparatuur aansturen via het Z-Wave protocol, communiceren met IP-camera's via het ONVIF protocol en ook gegevens en commando's uitwisselen met een cloudservice via de MQTT en RTMP protocollen. Een productielogica-engine werd ontwikkeld op basis van de vergelijking van logische regels en feiten gepresenteerd in JSON-formaat.

De slimme thuiscontroller wordt momenteel op verschillende locaties in Moskou en de regio Moskou getest.

De volgende versie van de controller is gepland om apparaten van andere typen aan te sluiten (RF, Bluetooth, wifi, bedraad). Voor het gemak van gebruikers zal de procedure voor het aansluiten van sensoren en IP-camera's worden overgezet naar de mobiele applicatie. Er zijn ook ideeën voor het optimaliseren van de serverprocescode en het porteren van de software naar het besturingssysteem. OpenWrtHierdoor bespaar je op een aparte controller en kun je de functionaliteit van een smart home overbrengen naar een gewone router.

Bron: www.habr.com