Sistema Automático de Irrigação e Rega de Plantas: Projeto de Circuito, Código e Relatório

Sistema Automático de Rega de Plantas – Código Fonte Completo, Circuito e Relatório de Projeto – Download PDF

Introdução

Nas operações diárias relacionadas à rega de plantas, esta é a prática cultural mais importante e a tarefa mais intensiva em mão de obra. Independentemente do clima, seja muito quente ou frio, muito seco ou úmido, é crucial controlar a quantidade de água que chega às plantas. Por isso, será eficaz usar a ideia de um sistema automático de rega de plantas que rega as plantas quando elas precisam. Um aspecto importante deste projeto é: "quando e quanto regar". Para reduzir atividades manuais do ser humano na rega de plantas, adota-se a ideia de sistema de rega de plantas. O método empregado monitora continuamente o nível de umidade do solo e decide se a rega é necessária ou não, e quanta água é necessária no solo da planta. Este projeto pode ser agrupado em subsistemas como: fonte de alimentação, relés, válvula solenoide, shield GSM Arduino, sensor de umidade do solo e LCD.

Essencialmente, o sistema é projetado e programado de forma que o sensor de umidade do solo detecta o nível de umidade das plantas em um determinado momento; se o nível de umidade do sensor for menor que o valor de limiar especificado, predefinido de acordo com a necessidade de água da planta, a quantidade desejada de água é fornecida até atingir o valor de limiar predefinido.

O sistema reporta seus estados atuais e envia mensagens de lembrete sobre rega de plantas e para adicionar água ao tanque. Toda essa notificação pode ser feita usando o shield GSM Arduino.

Objetivo do Projeto:

Atualmente, na era da tecnologia avançada e eletrônica, o estilo de vida humano deve ser inteligente, mais simples, fácil e muito mais conveniente. Portanto, há necessidade de muitos sistemas automatizados na rotina diária humana para reduzir suas atividades e tarefas diárias. Aqui, a ideia de um sistema chamado sistema automático de rega de plantas é muito útil. Como muitas pessoas enfrentam muitos problemas para regar plantas no jardim, especialmente quando estão longe de casa. Este modelo usa tecnologias de sensores com microcontrolador para criar um dispositivo de comutação inteligente para ajudar milhões de pessoas.

Em sua forma mais básica, o sistema é programado de forma que o sensor de umidade do solo detecta o nível de umidade da planta em um determinado momento; se o nível de umidade do sensor for menor que o valor de limiar especificado, predefinido de acordo com a planta específica, a quantidade desejada de água é fornecida à planta até que seu nível de umidade atinja o valor de limiar predefinido. O sistema envolve sensores de umidade e temperatura que monitoram a atmosfera atual do sistema e influenciam quando a rega ocorre. A válvula solenoide controla o fluxo de água no sistema; quando o Arduino lê o valor do sensor de umidade, ele aciona a válvula solenoide de acordo com a condição desejada. Além disso, o sistema reporta seus estados atuais e envia mensagens de lembrete sobre rega de plantas e recebe SMS do destinatário. Tudo isso pode ser feito usando o shield GSM Arduino.

Contexto do Sistema

Estudou-se nos livros de ciências na escola que as plantas são imperativas para toda a humanidade em muitos aspectos. Elas mantêm o ambiente limpo produzindo oxigênio fresco periodicamente. Sistemas automáticos de rega de plantas têm se tornado muito mais comuns com o aumento de objetos cotidianos conectados a tecnologias avançadas; esses sistemas são implementados em taxa crescente. Locais como residências e níveis industriais. O principal uso desses sistemas é eficiência e facilidade de uso.

O sistema de rega de plantas proporciona aos amantes de plantas a capacidade de cuidar de suas plantas domésticas enquanto estão fora – através do uso de componentes eficientes e confiáveis, como diferentes tipos de tecnologias de sensores.

Existem vários tipos diferentes/simples de sistemas de rega de plantas internas, dependendo do nível de automação necessário.

• Globos e Espigões de Rega de Plantas
• Sistema de Gotejamento Interno
• Tecnologia de Sensores
• Sensores de Temperatura e Umidade
• Sensor de Temperatura
• Sensores de Umidade
• Sensores de Umidade do Solo
• Termostato Bimetálico
• Termistor
• Detectores de Temperatura Resistivos (RTD)
• Termopares
• CIs de Sensores, LM35
• Sensor Digital de Temperatura (ADT7301)
• DHT11 e DHT22
• Módulo GSM
• Arquitetura GSM
• Relé
• Transistor
• LCD Hitachi 16×2

