Geekly articles weekly

Neues nooLite MR1132 Empfängermodul für Arduino

Bild

In diesem Artikel wird das neue nooLite-Signalempfängermodul für Arduino und Mikrocontroller erläutert. Was ist an diesem Modul bemerkenswert? Bisher gab es keine Möglichkeit, Informationen von Sensoren zu empfangen und die Übertragung von Signalen von den Fernbedienungen des nooLite- Systems auf Mikrocontrollern und Arduino zu steuern. Diese Möglichkeit bestand nur für Computer, die spezielle USB-Adapter verwenden.

Mit der Veröffentlichung des MR1132-Moduls ist es jetzt möglich, Daten zu Temperatur, Luftfeuchtigkeit, Beleuchtung und Anwesenheit von Personen im Raum von den drahtlosen Sensoren des nooLite-Systems in Ihren Skizzen auf Arduino zu empfangen, die Möglichkeit, Befehle zu verfolgen, die über Fernbedienungsschalter an nooLite-Netzteile ausgegeben wurden, und vieles mehr das war vorher nicht verfügbar.

In diesem Artikel werde ich Sie über die Funktionsweise dieses Moduls informieren und eine Arbeitsskizze geben, auf deren Grundlage Sie Ihre Geräte einfach auf dem MR1132 erstellen können. In den folgenden Artikeln werde ich über die Integration dieses Moduls in das beliebte Arduino Mega Server-System und über die wunderbaren Funktionen sprechen , die im Zusammenhang mit dieser Integration auftreten werden.

Modul


Das MR1132-Modul ist seinem Bruder, dem MT1132-Modul, sehr ähnlich (über das es bereits einen Artikelzyklus zu den Gimetays eins , zwei , drei gegeben hat ). Der Unterschied besteht darin, dass das MT1132-Modul ein Sender und das MR1132-Modul ein Empfänger ist und der größte Effekt erzielt werden kann, wenn sie zusammen verwendet werden.

Ein weiterer wichtiger Punkt ist, dass der MT1132-Sender universell ist und sowohl mit 3,3 V als auch mit 5 V (dh mit 3,3-Volt-Controllern und mit 5 Volt) und dem Empfänger arbeitet nur ab 5 V. Dies muss beim Entwurf Ihrer Geräte berücksichtigt werden und ggf. logische Ebenenkoordinatoren verwenden.

Bild

Der Anschluss ist so einfach wie beim MT1132-Modul - Versorgungsspannung, Masse und zwei Kontakte RX und TX. RTS kann auf die Versorgungsspannung hochgezogen werden, aber alles hat bei mir funktioniert, auch ohne diesen Ausgang anzuschließen.

Arbeit


Das Modul arbeitet über eine serielle Schnittstelle mit einer Geschwindigkeit von 9600. Das Modul empfängt Befehle von der Steuerung und gibt wiederum Daten aus der Luft aus (von Sensoren und nooLite-Fernbedienungen).

Schauen wir uns diesen Punkt genauer an, damit Sie ein klares Verständnis für die Funktionsweise dieses Moduls haben.

Alle Befehle, die der Controller über die serielle Schnittstelle an das Modul senden kann, beziehen sich auf das „Binden“ oder „Lösen“ von nooLite-Geräten, von denen das Modul dann Daten empfängt. Für dieses Modul sind keine Steuerbefehle mehr vorhanden. Sie haben beispielsweise den Temperatursensor nooLite PT112 an den Nullkanal gebunden (insgesamt 32 Kanäle, was sich im Modulnamen widerspiegelt). Danach empfängt das Modul Daten von diesem Sensor und gibt sie an die serielle Schnittstelle aus (wo unsere Aufgabe darin besteht, sie zu „fangen“ und für unsere zu verwenden Ziele).

Wenn wir keine Daten mehr von einem Sensor empfangen müssen, können wir einen Entkopplungsbefehl senden (in diesem Fall auf Kanal Null), und der Empfänger gibt dem Controller keine Informationen mehr von diesem Sensor.

