Geekly articles weekly

Nuevo módulo receptor nooLite MR1132 para Arduino

imagen

Este artículo discutirá el nuevo módulo receptor de señal nooLite para Arduino y microcontroladores. ¿Qué es lo notable de este módulo? Hasta ahora, no había formas de recibir información de los sensores y monitorear la transmisión de señales desde los controles remotos del sistema nooLite en microcontroladores y Arduino, esta posibilidad solo existía para computadoras que usaban adaptadores USB especiales.

Ahora, con el lanzamiento del módulo MR1132, es posible recibir datos sobre temperatura, humedad, iluminación y la presencia de personas en la habitación desde los sensores inalámbricos del sistema nooLite en sus bocetos en Arduino, la capacidad de rastrear comandos emitidos a las unidades de potencia nooLite por interruptores de control remoto y mucho más de eso que anteriormente no estaba disponible

En este artículo, le contaré sobre el funcionamiento de este módulo y le daré un boceto de trabajo, sobre la base del cual puede crear fácilmente sus dispositivos en el MR1132. En artículos posteriores hablaré sobre la integración de este módulo con el popular sistema Arduino Mega Server y sobre las maravillosas características que aparecerán en relación con esta integración.

Modulo


El módulo MR1132 es muy similar a su hermano, el módulo MT1132 (sobre el cual ya ha habido un ciclo de artículos sobre Gimetays uno , dos , tres ). La diferencia es que el módulo MT1132 es un transmisor, y el módulo MR1132 es un receptor y el mayor efecto se puede obtener cuando se usan juntos.

Otro punto significativo es que el transmisor MT1132 es universal y funciona tanto desde 3.3 V como desde 5 V (lo que significa que funciona con controladores de 3.3 voltios y con 5 voltios), y el receptor solo a partir de 5 V. Esto debe tenerse en cuenta al diseñar sus dispositivos y, si es necesario, utilizar coordinadores de nivel lógico.

imagen

La conexión es tan simple como el módulo MT1132: tensión de alimentación, tierra y dos contactos RX y TX. RTS se puede subir a la tensión de alimentación, pero todo funcionó para mí, incluso sin conectar esta salida.

Trabajo


El módulo funciona a través de una interfaz en serie a una velocidad de 9600. El módulo recibe comandos del controlador y, a su vez, emite datos recibidos del aire (de sensores y controles remotos nooLite).

Echemos un vistazo más de cerca a este punto, para que tenga una comprensión clara de cómo funciona este módulo.

Todos los comandos que el controlador puede enviar al módulo a través de la interfaz en serie están relacionados con los dispositivos nooLite "vinculantes" o "desatados", de los cuales el módulo recibirá datos. No existen más comandos de control para este módulo. Por ejemplo, conectó el sensor de temperatura nooLite PT112 en el canal cero (32 canales en total, que se refleja en el nombre del módulo) y luego el módulo comenzará a recibir datos de este sensor y los enviará a la interfaz en serie (donde nuestra tarea es "atraparlo" y usarlo para nuestro objetivos).

Si ya no necesitamos recibir datos de ningún sensor, entonces podemos enviar un comando de desacoplamiento (en este caso, en el canal cero) y el receptor ya no dará información al controlador desde este sensor.

En cuanto a la información recibida por el módulo MR1132 de los dispositivos nooLite, hay un documento separado que describe el formato de todos los comandos posibles. Nosotros, en el contexto de esta narrativa, de esta extensa lista nos interesaremos en los equipos de sensores de temperatura, humedad y movimiento. Estos comandos se discutirán en detalle a continuación, utilizando el boceto como ejemplo.

Sensores


En nuestros experimentos, se utilizarán tres sensores.

imagen

Sensor de temperatura PT112 y sensor de temperatura y humedad PT111. Se ven iguales y funcionan exactamente de la misma manera, la diferencia es que PT112 solo brinda información sobre la temperatura y PT111 brinda información sobre la temperatura y la humedad. Estos sensores pueden funcionar en modo sensor simple o en modo termostato e higrostato, pero nos interesará un modo sensor simple.

