Sketch comportamento strano - Arduino Yun

Ciao a tutti,

Ho questo sketch che funziona benissimo sull’Arduino Uno.
Tutti i sensori funzionano.

MA, con la Yun quando carico lo sketch il sensore DHT22 non funziona più,
e nella finestra seriale mi stampa i primi 2 secondi se mi va bene e poi si ferma non stampa più niente.
Eppure i sensori funzionano sulla Yun individualmente!! Non capisco :frowning:
Mi chiedo se in qualche modo l’interrupt nel void flusso potrebbe causare questo?
Stranamente se carico lo stesso sketch nella Uno e sposto i collegamenti su questa, funziona tutto! Non capisco cosa succede :frowning:

Sketch principale:

#include <DHT.h>                           //For DHT22 & AM2302 library
#include <OneWire.h>                       //For DS18B20
#include <LiquidCrystal.h>
#include <Wire.h>                          //For RTC
#include "RTClib.h"                        //For RTC

#define DHTPIN 3                           //DHT22
#define DHTTYPE DHT22
DHT dht(DHTPIN, DHTTYPE);

const byte DS18B20_Pin = 4;                //DS18B20 Signal pin on digital 4
OneWire ds(DS18B20_Pin);                   // on digital pin 4

int Calc;                                  //Sensore flusso
volatile int NbTopsFan;                    //measuring the rising edges of the signal
int hallsensor = 2;                        //The pin location of the sensor
void rpm ()                                //This is the function that the interupt calls 
{ 
  NbTopsFan++;                             //This function measures the rising and falling 
                                           //edge of the hall effect sensors signal
} 

RTC_DS1307 RTC;

LiquidCrystal lcd(7, 8, 9, 10, 11, 12);


void setup()
{  
  // ***For Flow sensor*****************************************
  pinMode(hallsensor, INPUT);              //initializes digital pin 2 as an input
  attachInterrupt(0, rpm, RISING);         //and the interrupt is attached
  // ***********************************************************
  
  Serial.begin(9600); 
  lcd.begin(16, 2);
  dht.begin();                             //DHT22
  Wire.begin();
  RTC.begin();
  
  //***For RTC module*******************************************
  if (! RTC.isrunning()) {                 //****commentare questa riga per aggiornare la data****
    Serial.println("RTC is NOT running!");
    // following line sets the RTC to the date & time this sketch was compiled
    RTC.adjust(DateTime(__DATE__, __TIME__));
  }                                       //****commentare questa riga per aggiornare la data*****
  //************************************************************
}


void loop()
{
rtc();
dht22();
ds18b20();
flusso();

delay(1000);                              //just to slow down the output it's easier to read

}

DHT22

void dht22()
{
  float h = dht.readHumidity();
  float t = dht.readTemperature();
  
  Serial.print("Umidita dentro casa : \t ");
  Serial.print(h);
  Serial.println(" % ");
  Serial.print("Temp. dentro casa : \t ");
  Serial.print(t);
  Serial.println(" c ");              
  
  lcd.print("Home  Hum  Tank");
  lcd.setCursor(0,1);
  lcd.print(t);
  lcd.print("c ");
  lcd.print(h);
  lcd.print("% ");
}

DS18B20

void ds18b20()
{
  float temperature = getTemp();     
  Serial.print("Temp. acqua :            ");
  Serial.print(temperature);
  Serial.println(" c");
  Serial.println(" ");

  lcd.print(temperature);
  lcd.println("c");
}

float getTemp()
{
  //returns the temperature from one DS18S20 in DEG Celsius
  byte data[12];
  byte addr[8];

  if ( !ds.search(addr)) 
  {
    //no more sensors on chain, reset search
    ds.reset_search();
    return -1000;
  }

  if ( OneWire::crc8( addr, 7) != addr[7]) 
  {
    Serial.println("CRC is not valid!");
    return -1000;
  }

  if ( addr[0] != 0x10 && addr[0] != 0x28) 
  {
    Serial.print("Device is not recognized");
    return -1000;
  }

  ds.reset();
  ds.select(addr);
  ds.write(0x44,1);                           // start conversion, with parasite power on at the end

  byte present = ds.reset();
  ds.select(addr);  
  ds.write(0xBE); // Read Scratchpad


  for (int i = 0; i < 9; i++)                  // we need 9 bytes
  {
    data[i] = ds.read();
  }

  ds.reset_search();

  byte MSB = data[1];
  byte LSB = data[0];

  float tempRead = ((MSB << 8) | LSB);         //using two's compliment
  float TemperatureSum = tempRead / 16;

  return TemperatureSum;                       

}

