controllo semina

ciao
vi sottopongo il risultato della applicazione di prova, per il controllo della semina in pieno campo, per una seminatrice con 6 elementi, i risultati sono incoraggianti

stefano

/*
stato operativo
versione con interrupt per due elementi
*/
//#include <LiquidCrystal.h>  // include the library code
//LiquidCrystal lcd(9,8,7,6,5,4); // initialize the library with the numbers of the interface pins

int statosensore1=HIGH;  //stato iniziale del sensore
int statosensore2=HIGH;  //stato iniziale del sensore

int i,j,k,x;

float Fmin,Fmax;
float freq[2]={0,0};//per la frequenza degli eventi di interrupt

int count[2]={0,0};//conteggio degli eventi per il calcolo del tempo

unsigned long tempo[2][10]={{0,0,0,0,0,0,0,0,0,0},
                            {0,0,0,0,0,0,0,0,0,0}};//memorizza l'istante di tempo in cui accade l'evento
unsigned long deltatempo1;//tempo di attesa in mancanza di eventi
unsigned long deltatempo2;//tempo di attesa in mancanza di eventi

//shiftout
int latchPinOUT = 7;//ST_CP di 74HC595 pin 12
int clockPinOUT =6;//SH_CP di 74HC595 pin 11
int dataPinOUT = 5;//DS di 74HC595  pin 14

byte ledRossiH = B00000000; //matrice 3x2 di led 
byte ledVerdi = B00000000; //matrice 3x2 di led 
byte ledRossiL = B00000000; //matrice 3x2 di led 

void setup() 
{
  delay(5000);
//lcd.begin(16,4);  // set up the LCD's number of columns and rows:
 i=0;
 j=0;
 k=0;
Fmin=3.0;
Fmax=10.0;
   attachInterrupt(0,sensore1,FALLING); //sensore collegato al pin 2
   attachInterrupt(1,sensore2,FALLING); //sensore collegato al pin 3
     
pinMode(2,INPUT);
pinMode(3,INPUT);

digitalWrite(2, HIGH);
digitalWrite(3, HIGH);
 
//--------------------------shiftout
  pinMode(latchPinOUT, OUTPUT);
  pinMode(clockPinOUT, OUTPUT);
  pinMode(dataPinOUT, OUTPUT);
  
// Serial.begin(9600); //per debug
}

void loop()
{
 //------------------------sensore 1
  if (statosensore1==LOW)       
{ 
  count[0]++; //incremento del contatore
 // Serial.println(count[0]); //per debug
  tempo[0][i]=millis();  //memorizzazione dell'istante di tempo
  i++; //incremento del contatore
    //   Serial.println(tempo[0]); //per debug
      //   Serial.println(tempo[9]); //per debug
      
   if(i==10)
  {
    freq[0]=(count[0]-1)*1000/(tempo[0][9]-tempo[0][0]);//calcolo della frequenza
   i=0;
   count[0]=0;
// Serial.println(freq[0]); //per debug
   }
  statosensore1=HIGH;
}
 
//---------------------------sensore 2
 if (statosensore2==LOW)        
{ 
  count[1]++;  //incremento del contatore
  tempo[1][j]=millis(); j++;  //memorizzazione dell'istante di tempo  
 if(j==10)
  {
    freq[1]=(count[1]-1)*1000/(tempo[1][9]-tempo[1][0]); //calcolo della frequenza
   j=0;  //azzeramento del contatore
   count[1]=0;  //azzeramento del contatore
 // Serial.println(freq[1]);  //per debug
   }
  statosensore2=HIGH;
}

deltatempo1=millis()-tempo[0][9];
//Serial.println(deltatempo1);
deltatempo2=millis()-tempo[1][9];

if (deltatempo1>2000)
{
freq[0]=0;  //azzeramento della frequenza dopo attesa di 2 sec
}

if (deltatempo2>2000)
{
freq[1]=0;  //azzeramento della frequenza dopo attesa di 2 sec
}

for(k=0;k<=1;k++)
{
 //  Serial.println("freq[0] ");
  // Serial.println(freq[0]);
 //  Serial.println("freq[1] ");
 //  Serial.println(freq[1]);
   
if(freq[k]>Fmin && freq[k]<Fmax)  //frequenza normale di lavoro
{
     bitWrite(ledRossiH,k,0);// 00000000
      bitWrite(ledVerdi,k,1);// 01000000 accensione del led centrale
     bitWrite(ledRossiL,k,0);// 00000000
   // Serial.println(freq[0]); 
 //Serial.println(bitRead(ledVerdi,k));
  
}
if(freq[k]<=Fmin)  //frequenza bassa di lavoro
{
 // Serial.println(pulseIn(k+2,LOW));
     bitWrite(ledRossiH,k,0);
      bitWrite(ledVerdi,k,0);
     bitWrite(ledRossiL,k,1);// accensione del led inferiore
}
if(freq[k]>=Fmax)  //frequenza alta di lavoro
{ 
     bitWrite(ledRossiH,k,1);// accensione del led superiore
      bitWrite(ledVerdi,k,0);
     bitWrite(ledRossiL,k,0);
}

    digitalWrite(latchPinOUT,1);     //Pull latch LOW to start sending data
     shiftOut(dataPinOUT, clockPinOUT, MSBFIRST, ledRossiH);    //Send the data byte rossi
       shiftOut(dataPinOUT, clockPinOUT, MSBFIRST, ledVerdi);    //Send the data byte verdi
     shiftOut(dataPinOUT, clockPinOUT, MSBFIRST, ledRossiL);    //Send the data byte rossi 
    digitalWrite(latchPinOUT,0);                      //Pull latch HIGH to stop sending data

}
}
  