Especificações de Produtos e Componentes

ID do Requisito	SRS-GSM-001
Título	Módulo GSM
Descrição	O sistema inclui o módulo GSM, que envia SMS de alerta ao destinatário e recebe SMS do usuário.
Versão	Versão 1.0

ID do Requisito	SRS-Microcontrolador-001
Título	ATmega328p
Descrição	O sistema inclui o microcontrolador que geralmente vem com Arduino Uno. Este microcontrolador lê as leituras do sensor e controla o sistema geral.
Versão	Versão 1.0

ID do Requisito	SRS-Temperatura e Umidade-001
Título	DHT11
Descrição	O sistema inclui o sensor de temperatura e umidade, que monitora os valores atuais de temperatura e umidade do ambiente e envia a leitura de volta ao microcontrolador.
Versão	Versão 1.0

ID do Requisito	SRS-Umidade-001
Título	Sensor de Umidade do Solo Grove
Descrição	O sistema inclui o sensor de umidade do solo, que faz a leitura da umidade do solo e envia a leitura de volta ao microcontrolador.
Versão	Versão 1.0

ID do Requisito	SRS-LCD-001
Título	LCD Hitachi 16×2
Descrição	O sistema inclui a interface LCD para o usuário, que exibe as leituras feitas pelos diferentes sensores no sistema.
Versão	Versão 1.0

Sistema Automatizado de Rega de Plantas Baseado em Arduino:

Diagrama de Blocos do Sistema Automático de Rega de Plantas

Diagrama Esquemático do Circuito de Sistema Automático de Rega e Irrigação

Segundo este sistema, existem dois componentes funcionais neste projeto: sensor de umidade e motor/bomba d'água. Em sua forma mais básica, o sensor de umidade detecta o nível de umidade do solo. Então o motor/bomba d'água fornece água às plantas.

Clique na imagem para ampliar

O esquema acima descreve o comportamento geral do sistema. O projeto usa Arduino Uno para controlar o motor. Consiste em ponte H que controla o fluxo do motor servo, ou seja, direção horária ou anti-horária. O sensor de umidade mede o nível do solo e envia o sinal ao Arduino; então o Arduino abre o motor servo se a rega for necessária. Então o motor/bomba d'água fornece água às plantas até que o nível de umidade desejado seja atingido.

No protótipo acima, o sensor de umidade detecta o nível de umidade e envia o sinal ao Arduino e então o Arduino abre a bomba d'água com a ajuda da ponte H e rega a planta específica. Isso é feito usando o software Arduino IDE.

Design do Projeto

Esta seção aborda qualquer trabalho concluído no design de software e hardware. Também entra em detalhes sobre o que o sistema inclui e por que diferentes componentes foram escolhidos para fazer um sistema de rega de plantas totalmente automatizado. Considere um diagrama na figura que mostra o modelo conceitual básico do sistema usando componentes escolhidos.

A funcionalidade do diagrama de blocos mostrado acima do sistema automatizado de rega de plantas é ilustrada abaixo:

• O sistema inclui módulo GSM que envia SMS ao destinatário e recebe SMS do destinatário.
• Usa sensores de umidade do solo, temperatura e umidade.
• Também inclui válvulas solenoides junto com circuito solenoide que controla o fluxo de água através das válvulas solenoides.
• O sensor de umidade é usado para determinar o nível de umidade da planta específica. Este nível de umidade é lido pelo microcontrolador, pois ele faz um loop e verifica se o valor do sensor está acima do valor de limiar ou não. Se o valor estiver acima do valor predefinido, o módulo GSM está pronto para enviar SMS ao destinatário.
• O sensor de temperatura e umidade é usado para determinar se está muito quente para a planta ou a umidade está muito alta. Isso é lido pelo chip ATmega328p (leia mais sobre O que é ATmega) no Arduino Uno. Essas leituras serão usadas para determinar se todas as solenoides no sistema devem ser ligadas ou desligadas.

Mais detalhes dos componentes podem ser encontrados no arquivo PDF (abaixo)

Design de Hardware

Esquemático dos Sensores

A figura abaixo mostra o esquemático do circuito dos sensores. Como todos os sensores conectados com pinos analógicos A0-A3 do Arduino. Pino A0 reservado para sensor de temperatura e umidade, enquanto pinos A1-A3 reservados para sensores de umidade. Todos os sensores têm alimentação comum 5V e Terra, conforme mostrado no esquemático.

