Sistema de segurança doméstica com Netduino Plus

Esses dias andei dando uma olhada nos projetos existentes do Netudino e achei um projeto muito interessante de um sistema de segurança doméstica feito com Netduino por Mike Linnen! Fantásico! Neste vídeo ele mostra como ele fez o sistema utilizando o Windows Azure e e 11 Netduino Plus conectados via rede.

No vídeo ele mostra a função de cada placa de Netduino Plus e a sua aplicação na solução global de segurança, ele dedica placas para aplicações específicas como botões de um painel e sinalização.

Link para página do Projeto: cloudhomesecurity

É fantástico! Estou realmente impressionado com o profissionalismo da solução, para a plicação ele utilizou a biblioteca MQTT que na verdade é um cliente .Net (. Net Framework,. Net Compact Framework e. Net Micro Framework) para  Internet of Things e comunicação M2M.

MQTT, abreviação de "Message Queue Telemetry Transport", é um protocolo de mensagens de peso leve que permite que dispositivos embarcados com recursos limitados para realizar a comunicação assíncrona em uma rede restrita.

MQTT protocolo baseia-se na publicação / assinatura padrão para que um cliente pode se inscrever em um ou mais tópicos e receber mensagens de outros clientes que publicam sobre estes temas.

Esta amostra é uma biblioteca contém um cliente MQTT que você pode usar para se conectar a qualquer corretor MQTT. É desenvolvido em linguagem C # e funciona na plataforma do Netduino veja: https://m2mqtt.codeplex.com/.

Estou vendo as popções do que posso fazer com o Netduino esse ano, essa solução me pareceu genial, estive pensando esses dias em projetar algumas placas para acoplar no Netduino e transmitir mais possibilidades, uma placa com Relés e I/O com mais potência multiplicadas, talvez um teclado. O grande problema e a viabilização disso, fabricar uma placa dessas requer minimamente umas 10 unidades de forma que fique viável assim eu acho interessante fazer uma para mim e com a divulgação no blog talvez vocês leitores se interessem e acabem comprando algumas.

Alocação de Memória: Struct vs Memory Allocation

Esse post surgiu de uma dúvida que está no Fórum do Netduino: Veja

No fórum, um membro Nofaca fez uma pergunta sobre alocação de memória dizendo que sempre ocorre um problema de OutOfMemoryException quando ele tenta alocar memória para arrays de estruturas.

Fato é que .NETMF tem uma forma própria de alocar memória, as vezes queremos que .NETMF seja igual ao .NET convencional mas não é bem assim, existem algumas limitações relacionadas com a natureza do processador, em outras palavras o .NETMF faz uma parte de um "tipo RTOS" - MSDOS transformando para alto nível o que está em muito baixo nível.

Continuando, ele colocou o seguinte exemplo de código:

 [Serializable, StructLayout(LayoutKind.Sequential)]  
 struct SColor  
 {  
      public byte R;  
      public byte G;  
      public byte B;  
      public byte Alpha;  
 }  

Fato é que ele pretende criar uma estrutura simples que armazena informações de cor. SColor seria uma estrutura para armazenamento de informações de cor RGB e intensidade (Alpha). Segundo o que ele disse não está conseguindo alocar a memória para essa estrutura. Eu tentei confirmar mas funciona bem com a classe de inteiro e com a estrutura SColor!

 Debug.Print("Memory free: " + Debug.GC(true).ToString());  
 int[] _buffer = new int[128 * 64];  

 Debug.Print("Memory free: " + Debug.GC(true).ToString());  
 SColor[] _colors = new SColor[128 * 64];  

A saída do debug dele foi:

 Memory free: 96948  
 Failed allocation for 8194 blocks, 98328 bytes  
 Failed allocation for 8194 blocks, 98328 bytes  

Fato é que existe pouca memória no Netduino isso faz com que facilmente o programa saia do espeço de memória utilizável.

Conforme o Chris Walker respondeu o NETMF teve alguma sobrecarga de memória adicional para cada variável criada. Dessa forma a memória extra utilizada foi mapeada para armazenanda a estrutura e as utilizações da estruturam, ou seja, deu overflow de memória... Quando em um código solto isso não afeta em nada, entenda-se um código solto como um código específico e pequeno.

A alternativa que o Chris Walker deu para esses casos é otimizar é compilando a estruturas dentro do próprio .NETMF compilando-o novamente! Solução Supersaiadin !!!