FLUSSO

void flusso()
{
  NbTopsFan = 0;	         //Set NbTops to 0 ready for calculations
  sei();		         //Enables interrupts
  delay (1000);	                 //Wait 1 second
  cli();		         //Disable interrupts
  Calc = (NbTopsFan * 60 / 7.5); //(Pulse frequency x 60) / 7.5Q, = flow rate 
                                 //in L/hour 
  Serial.print (Calc, DEC);      //Prints the number calculated above
  Serial.println (" L/hour\r\n");  //Prints "L/hour" and returns a  new line
  
  /*
  lcd.setCursor(0, 0);
  lcd.print("Flusso: ");
  //lcd.setCursor(0, 1);
  lcd.print(Calc, DEC);
  lcd.println(" L/h            ");
*/
}

RTC

void rtc()
{
  DateTime now = RTC.now();
  
    Serial.print(now.day(), DEC);
    Serial.print('/');
    Serial.print(now.month(), DEC);
    Serial.print('/');
    Serial.print(now.year(), DEC);
    Serial.print(' ');
    Serial.print(now.hour(), DEC);
    Serial.print(':');
    Serial.print(now.minute(), DEC);
    Serial.print(':');
    Serial.print(now.second(), DEC);
    Serial.println();
}

IN PIU’, quando carico questo sketch la scheda Yun mi sparisce nel menu delle porte usb, la vedo solo come wifi. Appena carico un’altro sketch compare di nuovo… Cosa succede?

Mi correggo, scritto cosi come ho postato sopra ho lo stesso problema per il sensore di flusso che non compare nella finestra seriale e questa finestra che si blocca dopo 2 secondi anche con la Uno.

In qualche modo lo sketch per il sensore di flusso non mi blocca solo la lettura in seriale ma tutto il programma si blocca... e non capisco perché!

C'è anche il problema del DHT22 che non funziona in questo sketch sulla Yùn quando in realtà funziona benissimo sulla Uno,

E la Yùn che mi sparisce delle connessioni usb con questo sketch.

Mah, che strano :(

Diciamo che ho poca esperienza con la yun, ma sulla parte Arduino (ATmega32U4) non deve essere una parte di sketch bridge che comunica con la parte Linux. Togliendo quello il Yun non diventa un semplice Leonado?

Ciao Uwe

L'interrupt 0 sulla YUN/Leonardo è sul pin 3 non sul pin 2. --> http://arduino.cc/en/Reference/attachInterrupt

Modifica il codice e l'assegnamento dei pin.

Ciao Paolo,

Grazie per la risposta.

Allora devo modificare qui giusto?

attachInterrupt(1, rpm, RISING);

Ho messo 1 al posto di 0 perché 1 è per il pin 2.

Ma poi cosa devo cambiare altro? Non devo cambiare il pin giusto perché è sul pin 2, con l’interrupt 1 (per il pin 2) quindi dovrei essere a posto no?

Eppure non mi va :frowning:

Non devi disabilitare gli interrupt. Devi usare millis al posto del delay.

Riparti da questo esempio --> http://playground.arduino.cc/Main/ReadingRPM

Wado: Ho messo 1 al posto di 0 perché 1 è per il pin 2.

Secondo quanto dichiarato sulla pagina della Yùn, questa è la corrispondenza fra pin e interrupt: INT0 - >D3 INT1 -> D2 INT2 -> D0 INT3 -> D1 INT4 -> D7

Attento quindi a come hai fatto i collegamenti. Poi, non serve dichiarare il pin dell'interrupt come input, l'interrupt viene sollevato lo stesso anche col pin lasciato con lo stato iniziale.

Altra cosa che non capisco è perché resetti la variabile usata nell'interrupt prima di disattivare l'interrupt stesso. Sarebbe meglio disattivarlo prima di resettarla (anche se sicuramente il problema non sarà quello). Per non parlare del delay(1000) che non si può vedere: usi gli interrupt per non avere ritardi nella lettura dei segnali e poi stacchi tutto e stai fermo 1000 ms? :sweat_smile:

Grazie per la risposta.

ho recuperato lo sketch in internet quindi diciamo che lo capisco finla.. Mi dici che resero la variabile ma non capisco dove??

Il delay mi serve per avere una lettura più facile nel seriale.

Ho tolto la dichiarazione del pin come input avevi ragione non serve :)

I miei collegamenti sono giusti uso il pin giusto con l'interrupt giusto sulle schede (adesso).

Quello che non capisco è perché questo sketch mi funziona bene con la Uno ma mi blocca la Yun?! Quello del flusso intendo, se lo carico solo quello con la Uno funziona bene ma con la Yùn non funziona proprio.. perché??!!?