Esquemático do LCD:

A figura abaixo mostra o esquemático do LCD. Pinos digitais 8–13 reservados para o LCD, conforme mostrado no esquemático. Pino 1 e Pino 3 são alimentação e terra, enquanto pino 2 é o pino de contraste no LCD que controla o contraste e conectado com potenciômetro. Deve ser mantido em mente ao conectar LCD que pinos digitais do Arduino e pinos de dados do LCD devem ser conectados na ordem correta, caso contrário o LCD exibirá apenas lixo na tela.

Esquemático da Solenoide

O diagrama abaixo mostra o diagrama de circuito do circuito da solenoide. Pinos digitais 4–7 reservados para as solenoides. Como o circuito consiste em relés, transistores, resistores e LEDs em vez da solenoide (CadStar não tem símbolo de solenoide). No esquemático, os relés utilizam 5V. Enquanto 5V também vai para o canal NA dos relés, isso porque no esquemático LEDs substituem a solenoide que funciona em (5V) seguido por resistor de 220-ohm.

Então, quando a tensão é aplicada à base dos transistores. O transistor comuta para terra permitindo que a bobina do relé seja magnetizada e comuta para o canal normalmente fechado, fazendo com que o LED conectado a esse relé específico acenda. Quando a tensão aplicada na base do transistor cai, o transistor retorna ao normal e a bobina do relé é desmagnetizada e o relé comuta para o canal NA novamente, fazendo com que o LED apague.

Após finalizar todos os esquemáticos do circuito, o próximo passo é construí-los na placa de ensaio (Veroboard). É importante projetar o circuito na folha de planejamento de layout de stripboard antecipadamente, pois existem certos princípios para projetar um circuito em Veroboard:

1. Marque as linhas de alimentação Vs e GND primeiro no canto superior direito da folha de planejamento de layout de stripboard.
2. Lembre-se de cortar a trilha entre os pinos de um CI. Marque os cortes no diagrama com um X.
3. Tente fazer resistores e capacitores axiais ficarem planos na stripboard. Resistores geralmente requerem um espaçamento de 4 furos, capacitor um espaçamento de 8 furos.
4. Se possível, numere os pinos dos CIs. O lado inferior da Veroboard consiste nas trilhas de cobre nas quais a tensão flui horizontalmente. Diferentes designs de Veroboard dos esquemáticos acima são mostrados abaixo:

Design de Software

Após concluir o hardware, é hora de testar o hardware com o software. Nesta seção, a implementação do design de software será descrita em detalhes para cada uma das diferentes tecnologias de automação usadas no sistema. Isso inclui o código Arduino escrito e carregado no Arduino.

A primeira coisa feita foi fazer o circuito da solenoide funcionar e como a solenoide agiria da perspectiva do microcontrolador. Para isso, um pequeno fluxograma foi feito, que pode ser visto na seção de fluxo de software na figura acima.

A Arduino IDE foi usada para carregar o software no Arduino. Para o circuito básico da solenoide, um programa simples foi escrito que basicamente pisca o LED a cada 1 seg. Pinos digitais 4, 5, 6 e 7 definidos inicialmente para testar o programa e o circuito. Então, quando o programa roda, ele faz todas as inicializações básicas, define todos os pinos de saída no void setup() e depois entra no void loop() onde roda constantemente e pisca LEDs a cada 1 seg.

Depois disso, um pequeno programa foi escrito e carregado no Arduino que obtém leituras dos diferentes sensores e as imprime no LCD. Para isso, um pequeno fluxograma foi feito, que também pode ser visto na seção de fluxo de software na figura. Quando o programa entra no void loop(), ele obtém as leituras do sensor, faz todos os cálculos básicos e imprime no LCD.

Próxima etapa é carregar o software para o módulo GSM no Arduino, através do qual o GSM poderia se comunicar com o microcontrolador. Teste do modem foi feito inicialmente, que faz todas as inicializações básicas e bibliotecas para o GSM e obtém o número IMEI e verifica se o modem está funcionando corretamente ao começar a se comunicar com Arduino. O próximo passo é teste de conexão de rede, que basicamente inicializa o GSM e exibe todas as outras redes que o módulo GSM pode suportar.

Uma vez que o módulo GSM é testado e funcionando corretamente, é hora de usar o módulo GSM para se comunicar com o destinatário, o que significa enviar SMS ao destinatário e receber SMS deles. Para fazer isso, outro programa simples de fiação Arduino foi escrito e carregado no Arduino. O programa inicializou o GSM e enviou SMS ao destinatário; em contraste, outro programa Arduino foi escrito no qual o GSM recebe SMS do usuário final.

