Geekly articles weekly

Novo módulo receptor nooLite MR1132 para Arduino

imagem

Este artigo discutirá o novo módulo receptor de sinal nooLite para Arduino e microcontroladores. O que é notável sobre este módulo? Até agora, não havia maneiras de receber informações dos sensores e controlar a transmissão de sinais dos controles remotos do sistema nooLite nos microcontroladores e no Arduino; essa possibilidade existia apenas para computadores que utilizam adaptadores USB especiais.

Agora, com o lançamento do módulo MR1132, tornou-se possível receber dados sobre temperatura, umidade, iluminação e presença de pessoas na sala dos sensores sem fio do sistema nooLite em seus esboços no Arduino, a capacidade de rastrear comandos emitidos para as unidades de energia nooLite por interruptores de controle remoto e muito mais disso que estava indisponível anteriormente.

Neste artigo, falarei sobre a operação deste módulo e darei um esboço de trabalho, com base no qual você pode criar facilmente seus dispositivos no MR1132. Nos artigos seguintes, falarei sobre a integração deste módulo com o popular sistema Mega Server do Arduino e sobre os maravilhosos recursos que aparecerão em conexão com essa integração.

Módulo


O módulo MR1132 é muito semelhante ao seu irmão, o módulo MT1132 (sobre o qual já houve um ciclo de artigos sobre o Gimetays um , dois , três ). A diferença é que o módulo MT1132 é um transmissor e o módulo MR1132 é um receptor, e o maior efeito pode ser obtido quando usados ​​em conjunto.

Outro ponto significativo é que o transmissor MT1132 é universal e funciona tanto de 3,3 V como de 5 V (o que significa que funciona com controladores de 3,3 volts e 5 volts) e o receptor somente a partir de 5 V. Isso deve ser levado em consideração ao projetar seus dispositivos e, se necessário, usar coordenadores de nível lógico.

imagem

A conexão é tão simples quanto o módulo MT1132 - tensão de alimentação, terra e dois contatos RX e TX. O RTS pode ser puxado para a tensão de alimentação, mas tudo funcionou para mim, mesmo sem conectar esta saída.

Trabalho


O módulo opera através de uma interface serial a uma velocidade de 9600. O módulo recebe comandos do controlador e, por sua vez, emite dados recebidos do ar (de sensores e controles remotos nooLite).

Vamos dar uma olhada mais de perto neste ponto, para que você tenha uma compreensão clara de como este módulo funciona.

Todos os comandos que o controlador pode enviar para o módulo via interface serial estão relacionados a dispositivos nooLite de "ligação" ou "desatamento", dos quais o módulo receberá dados. Não existem mais comandos de controle para este módulo. Por exemplo, você amarrou o sensor de temperatura nooLite PT112 no canal zero (32 canais no total, o que é refletido no nome do módulo) e depois o módulo começará a receber dados desse sensor e os enviará para a interface serial (onde nossa tarefa é "capturá-lo" e usá-lo em nosso canal). objetivos).

Se não precisarmos mais receber dados de nenhum sensor, podemos enviar um comando de desacoplamento (neste caso, no canal zero) e o receptor não fornecerá mais informações ao controlador a partir desse sensor.

Quanto às informações recebidas pelo módulo MR1132 dos dispositivos nooLite, existe um documento separado que descreve o formato de todos os comandos possíveis. Nós, no contexto desta narrativa, desta extensa lista, estaremos interessados ​​nas equipes de sensores de temperatura, umidade e movimento. Esses comandos serão discutidos em detalhes abaixo, usando o esboço como exemplo.

Sensores


Em nossos experimentos, três sensores serão usados.

imagem

Sensor de temperatura PT112 e sensor de temperatura e umidade PT111. Eles têm a mesma aparência e funcionam exatamente da mesma maneira, a diferença é que o PT112 fornece apenas informações sobre temperatura e o PT111 fornece informações sobre temperatura e umidade. Esses sensores podem funcionar no modo de sensor simples ou no modo de termostato e higrostato, mas estaremos interessados ​​em um modo de sensor simples.

imagem

O terceiro sensor é PM111. Este é um sensor de movimento que pode controlar diretamente as unidades de energia nooLite, mas estaremos interessados ​​apenas em nós como fonte de informações sobre o movimento e a presença de pessoas na sala.

Controlador



O Arduino Mega 2560 será usado como controlador de controle e suas duas interfaces seriais - Serial (para controle de informações visuais) Serial2 (para comunicação com o módulo receptor). Serial1 é reservado para o módulo transmissor MT1132.

imagem

Esboço


Na seção setup (), duas interfaces são ativadas, uma mensagem informativa sobre o início do esboço é exibida e um comando é emitido para ligar os dispositivos nooLite no canal zero. Este é um comando de teste e você pode comentá-lo ou substituí-lo por outro comando (por exemplo, ligações em outro canal ou desatamento).

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

Antes de trabalhar com um esboço, é necessário executar algumas etapas preliminares, a saber, vincular seus sensores ao módulo da seguinte maneira:

PT112 - canal zero
PT111 - canal um
PM111 - canal dois

Para isso, é necessário executar o esboço três vezes, alterando o comando de ligação

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

e sempre que pressionar o botão no sensor correspondente. Isso precisa ser feito apenas uma vez, e o comando de ligação pode ser comentado. Ou, em vez disso, coloque o comando desatar e desate qualquer um dos sensores conectados.

Na seção loop (), existe apenas uma função mrCheck (), responsável por “capturar” as mensagens do módulo MR1132 da interface 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 função preenche a matriz mrBuf [8] com dados provenientes do módulo ou transmite para a mensagem serial "OK", emitida pelo módulo MR1132. Além disso, o conteúdo da matriz mrBuf [8] é analisado de acordo com o formato de dados dos comandos do sistema nooLite, e as funções de esboço correspondentes estão envolvidas nisso.

A função mrNewData () extrai os dados principais da matriz mrBuf [8] e, dependendo do comando recebido, envia as informações necessárias para Serial (canal, comando, temperatura, umidade, status da bateria do 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()

As funções que contêm a palavra Imprimir em seu nome estão envolvidas na saída de informações para a interface serial para controle visual.

As funções a seguir descriptografam os dados no array mrBuf [8], de acordo com o formato de dados dos comandos do sistema nooLite:

mrSetTogl () - valor do contador de comandos recebidos
mrSetBindState () - status do módulo (binding / norm)
mrSetReceiveBit () - bit de recepção de controle novo comando
mrSetChannel () - número do canal
mrSetCommand () - comando
mrSetFormat () - formato de dados
mrSetDeviceType () - tipo de sensor
mrSetDatas () - preenche quatro bytes de dados
mrSetTemperature ()- obtendo o valor da temperatura
mrSetHumidity () - obtendo o valor da umidade
mrSetBrightness () - obtendo o valor da
temperatura mrSetBatteryState () - status da bateria do sensor

Você pode ver os detalhes da implementação dessas funções no código completo do esboço anexado abaixo.

Aqui está o esboço completo.

Código de esboço 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()


Conclusão


Na verdade, é tudo o que você precisa para começar a trabalhar com o módulo MR1132 e usá-lo em seus esboços e projetos. Este módulo também pode ser usado para controlar sinais de consoles de parede nooLite e seu sistema agora pode saber onde e qual console funcionou e qual comando foi enviado às unidades de energia.

Em breve, uma nova versão 0.15 do popular sistema Arduino Mega Server será lançada e, nesta versão, haverá suporte integrado aos módulos MR1132 e gerenciamento conveniente diretamente da página da web e muito mais.

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

More articles:


All Articles