Geekly articles weekly

Módulos Laurent e Casa Inteligente (Parte 2). Arduino e AMS

Este é o segundo artigo de uma série sobre a integração dos módulos Laurent da KernelChip nos sistemas de automação residencial e, nesta parte, focaremos na integração desses módulos ao ecossistema do Arduino. Na primeira parte da série, falamos sobre integração com o popular sistema de automação residencial MajorDoMo e, na terceira, você aprenderá como gerenciar esses módulos a partir de esboços na linguagem de programação Processing, diretamente da área de trabalho do seu computador.

imagem

Arduino é o nosso tudo


Onde sem o Arduino? Não vou descrever as vantagens dessa plataforma há muito tempo, sua popularidade fala por si mesma, então vamos imediatamente aos detalhes técnicos da interação entre os módulos Arduino e Laurent. E, ao longo do caminho, não esqueceremos o sistema Mega Server do Arduino , como um derivado muito interessante do ecossistema do Arduino.

Ferro


Para controlar módulos em uma rede, por exemplo, a placa Arduino Uno comum ou a igualmente popular placa Arduino Mega, completa com uma placa de interface de rede Ethernet Shield montada com base no chip W5100, são adequadas. Todos os exemplos neste artigo são fornecidos para essa combinação e foram testados na prática. Tudo funciona de forma confiável e sem problemas.

imagem
Ethernet Shield baseado no chip W5100

Ou seja, você só precisa pegar o esboço e enviá-lo para sua placa Uno ou Mega, depois de alterá-lo um pouco para suas tarefas.

Gerenciar módulos de esboço


Na primeira parte da série, eu já falei sobre os princípios de gerenciamento dos módulos Laurent pela rede. Para aqueles que ainda não leram a primeira parte, repetirei brevemente a teoria aqui.

As informações são trocadas com os módulos pela rede e, para começar a trabalhar com eles, é necessário estabelecer uma conexão TCP / IP na porta 2424. Depois que a conexão é estabelecida, você pode enviar comandos de texto (os chamados comandos KE) que controlam o módulo. O site do KernelChip possui documentação detalhada, incluindo uma descrição acessível dos comandos KE.

Agora, vamos tentar traduzir esses "termos de referência" teóricos na linguagem simples dos esboços do Arduino.

Esboço


Não explicarei aqui como instalar e configurar o ambiente de programação do Arduino, presume-se que você já tenha feito isso e possa escrever esboços simples. Portanto, para iniciantes, precisamos conectar as bibliotecas necessárias SPI.he Ethernet.h para controlar o barramento e o próprio módulo Ethernet.

#include <SPI.h>
#include <Ethernet.h>

Então você precisa definir as configurações de rede para o módulo Ethernet e o módulo Laurent, que gerenciaremos. Observe que os endereços MAC e IP devem ser exclusivos e LAURENT_PORT deve ser definido como 2424 e nenhum outro.

byte SELF_MAC[] = {0x00, 0x2A, 0xF5, 0x12, 0x67, 0xEE};
byte SELF_IP[] = {192, 168, 2, 20};

byte LAURENT_IP[] = {192, 168, 2, 19};
int LAURENT_PORT = 2424;

Ainda precisamos de um buffer para armazenar comandos de rede, ele é selecionado com um tamanho de 200 bytes com alguma margem; se você tiver problemas com falta de RAM, poderá reduzi-lo, por exemplo, para 100 bytes ou até menos.

char buf[200];

E o toque final é o cliente Ethernet para o módulo Laurent. Agora, realizaremos todas as operações com o módulo usando o objeto lclient.

EthernetClient lclient;

É isso, agora vamos ver uma função que envia comandos para o módulo Laurent.

void sendLaurentRequest() {
  if (lclient.connect(LAURENT_IP, LAURENT_PORT)) { 
    Serial.print("Command: ");
    Serial.println(buf);
    lclient.println(buf);
    delay(100);
  
    Serial.print("Answer:  ");
    while(lclient.available() != 0) {
      char c = lclient.read();
      Serial.print(c);
    }
    delay(500);
    lclient.stop();
  } else {
      Serial.println("Error sending command");
    }
}

