Balizadora Inteligente - PARTE 3

Fala galera! Tudo beleza?

Se você não viu a ultimo post, de uma olhada em: Balizadora Inteligente - PARTE 2.

Nessa etapa vamos abordar testes com painel solar, e consumo de corrente de todo circuito para cálculos de autonomia.

Analisando a tensão do painel solar quando o LED se apaga e acende, cheguei a conclusão que existe um limiar de tensão para fazer o controle do LED, uma tensão abaixo de 0.9v, faz com que o LED acenda, e qualquer nível de tensão que exceda 0.9v faz o LED apagar. Não percebi nenhuma variação na intensidade do brilho, apenas controle ON/OFF. Isso é feito  pelo circuito integrado no epóxi, uma outra forma de controlar, seria a utilização de um sensor de luminosidade como um LDR, na parte plastica é visível um orifício que poderia ser utilizado para isso, pois ele deixa passar a luz.

Com isso utilizando uma bateria com capacidade de 250mA, e consumo total variando de 10mA até 60mA. Vale lembrar que o consumo do NODEMCU varia de acordo com as funcionalidades ativas, poderemos tratar isso melhor na construção do software, abaixo segue tabela de consumo:

Post curto para esclarecer alguns dados, no próximo post vamos tratar da parte de programação do ESP8266.

Fica imagem do que vem pela frente!!

Balizadora Inteligente - PARTE 2

Fala galera! Tudo beleza?

Se você não viu a ultimo poste, de uma olhada em: Balizadora Inteligente - PARTE 1.

Enfim vamos colocar a mão nos componentes, começando pela balizadora:

Caixa onde vem a luminária:

Componentes da caixa e manual:

Bateria de 3,2V e 250mA acompanha o kit:

É muito tranquilo montar a balizadora:

Foto no jardim, sem flash:

Já com flash a LED apaga, provavelmente um circuito de controle de luminosidade ou tensão no painel solar:

Bom, esse é o funcionamento normal, sem nenhuma modificação. Vamos agora abrir o equipamento e fazer alguns testes com multímetro. Para abrir a caixa é muito simples, basta retirar os quatro parafusos com uma chave philips, é importante retirar a bateria para evitar qualquer dano.

Após abrir a tampa, temos acesso ao painel solar, o fio vermelho indica o polo positivo e o preto negativo, interessante notar que em volta do painel existe um tipo de cola/resina para evitar a entrada de água:

       

Focando no circuito de controle, é possível visualizar uma placa simples, existe um circuito integrado, porém com epóxi, assim não conseguimos identificar nenhuma informação, além disso a placa possui alguns resistores e capacitores.

            

LED é do tipo SMD:

A primeira modificação feita, foi adição de dois fios, positivo e negativo, partindo da bateria para alimentar o ESP8266, lembrando que a saída da bateria é de 3.2v, assim podemos ligar direto no VIN e GND do modulo NODEMCU:

          

Feito a conexão para alimentação do modulo, vamos adicionar agora outros fios para coleta de informações. Com um multímetro fiz a leitura da tensão do painel solar, utilizando uma luz externa foi possível perceber a variação da tensão onde o fio verde foi soldado, nesse ponto já temos um divisor de tensão do próprio circuito, possibilitando a leitura pelo canal analógico:

Um segundo fio azul, foi soldado no anodo(+) do LED, possibilitando assim a leitura digital para definir em software se LED esta aceso ou apagado:

Conectando os sinais no ESP8266, e adicionando o sensor DHT11 e acomodando os componentes:

Feito isso, no diagrama abaixo é possível visualizar as conexões feitas no modulo.

Bom é isso!! No próximo post vamos verificar o consumo de corrente, e fazer testes com o painel solar.

Balizadora Inteligente - PARTE 1

Olá a todos!!

Se você perdeu o ultimo post, veja "De volta".

Como comentei no ultimo post, nessa etapa vou mostrar como foi a compra dos componentes. Inicialmente vamos adquirir o principal, para depois se necessário ir comprando mais coisas.

