Controle automático de produção de leite

Boa tarde amigos, tenho um projeto em mente e já com cliente a vista já que a necessidade desses dados que o projeto vai gerar é muito importante para o produtor. Gostaria de compartilhar para possível idéias, sugestões, duvidas.

É um controle automático de produção de leite, a idéia é a seguinte: Cada vaca receberá uma tag RFID presa ao brinco de identificação na orelha do animal, quando ela chega no lugar de ser ordenhada o produtor passa o RFID e identifica que é a vaca N° 1  por exemplo,  o que passar de leite por um sensor de medição corresponderá a vaca n°1, quando acabar a ordenha dessa vaca o produtor le novamente a tag de identificação da vaca e está pronto o valor total lido pelo sensor nesse tempo deve ser salvo como produção da vaca n°1. E assim se procederá com as demais.

Todos esses dados deverão ser gravados em um cartão SD para que depois ao final do dia ou da semana o produtor possa abrir os dados em um computador e analizar a produção de seus animais.

Ainda não montei nada, fiz o pedido de um modulo RFID e um SD card, nunca usei esse 2 módulos e é onde acredito que vou ter mais dificuldades. Estou pesquisando a respeito.

Se alguém quiser dar alguma sugestão ou idéia, compartilhar algum trabalho que usou RFID para  identificação, tutoriais e coisas do tipo. 

Até o final da semana devo receber os matérias e vou começar a trabalhar.

Obrigado. Abraço  

Exibições: 6792

▶ Responder esta

Respostas a este tópico

Permalink Responder até ALLAN DAVID SILVA DA COSTA em 17 março 2014 at 22:27

Poxa nobre, que ótimo, que bom que "estamos" desenvolvendo o projeto.... posso testar, néh.... Farei no fim de semana.... e tentarei adicionar outras funcionalidades.... obrigado, amigão!

Permalink Responder até Adilson J. Ribeiro em 17 março 2014 at 23:11

Sidney, adicionei só 2 animais por só ter 2 tags, é só para teste, esqueci de comentar isso. A idéia é usar para quantos forem necessários.

Allan, vamo la mão na massa kkkkkkk, vamos fazer esse projeto dar certo, eu tenho muitas dificuldades em programação mas vamos nos ajudando, eu sou parcero no que eu puder ajudar.

Permalink Responder até ALLAN DAVID SILVA DA COSTA em 18 março 2014 at 8:08

Vc sabe qual a frequência do seu leitor de RFID?

Permalink Responder até Adilson J. Ribeiro em 18 março 2014 at 8:40

Allan a frequencia do módulo que comprei é 13,56 Mhz .É o módulo Rfid Mfrc522.

Permalink Responder até Adilson J. Ribeiro em 18 março 2014 at 10:46

Pessoal pensei em mais uma coisa para fazer nesse projeto. Além de gravar os dados no cartão SD, imprimir em uma impressora serial para facilitar aos produtores que não tem acesso a computadores por exemplo, assim ele acabaria o processo e teria os dados na mão. Que acham disso?

Permalink Responder até ALLAN DAVID SILVA DA COSTA em 18 março 2014 at 11:28

Pessoal,

Domino o SD.Card, podem deixar comigo.... até quinta coloco aqui algum trecho de codigo... para este shield.

Permalink Responder até Adilson J. Ribeiro em 18 março 2014 at 11:59

Ótimo Allan, já testou alguma coisa o código que postei? não to conseguindo rodar ele legal ele executa o loop até a parte do sensor e não executa o rfid.

Tava olhando o link da impressora que postou show de bola e não parece  ser dificil de usar com arduino. Como ta o preço dela será? Dei uma olhadinha e não achei igual, no mercado livre ao menos.

Permalink Responder até Adilson J. Ribeiro em 25 março 2014 at 14:05

Allan, vc disse que domina o SD card, então pode contribuir  nesse sketch?

Adiciono o n° do animal pelo teclado e no final apertando a letra "A"' ele zera as informações, grava na serial e deveria gravar no SD também, mas esta gravando só na serial.

Lmbrando estou usando arduino mega, testei um código de SD separado e esta funcionando, então minhas conexões estão corretas.