Se uma conexão for estabelecida com o módulo Laurent na porta 2424, o conteúdo do buffer será enviado ao módulo e duplicado em Serial para inspeção visual. São esperados 100 milissegundos e a resposta do módulo é recebida. Depois disso, uma pausa novamente e a comunicação com o módulo é interrompida. Se, por algum motivo, a conexão com o módulo não puder ser estabelecida, uma mensagem de erro será exibida.

Agora vamos analisar a inicialização. A inicialização da Ethernet é uma função simples

void ethernetInit() {
  Ethernet.begin(SELF_MAC, SELF_IP);
}

E o módulo Laurent é inicializado pela função laurentInit (), cuja operação iremos agora analisar em detalhes. É muito grande e você precisa entendê-lo bem, pois é com base no código dessa função que você pode criar suas próprias solicitações para os módulos Laurent.

void laurentInit() {
  Serial.println("Start modul Laurent Init...");
  Serial.print("Connect to Laurent... ");
  if (lclient.connect(LAURENT_IP, LAURENT_PORT)) {
    Serial.println("OK");
    lclient.stop();
    
    // Send test command
    Serial.println("Selftest...");
    sprintf(buf, "$KE");
    sendLaurentRequest();

    // Send password (default: "Laurent")
    Serial.println("Set password...");
    sprintf(buf, "$KE,PSW,SET,Laurent");   
    sendLaurentRequest();
  } else {
      Serial.println("failed");
    }
  delay(500);
    
  //   DATA
  sprintf(buf, "$KE,DAT,OFF");
  sendLaurentRequest();
  delay(100);
  
  //  
  sprintf(buf, "$KE,REL,2,0");
  sendLaurentRequest();
  
  Serial.println("Modul Laurent Init done");
}

Inicialmente, uma mensagem de inicialização é exibida e é feita uma tentativa de conexão com o módulo Laurent. Se isso falhar, uma mensagem de erro será exibida e se a conexão ao módulo for bem-sucedida, um comando de autodiagnóstico é enviado, ao qual o módulo íntegro deve responder com “#OK”.

Em seguida, um comando é enviado para inserir a senha (nesse caso, essa é a senha padrão). E são esperados 500 milissegundos.

Em seguida, dois comandos adicionais são introduzidos - um deles interrompe a saída de dados pelo módulo (se for o caso) e o segundo desliga o relé nº 2, que usamos em nossos experimentos. Em outras palavras, esses comandos levam o módulo a algum estado inicial.

Aqui está uma impressão do processo de inicialização no qual todos os comandos e todas as respostas do módulo estão visíveis:

Start modul Laurent Init...
Connect to Laurent... OK
Selftest...
Command: $KE
Answer:  #OK
Set password...
Command: $KE,PSW,SET,Laurent
Answer:  #PSW,SET,OK
Command: $KE,DAT,OFF
Answer:  #DAT,OK
Command: $KE,REL,2,0
Answer:  #REL,OK
Modul Laurent Init done

Agora, o código para a função setup () padrão. Todos os subsistemas são inicializados, incluindo uma porta serial a uma taxa de 9600 bauds padrão.

void setup() {  
  Serial.begin(9600);  
  ethernetInit();
  laurentInit();
}

Assim, inicializamos o módulo e podemos gerenciá-lo da maneira que precisamos: enviar comandos, ler respostas, criar lógica de controle levando em consideração os dados emitidos pelo módulo Laurent.

Considere, por exemplo, a tarefa mais simples - ligar e desligar a intervalos regulares a luz de uma lâmpada conectada ao segundo relé do módulo Laurent.

void loop() {
  //  
  sprintf(buf, "$KE,REL,2,1");
  sendLaurentRequest();
  delay(3000);
  //  
  sprintf(buf, "$KE,REL,2,0");
  sendLaurentRequest();
  delay(3000);
}

A função loop () é um loop infinito e a lâmpada, obedecendo aos nossos comandos, acende e apaga continuamente a cada 3 segundos. Isso, é claro, é apenas um exemplo; de fato, a lógica do trabalho pode ser qualquer e tudo depende de suas necessidades. E, é claro, você pode enviar não apenas comandos para ativar ou desativar cargas, mas também quaisquer outros suportados pelo módulo. Você pode encontrar uma lista completa de comandos e suas descrições na documentação dos módulos Laurent.