Finalmente, uma vez que todo o design de software foi concluído, é hora de mesclar todos os designs de software e construir um software final funcional para o sistema. Diferentes abordagens de algoritmo foram aplicadas, que podem ser vistas na seção de fluxo de software, para obter o software final funcionando e fazendo o que deveria fazer. A figura acima mostra o funcionamento do software final onde ele faz uma leitura, envia SMS, recebe SMS e continua fazendo o que fazia anteriormente.

Nota: Todo o código de software pode ser visto no apêndice abaixo.

NOTA: todo o código de software pode ser visualizado no apêndice. A saída do teste do modem e teste de conexão de rede não foi incluída no relatório porque o relatório real foi feito após a submissão do hardware.

Construção do Projeto e Teste de Software

Após concluir todo o design de hardware e software com sucesso, é hora da construção e teste do projeto. Nesta seção do relatório, detalhes serão dados sobre como os diferentes designs de hardware são implementados e testados. Esta seção também fala se havia algum problema oculto no código de software que era importante para solucionar e eliminar e construir o projeto com sucesso. O processo passo a passo pode ser visto no relatório completo do projeto em arquivo PDF dado abaixo, como procedimento de construção e teste.

Teste de Software

A fase de teste de software também é um aspecto importante do desenvolvimento do projeto. Teste de software é um procedimento de execução de um programa ou aplicação com o objetivo de encontrar bugs de software. Também pode ser expresso como o processo de validação e verificação de que um programa ou aplicação de software atende aos seus requisitos técnicos, funciona como esperado e pode ser executado com características semelhantes. Para fazer o teste de software, diferentes abordagens foram adotadas. Um documento de especificação de requisitos de software (SRS) foi escrito, que abordava totalmente o comportamento esperado de um sistema de software.

ID do Requisito	SRS-Sensor-010
Título	Sensor
Descrição	Sensores no sistema fazem as leituras e enviam de volta ao microcontrolador.
Versão	V 1.0

ID do Requisito	SRS-Dados-020
Título	Exibição de Dados
Descrição	Quando os usuários tentam obter a leitura do sistema. O display deve mostrar dados ao usuário, por exemplo: valor de temperatura e umidade seguido por leituras de umidade.
Versão	V1.0

ID do Requisito	SRS-Microcontrolador-030
Título	Microcontrolador
Descrição	Microcontrolador no sistema atua como cérebro do sistema que gerencia tudo no sistema.
Versão	V1.0

ID do Requisito	SRS-Latch-040
Título	Latch
Descrição	Latch no sistema expande os pinos digitais para o microcontrolador.
Versão	V1.0

ID do Requisito	SRS-GSM-050
Título	GSM
Descrição	O sistema reagirá enviando um alerta SMS ao destinatário sempre que o microcontrolador mandar.
Versão	V1.0

Após escrever o documento SRS, o design de software passou para a fase de teste estático, que inclui revisão do documento. É onde ocorre a verificação dos requisitos. Existem quatro tipos diversos de métodos de verificação definidos abaixo:

1. Inspeção (I): verificação visual ou de controle
2. Análise (A): verificação baseada em evidências analíticas
3. Demonstração (D): verificação de características operacionais, sem medição quantitativa.
4. Teste (T): verificação de características quantitativas com medição quantitativa. Para cada requisito do documento SRS, um método de verificação é definido com abreviação I, A, D e T.

Verificação:

ID do Requisito	Título do Requisito	Método
REQ-010	Verificar se os sensores do sistema obtêm leituras	I
REQ-020	Verificar se os Dados são Exibidos na tela.	D
REQ-030	Verifica-se que o microcontrolador do sistema está gerenciando ou funcionando corretamente, pois dá 100% de resultado para cada requisição.	D
REQ-040	Verificar se o circuito latch estava fazendo o que deveria. Que recebe 3 entradas e produz 8 pinos.	A
REQ-050	Verificar se o SMS foi enviado e recebido pelo GSM	D

Resultados

Como todos os testes foram feitos com resultado satisfatório. Como não há resultado particular que precise ser documentado. Como o sistema funciona com sensor de umidade e DHT11 (temperatura e umidade) que faz leituras de acordo com a temperatura e umidade atuais da sala. Leituras do sensor de umidade no circuito também dependem do nível de umidade atual da planta. Caso contrário, o resultado geral saindo do circuito em termos de funcionalidade foi bom para motivação.