Desconsidere umas partes do código que estão entre as barras, e ta meio bagunçado estou montando ainda.

#include <Keypad.h>
const byte ROWS = 4;
const byte COLS = 4;
char keys[ROWS][COLS] = {
  {'1','2','3','A'},
  {'4','5','6','B'},
  {'7','8','9','C'},
  {'*','0','#','D'}
};
byte rowPins[ROWS] = {37, 36, 35, 34}; //connect to the row pinouts of the keypad
byte colPins[COLS] = {33, 32, 31, 30}; //connect to the column pinouts of the keypad
Keypad keypad = Keypad( makeKeymap(keys), rowPins, colPins, ROWS, COLS );
int contador = 0;
char teste[] = {'0','0','0','0','\0'};
char senha [] = {'2','5','4','3','\0'};
#include <LiquidCrystal.h>
LiquidCrystal lcd(8, 7, 6, 5, 4, 3);

#define FLOWSENSORPIN 2
volatile uint16_t pulses = 0; // contar quantos pulsos
volatile uint8_t lastflowpinstate; // Controlar o estado do pino de pulso
volatile uint32_t lastflowratetimer = 0;  // Você pode tentar manter o tempo de quanto tempo é entre os pulsos
volatile float flowrate;   // E usá-lo para calcular um caudal
SIGNAL(TIMER0_COMPA_vect) {    // Interrupção é chamado uma vez um milésimo de segundo, olha para todos os pulsos do sensor!
uint8_t x = digitalRead(FLOWSENSORPIN);
if (x == lastflowpinstate) {
lastflowratetimer++;
return; // Nada mudou!
  }
  if (x == HIGH) {
   // baixo para alto transição!
    pulses++;
  }
  lastflowpinstate = x;
  flowrate = 1000.0;
  flowrate /= lastflowratetimer;  // in hertz
  lastflowratetimer = 0;
}

void useInterrupt(boolean v) {
  if (v) {
   // Timer0 já é usado para millis () - vamos interromper em algum lugar
   // No meio e chamar o "Compare A" função acima
    OCR0A = 0xAF;
    TIMSK0 |= _BV(OCIE0A);
  } else {
    // Não chamar a função COMPA interrupção mais
    TIMSK0 &= ~_BV(OCIE0A);
  }
}

#include <Wire.h>
#include <RTClib.h>
RTC_DS1307 RTC;

#include <SD.h>
#include <SPI.h>
File myFile;

void setup(){
  pinMode(53, OUTPUT);
 if (!SD.begin(53))
  Serial.begin(9600);
  lcd.begin(16, 2);
  pinMode(FLOWSENSORPIN, INPUT);
   digitalWrite(FLOWSENSORPIN, HIGH);
   lastflowpinstate = digitalRead(FLOWSENSORPIN);
   useInterrupt(true);
   Wire.begin();
  RTC.begin();
  if (!RTC.isrunning())
  {
    RTC.adjust(DateTime(__DATE__, __TIME__));
  }
  lcd.setCursor(0, 0);
  lcd.print("Vaca:   ");
  lcd.setCursor(9, 0);
  lcd.print("Quant:");
} 