void sensore1() //pin 2 a cui attaccare il fotosensore
{
  statosensore1=LOW;
}
void sensore2() //pin 3 a cui attaccare il fotosensore
{
  statosensore2=LOW;
}

fotosem.zip (2.58 MB)

Interessante, bel lavoro.

COMPLIMENTI 8)

il merito e un grazie va soprattutto a questo forum e a chi lo frequenta, fornendo risposte competenti

stefano

E' sempre interessante vedere progetti realizzati.
Ma toglimi una curiosità: perché usi 3 Arduino?

curiosità...
come mai hai preferito non usare pulsein per leggere il periodo fra un evento e l'altro?

ciao
bene fate fate domande
@PaoloP
Ma toglimi una curiosità: perché usi 3 Arduino? la macchina ha sei elementi 2 interrupt per arduino totale 3 arduini, ho cercato di avere 6 interrupt e qualcosa avevo fatto come programma ma i semi passano si regolarmente ma in istanti diversi tra loro, in pratica sono 6 onde quadre sfasate fra di loro e l'istante dura circa 5ms e quindi temevo di perdere qualcosa

@BrainBooster

curiosità...
come mai hai preferito  non usare pulsein per leggere il periodo fra un evento e l'altro?

è stato l'approccio iniziale ma poi mi sono reso conto che la durata degli impulsi non mi serviva quanto la frequenza di passaggio per poter decidere cosa fare se la frequenza fosse stata diversa da quella ottimale vedi i vari casi di IF, a questo proposito vorrei sapere se i vari IF

if(freq[k]>Fmin && freq[k]<Fmax)  //frequenza normale di lavoro
{
...    
}
if(freq[k]<=Fmin)  //frequenza bassa di lavoro
{
...
}
if(freq[k]>=Fmax)  //frequenza alta di lavoro
{
...
}

non siano sostituibili con lo SWITCH, sarebbe più elegante.

Appena sistemati gli schemi posto anche quelli
Un'altra domanda qualcuno sà come si può fare la marcatura CE?

stefano

ma dal periodo puoi risalire alla frequenza degli eventi con un semplice calcolo, e pulsein si sarebbe occupata della gestione degli interrupt.
Comunque se così funziona,il tuo metodo è già migliore di quello proposto :slight_smile:

ciao
@BrainBooster
ma il periodo non è dato dalla somma del tempo Low + quello High, con tutti questi calcoli magari 1 solo arduino non ce la faceva.
Pensando questo ho optato per l'uso degli interrupt, comunque io non sono un esperto lo dimostrano le domande che mi fate, riconosco che 3 arduini sono al momento uno spreco di risorse, per questo sto ragionando sulla sua evoluzione dove un quarto arduino riceva tramite I2c i valori dai primi 3 li visualizzi insieme alla quantità di semi per ettaro e ad altre cose come la temperatura esterna

stefano

Ma 3 o 4 ATtiny non ti basterebbero ?

Il risparmio (sia in termini di costi che di consumi) sarebbe notevole, no ?

ciao
penso di si, ho visto che in alcune discussioni se ne parla ma non ho mai approfondito, mi dai qualche link dove comprare italiano

stefano

Non ho seguito molto la discussione ma quando sento parlare di Attiny mi intrometto :stuck_out_tongue:
Che sensore usi per fare il conteggio? Per capire se ti basta un Attinyx5 oppure ti serve un Attinyx4. Buona l'idea infatti di usare il bus I2C per dialogare con un Arduino inviando le letture. Ah, con che frequenza cadono i semi, per capire se i tempi del bus I2C ti sono sufficienti.

ciao
@leo
i sensori sono IR tx e rx autocostruiti ci sono le foto allegate, la frequenza vale 5 semi/secondo minimo, 15 semi secondo/max

stefano

Uhm... vedo che comandi anche dei registri a scorrimento. Ma quanti pin usa il tuo progetto per singolo Arduino?

ciao
2 pin per interrupt
3 pin per i registri
una scheda per due elementi

stefano

stefa24:
ciao
2 pin per interrupt
3 pin per i registri
una scheda per due elementi

stefano

5 pin per Arduino? Potresti usare un Tiny84, allora. Ha 11 pin liberi. E puoi usare anche con esso i PcInt, ossia gli interrupt di cambio di stato sui pin.

e risparmi un sacco di soldi $$$$$$$ $) $$$$$$

ciao
se seguo questa discussione trovo informazioni utili?
http://arduino.cc/forum/index.php/topic,56772.0.html

dove compro italiano?

grazie
stefano

Io i Tiny, sia Tiny85 che Tiny84, li compro da RS. Prendi i modelli "A", che hanno l'ultimo core aggiornato di Atmel che lavorano sia a max 20 MHz di clock sia a 1,8V di tensione minima di alimentazione.

La discussione che hai linkato è quella da cui è nato tutto il lavoro che poi trovi riassunto nella mia guida che ti ho segnalato.

ciao
questo può andare bene
http://it.rs-online.com/web/p/microcontrollori/6962594/
non trovo la segnalazione della guida di cui parli

grazie
stefano