Código de Software Final e Completo para Sistema Automático de Rega de Plantas e Irrigação

Nota: Mais códigos relacionados ao projeto podem ser encontrados no arquivo PDF, como código de exemplo para testar válvula solenoide, código para testar sensores do sistema, código de teste de modem GSM, código de conexão de rede GSM, código GSM envia alerta SMS, código GSM recebe SMS,

Código Final do Projeto Auto Rega de Plantas

#include <dht.h> 
#define dht_dpin A0 
dht DHT; 
//———————– 
#include <LiquidCrystal.h> 
LiquidCrystal lcd (8, 9, 10, 11, 12, 13); 
//———————————- 
int plantPotMoisture[3] = {A1, A2, A3}; 
//——————— 
#include <GSM.h> 
#define PINNUMBER "" 
GSM gsmAccess; 
// include a 'true' parameter for debug enabled 
GSM_SMS sms; 
char remoteNumber[] = "0899506304"; 
String moistureMessage = "Moisture is Low on sensor: "; 
String SMS_Alert = "Sending SMS!"; 
String humidityMsg = "Humidity is High. Open All Solenoids"; 
String tempMsg = "Temperature is too HIGH!..Open ALl Solenoids "; 
String messageBuffer = ""; 
char senderNumber[20]; 
String stringOne = "Opens1"; 
String stringTwo = "Opens2"; 
String stringThree = "Opens3"; 
String stringFour = "OpenAll"; 
//————— 
#define solenoidData 5 
#define solenoidClockster 4 
#define solenoidLatch 6 
//————— 
const int master = 0; 
const int slave1 = 1; 
const int slave2 = 2; 
const int slave3 = 3; 
boolean takeReadings = true; 
int serialSolenoidOutput = 0; 

void setup() { 
  pinMode(solenoidData, OUTPUT); 
  pinMode(solenoidClockster, OUTPUT); 
  pinMode(solenoidLatch, OUTPUT); 
  digitalWrite(solenoidLatch, HIGH); 
  digitalWrite(solenoidLatch, LOW); 
  shiftOut(solenoidData, solenoidClockster, MSBFIRST, 0); 
  digitalWrite(solenoidLatch, HIGH); 
  //————————- 
  Serial.begin(9600); 
  lcd.begin (16, 2); 
  lcd.clear(); 
  lcd.setCursor(0, 0); 
  lcd.print("Wait Until"); 
  lcd.setCursor(0, 1); 
  lcd.print("GSM Initialized!"); 
  boolean notConnected = true; 
  while (notConnected) { 
    if (gsmAccess.begin(PINNUMBER) == GSM_READY) 
      notConnected = false; 
    else { 
      Serial.println("Not connected"); 
      delay(1000); 
    } 
  } 
} 

void loop() { 
  if (takeReadings) { 
    moistureSensor(); 
    TempAndHumidity (); 
    if (DHT.humidity > 50 || DHT.temperature > 25 && takeReadings ) { 
      takeReadings = false; 
      if (DHT.humidity > 50) { 
        sendSMS(humidityMsg); 
      } else if (DHT.temperature > 25) { 
        sendSMS(tempMsg); 
      } 
      while (!takeReadings) recieveSMS(); 
    } 
    if (plantPotMoisture[0] > 30 || plantPotMoisture[1] > 30 || plantPotMoisture[2] > 30 && takeReadings) { 
      takeReadings = false; 
      if (plantPotMoisture[0] > 30) { 
        sendSMS(moistureMessage + "1"); 
      } else if (plantPotMoisture[1] > 30) { 
        sendSMS(moistureMessage + "2"); 
      } else { 
        sendSMS(moistureMessage + "3"); 
      } 
      while (!takeReadings) recieveSMS(); 
    } 
  } 
} 

void moistureSensor() { 
  for (int i = 0 ; i < 3; i++) { 
    lcd.clear(); 
    plantPotMoisture[i] = analogRead(i); 
    plantPotMoisture[i] = map(plantPotMoisture[i], 550, 0, 0, 100); 
    Serial.print("Moisture" + i ); 
    lcd.print("Moisture" + i); 
    Serial.print(plantPotMoisture[i]); 
    lcd.print(plantPotMoisture[i]); 
    Serial.println("%"); 
    lcd.print("%"); 
    delay(1000); 
  } 
} 

