Programa em Arduino que utiliza dois sensores de Fluxo de água e um lcd 16x2 com placaI2C

Olá pessoal do Laboratório de Garagem!

Inicialmente agradeço a todos que cooperam pelo compartilhamento de conhecimento neste site.

Sou iniciante nesta área e tenho um problema quanto a utilização dos comandos sei() e cli() que numa placa de modelos Lafvin Uno processador Atmel 328p.

Segue anexo o código que não está reconhecendo estes dois comandos acima (todos os outros comandos ficam grafados, e na fonte que obtive este código inclusive, na cor avermelhada e no meu computador continua com fonte preta:

fluxoAgua.ino

Quando carrego este código para placa só aparece inicialmente no lcd: "Início".

Por que não aparece no LCD escrito os demais códigos e respostas do sensor?

Além disso, qual seria a programação para o seguinte problema:

preciso ler a quantidade de líquido em litros que passa em um sensor yf-s201c e descontar a quantidade de líquido que passa num segundo sensor e por fim calcular a quantidade de litros resultante dividido por um número x a cada vez que um sensor de fim de curso é acionado. Assim imprimindo no LCD este valor em litros.

Desde já grato.

Exibições: 1174

Responder esta

Respostas a este tópico

Boa dia FB, (se não gosta que te chame pelas iniciais, avise),

gostaria muito de te ajudar, mas para isto recomendo as seguintes ações:


1. Remova seu sketch da área de texto do seu tópico;
2. Leia http://labdegaragem.com/forum/topics/sugest-o-de-como-postar
3. Clique em : " Deseja carregar arquivos? " e depois em " Escolher arquivo" e anexe o arquivo
     com o seu sketch.

RV

olá Franciel.

      Li suas questões, e analisei seu código.  Franciel,  pelas suas perguntas e pelo seu código, claramente vc está bem "verde" em Programação.  Mas tranquilo,  todo mundo tem que iniciar de algum ponto, e o importante é isso:  ir em frente.

      Primeiro,  respondendo suas perguntas, na sequência que vc as colocou:

      1)  olhei na Internet o seu modelo de Arduino UNO "Lafvin".   Ele é um Arduino UNO convencional, e pode ser utilizado como qualquer outro UNO. Então vc não precisa se referir a ele especificamente por "Lafvin". Chame-o apenas de "UNO".

      2)  os "comandos"  "sei()" e "cli()" a que vc se refere,  nós chamamos tecnicamente de "statements",  e nada mais são do que funções para controle da Interrupção Geral  do Processador "AVR" (o Processador do Arduino UNO) ,  e que são equivalentes respectivamente às funções "interrupts()" e "noInterrupts()" do Arduino. Assim dê uma olhada no site do Arduino sobre estas duas funções. Os links são estes dois:  "interrupts"  e  "noInterrupts".  O site estará em inglês, então use o tradutor do Google conforme preferir.

      Estes dois "comandos",  só devem ser utilizados se vc tiver uma boa experiência com Programação (não precisa ser do Arduino).  Isto porque,  eles tem consequências diversas para o funcionamento adequado do Sistema, e se utilizados de forma inadequada, seu Sistema poderá ter efeitos colaterais estranhos e que poderão até confundir vc.

      E para o que vc quer fazer, não é necessário usar estes dois "comandos", como mostrarei adiante (no código que implementei).

      3)  o fato dos dois "comandos" não aparecerem "grafados" como vc diz,  é irrelevante.  Vou explicar.  Os "comandos" que aparecem "grafados",  aparecem assim porque eles estão descritos em um arquivo texto  em alguma Biblioteca do Arduinoe estes arquivos sempre tem o nome "keywords.txt".  Isto é usado apenas para ressaltar a visualização dos "comandos" no Editor do Arduino, e nada mais. Ou seja, não tem efeito no resultado da compilação do código. Então não se preocupe com isso.  Além disso, o "sei" e o "cli" não deveriam mesmo aparecerem "grafados", pois são "primitivas" do Compilador AVR,  e não exatamente "comandos", e de fato não deveriam estar em nenhum arquivo "keywords.txt" (e se estiverem, a pessoa que fez isso se equivocou, pois não domina a fundo o ambiente).

      4)  os valores e informações não aparecem adequadamente no Display LCD,  porque simplesmente os "comandos" (ou "statements"), estão sendo usados de forma totalmente equivocada no seu código.  A forma de se usar isto, é simples na plataforma Arduino. Então vc precisa "estudar" um pouco mais sobre isso,  e certamente vai entender como usá-los (no código que estou postando mais adiante, vc poderá ver como isso é feito, e então usar como exemplo).

      5)  como vc está bem "verde" em Programação,  primeiro vc precisa fazer o básico no seu código, e isto nada mais é do que medir a vazão em Litros/minuto  de forma adequada e confiável,  e então depois disso fazer a parte um pouco mais elaborada que vc descreveu (usando dois Sensores de Fluxo "yf-s201c" e um fim-de-curso).  Veja:  se vc medir adequadamente o Fluxo em um Sensor,  então conseguirá medir em dois (ou a quantidade de sensores que vc quiser).  Então bastará fazer os cálculos (algo muito simples em Programação)  no momento adequado (conforme o seu fim-de-curso).  E exibir os resultados no Display, será da mesma forma de sempre.   Mas há Técnicas de Programação, que vc certamente terá que ficar mais acostumado. O que posso te dizer sobre isso, é que as pessoas sempre complicam e são muito desorganizadas, e isto é a chave pra tudo dar errado em Programação.  Programação, exige que vc seja organizado, é imperativo.  Se vc não for assim, então em algum momento vai ter problemas com seu Sistema, e provavelmente eles serão difíceis de resolver (não vou explicar os motivos disto neste momento).

      Então pra dar um empurrão, estou postando um código para o Sistema que vc descreveu no seu código original.  Veja:  não é para o Sistema com dois sensores,  pois quero te mostrar como se faz a coisa mais simples primeiro.  O pessoal que me acompanha aqui, sabe que os Sistemas que posto aqui são bastante completos em termos de explicação e documentação,  e os códigos são totalmente comentados de forma funcional.  E 99% das vezes, eu posto também uma simulação do Sistema (usando o Proteus, devido à popularidade do mesmo).

      Então o que está sendo feito neste código?   Ele simplesmente mede o Fluxo de um Sensor (e nem precisa do "sei" e do "cli"),  e exibe isto no Display,  e após um minuto (ou 60 amostras),  ele calcula a Média da Vazão.  Ou seja, exatamente o que vc tentou fazer no seu código original.  No entanto vc vai perceber,  que o código que estou postando, é completamente diferente do seu original. Então analise o mesmo com atenção, sem pressa, e com a intenção de aprender.  No código, estou usando técnicas clássicas para obter os resultados esperados.  Assim se vc conseguir aprender, terá avançado tremendamente, e poderá seguir em frente com ainda mais confiança.

      Implementei também a Simulação do seu Sistema usando o Proteus,  e o Hardware equivalente, vc pode ver na figura a seguir:

(clique na figura para "zoom")

      Se ficar estranho pra vc o Hardware na figura anterior, não se preocupe,  pois realmente isso vai ocorrer se vc não está familiarizado com Hardware, com Eletrônica, e com o próprio Proteus. O importante é não achar que é algo transcendental ou do Egito antigo.

      O resultado da Simulação vc pode ver nas figuras a seguir, onde "printei" a tela do Proteus  em três momentos diferentes:  4 segundos após iniciar a execução do código,  depois após 32 segundos, e finalmente após 60 segundos (quando a média é calculada e exibida).  Após  a exibição da Média da Vazão,  o Sistema reinicia todo o processo de medição, e isto se repete indefinidamente. Veja os resultados nas figuras:

(clique nas figuras para "zoom")

      O código, vc pode usar diretamente no seu Hardware para verificar o resultado.  Apenas atente que o LCD I2C  usado no código e no Hardware,  tem a "pinagem" padrão  desses módulos comercializados na Internet, e que está especificado na linha 48 no código, conforme vc pode ver na figura a seguir:

(clique na figura para "zoom")

      Embora esta questão da "pinagem" do LCD I2C  estivesse muito confusa (e equivocada) no seu código original,  eu assumi que vc tem um módulo e Display I2C padrões,  e a "pinagem" que usei corresponde a isso.  Mas caso seja diferente (acho pouco provável),  informe aqui,  que tratarei da melhor forma que eu puder.

      O código está aqui:   "Fluxo_Agua_02.zip"

      Como eu disse, vc pode usar este código diretamente no seu Sistema, pois eu segui as definições e pinagens descritas no seu código original.

      E no arquivo zipado,  vc também encontrará os arquivos para Simulação no Proteus, caso deseje fazer a Simulação (lá vc pode variar a vazão, através de um Potenciômetro que altera a taxa de pulsos de forma equivalente ao Sensor "real", e pode até desligar o Fluxo através de uma chave equivalente a um "Registro" hidráulico).

      Espero ter ajudado.

      Abrçs

      Elcids