void loop(){
   float liters = pulses;
  liters /= 7.5;
  liters /= 39.0;
 // Serial.print(liters); Serial.println("Lt");
  lcd.setCursor(9, 1);
  lcd.print(liters); lcd.print(" Lt");
  delay(100);
 
/*  DateTime agora = RTC.now();
  String relogio_data  ;
  String relogio_hora  ;
 
  int dia = agora.day();
  int mes = agora.month();
  int ano = agora.year();
 
  relogio_data += dia;
  relogio_data += "/";
  relogio_data += mes;
 
 
  int hora = agora.hour();
  int minuto = agora.minute();
  int segundo = agora.second();
 
  relogio_hora += hora;
  relogio_hora += ":";
  relogio_hora += minuto;
  relogio_hora += ":";
  relogio_hora += segundo;
 
  lcd.setCursor(8, 0);
  lcd.print(relogio_data);
  lcd.setCursor(8, 1);
  lcd.print(relogio_hora);   */
 
  char key = keypad.getKey();
  if (key == 'B'){
contador=0;
 pulses = 0;
lcd.setCursor(9,1);
lcd.print("0,00");
lcd.setCursor(0,1);
lcd.print("       ");
Serial.println(" Cancelado");
lcd.setCursor(0,0);
lcd.print("Cancelado         ");
delay(1000);
lcd.setCursor(0,0);
lcd.print("Vaca:    ");
lcd.setCursor(9, 0);
lcd.print("Quant:");
 }
 if (key == 'A'){
contador=0;
 pulses = 0;
 lcd.setCursor(9,1);
lcd.print("0,00");
lcd.setCursor(0,1);
lcd.print("       ");
Serial.print("  ");  Serial.print(liters);  Serial.print("Lts");
Serial.println("");

 myFile = SD.open("Produção de leite", FILE_WRITE);
 if (myFile) {
 Serial.print("Gravando");
 myFile.print(liters);
 myFile.close();
  Serial.println(" Ok");
 }
 }
   else if(key)
  {
  lcd.setCursor(contador,1);
    lcd.print(key);
    Serial.print(key);
    delay(500);
    teste[contador] = key;
    contador++;
  }
 if (contador == 4)
  {
 teste[contador] = '\0';
 if ((teste[1]== senha[1]) && (teste[2]== senha[2]) && (teste[3]== senha[3])&& (teste[4]== senha[4]))
  {
 }
  }
} 
void limpaLinha(byte linha)
{
lcd.setCursor(0, linha);
lcd.print("                ");
}

Permalink Responder até ALLAN DAVID SILVA DA COSTA em 25 março 2014 at 20:54

Acho que é isso.... não testei

#include <Keypad.h>
const byte ROWS = 4;
const byte COLS = 4;
char keys[ROWS][COLS] = {
{'1','2','3','A'},
{'4','5','6','B'},
{'7','8','9','C'},
{'*','0','#','D'}
};
byte rowPins[ROWS] = {37, 36, 35, 34}; //connect to the row pinouts of the keypad
byte colPins[COLS] = {33, 32, 31, 30}; //connect to the column pinouts of the keypad
Keypad keypad = Keypad( makeKeymap(keys), rowPins, colPins, ROWS, COLS );
int contador = 0;
char teste[] = {'0','0','0','0','\0'};
char senha [] = {'2','5','4','3','\0'};
#include <LiquidCrystal.h>
LiquidCrystal lcd(8, 7, 6, 5, 4, 3);
#define FLOWSENSORPIN 2
volatile uint16_t pulses = 0; // contar quantos pulsos
volatile uint8_t lastflowpinstate; // Controlar o estado do pino de pulso
volatile uint32_t lastflowratetimer = 0; // Você pode tentar manter o tempo de quanto tempo é entre os pulsos
volatile float flowrate; // E usá-lo para calcular um caudal
SIGNAL(TIMER0_COMPA_vect) { // Interrupção é chamado uma vez um milésimo de segundo, olha para todos os pulsos do sensor!
uint8_t x = digitalRead(FLOWSENSORPIN);
if (x == lastflowpinstate) {
lastflowratetimer++;
return; // Nada mudou!
}
if (x == HIGH) {
// baixo para alto transição!
pulses++;
}
lastflowpinstate = x;
flowrate = 1000.0;
flowrate /= lastflowratetimer; // in hertz
lastflowratetimer = 0;
}
void useInterrupt(boolean v) {
if (v) {
// Timer0 já é usado para millis () - vamos interromper em algum lugar
// No meio e chamar o "Compare A" função acima
OCR0A = 0xAF;
TIMSK0 |= _BV(OCIE0A);
} else {
// Não chamar a função COMPA interrupção mais
TIMSK0 &= ~_BV(OCIE0A);
}
}
#include <Wire.h>
#include <RTClib.h>
RTC_DS1307 RTC;
#include <SPI.h>
///////////////////////////////////////////// SD CARD
#include <SD.h>
File myFile;
int pino_ethernet = 10 ; //USO O SHIELD ETHERNET+SDCARD
///////////////////////////////////////////// SD CARD

