GRIX.IT FORUM - Problema millis arduino su Elettronica Generale

guzzj

postato il:
16.03.2017, alle ore 18:55

Problema millis arduino

Buona sera a tutti. pongo una domanda a chi Ã¨ piÃ¹ esperto di me. mi sto cimentando con arduino per fare una centralina acquario. nella rete ho trovato uno sketc per le luci e uno per la temperatura. sono riuscito a unire i due programmi e quando lo carico su arduino funziona tuto bene tranne che per una cosa: in void loop ho dovuto togliere il delay del sensore temperatura se no mi bloccava tutto, e senza un ritardo nell\' acquisizione dati del sensore lm35 ho uno sfarfallamento nella lettura temperatura e nella fase on off del relay. secondo voi Ã¨ fattibile riuscire a ritardare la lettura del sensore usando millis al posto di delay? Ã¨ una settimana che ci provo ma non ci riesco. se qualcuno puÃ² indirizzarmi ve ne sarei grato.

Non è obbligatorio usare il paracadute, ma ricorda, lo puoi fare una volta sola.

guzzj

postato il:
16.03.2017, alle ore 19:27

ops ecco il codice.

#include <LiquidCrystal.h>
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

int reading = 0;
int sensorPin = A0;
int relay =7;
void setup() {

lcd.begin(16, 2);
pinMode(relay,OUTPUT);
}