Olá novamente, Franciel.

      Alterei o Sistema que publiquei aqui ontem,  a fim de que ele representasse o "problema" que vc propôs (eu chamaria de Projeto, mas vc chamou de "problema").

      Assim acrescentei um segundo Sensor de Fluxo,  e  uma Chave "Fim de Curso".

      No entanto, vc não deu detalhes de quando a quantidade de líquido é efetivamente calculada (ou seja: não ficou claro o que vc quis dizer com o "número x" e a relação deste número com o "Fim de Curso").  Então eu apenas estou exibindo o Fluxo em Litros/minuto de cada um dos Sensores,  e após 1 minuto  é exibida também  a média de cada Fluxo,  ou seja, de forma semelhante ao que eu tinha postado ontem.

      O Sistema ficou assim:

(clique na figura para "zoom")

      Observe que mostrei no circuito, a forma como vc deve implementar uma Proteção  para o Sistema, já que provavelmente os Sensores e o "Fim de Curso" estarão distantes do Arduino (e isso causa alguns problemas).  Mas usando as Proteções que coloquei, vc não terá problemas.  Note que nos Circuitos de Proteção, é usado o C.I.  74HC14.  Este circuito integrado (ou C.I.), tem 6 Inversores "Schmitt-Trigger" (embora a simbologia no Proteus não mostre o símbolo do "Schmitt-Trigger"),  mas apenas 3 Inversores estão sendo usados no Sistema (aqueles dois que estão dentro dos módulos representativos dos Sensores, não contam). Então lembre-se que as entradas dos Inversores que "sobrarem", não podem  ficar sem conexão (isto vale apenas as entradas!!!), e devem ser ligadas ou ao GND ou ao 5V do Arduino (o ideal é fazer isso via Resistores de 47k por exemplo, mas pra simplificar vc pode ligar diretamente ao GND ou ao 5V).  E claro:  também não se esqueça que o 74HC14  deve ser alimentado via pinos 7 e 14 do mesmo, respectivamente com o GND e 5V do Arduino.

      E também executei a simulação deste Sistema no Proteus, e vc pode ver o resultado nas figuras a seguir, que foram "printadas" após 3 segundos e 60 segundos de medição:

(clique nas figuras para "zoom")

      Aguardo suas informações com mais detalhes de quando e como a quantidade de líquido é calculada, e assim ajustar o código para fazer isso.

      Abrçs,

      Elcids

Elcids bom dia!

Muito grato pela ajuda mais que completa.

Vamos aos detalhes que aqui ainda não passei.

Este projeto visa atender uma necessidade num pulverizador agrícola.

Nisto preciso calcular a quantidade de litros de calda de defensivo agrícola que está sendo aplicado por Hectare.

Faria isto com o projeto acima, em que preciso medir a quantidade de calda que passa numa mangueira e descontar a quantidade que passa em outra (esta atende a uma necessidade do sistema em regular a pressão necessária e o líquido que passa nela volta ao tanque).

Desta forma, obtenho a quantidade real que está saindo do tanque.

Em seguida preciso uma forma de calcular a quantidade de metros percorridos.

Isso faria com o auxílio de um sensor fim de curso numa roda do trator.

Através deste sistema obtenho a quantidade de líquido que saiu do reservatório no período compreendido entre o último acionamento do sensor da roda até o próximo acionamento.

