Simulador De Controlador Para Sistema Hidroponico Em Estufa

Um sistema de cultivo hidropônico em estufa tem como vantagem um controle muito maior das variáveis ambientais e nutricionais necessárias para o desenvolvimento pleno de uma cultura. Neste projeto, estaremos simulando um Arduino UNO R3 conectado a 3 sensores analógicos hipotéticos. A partir das informações providenciadas por estes sensores, será automaticamente decidido sobre o acionamento ou não de uma bomba de alimentação e de um ventilador, fazendo uso de relés (interruptores controlados eletricamente).

O Projeto foi simulado usando o TinkerCad. Porém, nada impede de ser executado na prática.

- Arduino UNO R3
- 2 Protoboards
- 2 Relés LU-5-R (SPDT)
- 3 Potenciometros
- 2 LEDS azuis
- 2 LEDS vermelhos
- 2 LEDS verdes
- 1 LED amarelo
- 7 Resistores (1kΩ)
- Fios conectores

!!!ATENÇÃO!!! Ao se mexer com conexões com a rede elétrica comum tomar muito cuidado, pois acidentes podem causar ferimentos graves e até a morte. Caso não domine o assunto, peça ajuda a profissionais.

Relé nada mais é do que um componente que funciona como um interruptor acionado eletricamente: ao receber energia em uma bobina é gerado um campo eletromagnético que atrai um contato e assim a conexão é feita, e caso haja interrupção no fornecimento de energia nesta bobina, o contato é interrompido.

Como o Arduino não foi feito para ser fonte de alimentação de outros componentes, principalmente de equipamentos de consumo elevado, como uma bomba d'água e um ventilador, usa-se relés para condicionar o acionamento destas máquinas à lógica programada no nosso controlador.

Deve-se sempre olhar o datasheet do relé escolhido para que saibamos a pinagem dos nossos componentes. No caso do modelo escolhido ( LU-5-R), deve-se montar o circuito demonstrado na foto. Repare que as portas digitais do Arduino estão conectadas ao pino da bobina dos relés.


OBS.: A bateria 9V na simulação feita no TinkerCad está representando uma fonte de alimentação externa, na vida real ela seria substituída pelos cabos da rede elétrica comum. Os LEDs azuis foram adicionados para sinalizar o acionamento dos Relés, na vida real eles seriam os equipamentos propriamente ditos.

Os nossos 3 sensores hipotéticos analógicos serão representados por potenciometros, que estarão conectados às portas analógicas do nosso Arduino, que irá verificar a tensão entregue por estes componentes.

Com base nesta tensão lida pelo nosso micro controlador e nas curvas características dos sensores por nós arbitradas (em sensores reais as curvas características estão disponíveis em seus datasheets) , é possível fazer a conversão de Volt para a unidade da Variável em questão (Observe a equação da curva característica).

Para facilitar o monitoramento do funcionamento dos nossos "sensores", foram adicionados voltímetros para cada um deles, assim saberemos que tensão está sendo entregue ao Arduino pelo pino central dos potenciometros.

Neste exemplo, as variáveis escolhidas foram:

• EletroCondutividade (EC): Utilizada para verificar a necessidade de aplicação ou não de mais nutrientes na solução nutritiva de nosso cultivo hidropônico.
• Temperatura Ambiente: Parâmetro importante para se decidir sobre o acionamento de ventiladores/exaustores
• Umidade Relativa (UR): Parâmetro importante para se decidir sobre o acionamento de ventiladores/exaustores

Neste circuito também colocamos LEDs informativos, que serão acesos de acordo com a lógica programada no microcontrolador (Observe que eles estão ligados à portas digitais do Arduino). No caso específico optou-se por 2 LEDs vinculados aos resultado da leitura do sensor de EC e 3 vinculados para as leituras dos sensores de Temperatura e UR.

Agora juntaremos os dois circuitos e também definiremos quais as condições ideais no nosso cultivo hidropônico. Esta informação é necessária para que possamos programar corretamente a tomada de decisões automática pelo nosso Arduino .

Neste projeto utilizamos as condições de cultivo hidropônico em estufa para o Alface:

Temperatura: entre 7 e 24°C
Umidade Relativa: entre 60 e 70%
Eletrocondutividade: entre 2,22 e 2,70 mS/cm