imagen

El tercer sensor es PM111. Este es un sensor de movimiento que puede controlar directamente las unidades de potencia nooLite, pero solo nos interesará como fuente de información sobre el movimiento y la presencia de personas en la sala.

Controlador



Arduino Mega 2560 se utilizará como controlador de control y sus dos interfaces seriales: Serial (para control de información visual) Serial2 (para comunicación con el módulo receptor). Serial1 está reservado para el módulo transmisor MT1132.

imagen

Bosquejo


En la sección de configuración (), se lanzan dos interfaces, se muestra un mensaje de información sobre el inicio del boceto y se emite un comando para vincular los dispositivos nooLite en el canal cero. Este es un comando de prueba y puede comentarlo o reemplazarlo con otro comando (por ejemplo, enlaces en otro canal o desvinculación).

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

Antes de trabajar con un boceto, debe realizar algunos pasos preliminares, a saber, vincular sus sensores al módulo de la siguiente manera:

PT112 - canal cero
PT111 - canal uno
PM111 - canal dos

Para esto necesita ejecutar el boceto tres veces, cambiando el comando de enlace

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

y cada vez presione el botón en el sensor correspondiente. Esto debe hacerse solo una vez, luego el comando de enlace puede comentarse. O, en lugar de ello, coloque el comando para desatar y desate cualquiera de los sensores conectados.

En la sección loop (), solo hay una función mrCheck (), que es responsable de "capturar" mensajes del módulo MR1132 desde la interfaz serial Serial2.

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();
      }
  }
}

Esta función llena la matriz mrBuf [8] con datos provenientes del módulo o los transmite al mensaje en serie "OK", emitido por el módulo MR1132. Además, el contenido de la matriz mrBuf [8] se analiza de acuerdo con el formato de datos de los comandos del sistema nooLite, y las funciones de croquis correspondientes están involucradas en esto.

La función mrNewData () extrae los datos principales de la matriz mrBuf [8] y, según el comando entrante, envía la información necesaria a Serial (canal, comando, temperatura, humedad, estado de la batería del sensor, etc.).

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()

Las funciones que contienen la palabra Imprimir en su nombre se dedican a enviar información a la interfaz en serie para el control visual.

Las siguientes funciones descifran los datos en la matriz mrBuf [8], de acuerdo con el formato de datos de los comandos del sistema nooLite:

mrSetTogl () - valor del contador de comandos entrantes
mrSetBindState () - estado del módulo (enlace / norma)
mrSetReceiveBit () - bit de recepción de control nuevo comando
mrSetChannel () - número de canal
mrSetCommand () - comando
mrSetFormat () - formato de datos
mrSetDeviceType () - tipo de sensor
mrSetDatas () - llena cuatro bytes de datos
mrSetTemperature ()- obtener el valor de temperatura
mrSetHumidity () - obtener el valor de humedad
mrSetBrightness () - obtener el valor de
brillo mrSetBatteryState () - estado de la batería del sensor

Puede ver los detalles de la implementación de estas funciones en el código de esquema completo adjunto a continuación.

Aquí está el boceto completo.

Código de boceto completo
// 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()


Conclusión


De hecho, eso es todo lo que necesita para comenzar a trabajar con el módulo MR1132 y usarlo en sus bocetos y proyectos. Este módulo también se puede utilizar para controlar las señales de las consolas montadas en la pared de nooLite y su sistema ahora puede saber dónde y qué consola funcionó y qué comando envió a las unidades de potencia.

Pronto se lanzará una nueva versión 0.15 del popular sistema Arduino Mega Server y en esta versión habrá soporte incorporado para los módulos MR1132 y una administración conveniente directamente desde la página web y mucho más.

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

More articles:


All Articles