Für die Informationen, die das MR1132-Modul von nooLite-Geräten empfängt, gibt es ein separates Dokument , das das Format aller möglichen Befehle beschreibt. Wir werden uns im Rahmen dieser Erzählung aus dieser umfangreichen Liste für die Teams von Temperatur-, Feuchtigkeits- und Bewegungssensoren interessieren. Diese Befehle werden im Folgenden anhand der Skizze als Beispiel ausführlich erläutert.

Sensoren


In unseren Experimenten werden drei Sensoren verwendet.

Bild

Temperatursensor PT112 und Temperatur- und Feuchtigkeitssensor PT111. Sie sehen gleich aus und arbeiten genauso, der Unterschied besteht darin, dass PT112 nur Informationen über die Temperatur und PT111 Informationen über Temperatur und Luftfeuchtigkeit liefert. Diese Sensoren können entweder in einem einfachen Sensormodus oder in einem Thermostat- und Hygrostat-Modus arbeiten, aber wir werden an einem einfachen Sensormodus interessiert sein.

Bild

Der dritte Sensor ist PM111. Dies ist ein Bewegungssensor, der nooLite-Aggregate direkt steuern kann. Wir sind jedoch nur an uns als Informationsquelle über die Bewegung und Anwesenheit von Personen im Raum interessiert.

Controller



Arduino Mega 2560 wird als Steuerungscontroller und seine zwei seriellen Schnittstellen verwendet - Seriell (zur visuellen Informationssteuerung) Seriell2 (zur Kommunikation mit dem Empfängermodul). Serial1 ist für das Sendermodul MT1132 reserviert.

Bild

Skizze


Im Abschnitt setup () werden zwei Schnittstellen gestartet, eine Informationsmeldung zum Start der Skizze angezeigt und ein Befehl zum Binden der nooLite-Geräte an den Nullkanal ausgegeben. Dies ist ein Testbefehl, und Sie können ihn auskommentieren oder durch einen anderen Befehl ersetzen (z. B. Bindungen auf einem anderen Kanal oder Aufheben der Bindung).

void setup() {
  Serial.begin(9600);
  Serial2.begin(9600);
  Serial.println("*** Start sketch ***");
  mrBind(0);
  //mrUnbind(0);
}

Bevor Sie mit einer Skizze arbeiten, müssen Sie einige vorbereitende Schritte ausführen, nämlich Ihre Sensoren wie folgt an das Modul binden:

PT112 - Kanal Null
PT111 - Kanal Eins
PM111 - Kanal Zwei

Dazu müssen Sie die Skizze dreimal ausführen und den Bindungsbefehl ändern

mrBind(0);
mrBind(1);
mrBind(2);

und jedes Mal die Taste am entsprechenden Sensor drücken. Dies muss nur einmal durchgeführt werden, dann kann der Bindungsbefehl auskommentiert werden. Oder setzen Sie stattdessen den Befehl zum Auflösen und lösen Sie einen der angeschlossenen Sensoren.

Im Abschnitt loop () gibt es nur eine mrCheck () -Funktion, die für das "Abfangen" von Nachrichten vom MR1132-Modul von der seriellen Schnittstelle Serial2 verantwortlich ist.

void mrCheck() {
  if (Serial2.available() == 8) {
    mrBuf[0] = Serial2.read();
    mrBuf[1] = Serial2.read();
    mrBuf[2] = Serial2.read();
    mrBuf[3] = Serial2.read();
    if (mrBuf[0] == 79 && mrBuf[1] == 75 && mrBuf[2] == 13 && mrBuf[3] == 10) {
      Serial.println("OK");
    } else {
        mrBuf[4] = Serial2.read();
        mrBuf[5] = Serial2.read();
        mrBuf[6] = Serial2.read();
        mrBuf[7] = Serial2.read();
        mrNewData();
      }
  }
}

Diese Funktion füllt das Array mrBuf [8] mit Daten, die vom Modul stammen, oder sendet sie an die vom MR1132-Modul ausgegebene serielle Nachricht „OK“. Ferner wird der Inhalt des Arrays mrBuf [8] gemäß dem Datenformat der nooLite-Systembefehle analysiert, und die entsprechenden Skizzenfunktionen sind daran beteiligt.