void TempAndHumidity () { 
  DHT.read11(dht_dpin); 
  lcd.setCursor(0, 0); 
  lcd.print("Humidity="); 
  Serial.print("Current humidity = "); 
  Serial.print(DHT.humidity); 
  lcd.print(DHT.humidity); 
  lcd.print("%"); 
  Serial.print("%"); 
  Serial.print("temperature = "); 
  Serial.print(DHT.temperature); 
  Serial.println("C"); 
  lcd.setCursor(0, 1); 
  lcd.print("temp="); 
  lcd.print(DHT.temperature); 
  lcd.print("C "); 
  delay(1000); 
  lcd.clear(); 
} 

void sendSMS(String messageToSend) { 
  Serial.print("Sending a message to mobile number: "); 
  Serial.println(remoteNumber); 
  Serial.println("SENDING"); 
  lcd.print(SMS_Alert); 
  Serial.println(); 
  Serial.println("Message:"); 
  Serial.println(messageToSend); 
  sms.beginSMS(remoteNumber); 
  sms.print(messageToSend); 
  sms.endSMS(); 
  Serial.println("\nCOMPLETE!\n"); 
  lcd.clear(); 
  lcd.print("Completed!!!"); 
} 

void recieveSMS() { 
  char c; 
  if (sms.available()) { 
    lcd.clear(); 
    lcd.print("Message received from:"); 
    delay(800); 
    lcd.clear(); 
    sms.remoteNumber(senderNumber, 20); 
    lcd.print(senderNumber); 
    while (c = sms.read()) { 
      Serial.println(c); 
      messageBuffer += c; 
    } 
    Serial.println(messageBuffer); 
    if (messageBuffer == stringOne) { 
      toggleSolenoid1(); 
      takeReadings = true; 
    } else if (messageBuffer == stringTwo) { 
      toggleSolenoid2(); 
      takeReadings = true; 
    } else if (messageBuffer == stringThree) { 
      toggleSolenoid3(); 
      takeReadings = true; 
    } else if (messageBuffer == stringFour) { 
      toggleAll(); 
      takeReadings = true; 
    } else { 
      takeReadings = true; 
    } 
    messageBuffer = ""; 
    Serial.println("\nEND OF MESSAGE"); 
    // Delete message from modem memory 
    sms.flush(); 
    Serial.println("MESSAGE DELETED"); 
  } 
  delay(1000); 
} 

void toggleSolenoid1() { 
  solenoidWrite(master, HIGH); 
  delay(1000); 
  solenoidWrite(slave1, HIGH); 
  delay(1000); 
  solenoidWrite(slave1, LOW); 
  delay(1000); 
  solenoidWrite(master, LOW); 
  delay(1000); 
} 

void toggleSolenoid2() { 
  solenoidWrite(master, HIGH); 
  delay(1000); 
  solenoidWrite(slave2, HIGH); 
  delay(1000); 
  solenoidWrite(slave2, LOW); 
  delay(1000); 
  solenoidWrite(master, LOW); 
  delay(1000); 
} 

void toggleSolenoid3() { 
  solenoidWrite(master, HIGH); 
  delay(1000); 
  solenoidWrite(slave3, HIGH); 
  delay(1000); 
  solenoidWrite(slave3, LOW); 
  delay(1000); 
  solenoidWrite(master, LOW); 
  delay(1000); 
} 

void toggleAll() { 
  solenoidWrite(master, HIGH); 
  delay(1000); 
  solenoidWrite(slave1, HIGH); 
  delay(1000); 
  solenoidWrite(slave2, HIGH); 
  delay(1000); 
  solenoidWrite(slave3, HIGH); 
  delay(1000); 
  solenoidWrite(slave1, LOW); 
  delay(1000); 
  solenoidWrite(slave2, LOW); 
  delay(1000); 
  solenoidWrite(slave3, LOW); 
  delay(1000); 
  solenoidWrite(master, LOW); 
  delay(1000); 
} 

void solenoidWrite(int pin, bool state) { 
  if ( pin >= 0 && pin < 8) { 
    if (state) serialSolenoidOutput |= (1 << pin); 
    else serialSolenoidOutput &= ~(1 << pin); 
  } 
  digitalWrite(solenoidLatch, LOW); 
  shiftOut(solenoidData, solenoidClockster, MSBFIRST, serialSolenoidOutput); 
  digitalWrite(solenoidLatch, HIGH); 
}

Relatório Completo do Projeto Sistema Automático de Rega de Plantas (PDF) Download Gratuito

• Título: Sistema Automatizado de Rega de Plantas
• Formato: PDF
• Tamanho: 4,18MB
• Páginas: 77
• Download: Aqui