Controle de Saúde Agropecuário

Participantes:

Felipe Gabriel Bosada Rodrigues
Igor Henrique de Araújo Muralhes
Wendel Moraes

Resumo do projeto:

Efetuar de maneira eficiente o controle de saúde de animais de corte em sistema de confinamento, através da identificação de cada animal, pesagem e rotina de movimentação do animal.

Descrição do projeto:

PROJETO

Gado de corte e os suínos são amimais criados para abate e, para que eles estejam em perfeitas condições de saúde. Esses animais são criados em sistema de confinamento para que engordem de maneira mais rápida para o
abate.

Para que o produtor tenha um controle sobre a saúde de cada animal se faz necessário que haja um controle da alimentação, sensação térmica do animal entre outros estados de saúde do animal. 

Cada animal recebe uma identificação (TAG) e a partir desta identificação é possível realizar todo o monitoramento do animal.

A partir desta identificação o projeto tem como finalidade criar para o pecuarista um banco de dados relacionados ao animal, seja ela tanto como forma de ter um controle da saúde do animal, da linha genética do animal e o quanto um animal precisa consumir de alimentação para que esteja dentro da meta de abate.

ARQUITETURA

 

Quando o animal após se alimentar passa por um corredor com capacidade de no máximo um animal, onde é pesado e tem seu peso lançado ao servidor de acordo com sua TAG RFID. Desse modo é criado um registro com o peso do animal e sua evolução, quantidade de comida x peso, indicando que a linha genética do animal precisa de menos ou mais comida do que a linha genética de outro animal.

Neste banco de dados ainda deve conter informações de vacinação do animal, linhagem e o que mais for conveniente ao pecuarista. Através de um Smartphone ou um computador o pecuarista é capaz de saber como que anda a saúde do animal, prazos de vencimento de vacinas, evolução de peso e quando o animal estará pronto para o abate.

O processo de criação deve respeitar não só alimentação, é necessário controlar o sistema de refrigeração onde os animais através das sensação térmica podem sentir as variações climáticas. Com isso temos que a partir do smartphone o pecuarista verá também quando o sistema de refrigeração está acionado – podendo ou não desativá-lo – para garantir o bem estar do animal.

Histórico do desenvolvimento:

Semana 1 – 19/08 – 25/08

Reunião para a realização de definições e conhecimento da placa.

  • Definição dos grupos de entrega, premissas do projeto, definição de riscos e restrições.
  • Canvas: Semana 1 – Canvas

Semana 2 – 26/08 – 01/09

Reunião de alguns componentes eletrônicos para inicialização do desenvolvimento do processo de identificação de cada animal.

  • Arduino – Realização da interface microcontrolada com o leitor RFID; (REALIZADO)

  • Módulo RFID Mfrc522 – Para a leitura das tags que compõem a identificação de cada animal.(REALIZADO)

Semana 3 – 02/09 – 08/09