Die Funktion mrNewData () extrahiert die Hauptdaten aus dem mrBuf-Array [8] und gibt abhängig vom eingehenden Befehl die erforderlichen Informationen an Serial aus (Kanal, Befehl, Temperatur, Luftfeuchtigkeit, Sensorbatteriestatus usw.).

void mrNewData() {
  mrClearData();
  mrPrintHeader();
  
  mrSetBindState();
  mrPrintBindState();
  mrSetChannel();
  mrPrintChannel();

  mrSetCommand();
  mrSetDatas();

  switch (mrCommand) {
    case 0:
      Serial.print("PIR command: ");Serial.println("OFF");
      break;
    case 2:
      Serial.print("PIR command: "); Serial.println("ON");
      break;
    case 21:
      mrSetDeviceType();
      mrPrintDeviceType();
      if (mrDeviceType == 1) {
        mrSetTemperature();
        mrPrintTemperature();
      }
      if (mrDeviceType == 2) {
        mrSetTemperature();
        mrPrintTemperature();
        mrSetHumidity();
        mrPrintHumidity();
      }
      break;
    default: 
      ;
  } // switch
  mrSetBatteryState();
} // newData()

Funktionen, deren Name das Wort Drucken enthält, geben Informationen zur visuellen Steuerung an die serielle Schnittstelle aus.

Die folgenden Funktionen entschlüsseln die Daten im mrBuf-Array [8] gemäß dem Datenformat der Befehle des nooLite-Systems:

mrSetTogl () - Wert des Zählers der eingehenden Befehle
mrSetBindState () - Modulstatus (Bindung / Norm)
mrSetReceiveBit () - Empfangsbit steuern neuer Befehl
mrSetChannel () - Kanalnummer
mrSetCommand () - Befehl
mrSetFormat () - Datenformat
mrSetDeviceType () - Sensortyp
mrSetDatas () - Füllen Sie vier Datenbytes
mrSetTemperature ()-
Abrufen des Temperaturwerts mrSetHumidity () -
Abrufen des Feuchtigkeitswerts mrSetBrightness () -
Abrufen des Beleuchtungswerts mrSetBatteryState () - Status der Sensorbatterie

Einzelheiten zur Implementierung dieser Funktionen finden Sie im vollständigen Skizzencode unten.

Hier ist die vollständige Skizze.

Vollständiger Skizzencode
// TX2 16
// RX2 17
// TX1 18
// RX1 19

// nooLite MR1132 data
byte mrBuf[8];
int mrTogl = -1;
int mrBindState = -1;
int mrReceiveBit = -1;
int mrChannel = -1;
int mrCommand = -1;
int mrFormat = -1;
int mrData0 = -1;
int mrData1 = -1;
int mrData2 = -1;
int mrData3 = -1;
int mrDeviceType = -1;
int mrBatteryState = -1;
int mrHumidity = -1;
int mrBrightness = -1;
float mrTemp = -1.0;

// nooLite MR1132 bind/unbind

void mrSerialChannel(byte ch) {
switch (ch) {
case 0: Serial.println («0»); break;
case 1: Serial.println («1»); break;
case 2: Serial.println («2»); break;
case 3: Serial.println («3»); break;
case 4: Serial.println («4»); break;
case 5: Serial.println («5»); break;
case 6: Serial.println («6»); break;
case 7: Serial.println («7»); break;
case 8: Serial.println («8»); break;
case 9: Serial.println («9»); break;
case 10: Serial.println(«10»); break;
case 11: Serial.println(«11»); break;
case 12: Serial.println(«12»); break;
case 13: Serial.println(«13»); break;
case 14: Serial.println(«14»); break;
case 15: Serial.println(«15»); break;
case 16: Serial.println(«16»); break;
case 17: Serial.println(«17»); break;
case 18: Serial.println(«18»); break;
case 19: Serial.println(«19»); break;
case 20: Serial.println(«20»); break;
case 21: Serial.println(«21»); break;
case 22: Serial.println(«22»); break;
case 23: Serial.println(«23»); break;
case 24: Serial.println(«24»); break;
case 25: Serial.println(«25»); break;
case 26: Serial.println(«26»); break;
case 27: Serial.println(«27»); break;
case 28: Serial.println(«28»); break;
case 29: Serial.println(«29»); break;
case 30: Serial.println(«30»); break;
case 31: Serial.println(«31»); break;
} // switch
} // mrSerialChannel( )