Você pode pegar esse esboço e integrá-lo aos seus próprios projetos, adicionando suporte a eles para gerenciar os módulos Laurent. Ou vice-versa, tome esse esboço como base e aumente gradualmente sua funcionalidade. Não há limite para a perfeição. Aqui está o esboço completo.

Código de esboço completo
#include <SPI.h>
#include <Ethernet.h>

byte SELF_MAC[] = {0x00, 0x2A, 0xF5, 0x12, 0x67, 0xEE};
byte SELF_IP[] = {192, 168, 2, 20};

byte LAURENT_IP[] = {192, 168, 2, 19};
int LAURENT_PORT = 2424;

char buf[200];

EthernetClient lclient;

void ethernetInit() {
Ethernet.begin(SELF_MAC, SELF_IP);
}

void laurentInit() {
Serial.println(«Start modul Laurent Init...»);
Serial.print(«Connect to Laurent… „);
if (lclient.connect(LAURENT_IP, LAURENT_PORT)) {
Serial.println(“OK»);
lclient.stop();

// Send test command
Serial.println(«Selftest...»);
sprintf(buf, "$KE");
sendLaurentRequest();

// Send password (default: «Laurent»)
Serial.println(«Set password...»);
sprintf(buf, "$KE,PSW,SET,Laurent");
sendLaurentRequest();
} else {
Serial.println(«failed»);
}
delay(500);

// DATA
sprintf(buf, "$KE,DAT,OFF");
sendLaurentRequest();
delay(100);

//
sprintf(buf, "$KE,REL,2,0");
sendLaurentRequest();

Serial.println(«Modul Laurent Init done»);
} // laurentInit

void sendLaurentRequest() {
if (lclient.connect(LAURENT_IP, LAURENT_PORT)) {
Serial.print(«Command: „);
Serial.println(buf);
lclient.println(buf);
delay(100);

Serial.print(“Answer: „);
while(lclient.available() != 0) {
char c = lclient.read();
Serial.print©;
}
delay(500);
lclient.stop();
} else {
Serial.println(“Error sending command»);
}
} // sendLaurentRequest

void setup() {
Serial.begin(9600);
ethernetInit();
laurentInit();
}

void loop() {
//
sprintf(buf, "$KE,REL,2,1");
sendLaurentRequest();
delay(3000);

//
sprintf(buf, "$KE,REL,2,0");
sendLaurentRequest();
delay(3000);
}


Arduino Mega Server


imagem

O Arduino Mega Server (AMS) é um sistema poderoso para o Arduino Mega (agora também para o Arduino DUE e, em breve, para outras plataformas de 32 bits M0 (Zero) e Genuino 101), que contém o código "para todas as ocasiões" e muito mais servidor embutido e interface web amigável. O AMS suporta módulos Laurent imediatamente e você não precisa adicionar nada além da lógica do usuário.

O AMS possui uma estrutura modular e a ativação e desativação de módulos é feita simplesmente comentando uma linha em um esboço, por exemplo,

#define LAURENT_FEATURE

ou

//#define LAURENT_FEATURE

Se a linha for comentada, o módulo não é compilado e não participa do trabalho, como pode ser visto nos indicadores dos módulos no cabeçalho do site. Ou vice-versa, um módulo compilado e funcional é indicado em azul. Nesse caso, o módulo de controle LRT LRT não funciona.

imagem
Indicadores de operação do módulo

Trabalhando com respostas do módulo Laurent


Agora vamos adicionar a capacidade de não apenas mostrar as respostas dos módulos, mas também trabalhar com elas, por exemplo, analisá-las ou exibi-las nas páginas da web do Arduino Mega Server. Para fazer isso, precisamos de uma nova variável de string e uma constante que determine o comprimento da string que atribuímos às respostas dos módulos Laurent. No exemplo de teste, é igual a 25 caracteres, mas você pode aumentá-lo se as respostas não se enquadrarem nesse valor. Você só precisa lembrar que a RAM do microcontrolador é um recurso valioso e precisa salvá-la. Adicione as seguintes linhas ao módulo laurent.ino padrão do pacote AMS:

byte MAX_LEN_LREQUEST = 25;
String lrequest = String(MAX_LEN_LREQUEST);

Também precisamos alterar o código da função que faz as solicitações (as alterações adicionadas são destacadas pelas setas).