Ecco dove resetti dentro alla funzione flusso():

  NbTopsFan = 0;           //Set NbTops to 0 ready for calculations
  sei();               //Enables interrupts
  delay (1000);                    //Wait 1 second
  cli();               //Disable interrupts

Quello che non capisco è perché questo sketch mi funziona bene con la Uno ma mi blocca la Yun?!

La Yun è una scheda particolare, intanto ha un chip diverso dall'Atmega328 delle Uno e poi andrebbe visto se la libreria Bridge usata per comunicare con la parte Linux può dare noia alla gestione degli interrupt oppure essere disturbata da essa. Non ho la scheda quindi non ho mai approfondito come lavora e come funziona a basso livello.

@Wado
alleggerisci il carico :slight_smile:
Invece di usare RTC utilizza il datetime di Linux.

Dai un’occhiata alla funzione getTimeStamp() riportata qui:

Non riesco a caricare lo sketch nella yun mi si blocca tutto. Praticamente quando carico questo sketch nella Yun essa sparisce delle concessioni USB e rimane visibile solamente tramite wifi.

Se però mi collego in wifi colla scheda e carico un'altro sketch essa ricompare.

Perché?!?!?

Prova a commentare la riga dove disabiliti gli interrupt.

#include <DHT.h>                           //For DHT22 & AM2302 library
#include <OneWire.h>                       //For DS18B20
#include <LiquidCrystal.h>
#include <Wire.h>                          //For RTC
#include "RTClib.h"                        //For RTC

#define DHTPIN 3                           //DHT22
#define DHTTYPE DHT22
DHT dht(DHTPIN, DHTTYPE);

const byte DS18B20_Pin = 4;                //DS18B20 Signal pin on digital 4
OneWire ds(DS18B20_Pin);                   // on digital pin 4

int Calc;                                  //Sensore flusso
volatile int NbTopsFan;                    //measuring the rising edges of the signal
int hallsensor;                            //The pin location of the sensor is 2 (int0 on Yun = Pin 2)
void rpm ()                                //This is the function that the interupt calls 
{ 
  NbTopsFan++;                             //This function measures the rising and falling 
                                           //edge of the hall effect sensors signal
} 

RTC_DS1307 RTC;

LiquidCrystal lcd(7, 8, 9, 10, 11, 12);


void setup()
{  
  // ***For Flow sensor*****************************************
  pinMode(hallsensor, INPUT);              //initializes digital pin 2 as an input
  attachInterrupt(1, rpm, RISING);         //and the interrupt is attached
  // ***********************************************************
  
  Serial.begin(9600); 
  lcd.begin(16, 2);
  dht.begin();                             //DHT22
  Wire.begin();
  RTC.begin();
  
  //***For RTC module*******************************************
  if (! RTC.isrunning()) {                 //****commentare questa riga per aggiornare la data****
    Serial.println("RTC is NOT running!");
    // following line sets the RTC to the date & time this sketch was compiled
    RTC.adjust(DateTime(__DATE__, __TIME__));
  }                                       //****commentare questa riga per aggiornare la data*****
  //************************************************************
}


void loop()
{
rtc();
dht22();
ds18b20();
//flusso();

//delay(1000);                              //just to slow down the output it's easier to read

}

Io ho commentato tutta la parte chiamata flusso nel loop, ma non cambia niente purtroppo

Ad esempio, se carico questo sketch per il sensore dht22 mi funziona tutto e lego i valori su LCD e seriale con la Yun.

#include "DHT.h"          // DHT & AM2302 library
#include <LiquidCrystal.h>
 
// Version number
const float fVerNum = 0.03;
 
// Data pin connected to AM2302
#define DHTPIN 3
 
#define DHTTYPE DHT22       // DHT 22  (AM2302)
 
DHT dht(DHTPIN, DHTTYPE);   // LED pins

LiquidCrystal lcd(7, 8, 9, 10, 11, 12);
 
//////////////////////////////////////////////////////
//
// SETUP
//
void setup() {
  // Setup serial monitor
  Serial.begin(9600);
  lcd.begin(16, 2);
  
  // Wait 3 seconds
  delay(3000);
  
  Serial.println(F("\nAM2302 Sensor"));
  Serial.print(F("Version : "));
  Serial.println(fVerNum);
  Serial.println(F("Arduino - Derek Erb\n"));
  delay(5000);
  
  dht.begin();
}
  
 
void loop() {
  
  loopdht22();
}

loopdht22