O primeiro item é ESP8266, que pode ser encontrado em diversas versões, nesse caso vamos utilizar o ESP8266 NODEMCU.

         Essa versão do modulo foi escolhida, pois todos os pinos ficam disponíveis e de fácil acesso, além do mais temos uma porta USB que serve para comunicação com PC e alimentação, outro grande detalhe, a placa já possui um conversor de tensão para 3,3v, que é a tensão de alimentação do ESP8266, assim tudo fica mais fácil de ser alimentado. Em contrapartida a placa é um pouco maior que as demais, o que pode ser um problema para encaixar tudo em nossa luminária balizadora.

O modulo pode ser encontrado facilmente na internet com valores variando de 40 reais até 50 reais, por exemplo, no Mercado Livre.

O segundo item do nosso projeto é a luminária balizadora, existem diversas opções no mercado, a que achei interessante foi da marca Ecoforce, que pode ser encontrada na loja web do Walmart e do Leroy Merlin, em lojas de jardim e de iluminação também é possível encontrar.

A compra foi feita na loja física do Leroy Merlin em Contagem/MG o modelo 16738. 

Esse modelo foi escolhido por causa do seu espaço interno, é fácil adicionar uma bateria com maior capacidade e acomodar o modulo ESP8266. 

É isso ai pessoal, no próximo post vamos desmontar a luminária e fazer alguns testes em campo, até mais!!

De volta

A ideia de voltar a escrever no blog sempre vem na cabeça, mas o tempo sempre era curto.

Pois enfim, estou de volta, depois de um ano sem nenhuma postagem ou novidade, volto com nova bagagem e conhecimentos para compartilhar.

Como primeira novidade, é o site www.microembarcado.com.br, voltado a desenvolvimento de projetos sob medida. Visitem a pagina e compartilhem.

Vamos voltar com um projeto aplicando IoT, Internet of Things, ou para os mineiros como eu Internet dos Trem.  A ideia é utilizar uma luminária balizadora LED com painel solar como a da imagem:

De acordo com site do fabricante (ecoforce), essa luminária solar possui as seguintes características:

• Painel Solar 0,4W.

• Bateria de 3,2V – 600mAh.

• 2x LED de 0,2W.

A iluminação não é o foco do projeto, até porque os LEDs tem uma potência muito baixa, e são apenas decorativos. A parte interessante vai ficar por conta da adição de um modulo ESP8266 rodando NODEMCU para aplicar IoT.

O uso do modulo ESP8266 esta sendo muito difundido devido seu preço e facilidade de utilização, não vou entrar em muitos detalhes sobre o modulo, quem tiver interesse de conhecer mais eu recomendo a seguinte leitura no site Embarcados - Apresentando o módulo ESP8266.

Utilizando o ESP8266 a ideia é adicionar os seguintes recursos à luminária balizadora:

• Leitura Temperatura e Umidade  ambiente.

• Gerenciamento de bateria/painel solar.

• Conexão com internet e banco de dados.

Com isso, a ideia é mesclar o uso de diferentes áreas, para construir esse objeto inteligente de forma simples. Vou abordar a programação em LUA, NODECMU, analise de circuitos, construção de pagina WEB utilizando PHP/HTML e banco de dados.

Os posts vão acontecer a cada semana, e no próximo vou cobrir a compra dos componentes necessários.

Até mais!

Novidades!

Em breve novo projeto Seguidor Solar:

Automação residencial com Arduino e Ethernet

Fala pessoal!

Depois de muito tempo sem novidades, vamos começar um projeto novo!!!

A ideia desse projeto é automatizar um pequeno apartamento, nele vamos focar em itens básicos, para num futuro agregar mais funcionalidades.

Basicamente vamos utilizar no inicio do desenvolvimento:

• Arduino UNO
• Ethernet Shield

O Arduino ficara conectado ao Ethernet Shield, tudo conectado na rede do apartamento via porta RJ-45 do roteador WIFI, podendo ser acessado por smartphones/tablets e PCs em geral.

Feito isso, as funcionalidades iniciais serão:

1. Controlar todas luzes e tomadas.
2. Acendimento de luzes automática a noite.
3. Gerar sequencia de acendimento aleatória da luzes.
4. Acionar ar condicionado a distancia (via infra-vermelho).
5. Abrir portão da garagem a distancia (necessário controle remoto).
6. Abrir portão social a distancia.
7. Verificar temperatura/umidade
8. Verificar consumo kw.