Sabendo que a largura das barras aplicadoras do pulverizador são de 14 metros e a circunferência da roda tem por exemplo 3 metros (vou aferir ainda esta medida) no intervalo dos acionamentos da roda do trator foi aplicado calda numa área de 42 metros quadrados. Assim obtenho a um dos dados que preciso imprimir no LCD que é a quantidade média de litros de calda sendo aplicada por Hectare no instante, fazendo a quantidade de líquido por exemplo 5 litros vezes a proporção calculada dos 42 metros quadrados frente os 10000m2 de um hectare que é igual a 10000/42=238.

Concluindo que preciso multiplicar a quantidade de líquido aferido entre os dois último pulsos (por exemplo 5 L) por 238 (238 x 5 L = 1190 L/Hc) e imprimir no lcd este dado a cada acionamento do sensor da roda (L/Hc).

Outro dado bem mais simples que precisa ser impresso no LCD é a quantidade total de litros que saiu do tanque desde o início do sistema.

Esta é somente uma ideia. Pode ser alterada a forma de calcular estas informações.

Mas preciso da quantidade de litros aplicada por hectare no instante e a quantidade total de litros que saiu do tanque a partir do momento que o Arduíno foi ligado.

Mais que grato pela colaboração.

olá Franciel.

      Acredito que o Hardware do meu post anterior,  represente bem o Sistema que vc está descrevendo.  Claro, espero que vc aplique os cuidados que mencionei sobre as conexões dos Sensores e do "Fim de Curso", pois senão seu Sistema provavelmente não será "robusto" o suficiente para os problemas que ocorrem quando os "fios" são bem longos (e veja: o tratamento que fiz, é o básico).

      Agora sobre o código, o do último post está bastante preparado pra atender as requisições que vc mencionou, e na realidade faltam apenas alguns "acréscimos" pra isso.

      No entanto, eu percebo uma certa dificuldade em expressar com mais clareza estas requisições, e provavelmente isso ocorre justamente devido à questão "verde" que mencionei antes.  Mas com uma pequena ajuda  facilmente isto é superado, e vou te mostrar como.

      Mas antes entenda que numa primeira instância,  não é necessário que vc descreva a "real forma" que constitui seu Sistema, ou seja, não é necessário saber se são tratores ou se são outras coisas, ou se o líquido é água ou outra coisa. Na forma como estamos fazendo aqui via internet (e fórum), o que é preciso saber é quais são os elementos "medidos" pelo Sistema, e isso vc deixou claro:  dois Sensores de Fluxo e um "Fim de Curso". E claro também como o Sistema deve funcionar.

      Veja, está claro que existem dois Fluxos, e que a vazão destes é indicada por dois Sensores de Fluxo.  O Sistema então deve medir esta vazão (a partir dos pulsos dos Sensores),  exibir estes valores no Display,  e também calcular as Médias em um certo período de tempo, sendo estas Médias também exibidas no Display.  Isto já está sendo feito no Sistema que postei (o primeiro tinha apenas um Sensor de Fluxo, mas o segundo Sistema já tem os dois).  Então o que falta agora é processar de forma adequada estas informações.  Então vou dar um exemplo de como se descreve isto de forma que se possa usar estas informações no código, e assim vc entendendo isso, poderá postar dessa forma aqui, sem deixar dúvidas de como a coisa deve ser de fato.

      Então segue um exemplo  da descrição do seu Sistema (por favor, leia com atenção, pois a maior parte da descrição, acredito ser como seu Sistema deve funcionar):

      1)  dois Sensores indicam o Fluxo de Líquidos. São sensores semelhantes ao "YF-S201C".  Os sinais dos Sensores são aplicados aos pinos "2" e "3" de um Arduino UNO, a fim de medir o Fluxo em cada sensor, em Litros/segundo.

      2)  há também no Sistema, uma chave (ou botão) "Fim de Curso", conectada ao pino "4" do Arduino.  A chave será acionada após um certo tempo "Ta"  (abreviando "Tempo de avaliação"), e este tempo "Ta" é contado a partir do momento que as medições são iniciadas (ou seja, praticamente após o Arduino ser ligado).

      3)  os Fluxos dos dois Sensores, são exibidos no Display a cada segundo. Também é exibido no Display, uma contagem de tempo, que sempre inicia em 0 (zero) segundos, e vai até 59 segundos.  Esta contagem volta a zero após passado 1 minuto, e a contagem em segundos se repete.

      4)  quando é completado 1 minuto, é calculada a Média dos Fluxos neste período de tempo (60 segundos). As Médias de cada Fluxo são então exibidas no Display, e esta exibição dura alguns segundos (por exemplo 5 segundos).

      5)  quando o "Fim de Curso" é acionado,  são então calculadas em Litros, as quantidades de líquido de cada Fluxo.  Então,  a quantidade do Sensor 2  é subtraída da quantidade do Sensor 1, obtendo-se assim uma diferença  entre as duas quantidades. Vamos chamar esta diferença de "dQ" (abreviando "diferença das Quantidades").   Então  este valor  "dQ"  é exibido no Display (por algum tempo).

      6)  uma vez calculado o valor "dQ",  ele é multiplicado por um fator "K" (seria o "238" do exemplo que vc descreveu Franciel).  Vamos chamar este resultado que foi calculado, de "QT" (abreviatura de "Quantidade Total"). Então este valor "QT" é exibido no Display (também por um certo tempo).

      7)  então após este ciclo completo, o Sistema reinicia tudo, zerando a quantidade de Líquido dos dois Fluxos, e repetindo o ciclo.

      Veja Franciel,  uma descrição dessa forma permite que o código execute precisamente o comportamento descrito. Então veja como ela é importante.

      Claro, para a descrição que coloquei, apenas segui o que seu código original estava fazendo e inclui as informações de funcionamento que vc passou até aqui.

      Mas não sei se é exatamente isso,  porque é apenas minha interpretação das coisas.  E vc é quem pode dizer como realmente o Sistema deve se comportar.

      Assim,  aguardo suas informações a respeito, para que eu possa aplicar ao código e postá-lo aqui, incluindo uma Simulação do funcionamento.

      Uma questão:  vc não acha que seria interessante ao invés de usar um Display LCD 16x2,   usar-se o mesmo tipo de Display LCD I2C, porém aquele de 20x4, pois assim teria mais caracteres em uma linha e duas linhas a mais, o que facilitaria a exibição dos dados.

     Veja se é interessante também, incluir um "Módulo Buzzer", desses pra Arduino  que todo mundo usa.  Assim, quando o Sistema completar um ciclo e exibir os resultados, o Buzzer seria acionado indicando que os dados estão disponíveis. Você pode inclusive acrescentar um Botão, e após um ciclo terminar e este Botão ser acionado, então o Sistema reinicia todo o processo (ou ciclo), sem precisar desligar o Arduino.

      Fico no aguardo...

     Abrçs,

     Elcids