void mrSerial2Channel(byte ch) {
switch (ch) {
case 0: Serial2.print(«00»); break;
case 1: Serial2.print(«01»); break;
case 2: Serial2.print(«02»); break;
case 3: Serial2.print(«03»); break;
case 4: Serial2.print(«04»); break;
case 5: Serial2.print(«05»); break;
case 6: Serial2.print(«06»); break;
case 7: Serial2.print(«07»); break;
case 8: Serial2.print(«08»); break;
case 9: Serial2.print(«09»); break;
case 10: Serial2.print(«10»); break;
case 11: Serial2.print(«11»); break;
case 12: Serial2.print(«12»); break;
case 13: Serial2.print(«13»); break;
case 14: Serial2.print(«14»); break;
case 15: Serial2.print(«15»); break;
case 16: Serial2.print(«16»); break;
case 17: Serial2.print(«17»); break;
case 18: Serial2.print(«18»); break;
case 19: Serial2.print(«19»); break;
case 20: Serial2.print(«20»); break;
case 21: Serial2.print(«21»); break;
case 22: Serial2.print(«22»); break;
case 23: Serial2.print(«23»); break;
case 24: Serial2.print(«24»); break;
case 25: Serial2.print(«25»); break;
case 26: Serial2.print(«26»); break;
case 27: Serial2.print(«27»); break;
case 28: Serial2.print(«28»); break;
case 29: Serial2.print(«29»); break;
case 30: Serial2.print(«30»); break;
case 31: Serial2.print(«31»); break;
} // switch
} // mrSerial2Channel( )

void mrPrintBind(byte ch) {
Serial.print(«Bind on channel „);
mrSerialChannel(ch);
}

void mrBind(byte ch) {
mrPrintBind(ch);
Serial2.print(“bind_mode_cell_»);
mrSerial2Channel(ch);
Serial2.write(3); // End of Text — B00000011(BIN)
}

void mrPrintUnbind(byte ch) {
Serial.println(«Unbind on channel „);
mrSerialChannel(ch);
}

void mrUnbind(byte ch) {
mrPrintUnbind(ch);
Serial2.print(“clear_one_cell_»);
mrSerial2Channel(ch);
Serial2.write(3);
}

void mrBindStop() {
Serial.println(«Bind mode off»);
Serial2.print(«bind_mode_off»);
Serial2.write(3);
}

void mrClearAll() {
Serial.println(«Clear all cell»);
Serial2.print(«clear_all_cell»);
Serial2.write(3);
}

// nooLite MR1132 print works

void mrPrintHeader() {
Serial.println();
}

void mrPrintDeviceType() {
Serial.print(«Device: „);
if (mrDeviceType == 1) {
Serial.println(“PT112»);
}
if (mrDeviceType == 2) {
Serial.println(«PT111»);
}
}

void mrPrintBindState() {
if (mrBindState == 1) {
Serial.print(«Bind State: „);
Serial.println(“ON»);
}
}

void mrPrintBatteryState() {
if (mrBatteryState == 1) {
Serial.print(«Battery State: „);
Serial.println(“LOW!»);
}
}

void mrPrintChannel() {
Serial.print(«Channel: „);
Serial.println(mrChannel);
}

void mrPrintTemperature() {
Serial.print(“Temp: „);
Serial.println(mrTemp);
}

void mrPrintHumidity() {
Serial.print(“Humidity: „);
Serial.println(mrHumidity);
}

// nooLite MR1132 data works

void mrClearData() {
mrTogl = -1;
mrBindState = -1;
mrReceiveBit = -1;
mrChannel = -1;
mrCommand = -1;
mrFormat = -1;
mrData0 = -1;
mrData1 = -1;
mrData2 = -1;
mrData3 = -1;
mrDeviceType = -1;
mrBatteryState = -1;
mrHumidity = -1;
mrBrightness = -1;
mrTemp = -1.0;
}