Só falta programar a seguinte lógica em nosso circuito:

Variáveis Ambientais:

Pelo menos uma das duas (Temperatura e UR) acima dos limites superiores:

Acionamento do Relé ligado ao ventilador de exaustão e acender LED amarelo, para informar que se está tentando corrigir o desequilíbrio.

Ambas dentro do intervalo ideal:

Acender LED Verde 2.

Pelo menos uma das duas abaixo dos limites inferiores:

Acender LED Vermelho 2.

Obs.: Existe a possibilidade do LED Vermelho 2 estar aceso ao mesmo tempo em que o ventilador e o LED Amarelo também estão ativados.

Variável da solução nutritiva:

EC está acima do limite superior:

Acender LED Vermelho.

EC está dentro do intervalo ideal:

Acender LED Verde.

EC está abaixo do limite inferior:

Acender LED Vermelho e acionar relé da bomba de alimentação.

O código fonte abaixo faz isso (também disponível para download):

const int SensorEC = A5; // Cria constante para assinalar a porta A5
const int SensorTemp = A4;// Cria constante para assinalar a porta A4
const int SensorUR = A3;// Cria constante para assinalar a porta A3
const int Verde = 2; // Cria constante para assinalar o pino do LED Verde
const int Vermelho = 3;// Cria constante para assinalar o pino do LED Vermelho
const int Verde2 = 4; // Cria constante para assinalar o pino do LED Verde 2
const int Amarelo = 5;// Cria constante para assinalar o pino do LED Amarelo
const int Vermelho2 = 6;// Cria constante para assinalar o pino do LED Vermelho 2
const int ReleB = 12; // Cria constante para assinalar o pino do Relé da Bomba
const int ReleV = 13; // Cria constante para assinalar o pino do Relé do Ventilador

//Constantes de thresholds (Limites superiores e inferiores)

const int TempMax = 24;
const int TempMin = 7;
const int URMax = 70;
const int URMin = 60;
const float ECMax = 2.70;
const float ECMin = 2.22;



float LeituraSensorEC; // cria varável para registrar valor de leitura do Sensor de EletroCondutividade
float LeituraSensorTemp;// cria varável para registrar valor de leitura do Sensor de Temperatura
float LeituraSensorUR;// cria varável para registrar valor de leitura do Sensor de Umidade Relativa
float EC;// cria variável para armazenar valor da EletroCondutividade
float Temperatura;// cria variável para armazenar valor da Temperatura 
float UR;// cria variável para armazenar valor da Umidade Relativa
float voltec=0;// Cria variável para armazenar valor da tensão já transformada entregue pelo sensor de EletroConduvitividade
float volttemp=0;// Cria variável para armazenar valor da tensão já transformada entregue pelo sensor de temperatura
float voltur=0;// Cria variável para armazenar valor da tensão já transformada entregue pelo sensor de Umidade Relativa

void setup()
{
  pinMode(Verde, OUTPUT);// Determina que a porta definida para o LED Verde será uma saída
  pinMode(Vermelho, OUTPUT);// Determina que a porta definida para o LED Vermelho será uma saída
  pinMode(Verde2, OUTPUT); // Determina que a porta definida para o LED Verde 2 será uma saída
  pinMode(Amarelo, OUTPUT);// Determina que a porta definida para o LED amarelo será uma saída
  pinMode(Vermelho2, OUTPUT);// Determina que a porta definida para o LED Vermelho 2 será uma saída
  pinMode(ReleB, OUTPUT);// Determina que a porta definida para o Relé da Bomba será uma saída
  pinMode(ReleV, OUTPUT);// Determina que a porta definida para o Relé do Ventilador será uma saída
  pinMode(SensorEC, INPUT); // Determina que a porta definida para o sensor de Eletro Condutividade será uma Entrada
  pinMode(SensorTemp, INPUT); // Determina que a porta definida para o sensor de temperatura será uma Entrada
  pinMode(SensorUR, INPUT); // Determina que a porta definida para o sensor de Umidade relativa será uma Entrada
  Serial.begin(9600);//Configura a taxa de transferência em bits por segundo para a transmissão serial
}