void sendLaurentRequest() {
  if (lclient.connect(LAURENT_IP, LAURENT_PORT)) { 
    Serialprint("Command: ");
    Serial.println(buf);
    lclient.println(buf);
    delay(100);
  
    Serialprint("Answer:  ");
    // -------------------->
    lrequest = "";
    // -------------------->
    while(lclient.available() != 0) {
      char c = lclient.read();
      Serial.print(c);
      // -------------------->
      if (lrequest.length() < MAX_LEN_LREQUEST) {
        lrequest += (c);
      }
      // -------------------->
    }
    delay(500);
    lclient.stop();
  } else {
      Serialprint("Error sending command\n");
    }
}

Assim, aprendemos como obter respostas de Laurent na variável lrequest e agora podemos fazer o que acharmos adequado. A seguir, mostrarei como exibir os resultados das consultas diretamente no painel de instrumentos no cabeçalho do site AMS.

Uma pequena nota. Este exemplo usa a função Serialprint em vez do Serial.print padrão, pois economiza mais RAM. E pode ser facilmente convertido em um padrão simplesmente colocando um fim em duas palavras.

Saída da resposta do módulo para o cabeçalho do site


E o último exemplo. Vamos exibir as respostas dos módulos Laurent no cabeçalho do site do Arduino Mega Server. Para fazer isso, precisamos adicionar a solicitação ao loop principal () do esboço do AMS. Abra o arquivo arduino_mega_server.ino e digite o seguinte código antes da função cyclosInSecWork ():

    #ifdef LAURENT_FEATURE
      if (cycle30s) {
        sprintf(buf, "$KE");   
        sendLaurentRequest();
      }
    #endif

Esse código consultará a integridade do módulo Laurent a cada trinta segundos. Naturalmente, este é apenas um exemplo. Nesse local, pode haver qualquer solicitação e qualquer código. Assim, na variável lrequest, temos uma resposta sobre o estado do módulo e agora podemos exibi-lo no cabeçalho do site. Para fazer isso, abra o módulo server_ajax.ino e, no final, no código da função responseDash (EthernetClient cl), antes da linha cl.println (""); adicione o seguinte código:

    #ifdef LAURENT_FEATURE
      sendTagString("laurent", "", lrequest, cl);
    #endif

Na verdade, esse código envia as respostas do módulo para a página da web. Resta fazer duas coisas: a primeira é adicionar código JavaScript que "capturará" nossos dados e a segunda é o código HTML na própria página AMS, onde as respostas do módulo serão exibidas.

Portanto, abra o arquivo scripts.js e na função getDashData () antes do colchete de fechamento} // if (this.responseXML! = Null) digite o código que aceitará nossas instalações.

          // Laurent
          try {
            var laurent = this.responseXML.getElementsByTagName('laurent')[0].childNodes[0].nodeValue;
          } catch (err) {
              laurent = "-";
            }
          document.getElementById("laurent").innerHTML = laurent;

Resta apenas corrigir um pouco o arquivo dash.htm da entrega padrão do AMS e adicionar um código que exibirá informações na tela. Imediatamente após a linha que contém class = "online-device", inserimos nossa nova linha com o código:

<p>Laurent: <span class="value" id="laurent">...</span></p>

Isso é tudo. Exibimos as respostas do módulo Laurent no cabeçalho do site do Mega Server do Arduino. E aqui está o resultado de nossos esforços. O status do módulo é claramente visível no painel AMS e é atualizado a cada 30 segundos; portanto, se algo acontecer com o módulo, você saberá sobre ele após um período máximo de 30 segundos.

imagem

Conclusão


Como você pode ver, não há nada complicado no gerenciamento de módulos Laurent usando o Arduino e o Arduino Mega Server, e se você já possui esses módulos ou planeja adicioná-los ao seu sistema Smart Home, este artigo o ajudará a fazer isso de maneira fácil e simples.

E no próximo artigo do ciclo, você aprenderá como gerenciar Loranes diretamente na tela do seu computador e como tornar o processo de ensinar crianças a programação interativa e mais interessante.

Adição . Um canal do Youtube está aberto e aqui está um vídeo promocional do Arduino Mega Server, que demonstra como trabalhar com um sistema real.

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

More articles:


All Articles