void mrSetTogl() {
byte b0 = bitRead(mrBuf[0], 0);
byte b1 = bitRead(mrBuf[0], 1);
byte b2 = bitRead(mrBuf[0], 2);
byte b3 = bitRead(mrBuf[0], 3);
byte b4 = bitRead(mrBuf[0], 4);
byte b5 = bitRead(mrBuf[0], 5);
mrTogl = 32*b5 + 16*b4 + 8*b3 + 4*b2 + 2*b1 + b0;
}

void mrSetBindState() {
mrBindState = bitRead(mrBuf[0], 6);
}

void mrSetReceiveBit() {
mrReceiveBit = bitRead(mrBuf[0], 7);
}

void mrSetChannel() {
mrChannel = mrBuf[1];
}

void mrSetCommand() {
mrCommand = mrBuf[2];
}

void mrSetFormat() {
mrFormat = mrBuf[3];
}

void mrSetDeviceType() {
byte tp1 = bitRead(mrBuf[5], 4);
byte tp2 = bitRead(mrBuf[5], 5);
byte tp3 = bitRead(mrBuf[5], 6);
mrDeviceType = 4*tp3 + 2*tp2 + tp1;
}

void mrSetDatas() {
mrData0 = mrBuf[4];
mrData1 = mrBuf[5];
mrData2 = mrBuf[6];
mrData3 = mrBuf[7];
}

void mrSetTemperature() {
byte t8 = bitRead(mrData1, 0);
byte t9 = bitRead(mrData1, 1);
byte t10= bitRead(mrData1, 2);
int temp2 = 1024*t10 + 512*t9 + 256*t8;

int temp = mrData0 + temp2;

byte t11 = bitRead(mrData1, 3);
if (t11 == 1) {
temp = (4096 — temp) * -1;
}
mrTemp = (float)temp / 10.0;
}

void mrSetBatteryState() {
mrBatteryState = bitRead(mrBuf[5], 7);
}

void mrSetHumidity() {
mrHumidity = mrData2;
}

void mrSetBrightness() {
mrBrightness = mrData3;
}

void mrNewData() {
mrClearData();
mrPrintHeader();

mrSetBindState();
mrPrintBindState();
mrSetChannel();
mrPrintChannel();

mrSetCommand();
mrSetDatas();

switch (mrCommand) {
case 0:
Serial.print(“PIR command: „); Serial.println(“OFF»);
break;
case 2:
Serial.print(«PIR command: „); Serial.println(“ON»);
break;
case 21:
mrSetDeviceType();
mrPrintDeviceType();
if (mrDeviceType == 1) {
mrSetTemperature();
mrPrintTemperature();
}
if (mrDeviceType == 2) {
mrSetTemperature();
mrPrintTemperature();
mrSetHumidity();
mrPrintHumidity();
}
break;
default:
;
} // switch
mrSetBatteryState();
} // newData()

void mrCheck() {
if (Serial2.available() == 8) {
mrBuf[0] = Serial2.read();
mrBuf[1] = Serial2.read();
mrBuf[2] = Serial2.read();
mrBuf[3] = Serial2.read();
if (mrBuf[0] == 79 && mrBuf[1] == 75 && mrBuf[2] == 13 && mrBuf[3] == 10) {
Serial.println(«OK»);
} else {
mrBuf[4] = Serial2.read();
mrBuf[5] = Serial2.read();
mrBuf[6] = Serial2.read();
mrBuf[7] = Serial2.read();
mrNewData();
}
}
}

void setup() {
Serial.begin(9600);
Serial2.begin(9600);
Serial.println("*** Start sketch ***");
mrBind(0);
//mrUnbind(0);
}

void loop() {
mrCheck();
} // loop()


Fazit


Das ist in der Tat alles, was Sie brauchen, um mit dem MR1132-Modul zu arbeiten und es in Ihren Skizzen und Projekten zu verwenden. Dieses Modul kann auch zur Steuerung von Signalen von an der Wand montierten nooLite-Konsolen verwendet werden. Ihr System kann jetzt wissen, wo und welche Konsole funktioniert hat und welchen Befehl es an die Netzteile gesendet hat.

In Kürze wird eine neue 0.15-Version des beliebten Arduino Mega Server- Systems veröffentlicht. In dieser Version werden MR1132-Module und eine komfortable Verwaltung direkt von der Webseite aus unterstützt und vieles mehr.

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

More articles:


All Articles