void loop()
{
  LeituraSensorEC = analogRead(SensorEC);//Leitura da porta Analógica A5
  voltec=LeituraSensorEC * 4.887;//ajustando valor da leitura para mV
  EC = ((voltec*4)+0.0052)/1000;// Conversão da tensão lida para o valor de EC. Transformação oriunda da curva de comportamento do sensor 
  
  LeituraSensorTemp = analogRead(SensorTemp);//Leitura da porta Analógica A4
  volttemp= LeituraSensorTemp*4.887;//ajustando valor da leitura para mV
  Temperatura= (volttemp/0.1)/1000;// Conversão da tensão lida para o valor de Temperatura. Transformação oriunda da curva de comportamento do sensor 
  
  LeituraSensorUR =analogRead (SensorUR);//Leitura da porta Analógica A3
  voltur = LeituraSensorUR*4.887;//ajustando valor da leitura para mV
  UR = ((voltur/0.0714)/1000)+20;// Conversão da tensão lida para o valor de UR. Transformação oriunda da curva de comportamento do sensor 

  //Criação de variáveis para tornar o código mais legível:
  bool TemperaturaIdeal = (Temperatura >= TempMin) && (Temperatura <= TempMax); //Variável booleana (TRUE ou FALSE) resumindo se a temperatura está no intervalo ideal
  bool URIdeal = (UR>=60)&&(UR<=70);//Idem, só que em relacao a UR
  
  
  if ((Temperatura > TempMax)||(UR > URMax)) //Se a Temperatura ou a UR estiverem acima dos limites:
  {
    digitalWrite (ReleV,HIGH);//Acionar Relé do Ventilador
    digitalWrite (Amarelo, HIGH);//Acender LED Amarelo
  }
  else //Caso contrário:
  {
    digitalWrite (ReleV,LOW);//Desativar Relé do Ventilador
    digitalWrite (Amarelo, LOW);//Acender LED Amarelo
  }
  
    if((TemperaturaIdeal) && (URIdeal))//Verificar se Temperatura e UR estão dentro dos intervalos ideais, caso sim:
  {
    digitalWrite (Verde2, HIGH);//Acender LED Verde 2
  }
    else //Caso contrário:
    {
      digitalWrite (Verde2, LOW); //Apagar LED Verde2
    }
  
  if ((Temperatura < TempMin)||(UR < URMin)) // Verificar se a Temperatura ou a UR estão abaixo do valor mínimo, caso afirmativo:
  {
    digitalWrite (Vermelho2, HIGH);//Acender LED Vermelho
  }
  else //Caso contrário:
  {
    digitalWrite (Vermelho2, LOW); // Apagar LED vermelho
  }
  
 
  if ((EC >= ECMin) && (EC<=ECMax))//Verifica se a EC está no intervalo ideal, caso esteja:
  {
    digitalWrite (ReleB,LOW);//Desativa Relé da Bomba
    digitalWrite (Verde, HIGH);//Acende LED Verde
    digitalWrite (Vermelho, LOW);//apaga LED Vermelho  
  }
 
 else if (EC<ECMin)//Verifica se o Valor de EC é menor que o limite inferior, caso seja:
  {
    digitalWrite (ReleB,HIGH);//Acionar Relé da Bomba
    digitalWrite (Verde, LOW);//Apagar LED Verde
    digitalWrite (Vermelho, HIGH);//Acender LED Vermelho
  } 
  
 else if(EC> ECMax) //Verifica se o valor de EC é maior que o limite superior, caso seja?
  {
    digitalWrite (ReleB,LOW); //Desativa Relé da Bomba
    digitalWrite (Verde, LOW);//Apaga LED Verde
    digitalWrite (Vermelho, HIGH); //Acende LED Vermelho
  }
    
                
  
  //Para fins de testes e diagnósticos, exibindo as leituras dos sensores no Monitor Serial
  
  Serial.print("Temperatura:"); 
  Serial.print(Temperatura,1);
  Serial.println("C");
  Serial.print("UR: ");
  Serial.println(UR,1);
  Serial.print("EC: ");
  Serial.println(EC,2);
  delay(500);
    
}

Verifique o comportamento dos LEDs e dos Relés ao mexer nos potenciometros.

Perceba também que, por conta do nosso código, a ferramenta "Monitor Serial" da sua IDE do Arduino te permite verificar os valores das variáveis de interesse. Observe todos as possibilidades de casos!

Link para o projeto no TinkerCad