Como uma solução alternativa também seria trabalhar com array's simples de 4bytes identificados como ocorre no C. Isso reduz a necessidade de uma estrutura exclusiva para a aplicação em questão e reduz com isso a memória de código/uso utiliza para a estrutura. Para não ficar dependente do desmonte seria possível criar estruturas estilo #defines.

Achei interessante a dúvida porque as vezes temos muitos problemas com locação de memória, quem não trabalhou com a conversão de ponto fixo para ponto flutuante não tem ideia de como era difícil... saber a ordem de grandeza de tudo, estudar o erro e a imprecisão em função de onde se colocava a vígula, Q10, Q15, Q18, etc... As vezes isso que define a otimização de uma aplicação, não trata-se de um simples preciosismo mas sim de um recurso para utilização da ferramenta - Netduino - em sua plenitude.

Código alternativo para LCD 16x2 - μLiquidCrystal

Retomando os trabalhos com o Netduino vamos a algo prático e simples que se trata de escrever em um LCD 16x2. A maior parte dos artigos ensina como fazer isso com IC que converte de paralelo para serial isso porque muitas vezes o LCD não fica exatamente perto do dispositivo e mais ainda mais fios complicam ainda mais a criação do protótipo.

Fato é que o barramento paralelo utilizado pelo LCD 16x2 não é necessário para escrever os careceteres básicos, coisa de 98% do que se pretende escrever, só são necessárias 7 vias conforme mostrado por Jeroen em seu blog.

A maioria dos displays alfanuméricos estão baseados no controlador HD44780 por uma questão apenas de padronização para aplicações "plug-and-play". Dentro dessa interface paralela boa parte dos 8-bit são referenciados a controle de fluxo de dados, o barramento paralelo de fato são apenas 4-bits que levados a I/O vamos utilizar só 4! Para muitos metódicos isso seria muito e podemos dizer que um barramento serial só de ida utilizaria uma unica I/O, mas convenhamos, não temos Hardware adicional algum o que vale muito a pena.

Como eu me mudei estou sem a minha banca completa com todas as ferramentas que eu tinha antes e muitos dos meus componentes, fazer uma placa é quase impraticável ainda, foi desse ponto que decidi procurar uma maneira mais fácil de escrever as coisas no LCD e encontrei esse artigo no blog do Jeroen que fala sobre a uLiquidCristal uma implementação completa para comunicação do microframework com o LCD's.

Como temos 90% das vezes queremos uma coisa "easy-to-use" nada de escovação de bit's.... Então vamos a aplicação simples e clara.

Meu primeiro passo foi ir atrás da informação sobre o display que eu tinha disponível. Não foi difícil, uima rápida busca no Google consegui encontrar o Datasheet do dito cujo que me informava a pinagem correta.

O projeto não tem um Release para download no Codeplex então, você vai ter que baixar o código fonte e compila-lo, o que não é nenhum problema. Uma vez compilado basta você ir na sua solução e adicionar a *.dll no "References" do seu projeto.

public class Program

{

    public static void Main()

    {

        // create the transfer provider, use direct GPIO provider

        // Initialize the library with the numbers of the interface pins

        // Use wiring shown here http://arduino.cc/en/uploads/Tutorial/lcd_schem.png

        var lcdProvider = new GpioLcdTransferProvider(Pins.GPIO_PIN_D12,    // RS

                                                        Pins.GPIO_PIN_D11,    // ENABLE

                                                        Pins.GPIO_PIN_D5,     // D4

                                                        Pins.GPIO_PIN_D4,     // D5

                                                        Pins.GPIO_PIN_D3,     // D6

                                                        Pins.GPIO_PIN_D2);    // D7

 

        // create the LCD interface

        var lcd = new Lcd(lcdProvider);

 

        // set up the LCD's number of columns and rows:

        lcd.Begin(20, 2);

 

        // print a message to the LCD.

        lcd.Write("Hello world!");

 

        while (true)

        {

            // set the cursor to the first column on the second line

            lcd.SetCursorPosition(0, 1);

 

            // print the number of milliseconds since reset:

            lcd.Write((Utility.GetMachineTime().Ticks / 10000).ToString());

 

            Thread.Sleep(100);

        }

    }

}




Espero mais uma vez ter ajudado, estou voltando pouco a pouco a minhas atividades normais, vou tentar terminar algumas coisas como o medidor de nível de caixa d'água e o sensor de temperatura para depois partir para novos projetos.