Testes de comunicaçãos do entre módulo RFID e arduino.(REALIZADO

  • Realização da identificação de cada tag através da porta serial do arduino conectada ao módulo RFID.(REALIZADO)

Semana 4 – 23/09 – 31/09

  • Implementação da medição de temperatura
  • Testes com a Placa Telit, dimensionamento de circuito para alimentação da fonte, testes de comandos plea serial e teste de comunicação com o Arduino.

Semana 5 – 23/09 – 31/09

  • Comunicação entre arduino  e Telit.
  • Testes com o sensor de carga para pesagem dos animais ( nao sucedido)

Semana 6 – 08/10 a 15/10

  • Implementação do sensor de carga ( Não sucedido)
  • Testes de envio de dados para o servidor

 

 

Hardware:

  • Placa de interface ME910C1-WW
  • Arduino MEGA
  • Módulo RFID Mfrc522 + Tags
  • Sensor de temperatura LM35

Software/Firmware:

/*Copyright (C)

This program is free software: you can redistribute it and/or modify

it under the terms of the GNU General Public License as published by

the Free Software Foundation, either version 3 of the License, or

(at your option) any later version.

This program is distributed in the hope that it will be useful,

but WITHOUT ANY WARRANTY; without even the implied warranty of

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

GNU General Public License for more details.

You should have received a copy of the GNU General Public License

along with this program. If not, see <http://www.gnu.org/licenses/>.

<[email protected]>

Copyright (C)

This program comes with ABSOLUTELY NO WARRANTY; for details type show w’.

This is free software, and you are welcome to redistribute it

under certain conditions; type show c’ for details.
*

* ———————————–
* MFRC522 Arduino
* Reader/PCD Mega
* Signal Pin Pin
* ————————————-
* RST/Reset RST 5
* SPI SS SDA(SS) 53
* SPI MOSI MOSI 51
* SPI MISO MISO 50
* SPI SCK SCK 52
*
* ———————————–
* Temperature
* Sensor
* ———————————–
* Measure A1
*
* ———————————-
*/

#include <SPI.h>
#include <MFRC522.h>
#include <SoftwareSerial.h>

constexpr uint8_t RST_PIN = 5; // Configurable, see typical pin layout above
constexpr uint8_t SS_PIN = 53; // Configurable, see typical pin layout above

const int LM35 = A1;
int temp = 0;
String gps;
int amostras[10];
int i;
String information;

MFRC522 rfid(SS_PIN, RST_PIN); // Instance of the class

MFRC522::MIFARE_Key key;
SoftwareSerial telitSerial(10, 11);

// Init array that will store new NUID
byte nuidPICC[4];
String identidade= “”;

void setup() {
Serial.begin(9600);
SPI.begin(); // Init SPI bus
rfid.PCD_Init(); // Init MFRC522

for (byte i = 0; i < 6; i++) {
key.keyByte[i] = 0xFF;
}

Serial.begin(115200);
while (!Serial) {
;
}

telitSerial.begin(115200);
}

void loop() {

// Look for new cards
if ( ! rfid.PICC_IsNewCardPresent())
return;

// Verify if the NUID has been readed
if ( ! rfid.PICC_ReadCardSerial())
return;

Serial.print(F(“PICC type: “));
MFRC522::PICC_Type piccType = rfid.PICC_GetType(rfid.uid.sak);
Serial.println(rfid.PICC_GetTypeName(piccType));

// Check is the PICC of Classic MIFARE type
if (piccType != MFRC522::PICC_TYPE_MIFARE_MINI &&
piccType != MFRC522::PICC_TYPE_MIFARE_1K &&
piccType != MFRC522::PICC_TYPE_MIFARE_4K) {
Serial.println(F(“Your tag is not of type MIFARE Classic.”));
return;
}

if (rfid.uid.uidByte[0] != nuidPICC[0] ||
rfid.uid.uidByte[1] != nuidPICC[1] ||
rfid.uid.uidByte[2] != nuidPICC[2] ||
rfid.uid.uidByte[3] != nuidPICC[3] ) {
Serial.println(F(“A new card has been detected.”));

// Store NUID into nuidPICC array
for (byte i = 0; i < 4; i++) {
nuidPICC[i] = rfid.uid.uidByte[i];
}

Serial.println(F(“The NUID tag is:”));
saveDec(rfid.uid.uidByte, rfid.uid.size);
Serial.println();
}
else Serial.println(F(“Card read previously.”));

// Halt PICC
rfid.PICC_HaltA();

// Stop encryption on PCD
rfid.PCD_StopCrypto1();

temperatura();
location();
concatenat();
connectServer();
}

/**
* Helper routine to dump a byte array as hex values to Serial.
*/

/**
* Helper routine to dump a byte array as dec values to Serial.
*/
void saveDec(byte *buffer, byte bufferSize) {
String identidade = “”;
for (byte i = 0; i < bufferSize; i++) {
Serial.print(buffer[i] < 0x10 ? ” 0″ : ” “);
Serial.print(buffer[i], DEC);
identidade.concat(String(buffer[i] < 0x10 ? ” 0″ : ” “));
identidade.concat(String(buffer[i], DEC));
identidade.concat(“;”);

}
Serial.println();
Serial.print(“CARTAO :”);
identidade.remove(4,1);
identidade.remove(7,1);
identidade.remove(9,1);
Serial.print(identidade);
}

void temperatura(){
for(i=0;i<=9;i++){
amostras[i] = ( 5.0 * analogRead(LM35) * 100.0) / 1024.0;
temp = temp + amostras[i];
delay(100);
}
temp = temp/10.0;

Serial.print (“Temperatura: ” );
Serial.println (temp);

}

void location(){

telitSerial.write(“AT$GPSP=1”);
delay(1000);
telitSerial.write(Serial.read());
delay(1000);
telitSerial.write(“AT$GPSACP”);
delay(1000);
telitSerial.write(Serial.read());
delay(1000);
gps = Serial.read();
gps.concat(“;”);

}

void connectServer(){
telitSerial.write(“AT#SD=1,0,6535,189.112.192.145,0,,0,0,1”);
telitSerial.write(Serial.read());
delay(1000);
telitSerial.write(“AT#SSEND=1”);
telitSerial.print(information);
delay(1000);
telitSerial.write(Serial.read());
;

}
void concatenat(){

information = identidade + gps + temp;

}

GATEWAY

Link:https://drive.google.com/file/d/1Liv2InAj2eZ64479q1QoBW75oGk59Oob/view

 

 

Referências:

Biblioteca MFRC522 : https://github.com/miguelbalboa/rfid

http://blog.eletrogate.com/balanca-digital-com-arduino-aprenda-a-usar-a-celula-de-carga/

Comandos AT Telit:https://y1cj3stn5fbwhv73k0ipk1eg-wpengine.netdna-ssl.com/wp-content/uploads/2017/10/Telit_ME910C1_AT_Commands_Reference_Guide_r2.pdf

 

Manual da Placa:https://y1cj3stn5fbwhv73k0ipk1eg-wpengine.netdna-ssl.com/wp-content/uploads/2017/11/1VV0301351_ME910C1_HW_User_Guide_r7.pdf