void loop() {
reading = analogRead(sensorPin);
int celsius = reading/2;
lcd.setCursor(0, 0);
lcd.print(\"Temperatura: \");
lcd.setCursor(0,1);
lcd.print(celsius, DEC);
lcd.print((char)223);
lcd.print(\"C\");
if (celsius >28) {
digitalWrite(7,HIGH);
lcd.print(\" ON\");
} else {
digitalWrite(7,LOW);
lcd.print(\" OFF\");
}
delay(500);
lcd.clear();
}

sistemato l\'allegato code, un pò di logica però F.G.

Non è obbligatorio usare il paracadute, ma ricorda, lo puoi fare una volta sola.

picmicro675

postato il:
16.03.2017, alle ore 21:07

La sezione dovrebbe essere PIC MICRO: Comunque ...

Delay() è bloccante, che vuol dire che sin tanto che non è trascorso il determinato periodo sta li ad aspettare. Con millis() si fa in modo che avviene una verifica e quando ha raggiunto tale periodo esegue il resto del codice. Per cui se la condizione non è vera, l' istruzione passa a quella successiva a millis().
Prova questo

#include <LiquidCrystal.h>
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

#define sensorPin A0

int reading = 0;
byte relay = 7;
unsigned long lastmillis;

void setup()
{
    lcd.begin(16, 2);
    pinMode(relay,OUTPUT);
}

int sampling(void)
/* campionamento della lettura analogica. Si rielvano 60 campioni
* poi si fa la media
*/
{
    for (byte = i; i << 60; i++) {
        reading += analogRead(sensorPin);
    }
    return reading / i;
}

void loop()
{
    // attesa di 2 secondi prima di prendere una nuova campionatura
    if (millis() > (lastmillis + 2000)) {
        int celsius = sampling / 2;
    }
    lcd.setCursor(0, 0);
    lcd.print("Temperatura: ");
    lcd.setCursor(0,1);
    lcd.print(celsius);
    lcd.print((char)223);
    lcd.print("C");
    if (celsius >28) {
        digitalWrite(7,HIGH);
        lcd.print(" ON");
    }
    else {
        digitalWrite(7,LOW);
        lcd.print(" OFF");
    }
    delay(500);
    lcd.clear();
}

Comunque non è chiaro cosa intendi per fare la lettura del sensore.
Io ho messo una funzione che fa una media di 60 campioni, l' aggiornamento del valore avviene ogni 2000 millisecondi , per avere un valore ottimale. Il ritardo in fondo dovrebbe rimanere, per non forzare troppo l' aggiornamento del display.

Comunque non riesco a capire se hai una conversione proporzionale al valore letto su piedino analogico.

Anno nuovo, forum nuovo.
Mi sa che lascio.

picmicro675

postato il:
16.03.2017, alle ore 21:16

Ah! non l' ho provato. Ecco quello che si compila

#include <LiquidCrystal.h>
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

#define sensorPin A0

int reading = 0;
uint8_t relay = 7;
int celsius;
unsigned long lastmillis;

void setup()
{
    lcd.begin(16, 2);
    pinMode(relay,OUTPUT);
}

int sampling(void)
/* campionamento della lettura analogica. Si rielvano 60 campioni
* poi si fa la media
*/
{
    uint8_t i=0;
    for ( ; i << 60; i++) {
        reading += analogRead(sensorPin);
    }
    return reading / i;
}

void loop()
{
    // attesa di 2 secondi prima di prendere una nuova campionatura
    if (millis() > (lastmillis + 2000)) {
        celsius = sampling() / 2;
    }
    lcd.setCursor(0, 0);
    lcd.print("Temperatura: ");
    lcd.setCursor(0,1);
    lcd.print(celsius);
    lcd.print((char)223);
    lcd.print("C");
    if (celsius >28) {
        digitalWrite(7,HIGH);
        lcd.print(" ON");
    }
    else {
        digitalWrite(7,LOW);
        lcd.print(" OFF");
    }
    delay(500);
    lcd.clear();
}

Anno nuovo, forum nuovo.
Mi sa che lascio.

guzzj

postato il:
16.03.2017, alle ore 21:35

Praticamente avrei bisogno che la temperatura venisse letta solo ogni tot secondi o minuti, per non avere al raggiungimento dei 28 gradi un continuo on off sul Pin del relay.

Non è obbligatorio usare il paracadute, ma ricorda, lo puoi fare una volta sola.

guzzj

postato il:
16.03.2017, alle ore 22:56

Grazie picmicro ma anche solo eseguendo il tuo codice la temperatura mi rimane fissa a -1 gradi. posto il codice completo(spero di far giusto) in cui ho unito il codice temperatura. la stringa delay del codice temperatura non la posso usare se no si impalla il resto.

// include the libraries:
#include <LiquidCrystal.h>
#include <Wire.h>
#include <Button.h>
#include <EEPROM.h>
#include <EEPROMVar.h>

/**** Define Variables & Constants ****/
/**************************************/

// set the relais
int reading = 0;
int sensorPin = A3;
int relay =1;
// set the RTC's I2C address
#define DS1307_I2C_ADDRESS 0x68
// create the LCD
LiquidCrystal lcd(8, 7, 5, 4, 16, 2);
// set up backlight
int bkl = 6; // backlight pin
byte bklIdle = 50; // PWM value for backlight at idle
byte bklOn = 70; // PWM value for backlight when on
int bklDelay = 10000; // ms for the backlight to idle before turning off
unsigned long bklTime = 0; // counter since backlight turned on
// create the menu counter
int menuCount = 1;
int menuSelect = 0;

//create the plus and minus navigation delay counter with its initial maximum of 250.
byte btnMaxDelay = 200;
byte btnMinDelay = 25;
byte btnMaxIteration = 5;
byte btnCurrIteration;

//create manual override variables
boolean override = false;
byte overmenu = 0;
int overpercent = 0;

// create the buttons
Button menu = Button(12,PULLDOWN);
Button select = Button(13,PULLDOWN);
Button plus = Button(14,PULLDOWN);
Button minus = Button(15,PULLDOWN);

// LED variables. These control the behavior of lighting. Change these to customize behavoir
int minCounter = 0; // counter that resets at midnight.
int oldMinCounter = 0; // counter that resets at midnight.
int oneLed = 9; // pin for channel 1
int twoLed = 10; // pin for channel 2
int threeLed = 11; // pin for channel 3
int fourLed = 3; // pin for channel 4

int oneVal = 0; // current value for channel 1
int twoVal = 0; // current value for channel 2
int threeVal = 0; // current value for channel 3
int fourVal = 0; // current value for channel 4

// Variables making use of EEPROM memory:

EEPROMVar<int> oneStartMins = 750; // minute to start this channel.
EEPROMVar<int> onePhotoPeriod = 720; // photoperiod in minutes for this channel.
EEPROMVar<int> oneMax = 100; // max intensity for this channel, as a percentage
EEPROMVar<int> oneFadeDuration = 60; // duration of the fade on and off for sunrise and sunset for
// this channel.
EEPROMVar<int> twoStartMins = 810;
EEPROMVar<int> twoPhotoPeriod = 600;
EEPROMVar<int> twoMax = 100;
EEPROMVar<int> twoFadeDuration = 60;

EEPROMVar<int> threeStartMins = 810;
EEPROMVar<int> threePhotoPeriod = 600;
EEPROMVar<int> threeMax = 100;
EEPROMVar<int> threeFadeDuration = 60;

EEPROMVar<int> fourStartMins = 480;
EEPROMVar<int> fourPhotoPeriod = 510;
EEPROMVar<int> fourMax = 100;
EEPROMVar<int> fourFadeDuration = 60;

// variables to invert the output PWM signal,
// for use with drivers that consider 0 to be "on"
// i.e. buckpucks. If you need to provide an inverted
// signal on any channel, set the appropriate variable to true.
boolean oneInverted = false;
boolean twoInverted = false;
boolean threeInverted = false;
boolean fourInverted = false;

/*
int oneStartMins = 1380; // minute to start this channel.
int onePhotoPeriod = 120; // photoperiod in minutes for this channel.
int oneMax = 100; // max intensity for this channel, as a percentage
int oneFadeDuration = 60; // duration of the fade on and off for sunrise and sunset for
// this channel.
int twoStartMins = 800;
int twoPhotoPeriod = 60;
int twoMax = 100;
int twoFadeDuration = 15;

int threeStartMins = 800;
int threePhotoPeriod = 60;
int threeMax = 100;
int threeFadeDuration = 30;

int fourStartMins = 800;
int fourPhotoPeriod = 120;
int fourMax = 100;
int fourFadeDuration = 60;
*/

/****** RTC Functions ******/
/***************************/

// Convert decimal numbers to binary coded decimal
byte decToBcd(byte val)
{
  return ( (val/10*16) + (val%10) );
}

// Convert binary coded decimal to decimal numbers
byte bcdToDec(byte val)
{
  return ( (val/16*10) + (val%16) );
}

// Sets date and time, starts the clock
void setDate(byte second, // 0-59
byte minute, // 0-59
byte hour, // 1-23
byte dayOfWeek, // 1-7
byte dayOfMonth, // 1-31
byte month, // 1-12
byte year) // 0-99
{
  Wire.beginTransmission(DS1307_I2C_ADDRESS);
  Wire.send(0);
  Wire.send(decToBcd(second));
  Wire.send(decToBcd(minute));
  Wire.send(decToBcd(hour));
  Wire.send(decToBcd(dayOfWeek));
  Wire.send(decToBcd(dayOfMonth));
  Wire.send(decToBcd(month));
  Wire.send(decToBcd(year));
  Wire.endTransmission();
}

// Gets the date and time
void getDate(byte *second,
byte *minute,
byte *hour,
byte *dayOfWeek,
byte *dayOfMonth,
byte *month,
byte *year)
{
  Wire.beginTransmission(DS1307_I2C_ADDRESS);
  Wire.send(0);
  Wire.endTransmission();
  Wire.requestFrom(DS1307_I2C_ADDRESS, 7);
  *second = bcdToDec(Wire.receive() & 0x7f);
  *minute = bcdToDec(Wire.receive());
  *hour = bcdToDec(Wire.receive() & 0x3f);
  *dayOfWeek = bcdToDec(Wire.receive());
  *dayOfMonth = bcdToDec(Wire.receive());
  *month = bcdToDec(Wire.receive());
  *year = bcdToDec(Wire.receive());
}

/****** LED Functions ******/
/***************************/
//function to set LED brightness according to time of day
//function has three equal phases - ramp up, hold, and ramp down

int setLed(int mins, // current time in minutes
int ledPin, // pin for this channel of LEDs
int start, // start time for this channel of LEDs
int period, // photoperiod for this channel of LEDs
int fade, // fade duration for this channel of LEDs
int ledMax, // max value for this channel
boolean inverted // true if the channel is inverted
) {
  int val = 0;

  //fade up
  if (mins > start || mins <= start + fade) {
    val = map(mins - start, 0, fade, 0, ledMax);
  }
  //fade down
  if (mins > start + period - fade && mins <= start + period) {
    val = map(mins - (start + period - fade), 0, fade, ledMax, 0);
  }
  //off or post-midnight run.
  if (mins <= start || mins > start + period) {
    if((start+period)%1440 < start && (start + period)%1440 > mins )
    {
      val=map((start+period-mins)%1440,0,fade,0,ledMax);
    }
    else
      val = 0;
  }

  if (val > ledMax) {
    val = ledMax;
  }
  if (val < 0) {
    val = 0;
  }

  if (inverted) {
    analogWrite(ledPin, map(val, 0, 100, 255, 0));
  }
  else {
    analogWrite(ledPin, map(val, 0, 100, 0, 255));
  }
  if(override){
    val=overpercent;
  }
  return val;
}

/**** Display Functions ****/
/***************************/

//button hold function
int btnCurrDelay(byte curr)
{
  if(curr==btnMaxIteration)
  {
    btnCurrIteration = btnMaxIteration;
    return btnMaxDelay;
  }
  else if(btnCurrIteration ==0)
  {
    return btnMinDelay;
  }
  else
  {
    btnCurrIteration--;
    return btnMaxDelay;
  }
}

// format a number of minutes into a readable time (24 hr format)
void printMins(int mins, //time in minutes to print
boolean ampm //print am/pm?
) {
  int hr = (mins%1440)/60;
  int mn = mins%60;
  if(hr<10){
    lcd.print(" ");
  }
  lcd.print(hr);
  lcd.print(":");
  if(mn<10){
    lcd.print("0");
  }
  lcd.print(mn);
}

// format hours, mins, secs into a readable time (24 hr format)
void printHMS (byte hr,
byte mn,
byte sec //time to print
)
{

  if(hr<10){
    lcd.print(" ");
  }
  lcd.print(hr, DEC);
  lcd.print(":");
  if(mn<10){
    lcd.print("0");
  }
  lcd.print(mn, DEC);
  lcd.print(":");
  if(sec<10){
    lcd.print("0");
  }
  lcd.print(sec, DEC);
}
void ovrSetAll(int pct){
  analogWrite(oneLed,map(pct,0,100,0,255));
  analogWrite(twoLed,map(pct,0,100,0,255));
  analogWrite(threeLed,map(pct,0,100,0,255));
  analogWrite(fourLed,map(pct,0,100,0,255));
}

/**** Setup ****/
/***************/

void setup() {
  Wire.begin();
  pinMode(bkl, OUTPUT);
  pinMode(relay,OUTPUT);
  lcd.begin(16, 2);
  digitalWrite(bkl, HIGH);
  lcd.print(" Acquario-Guzzi");
  lcd.setCursor(0,1);
  lcd.print("Contato M.Teresa");
  delay(5000);
  lcd.clear();
  analogWrite(bkl,bklIdle);
  btnCurrIteration = btnMaxIteration;
}

/***** Loop *****/
/****************/

void loop() {
  //relais
  reading = analogRead(sensorPin);
  int celsius = reading/2;

  byte second, minute, hour, dayOfWeek, dayOfMonth, month, year;

  getDate(&second, &minute, &hour, &dayOfWeek, &dayOfMonth, &month, &year);
  oldMinCounter = minCounter;
  minCounter = hour * 60 + minute;

  //reset plus & minus acceleration counters if the button's state has changed
  if(plus.stateChanged())
  {
    btnCurrDelay(btnMaxIteration);
  }
  if(minus.stateChanged())
  {
    btnCurrDelay(btnMaxIteration);
  }

  //check & set fade durations
  if(oneFadeDuration > onePhotoPeriod/2 && onePhotoPeriod >0){
    oneFadeDuration = onePhotoPeriod/2;
  }
  if(oneFadeDuration<1){
    oneFadeDuration=1;
  }

  if(twoFadeDuration > twoPhotoPeriod/2 && twoPhotoPeriod >0){
    twoFadeDuration = twoPhotoPeriod/2;
  }
  if(twoFadeDuration<1){
    twoFadeDuration=1;
  }

  if(threeFadeDuration > threePhotoPeriod/2 && threePhotoPeriod >0){
    threeFadeDuration = threePhotoPeriod/2;
  }
  if(threeFadeDuration<1){
    threeFadeDuration=1;
  }

  if(fourFadeDuration > fourPhotoPeriod/2 && fourPhotoPeriod > 0){
    fourFadeDuration = fourPhotoPeriod/2;
  }
  if(fourFadeDuration<1){
    fourFadeDuration=1;
  }

  //check & set any time functions

  //set outputs
  if(!override){
    oneVal = setLed(minCounter, oneLed, oneStartMins, onePhotoPeriod, oneFadeDuration, oneMax, oneInverted);
    twoVal = setLed(minCounter, twoLed, twoStartMins, twoPhotoPeriod, twoFadeDuration, twoMax, twoInverted);
    threeVal = setLed(minCounter, threeLed, threeStartMins, threePhotoPeriod, threeFadeDuration, threeMax, threeInverted);
    fourVal = setLed(minCounter, fourLed, fourStartMins, fourPhotoPeriod, fourFadeDuration, fourMax, fourInverted);
  }
  else{
    ovrSetAll(overpercent);
  }

  //turn the backlight off and reset the menu if the idle time has elapsed
  if(bklTime + bklDelay < millis() && bklTime > 0 ){
    analogWrite(bkl,bklIdle);
    menuCount = 1;
    lcd.clear();
    bklTime = 0;
  }

  //iterate through the menus
  if(menu.uniquePress()){
    analogWrite(bkl,bklOn);
    bklTime = millis();
    if(menuCount < 20){
      menuCount++;
    }
    else {
      menuCount = 1;
    }
    lcd.clear();
  }
  if(menuCount == 1){
    //main screen turn on!!!
    if (minCounter > oldMinCounter){
      lcd.clear();
    }

    lcd.setCursor(0,0);
    printHMS(hour, minute, second);
    lcd.setCursor(9,0);
    lcd.print(celsius, DEC);
    lcd.print((char)223);
    lcd.print("C");
    if (celsius >28) {
      digitalWrite(1,HIGH);
      lcd.print(" ON");
    }
    else {
      digitalWrite(1,LOW);
      lcd.print(" OF");
    }
    lcd.setCursor(0,1);
    lcd.print("A");
    lcd.print(oneVal);
    lcd.setCursor(4,1);
    lcd.print("B");
    lcd.print(twoVal);
    lcd.setCursor(8,1);
    lcd.print("C");
    lcd.print(threeVal);
    lcd.setCursor(12,1);
    lcd.print("D");
    lcd.print(fourVal);
    //debugging function to use the select button to advance the timer by 1 minute
    //if(select.uniquePress()){setDate(second, minute+1, hour, dayOfWeek, dayOfMonth, month, year);}
  }

  if(menuCount == 2){
    //Manual Override Menu
    lcd.setCursor(0,0);
    lcd.print("Impost. manuale");
    lcd.setCursor(0,1);
    lcd.print("Canali: ");
    if(select.uniquePress()){
      if(menuSelect < 3){
        menuSelect++;
      }
      else{
        menuSelect = 0;
      }
      bklTime = millis();
    }

    if(menuSelect == 0){
      lcd.print("Auto");
      override = false;
    }
    if(menuSelect == 1){
      lcd.print("ON ");
      overpercent = 100;
      override = true;
    }
    if(menuSelect == 2){
      lcd.print("OFF ");
      overpercent = 0;
      override = true;
    }
    if(menuSelect == 3){
      override = true;
      lcd.print(overpercent,DEC);
      lcd.print("% ");
      if(plus.isPressed() && overpercent <100)
      {
        overpercent++;
        delay(btnCurrDelay(btnCurrIteration-1));
        bklTime = millis();
      }

      if(minus.isPressed() && overpercent > 0)
      {
        overpercent--;
        delay(btnCurrDelay(btnCurrIteration-1));
        bklTime = millis();
      }
    }
  }

  if(menuCount == 3){
    //set start time for channel one
    lcd.setCursor(0,0);
    lcd.print("Canale A Inizio");
    lcd.setCursor(0,1);
    printMins(oneStartMins, true);

    if(plus.isPressed() && oneStartMins < 1440){
      oneStartMins++;
      if(onePhotoPeriod >0){
        onePhotoPeriod--;
      }
      else{
        onePhotoPeriod=1439;
      }
      delay(btnCurrDelay(btnCurrIteration-1));
      bklTime = millis();
    }
    if(minus.isPressed() && oneStartMins > 0){
      oneStartMins--;
      if(onePhotoPeriod<1439){
        onePhotoPeriod++;
      }
      else{
        onePhotoPeriod=0;
      }
      delay(btnCurrDelay(btnCurrIteration-1));
      bklTime = millis();
    }
  }

  if(menuCount == 4){
    //set end time for channel one
    lcd.setCursor(0,0);
    lcd.print("Canale A Fine");
    lcd.setCursor(0,1);
    printMins(oneStartMins+onePhotoPeriod, true);
    if(plus.isPressed()){
      if(onePhotoPeriod < 1439){
        onePhotoPeriod++;
      }
      else{
        onePhotoPeriod=0;
      }
      delay(btnCurrDelay(btnCurrIteration-1));
      bklTime = millis();
    }
    if(minus.isPressed()){
      if(onePhotoPeriod >0){
        onePhotoPeriod--;
      }
      else{
        onePhotoPeriod=1439;
      }
      delay(btnCurrDelay(btnCurrIteration-1));
      bklTime = millis();
    }
  }

  if(menuCount == 5){
    //set fade duration for channel one
    lcd.setCursor(0,0);
    lcd.print("Canale A Dissolv");
    lcd.setCursor(0,1);
    printMins(oneFadeDuration, false);
    if(plus.isPressed() && (oneFadeDuration < onePhotoPeriod/2 || oneFadeDuration == 0)){
      oneFadeDuration++;
      delay(btnCurrDelay(btnCurrIteration-1));
      bklTime = millis();
    }
    if(minus.isPressed() && oneFadeDuration > 1){
      oneFadeDuration--;
      delay(btnCurrDelay(btnCurrIteration-1));
      bklTime = millis();
    }
  }

  if(menuCount == 6){
    //set intensity for channel one
    lcd.setCursor(0,0);
    lcd.print("Canale A Intensi");
    lcd.setCursor(1,1);
    lcd.print(oneMax);
    lcd.print(" ");
    if(plus.isPressed() && oneMax < 100){
      oneMax++;
      delay(btnCurrDelay(btnCurrIteration-1));
      bklTime = millis();
    }
    if(minus.isPressed() && oneMax > 0){
      oneMax--;
      delay(btnCurrDelay(btnCurrIteration-1));
      bklTime = millis();
    }
  }

  if(menuCount == 7){
    //set start time for channel two
    lcd.setCursor(0,0);
    lcd.print("Canale B Inizio");
    lcd.setCursor(0,1);
    printMins(twoStartMins, true);
    if(plus.isPressed() && twoStartMins < 1440){
      twoStartMins++;
      if(twoPhotoPeriod >0){
        twoPhotoPeriod--;
      }
      else{
        twoPhotoPeriod=1439;
      }
      delay(btnCurrDelay(btnCurrIteration-1));
      bklTime = millis();
    }
    if(minus.isPressed() && twoStartMins > 0){
      twoStartMins--;
      if(twoPhotoPeriod<1439){
        twoPhotoPeriod++;
      }
      else{
        twoPhotoPeriod=0;
      }
      delay(btnCurrDelay(btnCurrIteration-1));
      bklTime = millis();
    }
  }

  if(menuCount == 8){
    //set end time for channel two
    lcd.setCursor(0,0);
    lcd.print("Canale B Fine");
    lcd.setCursor(0,1);
    printMins(twoStartMins+twoPhotoPeriod, true);
    if(plus.isPressed()){
      if(twoPhotoPeriod < 1439){
        twoPhotoPeriod++;
      }
      else{
        twoPhotoPeriod=0;
      }
      delay(btnCurrDelay(btnCurrIteration-1));
      bklTime = millis();
    }
    if(minus.isPressed()){
      if(twoPhotoPeriod >0){
        twoPhotoPeriod--;
      }
      else{
        twoPhotoPeriod=1439;
      }
      delay(btnCurrDelay(btnCurrIteration-1));
      bklTime = millis();
    }
  }

  if(menuCount == 9){
    //set fade duration for channel two
    lcd.setCursor(0,0);
    lcd.print("Canale B Dissolv");
    lcd.setCursor(0,1);
    printMins(twoFadeDuration, false);
    if(plus.isPressed() && (twoFadeDuration < twoPhotoPeriod/2 || twoFadeDuration == 0)){
      twoFadeDuration++;
      delay(btnCurrDelay(btnCurrIteration-1));
      bklTime = millis();
    }
    if(minus.isPressed() && twoFadeDuration > 1){
      twoFadeDuration--;
      delay(btnCurrDelay(btnCurrIteration-1));
      bklTime = millis();
    }
  }

  if(menuCount == 10){
    //set intensity for channel two
    lcd.setCursor(0,0);
    lcd.print("Canale B Intensi");
    lcd.setCursor(1,1);
    lcd.print(twoMax);
    lcd.print(" ");
    if(plus.isPressed() && twoMax < 100){
      twoMax++;
      delay(btnCurrDelay(btnCurrIteration-1));
      bklTime = millis();
    }
    if(minus.isPressed() && twoMax > 0){
      twoMax--;
      delay(btnCurrDelay(btnCurrIteration-1));
      bklTime = millis();
    }
  }

  if(menuCount == 11){
    //set start time for channel three
    lcd.setCursor(0,0);
    lcd.print("Canale C Inizio");
    lcd.setCursor(0,1);
    printMins(threeStartMins, true);
    if(plus.isPressed() && threeStartMins < 1440){
      threeStartMins++;
      if(threePhotoPeriod >0){
        threePhotoPeriod--;
      }
      else{
        threePhotoPeriod=1439;
      }
      delay(btnCurrDelay(btnCurrIteration-1));
      bklTime = millis();
    }
    if(minus.isPressed() && threeStartMins > 0){
      threeStartMins--;
      if(threePhotoPeriod<1439){
        threePhotoPeriod++;
      }
      else{
        threePhotoPeriod=0;
      }
      delay(btnCurrDelay(btnCurrIteration-1));
      bklTime = millis();
    }
  }

  if(menuCount == 12){
    //set end time for channel three
    lcd.setCursor(0,0);
    lcd.print("Canale C Fine");
    lcd.setCursor(0,1);
    printMins(threeStartMins+threePhotoPeriod, true);
    if(plus.isPressed()){
      if(threePhotoPeriod < 1439){
        threePhotoPeriod++;
      }
      else{
        threePhotoPeriod=0;
      }
      delay(btnCurrDelay(btnCurrIteration-1));
      bklTime = millis();
    }
    if(minus.isPressed()){
      if(threePhotoPeriod >0){
        threePhotoPeriod--;
      }
      else{
        threePhotoPeriod=1439;
      }
      delay(btnCurrDelay(btnCurrIteration-1));
      bklTime = millis();
    }
  }

  if(menuCount == 13){
    //set fade duration for channel three
    lcd.setCursor(0,0);
    lcd.print("Canale C Dissolv");
    lcd.setCursor(0,1);
    printMins(threeFadeDuration, false);
    if(plus.isPressed() && (threeFadeDuration < threePhotoPeriod/2 || threeFadeDuration == 0)){
      threeFadeDuration++;
      delay(btnCurrDelay(btnCurrIteration-1));
      bklTime = millis();
    }
    if(minus.isPressed() && threeFadeDuration > 1){
      threeFadeDuration--;
      delay(btnCurrDelay(btnCurrIteration-1));
      bklTime = millis();
    }
  }

  if(menuCount == 14){
    //set intensity for channel three
    lcd.setCursor(0,0);
    lcd.print("Canale C Intensi");
    lcd.setCursor(1,1);
    lcd.print(threeMax);
    lcd.print(" ");
    if(plus.isPressed() && threeMax < 100){
      threeMax++;
      delay(btnCurrDelay(btnCurrIteration-1));
      bklTime = millis();
    }
    if(minus.isPressed() && threeMax > 0){
      threeMax--;
      delay(btnCurrDelay(btnCurrIteration-1));
      bklTime = millis();
    }
  }

  if(menuCount == 15){
    //set start time for channel four
    lcd.setCursor(0,0);
    lcd.print("Canale D Inizio");
    lcd.setCursor(0,1);
    printMins(fourStartMins, true);
    if(plus.isPressed() && fourStartMins < 1440){
      fourStartMins++;
      if(fourPhotoPeriod >0){
        fourPhotoPeriod--;
      }
      else{
        fourPhotoPeriod=1439;
      }
      delay(btnCurrDelay(btnCurrIteration-1));
      bklTime = millis();
    }
    if(minus.isPressed() && fourStartMins > 0){
      fourStartMins--;
      if(fourPhotoPeriod<1439){
        fourPhotoPeriod++;
      }
      else{
        fourPhotoPeriod=0;
      }
      delay(btnCurrDelay(btnCurrIteration-1));
      bklTime = millis();
    }
  }

  if(menuCount == 16){
    //set end time for channel four
    lcd.setCursor(0,0);
    lcd.print("Canale D Fine");
    lcd.setCursor(0,1);
    printMins(fourStartMins+fourPhotoPeriod, true);
    if(plus.isPressed()){
      if(fourPhotoPeriod < 1439){
        fourPhotoPeriod++;
      }
      else{
        fourPhotoPeriod=0;
      }
      delay(btnCurrDelay(btnCurrIteration-1));
      bklTime = millis();
    }
    if(minus.isPressed()){
      if(fourPhotoPeriod >0){
        fourPhotoPeriod--;
      }
      else{
        fourPhotoPeriod=1439;
      }
      delay(btnCurrDelay(btnCurrIteration-1));
      bklTime = millis();
    }
  }

  if(menuCount == 17){
    //set fade duration for channel four
    lcd.setCursor(0,0);
    lcd.print("Canale D Dissolv");
    lcd.setCursor(0,1);
    printMins(fourFadeDuration, false);
    if(plus.isPressed() && (fourFadeDuration < fourPhotoPeriod/2 || fourFadeDuration == 0)){
      fourFadeDuration++;
      delay(btnCurrDelay(btnCurrIteration-1));
      bklTime = millis();
    }
    if(minus.isPressed() && fourFadeDuration > 1){
      fourFadeDuration--;
      delay(btnCurrDelay(btnCurrIteration-1));
      bklTime = millis();
    }
  }

  if(menuCount == 18){
    //set intensity for channel four
    lcd.setCursor(0,0);
    lcd.print("Canale D Intensi");
    lcd.setCursor(1,1);
    lcd.print(fourMax);
    lcd.print(" ");
    if(plus.isPressed() && fourMax < 100){
      fourMax++;
      delay(btnCurrDelay(btnCurrIteration-1));
      bklTime = millis();
    }
    if(minus.isPressed() && fourMax > 0){
      fourMax--;
      delay(btnCurrDelay(btnCurrIteration-1));
      bklTime = millis();
    }
  }

  if(menuCount == 19){
    //set hours
    lcd.setCursor(0,0);
    lcd.print("Set Time: Ora");
    lcd.setCursor(0,1);
    printHMS(hour, minute, second);
    if(plus.isPressed() && hour < 23){
      hour++;
      delay(btnCurrDelay(btnCurrIteration-1));
      bklTime = millis();
    }
    if(minus.isPressed() && hour > 0){
      hour--;
      delay(btnCurrDelay(btnCurrIteration-1));
      bklTime = millis();
    }
    setDate(second, minute, hour, dayOfWeek, dayOfMonth, month, year);
  }

  if(menuCount == 20){
    //set minutes
    lcd.setCursor(0,0);
    lcd.print("Set Time: Min");
    lcd.setCursor(0,1);
    printHMS(hour, minute, second);
    if(plus.isPressed() && minute < 59){
      minute++;
      delay(btnCurrDelay(btnCurrIteration-1));
      bklTime = millis();
    }
    if(minus.isPressed() && minute > 0){
      minute--;
      delay(btnCurrDelay(btnCurrIteration-1));
      bklTime = millis();
    }
    setDate(second, minute, hour, dayOfWeek, dayOfMonth, month, year);
  }
}

Non è obbligatorio usare il paracadute, ma ricorda, lo puoi fare una volta sola.

picmicro675

postato il:
17.03.2017, alle ore 08:59

Quando i listati sono lunghi, meglio caricarli su file hosting o propria pagina e dare il link. È scomodo da leggere nel browser., anche il topico diventa difficile da leggere.
Noterai che la larghezza non dovrebbe superare le 80 colonne, altrimenti il listato diventa scomodo anche da leggere.
La gestione dell' RTC è alquanto voluminosa, c'è la sua libreria che migliora la leggibilità del codice.

Ci faccio uno studio.

Anno nuovo, forum nuovo.
Mi sa che lascio.

gironico

postato il:
17.03.2017, alle ore 12:25

se il programma luci ti va bene, premesso che non ho letto bene il codice in quanto leggerlo cosi nn ci capisco molto, ora non posso copiarlo e passarlo sull'ide....

Consiglio veloce e indolore:

Usi la rtcSw, un bottino ma chi se ne frega.... per esempio al 30imo secondo di ogni minuto ti fai la misura della temperatura.... Un po' tende ad oscillare di suo lm35... infilaci una capacità e già ti migliora...

fai un ciclo di 10 misure e poi fai la media....

Proprio giorni fa ho fatto un'alba tramonto con ardu per l'acquario della mia figlia....promesso che quando ho tempo lo pubblico e vedrai che ci aggiungi al volo la misura della temperatura

La vita è troppo breve per bere vini mediocri

guzzj

postato il:
17.03.2017, alle ore 12:44

Giro, si il programma luci va benissimo e non è farina del mio sacco, l'avevo trovato sul forum di microcosmo acquari, e io lo avevo adattato solo per schermo lcd da 16x20 anziché 20x4, tra laltro con le quattro uscite in combinazione con gli irf520 ottengo un alba e tramonto totalmente impostabile. la lettura della temperatura che ho aggiunto allo skatc alla fine funziona, è solo il problema di quando deve eccitarsi il rele, che durante il raggiungimento della soglia, ottengo un off on per qualche secondo, che con un delay era risolvibile, ma nel codice luci non posso usarlo.
colpa tua giro che mi hai fatto venire voglia di cimentarmi con arduino, e per questo ti ringrazio.
ps sono alle primissime armi

Non è obbligatorio usare il paracadute, ma ricorda, lo puoi fare una volta sola.

gironico

postato il:
17.03.2017, alle ore 13:49

secondo me il problema ti risiede per questo motivo:

codice scritto da te:

if (celsius >28) {
digitalWrite(7,HIGH);
lcd.print(\" ON\");
} else {
digitalWrite(7,LOW);
lcd.print(\" OFF\");
}
delay(500);
lcd.clear();
}

chiaramente usando else appena hai una lettura oscillante che ti riporta appena sotto i 28 ti stacca il relè... ti basta che ti misuri 27.5 C e hai già il problema

se al posto di else nidifichi

if (celsius<26){
digitalWrite(7,LOW);
}

cosi già eviti il rimbalzo perché ampli la finestra di intervento.... che caxxx te ne frega di uno sbalzo termico di due gradi su 28 con un sensore che riesce a vederne 0.5 per volta.

Gia cosi risolvi il problema abbastanza bene... ti torna?

Questo è il modo più semplice.... per esempio potresti creare variabili di comodo della serie che se sei arrivato a temperatura cambi stato alla variabile e fai partire il conteggio dei millis su un'altra variabile che fino a per esempio 10mila millis il relè non commuterà anche se avviene la condizione di gradi <28

altro consiglio, ho visto che fai uso esagerato della funzione lcdclear();

impara a sovrascrive e non a cancellare ogni volta... il tempo di reflesh di questo tipo di lcd è molto lento... affievolisce le scritte e ti risponde in ritardo...

Fammi sapere se ti migliora o ti può andar bene il discorso...

La vita è troppo breve per bere vini mediocri