Olá Elcids Chagas!

 

Vamos então ao enunciado solicitado. Realmente conforme meu projeto necessitamos de alguns ajustes que seguem abaixo.

1)  dois Sensores indicam o Fluxo de Líquidos. São sensores semelhantes ao "YF-S201C".  Os sinais dos Sensores são aplicados aos pinos "2" e "3" de um Arduino UNO, a fim de medir o Fluxo em cada sensor, em Litros.

2)  há também no Sistema, uma chave (ou botão) "Fim de Curso", conectada ao pino "4" do Arduino

3)Entre os acionamentos do "Fim de Curso"  são então calculadas em Litros, as quantidades de líquido de cada Fluxo.  Então,  a quantidade do Sensor 2  é subtraída da quantidade do Sensor 1, obtendo-se assim uma diferença  entre as duas quantidades. Vamos chamar esta diferença de "dQ" (abreviando "diferença das quantidades). A “dQ” (diferença das Quantidades) é multiplicada por 238.

4) No visor do LCD é necessário impressão de apenas duas informações continuamente. São elas na primeira linha a informação calculada no item “3)” registrado acima, por exemplo, 754 acompanhada de “L/Hc” e na segunda linha a quantidade total do “dQ” em Litros desde o início do programa. Resumindo as informações impressas no LCD ficaria assim:

Vaz = 754 L/Hc

Total = 400 L