void loopdht22()
{
  // Reading temperature or humidity takes about 250 milliseconds!
  // Sensor readings may also be up to 2 seconds 'old' (its a very slow sensor)
  float h = dht.readHumidity();
  float t = dht.readTemperature();
 
  // check if returns are valid, if they are NaN (not a number) then something went wrong!
  if (isnan(t) || isnan(h)) {
    Serial.println(F("Failed to read from DHT"));
  }
  else {
    Serial.print(F("Humidity: ")); 
    Serial.print(h);
    Serial.print(F(" %\t"));
    Serial.print(F("Temperature: ")); 
    Serial.print(t);
    Serial.println(F(" C"));
    
  lcd.print(" Home   Humidity");
  lcd.setCursor(0,1);
  lcd.print(t);
  lcd.print("c   ");
  lcd.print(h);
  lcd.print("% ");
  }
  
  // Wait 3 seconds
  delay(1000);
}

MA, lo stesso identico sensore, con i stessi identici collegamenti incorporato nel mio sketch progetto dove commento nel loop gli altri sensori per lasciare solo il dht22 non mi funziona e lego valori a 0 da per tutto.

#include <DHT.h>                           //For DHT22 & AM2302 library
#include <OneWire.h>                       //For DS18B20
#include <LiquidCrystal.h>
#include <Wire.h>                          //For RTC
#include "RTClib.h"                        //For RTC

#define DHTPIN 3                           //DHT22
#define DHTTYPE DHT22
DHT dht(DHTPIN, DHTTYPE);

const byte DS18B20_Pin = 4;                //DS18B20 Signal pin on digital 4
OneWire ds(DS18B20_Pin);                   // on digital pin 4

int Calc;                                  //Sensore flusso
volatile int NbTopsFan;                    //measuring the rising edges of the signal
int hallsensor;                            //The pin location of the sensor is 2 (int0 on Yun = Pin 2)
void rpm ()                                //This is the function that the interupt calls 
{ 
  NbTopsFan++;                             //This function measures the rising and falling 
                                           //edge of the hall effect sensors signal
} 

RTC_DS1307 RTC;

LiquidCrystal lcd(7, 8, 9, 10, 11, 12);


void setup()
{  
  // ***For Flow sensor*****************************************
  pinMode(hallsensor, INPUT);              //initializes digital pin 2 as an input
  attachInterrupt(1, rpm, RISING);         //and the interrupt is attached
  // ***********************************************************
  
  Serial.begin(9600); 
  lcd.begin(16, 2);
  dht.begin();                             //DHT22
  Wire.begin();
  RTC.begin();
  
  //***For RTC module*******************************************
  if (! RTC.isrunning()) {                 //****commentare questa riga per aggiornare la data****
    Serial.println("RTC is NOT running!");
    // following line sets the RTC to the date & time this sketch was compiled
    RTC.adjust(DateTime(__DATE__, __TIME__));
  }                                       //****commentare questa riga per aggiornare la data*****
  //************************************************************
}


void loop()
{
//rtc();
dht22();
//ds18b20();
//flusso();

//delay(1000);                              //just to slow down the output it's easier to read

}

DHT22

void dht22()
{
  float h = dht.readHumidity();
  float t = dht.readTemperature();
  
  Serial.print("Umidita dentro casa : \t ");
  Serial.print(h);
  Serial.println(" % ");
  Serial.print("Temp. dentro casa : \t ");
  Serial.print(t);
  Serial.println(" c ");              
  
  lcd.print("Home  Hum  Tank");
  lcd.setCursor(0,1);
  lcd.print(t);
  lcd.print("c ");
  lcd.print(h);
  lcd.print("% ");
}

E IN PIU’ mi sparisce la scheda Yun nelle porte usb, la vedo solo come wifi.

Sembra ci sia qualcosa che crea problemi o nel setup o prima, visto che anche se commento il loop mi crea problemi lo stesso.

Qualcuno ha un'idea?

La differenza tra i due sketch sono le librerie OneWire e RTClib.
Prova ad includerne solo una e riprova.
Andando per esclusione dovresti trovare il punto che fa impazzire la YUN.

Funzionaaaaaaaaa grazie grazie grazie a tutti e in particolare a PaoloP!!

Era qualcosa legato al RTC, ho cancellato tutto e adesso non ho più problemi di scheda che sparisce o di sensori bloccati.

Grazie mille veramente non avrei pensato che una libreria possa creare problemi grazie grazie grazie ancora!

Al posto della RTC sulla YUN puoi prendere l'orario tramite il Bridge.

Al posto della RTC sulla YUN puoi prendere l'orario tramite il Bridge.

:D come detto parecchi post fa...