Intel Edison Arbeiten mit Intel IoT Analytics Cloud: Geräteverwaltung

Intel IoT Analytics-Geräteverwaltung

Die fortgesetzte Arbeit mit der Intel IoT Analytics- Cloud konzentriert sich auf Gerätefeedback und sendet Befehle zur Verwaltung des Geräts. Der erste Teil von Intel Edison. Arbeiten mit der Cloud Intel IoT Analytics: Registrierung und Senden von Daten . Wir realisieren den Vorgang des Ein- und Ausschaltens der LED und des Relais. Nehmen Sie zur Demonstration einen Standpunkt aus einem früheren Beitrag ein.
Um Befehle an das Gerät zu senden, wird ein spezieller Komponententyp verwendet - Aktivierung . In einem früheren Beitrag haben wir den Typ der Komponente „Sensor“ betrachtet, mit dem Sie Daten vom Gerät senden können. Die Aktivierung überträgt Daten über das MQTT-Protokoll und WebSocket. Dieser Komponententyp ruft den Befehl string string und seine Namen- / Wertparameter auf.

Registrieren der Aktivierung in der Intel IoT Analytics Cloud Beachten
Sie die Standardaktivierung , die ohne Änderungen für die LED funktioniert. Öffnen Sie das Konto Abschnitt, Katalogabschnitt , Powerswitch.v1.0 Komponente. Powerswitch.v1.0 Komponente Eigenschaften
Intel IoT Analytics-Geräteverwaltung
Fenster Actuator
Intel IoT Analytics-Geräteverwaltung
Komponententyp . weil LED kann nur in zwei Zuständen sein, dann ist der Datentyp Boolean . LED.v1.0 - Befehl für die LED. Schlüssel / Wert, Name - LED , der akzeptierte Wert ist 0 oder 1 . Das Relais ist der gleiche Komponententyp mit einer LED, daher erstellen wir auch einen Aktuator für das Relais.

Intel IoT Analytics-Geräteverwaltung
Komponententypen erstellt.

Konfigurieren des iotkit-Agenten unter Intel Edison
Jetzt müssen Sie sich über SSH bei Intel Edison anmelden. In einem früheren Beitrag wurde Wi-Fi konfiguriert, sodass Sie über LAN eine Verbindung zum Gerät herstellen können.
Betätigungskomponente Unterstützung wurde nur mit Agent - Version 1.5.2 und höher angekündigt. Es wird empfohlen, den Agenten auf die neueste aktuelle Version zu aktualisieren.

Finden Sie die Version des Agenten heraus:
# iotkit-admin -V
Befehl zum
Aktualisieren des Agenten : # npm update iotkit-agent

In der neuesten Version des Agenten wurde es möglich, mit WebSocket zu arbeiten. Um mit WebSocket arbeiten zu können, müssen Sie den Agenten mit dem folgenden Befehl konfigurieren:
# iotkit-admin protocol rest + ws

Zurückschalten in den MQTT-Modus:
# iotkit-admin protocol mqtt

Registrieren Sie den Aktuator für die LED und das Relais bei Intel Edison.
Die Registrierung der Sensoren erfolgt über den Befehl # iotkit-admin register [sensor_name] [sensor_type] . Wir führen die Befehle aus:
# iotkit-admin register led1 Powerswitch.v1.0
# iotkit-admin Register Relay1 Relay.v1.0 Erstellen
Intel IoT Analytics-Geräteverwaltung

einer Skizze für Arduino
Die Komponenten werden registriert. Jetzt bereiten wir eine Skizze für Arduino vor, nehmen wir das IoTKitActuationExample als Beispiel .

Betrachten Sie den Code:
Die Funktion void setup () unterscheidet sich nicht vom vorherigen Beispiel.
In der Funktion void loop () wird eine Funktion eingeführt, mit der empfangene Nachrichten regelmäßig überprüft werden, wobei json ein Zeiger auf eine Nachricht im JSON-Format ist.
void loop() {
  iotkit.receive(callback);
  delay(5000);
}