5) Reforço que estas informações acima ficam sendo impressas continuamente.

6) Há também no sistema um botão (solicito auxilio para em qual pino ligá-lo) que ao pressioná-lo deverá ser zerada a quantidade total lida desde o início do programa. Depois do acionamento deste botão as informações continuam sendo impressas normalmente no LCD, mas iniciando do zero a contagem de litros da segunda linha do LCD.

Muito grato pela ajuda.

olá Franciel.

      Antes de tudo, me perdoe pelo tempo que demorei em responder. Eu fiz a implementação do Sistema conforme sua descrição, mas também acabei ficando distante do LDG este mesmo tempo. Então antes que o mês se acabe e fique parecendo que abandonei o tópico em questão, irei postar esta implementação, juntamente com a respectiva simulação do funcionamento.

      Mas antes das descrições referentes ao código, é preciso apresentar uma particularidade sobre o Hardware. Foi feita a implementação usando um Display LCD 16x2 via Interface I2C, conforme o Hardware originalmente descrito, e a grande vantagem dessa implementação é que diversos pinos do Arduino ficam “livres” para serem usados em outras funções. Mesmo assim também fiz uma implementação com o mesmo Display LCD 16x2, porém via Interface Paralela  “original” do Display. E claro, nesta última implementação são “consumidos” muito mais pinos do Arduino. Mas eventualmente alguns irão preferir essa implementação via Interface Paralela, pois ela deixa a execução do código bem mais ágil. Além disso a Simulação do I2C no Proteus, tem alguns problemas e eventualmente trava (isto irá variar de computador para computador), e estes problemas não ocorrem com a Interface Paralela. Então já fica a recomendação: para quem for fazer a Simulação para avaliação do funcionamento, é melhor usar a versão com Interface Paralela, principalmente se for deixar a simulação executando por diversos minutos ou mesmo horas.

      Mas para facilitar a coisa toda, no próprio código é possível selecionar qual Interface está sendo usado para o Display. Esta seleção está descrita mais adiante.

      Então, inicio a apresentação do Hardware  usado na simulação para teste do código, nas duas versões para a Interface com o Display. Nas duas figuras a seguir, são mostradas respectivamente a versão com Interface I2C para o Display, e a versão com Interface Paralela:

(clique na figura para “zoom”)

 

(clique na figura para “zoom”)

      Como se vê nas duas figuras anteriores, além dos dois Sensores de Fluxo (ou vazão), do Sensor de giro da Roda do Trator (que na prática é uma chave tipo “Fim de Curso”), do Display LCD 16x2, e do BotãoReiniciar” (ou “Iniciar/Reiniciar”), há também no Sistema, um LEDAlive”, um Botão chamado “Pausa” (ou “Pausa/Continua”), e um Buzzer (no código pode-se selecionar um Buzzer “passivo” ou um “ativo”).

      Para cada um dos três sensores, há também um Circuito de Interface composto por Resistores/Capacitores, cuja função é promover uma proteção adicional para o Arduino, além de Filtrar ruídos e evitar “bouncing” mecânico (principalmente no “Fim de Curso” usado como sensor de giro da Roda do Trator). É altamente recomendável que estes circuitos sejam usados, principalmente porque os três sensores provavelmente estarão distantes do Arduino e conectados via cabos com comprimento considerável.

      A função do LEDAlive” é indicar que o Sistema está operando. Mas ele também indica se o Sistema está “pausado” ou não. Quando o Sistema está pausado, o LED “Alive” pisca duas vezes por segundo. Quando o Sistema está medindo as vazões, o LED “Alive” pisca a cada três segundos. Estes períodos podem ser facilmente alterados no código.

      E o BotãoPausa/Continua”, permite que se pause a medição da vazão. Acionando novamente este Botão, a medição da vazão é retomada. Isto pode ser usado por exemplo, quando o Trator chega ao fim da área linear a ser pulverizada, e é preciso manobrar o Trator para posicioná-lo melhor para continuar a pulverização dentro do mesmo hectare. E claro, durante a manobra, a pulverização pode ser interrompida para evitar desperdício, e neste caso o giro da Roda não seria contabilizado já que o BotãoPausa” foi acionado.

      Já o Buzzer, é usado para fazer sinalizações sonoras, como por exemplo justamente quando o BotãoPausa/Continua” é acionado, pois uma sinalização sonora é mais eficiente que uma sinalização visual para notificar uma alteração imediata. Claro, dependendo do ruído sonoro no ambiente, pode ser necessário usar um sinalizador sonoro mais “forte” que um simples Buzzer, mas isto é uma substituição simples.

      E como já disse anteriormente neste tópico, para a Simulação usei circuitos que geram sinais similares aos dos Sensores de Fluxo e ao “Fim de Curso” (e neste caso sendo acionado de forma cíclica pela Roda do Trator).

      Prints da execução da Simulação são mostrados na duas figuras seguintes, para cada versão da  Interface do LCD  (I2C e paralela):