void setup(){
Serial.begin(9600);

///////////////////////////////////////////// SD CARD
while ( !Serial ) { ; }
pinMode ( pino_ethernet, OUTPUT ) ;
if (!SD.begin (53) ) {
Serial.println ( "Falha na Comunicação ...... " ) ;
return ; }
///////////////////////////////////////////// SD CARD

lcd.begin(16, 2);
pinMode(FLOWSENSORPIN, INPUT);
digitalWrite(FLOWSENSORPIN, HIGH);
lastflowpinstate = digitalRead(FLOWSENSORPIN);
useInterrupt(true);
Wire.begin();
RTC.begin();
if (!RTC.isrunning())
{
RTC.adjust(DateTime(__DATE__, __TIME__));
}
lcd.setCursor(0, 0);
lcd.print("Vaca: ");
lcd.setCursor(9, 0);
lcd.print("Quant:");
}
void loop(){
float liters = pulses;
liters /= 7.5;
liters /= 39.0;
// Serial.print(liters); Serial.println("Lt");
lcd.setCursor(9, 1);
lcd.print(liters); lcd.print(" Lt");
delay(100);

/* DateTime agora = RTC.now();
String relogio_data ;
String relogio_hora ;

int dia = agora.day();
int mes = agora.month();
int ano = agora.year();

relogio_data += dia;
relogio_data += "/";
relogio_data += mes;


int hora = agora.hour();
int minuto = agora.minute();
int segundo = agora.second();

relogio_hora += hora;
relogio_hora += ":";
relogio_hora += minuto;
relogio_hora += ":";
relogio_hora += segundo;

lcd.setCursor(8, 0);
lcd.print(relogio_data);
lcd.setCursor(8, 1);
lcd.print(relogio_hora); */

char key = keypad.getKey();
if (key == 'B'){
contador=0;
pulses = 0;
lcd.setCursor(9,1);
lcd.print("0,00");
lcd.setCursor(0,1);
lcd.print(" ");
Serial.println(" Cancelado");
lcd.setCursor(0,0);
lcd.print("Cancelado ");
delay(1000);
lcd.setCursor(0,0);
lcd.print("Vaca: ");
lcd.setCursor(9, 0);
lcd.print("Quant:");
}
if (key == 'A'){
contador=0;
pulses = 0;
lcd.setCursor(9,1);
lcd.print("0,00");
lcd.setCursor(0,1);
lcd.print(" ");
Serial.print(" "); Serial.print(liters); Serial.print("Lts");
Serial.println("");

///////////////////////////////////////////// SD CARD
myFile = SD.open("ProduçãodeLeite.txt", FILE_WRITE);
if (myFile) {
Serial.print("Gravando");
myFile.print(liters);
myFile.print( " " );
myFile.println(Litros);
myFile.close();
Serial.println(" Ok");
delay (500);
}
///////////////////////////////////////////// SD CARD

}
else if(key)
{
lcd.setCursor(contador,1);
lcd.print(key);
Serial.print(key);
delay(500);
teste[contador] = key;
contador++;
}
if (contador == 4)
{
teste[contador] = '\0';
if ((teste[1]== senha[1]) && (teste[2]== senha[2]) && (teste[3]== senha[3])&& (teste[4]== senha[4]))
{
}
}
}
void limpaLinha(byte linha)
{
lcd.setCursor(0, linha);
lcd.print(" ");
}

Permalink Responder até Adilson J. Ribeiro em 26 março 2014 at 8:47

Allan se tiver como testar aí, pra mim continua sem gravar no SD, na verdade ele não ta nem iniciando.

Permalink Responder até ALLAN DAVID SILVA DA COSTA em 26 março 2014 at 8:52

Qual Shield vc esta usando?

Permalink Responder até Sidney Alves Bastos em 18 março 2014 at 11:07

Eu também já tinha pensado nisso e até já vi uma impressora ttl.

RSS

Destaques

Registre-se no Lab de Garagem
clicando aqui

Convide um amigo para fazer parte

curso gratis de arduino

© 2024   Criado por Marcelo Rodrigues.   Ativado por

Badges  |  Relatar um incidente  |  Termos de serviço