Rückruffunktion ungültig machen (char * json)
void callback(char* json) {
  Serial.println(json);
  aJsonObject* parsed = aJson.parse(json);
  if (&parsed == NULL) {
    // invalid or empty JSON
    Serial.println("recieved invalid JSON");
    return;
  }

Wenn die empfangenen Daten vorhanden sind, analysieren wir sie weiter.
  aJsonObject* component = aJson.getObjectItem(parsed, "component");
  aJsonObject* command = aJson.getObjectItem(parsed, "command");
  aJsonObject* argv = aJson.getObjectItem(parsed, "argv");
  aJsonObject* argvArray = argv->child;
  aJsonObject* name = argvArray->child; // name : on
  aJsonObject* value = name->next; // value: 1/0

Überprüfen der empfangenen LED.v1.0-Befehle und der Werte "0" oder "1"
  if ((component != NULL)) {
    if (strcmp(component->valuestring, "power") == 0) {
      if ((command != NULL)) {
        if (strcmp(command->valuestring, "LED.v1.0") == 0 && strcmp(value->valuestring, "0") == 0) {
          Serial.println("Light Off!");
          pinMode(13, OUTPUT);
          digitalWrite(13, false);
        }
        if (strcmp(command->valuestring, "LED.v1.0") == 0 && strcmp(value->valuestring, "1") == 0) {
          Serial.println("Light on!");
          pinMode(13, OUTPUT);
          digitalWrite(13, true);
        }
      }
    }
  }


Letzte Skizze mit Sensoren und Bedienelementen:
//LCD 
#include <Wire.h>
#include <LCD.h>
#include <LiquidCrystal_I2C.h>
#define LCD_I2C_ADDR    0x20 // Define I2C Address where the PCF8574T is
#define BACKLIGHT     7
#define LCD_EN  4
#define LCD_RW  5
#define LCD_RS  6
#define LCD_D4  0
#define LCD_D5  1
#define LCD_D6  2
#define LCD_D7  3
LiquidCrystal_I2C       lcd(LCD_I2C_ADDR,LCD_EN,LCD_RW,LCD_RS,LCD_D4,LCD_D5,LCD_D6,LCD_D7);
//BMP085 Barometric Pressure & Temp Sensor
#include <Wire.h>
#include <Adafruit_BMP085.h>
Adafruit_BMP085 bmp;

//for Intel Cloud
#include <IoTkit.h>    // include IoTkit.h to use the Intel IoT Kit
#include <Ethernet.h>  // must be included to use IoTkit
// create an object of the IoTkit class
IoTkit iotkit;
float temperature1;
int pressure1;
int moisturevalue1;
bool led1,relay1;

void setup() {  
  iotkit.begin();
  Serial.begin(9600);
  bmp.begin();
  //init LCD
  lcd.begin (20,4);
  lcd.setBacklightPin(BACKLIGHT,NEGATIVE); // init the backlight
  lcd.setBacklight(HIGH); // Backlight on
  lcd.home ();                  // go home
  lcd.setCursor ( 0, 0 );        
  lcd.print("Edison. Habrahabr");
  //Current state Actiator
  //LED  DFRobot  
  pinMode(8, OUTPUT);
  digitalWrite(8, !false);
  pinMode(9, OUTPUT);
  digitalWrite(9, false);
  //Send state Actiator
  iotkit.send("led1", 0);
  iotkit.send("relay1", 0);
}

void loop() {
  lcd.setCursor ( 0, 1 );  
  lcd.print("Tempera. = ");
  lcd.print(bmp.readTemperature());
  lcd.print(" *C");
  //
  lcd.setCursor ( 0, 2 );        
  lcd.print("Pressure = ");
  lcd.print(bmp.readPressure());
  lcd.print(" Pa");
  //
  lcd.setCursor ( 0, 3 );        
  lcd.print("Moisture Value = ");
  lcd.print(analogRead(0));
  //read
  temperature1=bmp.readTemperature();
  pressure1=bmp.readPressure();
  moisturevalue1=analogRead(0);
  //Console and Send to Intel Cloud
  Serial.println("Sensors");
  Serial.print("temperature1=");
  Serial.println(temperature1);
  iotkit.send("temperature1", temperature1);
  delay(2000); 
  Serial.print("pressure1=");
  Serial.println(pressure1);
  iotkit.send("pressure1", pressure1);
  delay(2000); 
  Serial.print("moisturevalue1=");
  Serial.println(moisturevalue1);
  moisturevalue1=20;
  iotkit.send("moisturevalue1", moisturevalue1);
  //Get command for Actiator
  iotkit.receive(callback);
  //
  delay(1000);               // wait for a second
}

void callback(char* json) {
  Serial.println(json);
  aJsonObject* parsed = aJson.parse(json);
  if (&parsed == NULL) {
    // invalid or empty JSON
    Serial.println("recieved invalid JSON");
    return;
  }   
  aJsonObject* component = aJson.getObjectItem(parsed, "component");
  aJsonObject* command = aJson.getObjectItem(parsed, "command"); 
  aJsonObject* argv = aJson.getObjectItem(parsed, "argv");
  aJsonObject* argvArray = argv->child;
  aJsonObject* name = argvArray->child; // name : on
  aJsonObject* value = name->next; // value: 1/0
  //LED
  if ((component != NULL)) {
    if (strcmp(component->valuestring, "led1") == 0) {
      if ((command != NULL)) {
        if (strcmp(command->valuestring, "LED.v1.0") == 0 && strcmp(value->valuestring, "0") == 0) {
          Serial.println("Light Off!");
          digitalWrite(8, !false);
          //Send state Actiator
          iotkit.send("led1", 0);
        }
        if (strcmp(command->valuestring, "LED.v1.0") == 0 && strcmp(value->valuestring, "1") == 0) {
          Serial.println("Light on!");
          digitalWrite(8, !true);
          //Send state Actiator
          iotkit.send("led1", 0);
        }
      }
    }
  }
  //RELAY
  if ((component != NULL)) {
    if (strcmp(component->valuestring, "relay1") == 0) {
      if ((command != NULL)) {
        if (strcmp(command->valuestring, "RELAY.v1.0") == 0 && strcmp(value->valuestring, "0") == 0) {
          Serial.println("Relay Off!");
          digitalWrite(9, false);
          //Send state Actiator
          iotkit.send("relay1", 0);
        }
        if (strcmp(command->valuestring, "RELAY.v1.0") == 0 && strcmp(value->valuestring, "1") == 0) {
          Serial.println("Relay on!");
          digitalWrite(9, true);
          //Send state Actiator
          iotkit.send("relay1", 0);
        }
      }
    }
  }  
}


Senden von Managementteams
Senden Sie Managementteams aus der Intel IoT Analytics-Cloud. Öffnen Sie den Kontrollbereich . Wählen Sie ein Gerät und eine Komponente.
Intel IoT Analytics-Geräteverwaltung

Fügen Sie Aktionen hinzu, um die LED ein- und auszuschalten. Klicken Sie nach dem Ausfüllen der Felder auf die Schaltfläche Aktion hinzufügen .
Intel IoT Analytics-Geräteverwaltung

Wir machen das gleiche für Relais. Infolgedessen werden vier Einträge in der Tabelle angezeigt. Um die LED einzuschalten, wählen Sie die letzte Zeile aus und klicken Sie auf den Link Senden .
Intel IoT Analytics-Geräteverwaltung

Nach einigen Sekunden leuchtet die LED auf.
Intel IoT Analytics-Geräteverwaltung

Zusammenfassend ist die
Geräteverwaltung nicht komplizierter als das Empfangen von Daten von Sensoren. Der Entwickler muss die eingehende Anforderung im JSON-Format analysieren und die entsprechende Logik anwenden.

Verweise
  1. Skizze zur Auflistung des IoTkit-Codes
  2. github.com - enableiotcom
  3. Edison Erste Schritte - Windows
  4. Blinkender Intel Edison (verkabelt) - Windows
  5. Cloud Intel IoT Analytics
  6. Intel Internet of Things (IoT) -Entwickler-Kit IoT Cloud-Based Analytics-Benutzerhandbuch November 2014

Source: https://habr.com/ru/post/de384631/


All Articles