(clique na figura para “zoom”)

 

(clique na figura para “zoom”)

      Observar que no “Terminal do Arduino” é constantemente exibida a Vazão individual de cada Sensor de Fluxo, em Litros por minuto. É também exibida a vazão em Litros por giro completo da Roda do Trator, sendo esta vazão já efetiva, ou seja, já considera a diferença entre a vazão dos dois Sensores de Fluxo.

      No LCD, é exibida a vazão instantânea em Litros por Hectare, que é atualizada a cada giro completo da Roda do Trator. Também é exibida a vazão total acumulada, em Litros.

      Como um “feature” a mais, momentaneamente e rapidamente, é exibido no LCD também o tempo que já dura a pulverização, em horas, minutos, e segundos. Assim, o LCD fica trocando entre exibir os dados da vazão e o tempo decorrido. O período que dura cada exibição é facilmente alterado no código. As duas figuras a seguir mostram o detalhe de cada exibição no LCD:

(clique na figura para “zoom”)

(clique na figura para “zoom”)

      Na Simulação, deixei as vazões setadas em 8 Litros/minuto e 3,5 Litros/minuto  para os dois Sensores de Fluxo. Mas isso pode ser alterado facilmente nos dois Potenciômetros TP10 e TP20 que fazem parte do circuito que faz a emulação dos sensores. Os Frequencímetros junto a estes circuitos, são usados para verificar a taxa de pulsos, e assim conferir se o código está medindo corretamente (sendo que cada 55 Hz  equivale a 10 Litros por minuto, então basta se fazer uma “regra de três”).

      Já para o “Fim de Curso” que é acionado a cada giro da Roda do Trator, um circuito pouca coisa mais complexo, emula a função na Simulação. Da mesma forma, um Potenciômetro é usado, neste caso para alterar a velocidade de giro da Roda. Um LED “amarelo” indica que a Roda completou um giro e que o “Fim de Curso” foi acionado. O medidor digital ali presente (semelhante ao Frequencímetro usado nos Sensores de Fluxo), indica o tempo decorrido a cada giro da Roda. Neste caso eu deixei setado cada giro em torno de 10 segundos, mas pode ser facilmente alterado no Potenciômetro TP30. A figura a seguir é um “print” do momento em que o “Fim de Curso” é acionado, indicado pelo acionamento momentâneo do LED “amarelo”:

(clique na figura para “zoom”)

      Nestes circuitos que emulam os Sensores de Fluxo e o “Fim de Curso”, as chaves ali existentes, permitem que se pare a vazão nos Sensores de Fluxo, e também o “giro da Roda” (ou seja, parar o Trator).

      Os valores dos Resistores e Capacitores nos Circuitos de Interface dos Sensores e “Fim de Curso”, foram calculados adequadamente para cada tipo de "sinal real”. Os Capacitores C2 e C3 devem ser do tipo Cerâmico. Já C1 pode ser do tipo Eletrolítico comum. E os Resistores podem ser comuns, com 5% de tolerância, e podem ser de baixa potência (por exemplo 1/8 W).

      Agora seguem as descrições sobre as configurações no código para o Arduino, uma vez que o funcionamento do Sistema já foi descrito anteriormente neste tópico.

      Como a “área básica” coberta pela pulverização depende do comprimento da Barra Pulverizadora, e do comprimento linear da circunferência da Roda do Trator, as definições mostradas na figura a seguir estão relacionadas a estes dois parâmetros, e estão logo no início do código:

(clique na figura para “zoom”)


      Assim basta alterar estes dois parâmetros conforme cada caso. Observar que o comprimento da Barra é especificado em metros. Já para se obter o comprimento linear da circunferência da Roda do Trator, basta que seja especificado o raio da Roda, que está definido no código em centímetros. A especificação do raio da Roda facilita a medição na prática (e o código calcula o comprimento linear automaticamente).

      Ainda relacionado à vazão, há a definição do “Fator de Vazão”, conforme mostrado na figura a seguir. O texto na figura explica como este Fator é usado no código, dispensando descrever isso aqui novamente:

(clique na figura para “zoom”)


      Caso o BotãoPausar/Continuar” não seja usado no Sistema, ele pode ser desabilitado no código, no trecho mostrado na figura a seguir:

(clique na figura para “zoom”)


      Já o tipo da Interface usada para o Display LCD, e o número de Colunas x Linhas deste Display, podem ser especificados no código conforme mostrado nas duas figuras a seguir:

(clique na figura para “zoom”)


(clique na figura para “zoom”)


      Se a Interface for I2C, também deve ser definido o Endereço do LCD no barramento I2C, conforme mostrado na figura a seguir:

(clique na figura para “zoom”)


      Observar que está marcado em verde na figura anterior, a correspondente pinagem do LCD em relação ao Módulo I2C usado no Hardware. Normalmente isto é padrão para interfaces baseadas no CI PCF8574 (ou o PCF8574A), e não necessita ser alterado.

      Mas se a Interface usada para o LCD for a “paralela”, então as conexões dos pinos do LCD aos pinos do Arduino, devem ser especificadas, conforme mostrado na figura a seguir:

(clique na figura para “zoom”)

      E se o LEDAlive” ou o Buzzer  não existirem no Sistema, eles podem ser individualmente desabilitados no código, nos dois trechos mostrados a seguir:

(clique na figura para “zoom”)

(clique na figura para “zoom”)

      Um detalhe importante referente a todos os pontos no código onde um “elemento” de Hardware  é habilitado ou desabilitado: se o elemento é desabilitado, então não é necessário alterar nenhuma outra configuração deste elemento, pois não será configurado o pino correspondente ao elemento, e dessa forma mesmo que as funções correspondentes ainda estejam sendo chamadas no código, elas não terão efeito pois o controle do elemento no código já está “preparado” para isto. Então basta somente desabilitar o elemento.

      Segue o código para o Arduino:   "Vazao_Pulverizador_01.zip"

      Seguem os arquivos para Simulação no Proteus:   "Simulacao_Proteus.zip"

      Assim encerro minha participação neste tópico, mas fico à disposição para quaisquer dúvidas a respeito.

      Abrçs,

      Elcids 

oi Franciel.

      Na postagem anterior, esqueci de mencionar uma característica que implementei em relação ao acionamento dos Botões  "Iniciar/Reiniciar"  e "Pausa/Continua".

      Como estes são controles importantes,  para evitar que ocorram acionamentos acidentais (por exemplo ao se pressionar acidentalmente um dos Botões),  eu fiz com que eles fossem considerados apenas quando são mantidos pressionados por um certo tempo.

      Assim,  veja como eles operam no Sistema:

      1)  para acionar a função "Iniciar/Reiniciar", o Botão correspondente deve ser pressionado por 4 segundos.

      2)  para acionar a função "Pausa/Continua", o Botão correspondente deve ser pressionado por 2 segundos.

      Além disso,  ao se energizar o Arduino, será mostrado no Display LCD, uma mensagem indicando que o Sistema está aguardando que seja acionado o Botão "Iniciar/Reiniciar" por 4 segundos.  Após o acionamento do Botão pelo tempo referido, o Sistema inicia as medições de Vazão.  Isso facilita o "sincronismo" com o início efetivo da pulverização.

      Os tempos de acionamentos dos Botões, podem ser facilmente alterados no código.

      Abrçs,

      Elcids

RSS

© 2024   Criado por Marcelo Rodrigues.   Ativado por

Badges  |  Relatar um incidente  |  Termos de serviço