Para controlar os dispositivos a distancia sem fios, vamos utilizar um transmissor de radiofrequência, cada objeto terá um receptor. A parte do controle vamos deixar para depois. Inicialmente vamos focar na pagina WEB que o usuário acessa para dar comandos ao microcontrolador.

Essa é a cara de nossa pagina:

Simples, mas funcional, ao apertar os botões o microcontrolador ira enviar um código RF, os receptores de RF vão receber esse código e analisar se tem que tomar alguma ação ou não, controlando assim os dispositivos.

Nesse post não vamos tratar da configuração de rede entre o modulo ethernet (IP/MAC) verifique os códigos de exemplo e a pagina do arduino.

Para construir a pagina acima utilize o seguinte código:

1. #include <SPI.h>
2. #include <Ethernet.h>
3. #include <TextFinder.h>
5. byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
6. byte ip[] = { 192,168,0,75 };
7. EthernetServer server(80);
9. String leituraString;
11. char flag_a;
12. char flag_b;
13. char flag_c;
14. char flag_d;
16. void setup()
17. {
18.   pinMode(5, OUTPUT);
19.   pinMode(6, OUTPUT);
20.   pinMode(7, OUTPUT);
21.   pinMode(8, OUTPUT);
23.   Serial.begin(9600);
25.   Ethernet.begin(mac, ip);
26.   server.begin();
27.   Serial.print("Meu IP:");
28.   Serial.println(Ethernet.localIP());
29. }
31. void loop()
32. {
33.   EthernetClient client = server.available();
35.   if (client)
36.     {
37.      while (client.connected())
38.       {    
39.       if (client.available())
40.         {
41.         char c = client.read();
42.         if (leituraString.length() < 100)
43.           {
44.           leituraString += c;
45.           //Serial.print(c);
46.           }
47.         if (c == '\n')
48.           {
49.           Serial.println(leituraString);
51.           client.println("HTTP/1.1 200 OK");
52.           client.println("Content-Type: text/html");
53.           client.println();
55.           client.println("<HTML>");
56.           client.println("<HEAD>");
57.           client.println("<TITLE>Nosso AP</TITLE>");
58.           client.println("</HEAD>");
59.           client.println("<BODY>");
60.           client.println("<center>");
61.           client.println("<H1>Nosso AP - Controle Remoto </H1>");
62.           client.println("</center>");
64.             client.println("Tempo de funcionamento:");
65.             long tempo=((millis()/1000)/60);
66.             if(tempo<=1)
67.               {
68.                client.println(tempo);
69.                client.print(" minuto");
70.               }
71.             if(tempo>=2)
72.               {
73.                client.println(tempo);
74.                client.print(" minutos");
75.               }
76.             client.print("<br>");
77.            
78.             client.println("Controle T:");
79.             client.print("&nbsp;<input type=submit value='ALL ON' style=width:100px;height:45px onClick=location.href='/?on2468'>");
80.             client.print("&nbsp;<input type=submit value='ALL OFF' style=width:100px;height:45px onClick=location.href='/?off3579'>");
81.            
82.             client.print("<br><br>");
83.            
84.             client.println("Controle A:");
85.             client.print("<input type=submit value=ON style=width:100px;height:45px onClick=location.href='/?on2'>");
86.             client.print("<input type=submit value=OFF style=width:100px;height:45px onClick=location.href='/?off3'>");
87.            
88.             client.print("<br><br>");
89.            
90.             client.println("Controle B:");
91.             client.print("<input type=submit value=ON style=width:100px;height:45px onClick=location.href='/?on4'>");
92.             client.print("<input type=submit value=OFF style=width:100px;height:45px onClick=location.href='/?off5'>");
93.            
94.             client.print("<br><br>");
95.            
96.             client.println("Controle C:");
97.             client.print("<input type=submit value=ON style=width:100px;height:45px onClick=location.href='/?on6'>");
98.             client.print("<input type=submit value=OFF style=width:100px;height:45px onClick=location.href='/?off7'>");
99.            
100.             client.print("<br><br>");
101.            
102.             client.println("Controle D:");
103.             client.print("<input type=submit value=ON style=width:100px;height:45px onClick=location.href='/?on8'>");
104.             client.print("<input type=submit value=OFF style=width:100px;height:45px onClick=location.href='/?off9'>");
106.             client.println("<center>");
107.             client.println("<H1>Status Atual </H1>");
108.             client.println("</center>");    
109.            
110.             client.println("Controle A:");
111.               if(leituraString.indexOf('2') >0)
112.                 {
113.                   flag_a=1;
114.                 }
115.               if(leituraString.indexOf('3') >0)
116.                 {
117.                   flag_a=0;
118.                 }
119.               if(flag_a==1)
120.                 {
121.                   client.print("Ligado");
122.                 }
123.               if(flag_a==0)
124.                 {
125.                   client.print("Desligado");
126.                 }
127.                  
128.             client.print("<br>");
129.                  
130.             client.println("Controle B:");
131.               if(leituraString.indexOf('4') >0)
132.                 {
133.                   flag_b=1;
134.                 }
135.               if(leituraString.indexOf('5') >0)
136.                 {
137.                   flag_b=0;
138.                 }
139.               if(flag_b==1)
140.                 {
141.                   client.print("Ligado");
142.                 }
143.               if(flag_b==0)
144.                 {
145.                   client.print("Desligado");
146.                 }
147.                  
148.             client.print("<br>");
149.            
150.             client.println("Controle C:");
151.               if(leituraString.indexOf('6') >0)
152.                 {
153.                   flag_c=1;
154.                 }
155.               if(leituraString.indexOf('7') >0)
156.                 {
157.                   flag_c=0;  
158.                 }
159.                 if(flag_c==1)
160.                 {
161.                   client.print("Ligado");
162.                 }
163.               if(flag_c==0)
164.                 {
165.                   client.print("Desligado");
166.                 }
167.                                    
168.              client.print("<br>");
169.              
170.              client.println("Controle D:");
171.               if(leituraString.indexOf('8') >0)
172.                 {
173.                   flag_d=1;
174.                 }
175.               if(leituraString.indexOf('9') >0)
176.                 {
177.                   flag_d=0;
178.                 }
179.               if(flag_d==1)
180.                 {
181.                   client.print("Ligado");
182.                 }
183.               if(flag_d==0)
184.                 {
185.                   client.print("Desligado");
186.                 }
187.           // adiciona uma meta de refrescamento, o browser vai pegar dados a cada 5 segundos:
188.           client.println("<meta http-equiv=\"refresh\" content=\"5\">");
190.           client.println("</BODY>");
191.           client.println("</HTML>");
193.           delay(1);
194.           client.stop();
196.           if(leituraString.indexOf('2') >0)//checa por 2
197.           {
198.             digitalWrite(5, HIGH);    // pino 5 alto
199.             Serial.println("Computador a Ligado");
200.           }
201.           if(leituraString.indexOf('3') >0)
202.           {
203.             digitalWrite(5, LOW);  
204.             Serial.println("Computador a Desligado");
205.           }
206.          
207.           if(leituraString.indexOf('4') >0)
208.           {
209.             digitalWrite(6, HIGH);    
210.             Serial.println("Computador b Ligado");
211.           }
212.           if(leituraString.indexOf('5') >0)
213.           {
214.             digitalWrite(6, LOW);  
215.             Serial.println("Computador b Desligado");
216.           }
217.          
218.            if(leituraString.indexOf('6') >0)
219.           {
220.             digitalWrite(7, HIGH);  
221.             Serial.println("Computador c Ligado");
222.           }
223.           if(leituraString.indexOf('7') >0)
224.           {
225.             digitalWrite(7, LOW);  
226.             Serial.println("Computador c Desligado");
227.           }    
228.          
229.             if(leituraString.indexOf('8') >0)
230.           {
231.             digitalWrite(8, HIGH);  
232.             Serial.println("Computador d Ligado");
233.           }
234.           if(leituraString.indexOf('9') >0)
235.           {
236.             digitalWrite(8, LOW);    
237.             Serial.println("Computador d Desligado");
238.           }        
239.           leituraString="";
240.         }
241.       }
242.     }
243.   }
244. }

Programe seu microcontrolador e entre no IP especificado!

Até a próxima.