Benvenuti sul Forum di AcquaPortal, la più grande community italiana di acquariofilia!
Sul Forum di AcquaPortal puoi discutere con altri appassionati di acquariofilia, tenere un tuo Blog personale, inserire foto e video, chattare, ed aiutarci a creare un grande database con schede di pesci, invertebrati e prodotti di acquariofilia.
Per entrar a far parte della comunità occorre registrarsi.
Per farlo premi su
Al momento della registrazione ti verrà richiesto di accettare il Regolamento che ti consigliamo di leggere attentamente.
Ti consigliamo inoltre di leggere le FAQ per apprendere le funzionalità principali del forum.
Se invece sei un utente registrato e hai dimenticato i tuoi dati di accesso devi effettuare il Recupero dati.
Fai da te marinoPer parlare delle tecniche di costruzione artigianale, per presentare le vostre realizzazioni, e per avere informazioni su dove reperire materiale ed attrezzatura risparmiando tempo e denaro.
Sperando che sia leggibile posto un mio programmino che gestisce 9 pwm per le luci (blu dx e sx, 10000K dx e sx, 20000K dx e sx e rgb).
io uso l'arduino mega per via dei display. come interfaccia utente ha solo il web per ora.
possiede un log per salvare sulla memory i dati della vasca secondo per secondo
codice:
// Include delle librerie usate
#include "EtherShield.h" // EtherShield_1.6.zip
#include <SD.h> // Inclusa
#include "Wire.h" // Inclusa
#include <EEPROM.h> // Inclusa
// Definizione pin utilizzati
#define SD_INT 2
#define PWM_BLU_SX 3
#define SD_CS 4
#define PWM_BLU_DX 5
#define PWM_10K_SX 6
#define PWM_10K_DX 7
#define PWM_20K_SX 8
#define PWM_20K_DX 9
#define PWM_RGB_RED 10
#define PWM_RGB_GREEN 11
#define PWM_RGB_BLUE 12
#define LED_ONBOARD 13
#define I2C_SDA 20
#define I2C_SCL 21
#define SPI_MISO 50
#define SPI_MOSI 51
#define SPI_SCK 52
#define ENC28J60_CONTROL_CS 53
// please modify the following two lines. mac and ip have to be unique
// in your local area network. You can not have the same numbers in
// two devices:
static uint8_t mymac[6] = {0x54,0x55,0x58,0x10,0x00,0x25};
static uint8_t myip[4] = {192,168,1,25};
static uint8_t buf[BUFFER_SIZE + 1];
static char strbuf[STR_BUFFER_SIZE];
static long msLogger;
static long msResetWeb;
static unsigned long msCurrent;
static long msLastUpdateBluDx;
static long msLastUpdateBluSx;
static long msLastUpdate10kDx;
static long msLastUpdate10kSx;
static long msLastUpdate20kDx;
static long msLastUpdate20kSx;
static long msLastUpdateRRGB;
static long msLastUpdateGRGB;
static long msLastUpdateBRGB;
static long msLastUpdateRTC;
static int sdError;
static int sdLogInCorso;
static File sdDataFile;
static String sdDataString;
static int rtcSecond;
static int rtcMinute;
static int rtcHour;
static int rtcWeekDay;
static int rtcMonthDay;
static int rtcMonth;
static int rtcYear;
static int luciOraAccensione;
static int luciMinutoAccensione;
static int luciMinutiDurataAlba;
static int luciOreAccensioneCompleta;
static int luciMinutiAccensioneCompleta;
static int luciMinutiDurataTramonto;
static int luciTargetBluSx;
static int luciTargetBluDx;
static int luciTarget10kSx;
static int luciTarget10kDx;
static int luciTarget20kSx;
static int luciTarget20kDx;
static int luciTargetRRGB;
static int luciTargetGRGB;
static int luciTargetBRGB;
static int luciTipoAlbaTramonto; // bit 0 (prima blu poi bianchi), bit 1 (effetto est/ovest)
static int luciTargetRRGBLunare;
static int luciTargetGRGBLunare;
static int luciTargetBRGBLunare;
static int luciCurrentBluDx;
static int luciCurrentBluSx;
static int luciCurrent10kDx;
static int luciCurrent10kSx;
static int luciCurrent20kDx;
static int luciCurrent20kSx;
static int luciCurrentRRGB;
static int luciCurrentGRGB;
static int luciCurrentBRGB;
//static int secondoCorrente;
//static int secondoAccensioneBluDx;
//static int secondoAccensioneBluSx;
//static int secondoAccensioneBiancoDx;
//static int secondoAccensioneBiancoSx;
//static int secondoSpegnimentoBluDx;
//static int secondoSpegnimentoBluSx;
//static int secondoSpegnimentoBiancoDx;
//static int secondoSpegnimentoBiancoSx;
//static int decimiSecondoIncrementoBluDx;
//static int decimiSecondoIncrementoBluSx;
//static int decimiSecondoIncremento10kDx;
//static int decimiSecondoIncremento10kSx;
//static int decimiSecondoIncremento20kDx;
//static int decimiSecondoIncremento20kSx;
//static int decimiSecondoIncrementoRRGB;
//static int decimiSecondoIncrementoGRGB;
//static int decimiSecondoIncrementoBRGB;
//static int decimiSecondoDecrementoBluDx;
//static int decimiSecondoDecrementoBluSx;
//static int decimiSecondoDecremento10kDx;
//static int decimiSecondoDecremento10kSx;
//static int decimiSecondoDecremento20kDx;
//static int decimiSecondoDecremento20kSx;
//static int decimiSecondoDecrementoRRGB;
//static int decimiSecondoDecrementoGRGB;
//static int decimiSecondoDecrementoBRGB;
//static int luceBluDxAccesa;
//static int luceBluSxAccesa;
//static int luceBiancaDxAccesa;
//static int luceBiancaSxAccesa;
//static int luceRGBDiurnaAccesa;
// Include dei files del programma
#include "luci.h"
#include "web.h"
#include "sd.h"
#include "rtc.h"
void setup()
{
msCurrent = 0;
// Serial.begin(9600);
// Serial.println("inizio");
inizializza_enc28j60();
inizializza_sd();
inizializza_rtc();
inizializza_luci();
}
void loop()
{
msCurrent = millis();
rtc_getDateTime();
gestione_luci();
logger_sd();
webserver();
// Serial.println("inizio ----------------------------");
// Serial.print("secondoCorrente: ");
// Serial.println(secondoCorrente);
// Serial.print("luceBluDxAccesa: ");
// Serial.println(luceBluDxAccesa);
// Serial.print("luceBluSxAccesa: ");
// Serial.println(luceBluSxAccesa);
// Serial.print("luceBiancaDxAccesa: ");
// Serial.println(luceBiancaDxAccesa);
// Serial.print("luceBiancaSxAccesa: ");
// Serial.println(luceBiancaSxAccesa);
// Serial.print("luceRGBDiurnaAccesa: ");
// Serial.println(luceRGBDiurnaAccesa);
//
// Serial.print("luciCurrentBluDx: ");
// Serial.println(luciCurrentBluDx);
// Serial.print("luciCurrentBluSx: ");
// Serial.println(luciCurrentBluSx);
// Serial.print("luciCurrent10kDx: ");
// Serial.println(luciCurrent10kDx);
// Serial.print("luciCurrent10kSx: ");
// Serial.println(luciCurrent10kSx);
// Serial.print("luciCurrent20kDx: ");
// Serial.println(luciCurrent20kDx);
// Serial.print("luciCurrent20kSx: ");
// Serial.println(luciCurrent20kSx);
// Serial.print("luciCurrentRRGB: ");
// Serial.println(luciCurrentRRGB);
// Serial.print("luciCurrentGRGB: ");
// Serial.println(luciCurrentGRGB);
// Serial.print("luciCurrentBRGB: ");
// Serial.println(luciCurrentBRGB);
}
void inizializza_sd()
{
sdError = 0;
msLogger = 0;
sdLogInCorso = 0;
if (!SD.begin(SD_CS)) {sdError = 1;} // memory non inerita all'accensione
else
{
sdDataFile = SD.open("logger.txt", FILE_READ);
if (sdDataFile)
{
if (sdDataFile.available())
{
if (sdDataFile.read() == 70) {sdError = 0;} // Ok il file deve iniziare con una "F"
else {sdError = 2;} // file corrotto (non inizia con la lettera giusta all'accensione
}
else {sdError = 3;} // file vuoto all'accensione
}
else {sdError = 4;} // file non esistente all'accensione
sdDataFile.close();
}
}
void logger_sd()
{
// String sdDataString = "";
if (sdLogInCorso)
{
if((msCurrent - msLogger) > 5000) // LIMITE tenere se possibile 5 secondi con 1 alle volte si una un crash
{
msLogger = msCurrent;
if (sdError) {return;}
// test se la memory funziona o se è stata rimossa durante il log
sdDataFile = SD.open("logger.txt", FILE_READ);
if (sdDataFile)
{
if (sdDataFile.available())
{
if (sdDataFile.read() == 70) {sdError = 0;} // Ok il file deve iniziare con una "F"
else {sdError = 5;} // file corrotto (non inizia con la lettera giusta) durante la scrittura
}
else {sdError = 6;} // file vuoto durante la scrittura
}
else {sdError = 7;} // file non esistente durante la scrittura
sdDataFile.close();
if (sdError != 0)
{
sdLogInCorso = 0;
return;
}
// scrittura dei file di log
// sdDataString = String(millis());
sdDataString = "";
sdDataString += "4"; // LIMITE alle volte nel log al posto della prima colonna 4 mette 111. Non si capisce cosa è 111
sdDataString += ",";
// if (rtcMonth < 10) {sdDataString += "0";}
// sdDataString += String(rtcMonth);
// if (rtcMonthDay < 10) {sdDataString += "0";}
// sdDataString += String(rtcMonthDay);
// if (rtcHour < 10) {sdDataString += "0";}
// sdDataString += String(rtcHour);
// if (rtcMinute < 10) {sdDataString += "0";}
// sdDataString += String(rtcMinute);
// if (rtcSecond < 10) {sdDataString += "0";}
// sdDataString += String(rtcSecond);
// sdDataString += " 1234567890 1234567890 1234567890"; // LIMITE tenere massimo 40 caratteri per scrittura. con più caratteri alle volte si una un crash
// sdDataString += ","; // LIMITE tenere massimo 40 caratteri per scrittura. con più caratteri alle volte si una un crash
sdDataString += String(luciCurrentBluDx);
sdDataString += ",";
sdDataString += String(luciCurrentBluSx);
sdDataString += ",";
sdDataString += String(luciCurrent10kDx);
sdDataString += ",";
sdDataString += String(luciCurrent10kSx);
sdDataString += ",";
sdDataString += String(luciCurrent20kDx);
sdDataString += ",";
sdDataString += String(luciCurrent20kSx);
// sdDataString += ",";
// sdDataString += String(luciCurrentRRGB);
// sdDataString += ",";
// sdDataString += String(luciCurrentGRGB);
// sdDataString += ",";
// sdDataString += String(luciCurrentBRGB);
sdDataFile = SD.open("logger.txt", FILE_WRITE);
sdDataFile.println(sdDataString);
sdDataFile.close();
}
}
}
void formattazione_sd()
{
sdError = 0;
SD.remove("logger.txt");
sdDataFile = SD.open("logger.txt", FILE_WRITE);
sdDataFile.println("File di LOG del controller per acquari AquaControl");
sdDataFile.close();
}
web.h
codice:
// The ethernet shield
EtherShield es = EtherShield();
#include "pagine.h"
void inizializza_sd();
void formattazione_sd();
void rtc_setDateTime();
// The returned value is stored in the global var strbuf
uint8_t find_key_val(char *str,char *key)
{
uint8_t found = 0;
uint8_t i = 0;
char *kp;
kp = key;
while(*str && *str!=' ' && found == 0)
{
if (*str == *kp)
{
kp++;
if (*kp == '\0')
{
str++;
kp = key;
if (*str == '=') {found = 1;}
}
}
else {kp = key;}
str++;
}
if (found == 1)
{
// while(*str && *str != ' ' && *str != '&' && i < STR_BUFFER_SIZE)
while(*str && *str != ' ' && *str != '&' && i < STR_BUFFER_SIZE)
{
strbuf[i] = *str;
i++;
str++;
}
strbuf[i] = '\0'
}
return(found);
}
int8_t analyse_sez(char *str)
{
int8_t r = -1;
if (find_key_val(str,"sez")) {if (*strbuf < 0x3a && *strbuf > 0x2f) {r = (*strbuf - 0x30);}}
return r;
}
int8_t analyse_cmd(char *str)
{
int8_t r = -1;
if (find_key_val(str,"cmd")) {if (*strbuf < 0x3a && *strbuf > 0x2f) {r = (*strbuf - 0x30);}}
return r;
}
int8_t analyse_act(char *str)
{
int8_t r = -1;
if (find_key_val(str,"act")) {if (*strbuf < 0x3a && *strbuf > 0x2f) {r = (*strbuf - 0x30);}}
return r;
}
void webserver()
{
uint16_t plen, dat_p;
int8_t sez;
int8_t cmd;
int8_t act;
// LIMITE ogni 30 secondi è bene resettare il webserver che impiegherà 2 secondi a ripartire (serve in caso di crash)
if((msCurrent - msResetWeb) > 30000)
{
msResetWeb = msCurrent;
es.ES_enc28j60Init(mymac);
es.ES_init_ip_arp_udp_tcp(mymac,myip, MYWWWPORT);
}
while(1) {
// read packet, handle ping and wait for a tcp packet:
dat_p = es.ES_packetloop_icmp_tcp(buf,es.ES_enc28j60PacketReceive(BUFFER_SIZE, buf));
/* dat_p will be unequal to zero if there is a valid
* http get */
if (dat_p == 0)
{
return;
}
// tcp port 80 begin
if (strncmp("GET ",(char *)&(buf[dat_p]),4) != 0)
{
// head, post and other methods:
dat_p = http200ok();
dat_p = es.ES_fill_tcp_data_p(buf,dat_p,PSTR("<h1>200 OK</h1>"));
goto SENDTCP;
}
// just one web page in the "root directory" of the web server
if (strncmp("/ ",(char *) & (buf[dat_p + 4]),2) == 0)
{
dat_p = homepage(buf);
goto SENDTCP;
}
sez = analyse_sez((char *) & (buf[dat_p+5]));
cmd = analyse_cmd((char *) & (buf[dat_p+5]));
act = analyse_act((char *) & (buf[dat_p+5]));
//***********************************************************************************************************************
//***********************************************************************************************************************
//***********************************************************************************************************************
//***********************************************************************************************************************
//***********************************************************************************************************************
if (sez == 4)
{
if ((cmd == 1) || (cmd == 2))
{
if (cmd == 1)
{
if (act == 1)
{
if (luciOraAccensione >= 23) {luciOraAccensione = 0u;}
else {luciOraAccensione++;}
EEPROM.write(INDIRIZZOLUCIORAACCENSIONE, luciOraAccensione);
}
else if (act == 2)
{
if (luciOraAccensione == 0) {luciOraAccensione = 23u;}
else {luciOraAccensione--;}
EEPROM.write(INDIRIZZOLUCIORAACCENSIONE, luciOraAccensione);
}
else if (act == 3)
{
if (luciMinutoAccensione >= 59) {luciMinutoAccensione = 0u;}
else {luciMinutoAccensione++;}
EEPROM.write(INDIRIZZOLUCIMINUTOACCENSIONE, luciMinutoAccensione);
}
else if (act == 4)
{
if (luciMinutoAccensione == 0) {luciMinutoAccensione = 59u;}
else {luciMinutoAccensione--;}
EEPROM.write(INDIRIZZOLUCIMINUTOACCENSIONE, luciMinutoAccensione);
}
else if (act == 5)
{
if (luciMinutiDurataAlba >= 54) {luciMinutiDurataAlba = 5u;}
else {luciMinutiDurataAlba++;}
EEPROM.write(INDIRIZZOLUCIMINUTIDURATAALBA, luciMinutiDurataAlba);
}
else if (act == 6)
{
if (luciMinutiDurataAlba <= 5) {luciMinutiDurataAlba = 54u;}
else {luciMinutiDurataAlba--;}
EEPROM.write(INDIRIZZOLUCIMINUTIDURATAALBA, luciMinutiDurataAlba);
}
}
else
{
if (act == 1)
{
if (luciOreAccensioneCompleta >= 16) {luciOreAccensioneCompleta = 0u;}
else {luciOreAccensioneCompleta++;}
EEPROM.write(INDIRIZZOLUCIOREACCENSIONECOMPLETA, luciOreAccensioneCompleta);
}
else if (act == 2)
{
if (luciOreAccensioneCompleta == 0) {luciOreAccensioneCompleta = 16u;}
else {luciOreAccensioneCompleta--;}
EEPROM.write(INDIRIZZOLUCIOREACCENSIONECOMPLETA, luciOreAccensioneCompleta);
}
else if (act == 3)
{
if (luciMinutiAccensioneCompleta >= 59) {luciMinutiAccensioneCompleta = 0u;}
else {luciMinutiAccensioneCompleta++;}
EEPROM.write(INDIRIZZOLUCIMINUTIACCENSIONECOMPLETA, luciMinutiAccensioneCompleta);
}
else if (act == 4)
{
if (luciMinutiAccensioneCompleta == 0) {luciMinutiAccensioneCompleta = 59u;}
else {luciMinutiAccensioneCompleta--;}
EEPROM.write(INDIRIZZOLUCIMINUTIACCENSIONECOMPLETA, luciMinutiAccensioneCompleta);
}
else if (act == 5)
{
if (luciMinutiDurataTramonto >= 54) {luciMinutiDurataTramonto = 5u;}
else {luciMinutiDurataTramonto++;}
EEPROM.write(INDIRIZZOLUCIMINUTIDURATATRAMANTO, luciMinutiDurataTramonto);
}
else if (act == 6)
{
if (luciMinutiDurataTramonto <= 5) {luciMinutiDurataTramonto = 54u;}
else {luciMinutiDurataTramonto--;}
EEPROM.write(INDIRIZZOLUCIMINUTIDURATATRAMANTO, luciMinutiDurataTramonto);
}
}
dat_p = page_fotoperiodo(buf);
}
else if ((cmd == 3) || (cmd == 4))
{
if (cmd == 3)
{
if (act == 1)
{
if (luciTargetBluSx >= 255) {luciTargetBluSx = 0u;}
else {luciTargetBluSx++;}
EEPROM.write(INDIRIZZOLUCITARGETBLUSX, luciTargetBluSx);
}
else if (act == 2)
{
if (luciTargetBluSx == 0) {luciTargetBluSx = 255u;}
else {luciTargetBluSx--;}
EEPROM.write(INDIRIZZOLUCITARGETBLUSX, luciTargetBluSx);
}
else if (act == 3)
{
if (luciTargetRRGB >= 255) {luciTargetRRGB = 0u;}
else {luciTargetRRGB++;}
EEPROM.write(INDIRIZZOLUCITARGETRRGB, luciTargetRRGB);
}
else if (act == 4)
{
if (luciTargetRRGB == 0) {luciTargetRRGB = 255u;}
else {luciTargetRRGB--;}
EEPROM.write(INDIRIZZOLUCITARGETRRGB, luciTargetRRGB);
}
else if (act == 5)
{
if (luciTargetBluDx >= 255) {luciTargetBluDx = 0u;}
else {luciTargetBluDx++;}
EEPROM.write(INDIRIZZOLUCITARGETBLUDX, luciTargetBluDx);
}
else if (act == 6)
{
if (luciTargetBluDx == 0) {luciTargetBluDx = 255u;}
else {luciTargetBluDx--;}
EEPROM.write(INDIRIZZOLUCITARGETBLUDX, luciTargetBluDx);
}
else if (act == 7)
{
if (luciTarget10kSx >= 255) {luciTarget10kSx = 0u;}
else {luciTarget10kSx++;}
EEPROM.write(INDIRIZZOLUCITARGET10KSX, luciTarget10kSx);
}
else if (act == 8)
{
if (luciTarget10kSx == 0) {luciTarget10kSx = 255u;}
else {luciTarget10kSx--;}
EEPROM.write(INDIRIZZOLUCITARGET10KSX, luciTarget10kSx);
}
else if (act == 9)
{
if (luciTargetGRGB >= 255) {luciTargetGRGB = 0u;}
else {luciTargetGRGB++;}
EEPROM.write(INDIRIZZOLUCITARGETGRGB, luciTargetGRGB);
}
}
else if (cmd == 4)
{
if (act == 1)
{
if (luciTargetGRGB == 0) {luciTargetGRGB = 255u;}
else {luciTargetGRGB--;}
EEPROM.write(INDIRIZZOLUCITARGETGRGB, luciTargetGRGB);
}
else if (act == 2)
{
if (luciTarget10kDx >= 255) {luciTarget10kDx = 0u;}
else {luciTarget10kDx++;}
EEPROM.write(INDIRIZZOLUCITARGET10KDX, luciTarget10kDx);
}
else if (act == 3)
{
if (luciTarget10kDx == 0) {luciTarget10kDx = 255u;}
else {luciTarget10kDx--;}
EEPROM.write(INDIRIZZOLUCITARGET10KDX, luciTarget10kDx);
}
else if (act == 4)
{
if (luciTarget20kSx >= 255) {luciTarget20kSx = 0u;}
else {luciTarget20kSx++;}
EEPROM.write(INDIRIZZOLUCITARGET20KSX, luciTarget20kSx);
}
else if (act == 5)
{
if (luciTarget20kSx == 0) {luciTarget20kSx = 255u;}
else {luciTarget20kSx--;}
EEPROM.write(INDIRIZZOLUCITARGET20KSX, luciTarget20kSx);
}
else if (act == 6)
{
if (luciTargetBRGB >= 255) {luciTargetBRGB = 0u;}
else {luciTargetBRGB++;}
EEPROM.write(INDIRIZZOLUCITARGETBRGB, luciTargetBRGB);
}
else if (act == 7)
{
if (luciTargetBRGB == 0) {luciTargetBRGB = 255u;}
else {luciTargetBRGB--;}
EEPROM.write(INDIRIZZOLUCITARGETBRGB, luciTargetBRGB);
}
else if (act == 8)
{
if (luciTarget20kDx >= 255) {luciTarget20kDx = 0u;}
else {luciTarget20kDx++;}
EEPROM.write(INDIRIZZOLUCITARGET20KDX, luciTarget20kDx);
}
else if (act == 9)
{
if (luciTarget20kDx == 0) {luciTarget20kDx = 255u;}
else {luciTarget20kDx--;}
EEPROM.write(INDIRIZZOLUCITARGET20KDX, luciTarget20kDx);
}
}
dat_p = page_illuminazione_potenza(buf);
}
else if (cmd == 5)
{
if (luciTipoAlbaTramonto >= 4u) {luciTipoAlbaTramonto = 0u;}
if (act == 1)
{
if (luciTipoAlbaTramonto == 0u) {luciTipoAlbaTramonto = 1u;}
else if (luciTipoAlbaTramonto == 1u) {luciTipoAlbaTramonto = 0u;}
else if (luciTipoAlbaTramonto == 2u) {luciTipoAlbaTramonto = 3u;}
else if (luciTipoAlbaTramonto == 3u) {luciTipoAlbaTramonto = 2u;}
EEPROM.write(INDIRIZZOLUCITIPOALBATRAMONTO, luciTipoAlbaTramonto);
}
else if (act == 2)
{
if (luciTipoAlbaTramonto == 0u) {luciTipoAlbaTramonto = 2u;}
else if (luciTipoAlbaTramonto == 1u) {luciTipoAlbaTramonto = 3u;}
else if (luciTipoAlbaTramonto == 2u) {luciTipoAlbaTramonto = 0u;}
else if (luciTipoAlbaTramonto == 3u) {luciTipoAlbaTramonto = 1u;}
EEPROM.write(INDIRIZZOLUCITIPOALBATRAMONTO, luciTipoAlbaTramonto);
}
else if (act == 3)
{
if (luciTargetRRGBLunare >= 255) {luciTargetRRGBLunare = 0u;}
else {luciTargetRRGBLunare++;}
EEPROM.write(INDIRIZZOLUCITARGETRRGBLUNARE, luciTargetRRGBLunare);
}
else if (act == 4)
{
if (luciTargetRRGBLunare == 0) {luciTargetRRGBLunare = 255u;}
else {luciTargetRRGBLunare--;}
EEPROM.write(INDIRIZZOLUCITARGETRRGBLUNARE, luciTargetRRGBLunare);
}
else if (act == 5)
{
if (luciTargetGRGBLunare >= 255) {luciTargetGRGBLunare = 0u;}
else {luciTargetGRGBLunare++;}
EEPROM.write(INDIRIZZOLUCITARGETGRGBLUNARE, luciTargetGRGBLunare);
}
else if (act == 6)
{
if (luciTargetGRGBLunare == 0) {luciTargetGRGBLunare = 255u;}
else {luciTargetGRGBLunare--;}
EEPROM.write(INDIRIZZOLUCITARGETGRGBLUNARE, luciTargetGRGBLunare);
}
else if (act == 7)
{
if (luciTargetBRGBLunare >= 255) {luciTargetBRGBLunare = 0u;}
else {luciTargetBRGBLunare++;}
EEPROM.write(INDIRIZZOLUCITARGETBRGBLUNARE, luciTargetBRGBLunare);
}
else if (act == 8)
{
if (luciTargetBRGBLunare == 0) {luciTargetBRGBLunare = 255u;}
else {luciTargetBRGBLunare--;}
EEPROM.write(INDIRIZZOLUCITARGETBRGBLUNARE, luciTargetBRGBLunare);
}
dat_p = page_illuminazione_effetti(buf);
}
else
{
dat_p = page_illuminazione(buf);
}
goto SENDTCP;
}
//***********************************************************************************************************************
//***********************************************************************************************************************
//***********************************************************************************************************************
//***********************************************************************************************************************
//***********************************************************************************************************************
if (sez == 8)
{
if (act == 1) {rtcHour++;}
if (rtcHour >= 24) {rtcHour = 0u;}
if (act == 2)
{
if (rtcHour == 0) {rtcHour = 23u;}
else {rtcHour--;}
}
if (act == 3) {rtcMinute++;}
if (rtcMinute >= 60) {rtcMinute = 0u;}
if (act == 4)
{
if (rtcMinute == 0) {rtcMinute = 59u;}
else {rtcMinute--;}
}
if (act == 5) {rtcMonthDay++;}
if (rtcMonthDay >= 32) {rtcMonthDay = 1u;}
if (act == 6)
{
if (rtcMonthDay <= 1) {rtcMonthDay = 31u;}
else {rtcMonthDay--;}
}
if (act == 7) {rtcMonth++;}
if (rtcMonth >= 13) {rtcMonth = 1u;}
if (act == 8) {rtcYear++;}
if (rtcYear >= 100) {rtcYear = 11u;}
if (act == 9) {rtcYear--;}
if (rtcYear <= 10) {rtcYear = 99u;}
if (act == 0) {rtcWeekDay++;}
if (rtcWeekDay >= 8) {rtcWeekDay = 1u;}
rtc_setDateTime();
dat_p = page_orologio(buf);
goto SENDTCP;
}
//***********************************************************************************************************************
//***********************************************************************************************************************
//***********************************************************************************************************************
//***********************************************************************************************************************
//***********************************************************************************************************************
if (sez == 9)
{
if ((act == 1) && (sdError == 0)) {sdLogInCorso = 1;}
if (act == 2) {sdLogInCorso = 0;}
if (act == 3)
{
inizializza_sd();
sdError = 0;
}
if (act == 4) {formattazione_sd();}
dat_p = page_logger(buf);
goto SENDTCP;
}
//***********************************************************************************************************************
//***********************************************************************************************************************
//***********************************************************************************************************************
//***********************************************************************************************************************
//***********************************************************************************************************************
SENDTCP:
es.ES_www_server_reply(buf,dat_p); // send web page data
// tcp port 80 end
}
}
void inizializza_enc28j60()
{
// Configuro l'uscita per il CS del chip
pinMode(ENC28J60_CONTROL_CS, OUTPUT);
// initialize enc28j60
es.ES_enc28j60Init(mymac);
// init the ethernet/ip layer:
es.ES_init_ip_arp_udp_tcp(mymac,myip, MYWWWPORT);
msResetWeb = 0;
}
Tramite internet si regola l'orologio, l'ora di accensione della lampada, la durata dell'alba, la durata del tramonto, il tipo di dimmerazione (blu e bianchi assieme oppure prima blu poi bianchi e sinistra e destra assieme o prima sinistra poi destra), la potenza massima di ogni uscita, il colore del led rgb di notte o di giorno ed altro.
Sperando che sia leggibile posto un mio programmino che gestisce 9 pwm per le luci (blu dx e sx, 10000K dx e sx, 20000K dx e sx e rgb).
io uso l'arduino mega per via dei display. come interfaccia utente ha solo il web per ora.
possiede un log per salvare sulla memory i dati della vasca secondo per secondo
codice:
// Include delle librerie usate
#include "EtherShield.h" // EtherShield_1.6.zip
#include <SD.h> // Inclusa
#include "Wire.h" // Inclusa
#include <EEPROM.h> // Inclusa
// Definizione pin utilizzati
#define SD_INT 2
#define PWM_BLU_SX 3
#define SD_CS 4
#define PWM_BLU_DX 5
#define PWM_10K_SX 6
#define PWM_10K_DX 7
#define PWM_20K_SX 8
#define PWM_20K_DX 9
#define PWM_RGB_RED 10
#define PWM_RGB_GREEN 11
#define PWM_RGB_BLUE 12
#define LED_ONBOARD 13
#define I2C_SDA 20
#define I2C_SCL 21
#define SPI_MISO 50
#define SPI_MOSI 51
#define SPI_SCK 52
#define ENC28J60_CONTROL_CS 53
// please modify the following two lines. mac and ip have to be unique
// in your local area network. You can not have the same numbers in
// two devices:
static uint8_t mymac[6] = {0x54,0x55,0x58,0x10,0x00,0x25};
static uint8_t myip[4] = {192,168,1,25};
static uint8_t buf[BUFFER_SIZE + 1];
static char strbuf[STR_BUFFER_SIZE];
static long msLogger;
static long msResetWeb;
static unsigned long msCurrent;
static long msLastUpdateBluDx;
static long msLastUpdateBluSx;
static long msLastUpdate10kDx;
static long msLastUpdate10kSx;
static long msLastUpdate20kDx;
static long msLastUpdate20kSx;
static long msLastUpdateRRGB;
static long msLastUpdateGRGB;
static long msLastUpdateBRGB;
static long msLastUpdateRTC;
static int sdError;
static int sdLogInCorso;
static File sdDataFile;
static String sdDataString;
static int rtcSecond;
static int rtcMinute;
static int rtcHour;
static int rtcWeekDay;
static int rtcMonthDay;
static int rtcMonth;
static int rtcYear;
static int luciOraAccensione;
static int luciMinutoAccensione;
static int luciMinutiDurataAlba;
static int luciOreAccensioneCompleta;
static int luciMinutiAccensioneCompleta;
static int luciMinutiDurataTramonto;
static int luciTargetBluSx;
static int luciTargetBluDx;
static int luciTarget10kSx;
static int luciTarget10kDx;
static int luciTarget20kSx;
static int luciTarget20kDx;
static int luciTargetRRGB;
static int luciTargetGRGB;
static int luciTargetBRGB;
static int luciTipoAlbaTramonto; // bit 0 (prima blu poi bianchi), bit 1 (effetto est/ovest)
static int luciTargetRRGBLunare;
static int luciTargetGRGBLunare;
static int luciTargetBRGBLunare;
static int luciCurrentBluDx;
static int luciCurrentBluSx;
static int luciCurrent10kDx;
static int luciCurrent10kSx;
static int luciCurrent20kDx;
static int luciCurrent20kSx;
static int luciCurrentRRGB;
static int luciCurrentGRGB;
static int luciCurrentBRGB;
//static int secondoCorrente;
//static int secondoAccensioneBluDx;
//static int secondoAccensioneBluSx;
//static int secondoAccensioneBiancoDx;
//static int secondoAccensioneBiancoSx;
//static int secondoSpegnimentoBluDx;
//static int secondoSpegnimentoBluSx;
//static int secondoSpegnimentoBiancoDx;
//static int secondoSpegnimentoBiancoSx;
//static int decimiSecondoIncrementoBluDx;
//static int decimiSecondoIncrementoBluSx;
//static int decimiSecondoIncremento10kDx;
//static int decimiSecondoIncremento10kSx;
//static int decimiSecondoIncremento20kDx;
//static int decimiSecondoIncremento20kSx;
//static int decimiSecondoIncrementoRRGB;
//static int decimiSecondoIncrementoGRGB;
//static int decimiSecondoIncrementoBRGB;
//static int decimiSecondoDecrementoBluDx;
//static int decimiSecondoDecrementoBluSx;
//static int decimiSecondoDecremento10kDx;
//static int decimiSecondoDecremento10kSx;
//static int decimiSecondoDecremento20kDx;
//static int decimiSecondoDecremento20kSx;
//static int decimiSecondoDecrementoRRGB;
//static int decimiSecondoDecrementoGRGB;
//static int decimiSecondoDecrementoBRGB;
//static int luceBluDxAccesa;
//static int luceBluSxAccesa;
//static int luceBiancaDxAccesa;
//static int luceBiancaSxAccesa;
//static int luceRGBDiurnaAccesa;
// Include dei files del programma
#include "luci.h"
#include "web.h"
#include "sd.h"
#include "rtc.h"
void setup()
{
msCurrent = 0;
// Serial.begin(9600);
// Serial.println("inizio");
inizializza_enc28j60();
inizializza_sd();
inizializza_rtc();
inizializza_luci();
}
void loop()
{
msCurrent = millis();
rtc_getDateTime();
gestione_luci();
logger_sd();
webserver();
// Serial.println("inizio ----------------------------");
// Serial.print("secondoCorrente: ");
// Serial.println(secondoCorrente);
// Serial.print("luceBluDxAccesa: ");
// Serial.println(luceBluDxAccesa);
// Serial.print("luceBluSxAccesa: ");
// Serial.println(luceBluSxAccesa);
// Serial.print("luceBiancaDxAccesa: ");
// Serial.println(luceBiancaDxAccesa);
// Serial.print("luceBiancaSxAccesa: ");
// Serial.println(luceBiancaSxAccesa);
// Serial.print("luceRGBDiurnaAccesa: ");
// Serial.println(luceRGBDiurnaAccesa);
//
// Serial.print("luciCurrentBluDx: ");
// Serial.println(luciCurrentBluDx);
// Serial.print("luciCurrentBluSx: ");
// Serial.println(luciCurrentBluSx);
// Serial.print("luciCurrent10kDx: ");
// Serial.println(luciCurrent10kDx);
// Serial.print("luciCurrent10kSx: ");
// Serial.println(luciCurrent10kSx);
// Serial.print("luciCurrent20kDx: ");
// Serial.println(luciCurrent20kDx);
// Serial.print("luciCurrent20kSx: ");
// Serial.println(luciCurrent20kSx);
// Serial.print("luciCurrentRRGB: ");
// Serial.println(luciCurrentRRGB);
// Serial.print("luciCurrentGRGB: ");
// Serial.println(luciCurrentGRGB);
// Serial.print("luciCurrentBRGB: ");
// Serial.println(luciCurrentBRGB);
}
è leggermente complesso perchè tiene conto dei tempi di alba e tramonto che sono programmabili via web e se uno imposta 15 minuti per esempio, se scegli il programma sx e dx assieme e bianchi e blu assieme fa durare la rampa di accensione 15 minuti per tutti i canali tenendo conto di dover raggiungere il valore massimo impostato per ogni canale (quindi se il 10000K deve raggiungere solo il 50% ed il blu il 90% termineranno la rampa nello stesso secondo), se uno sceglie prima blu poi bianchi invece i blu ci accendono in 7,5 minuti e così i bianchi, se uno inoltre sceglie prima bianchi poi blu e l'effetto est/ovest i blu dx si accendono in 3 minuti e 45 e così gli altri canali
Come avevo anticipato posto il codice del mio programma gestione Plafoniera a LED....è lungo e complesso....però al momento funziona bene. le librerie per la maggioranza le trovate sul sito ufficiale di Arduino alcune invece le ho modificate per adattarle al mio schema....comunque può servire per prendere spunto.
codice:
//Programma di controllo della scheda ARQUARIUM
//per la gestione di una plafoniera dimmerabile per
//effetto alba tramonto in pwm 0 - 5 volt
//canali disponibili 5
//# Include
//# ==================================
#include <LiquidCrystal_I2C.h>
#include <Menu.h>
#include <LCDMenu2_I2C.h>
#include <EEPROM.h>
#include <DS1307.h>
#include <Wire.h>
#include <WProgram.h>
#include <EEPROMVar.h>
//# Define
//# ==================================
#define _LCD_rows 4 // numero di righe del display alfanumerico
#define _LCD_cols 20 // numero di colonne del display
#define _BUTTON_up 2
#define _BUTTON_down 4
#define _BUTTON_enter 7
#define _BUTTON_left 14
#define _BUTTON_right 15
#define _BUTTON_prestat 0
#define _BUTTON_press_time 500 //250
#define OPEN_PLAFO 8 // ingresso dell'interruttore per spegnimento plafo quando sollevata
#define ONE_LED 9 // primo canale LED pwm warm nel dolce
#define TWO_LED 10 // secondo canale LED pwm cool nel dolce
#define THREE_LED 11 // terzo canale LED pwm red nel dolce
#define FOUR_LED 3 // quarto canale LED pwm
#define FIVE_LED 5 // quinto canale LED pwm
#define LCD_LIGHT 6 // uscita per backlight del display
#define TEMP_INPUT 16 // ingresso per sensore temperatura
//# Definizioni variabili EEPROM
EEPROMVar<int> EpromOneStartHour = 9; // ora accensione canale uno
EEPROMVar<int> EpromOneStartMinute = 5; // minuto accensione canale uno
EEPROMVar<int> EpromOneStopHour = 20; // ora spegnimento canale uno
EEPROMVar<int> EpromOneStopMinute = 55; // minuto spegnimento canale uno
EEPROMVar<int> EpromOneMax = 100; // massima luminosità canale uno
EEPROMVar<int> EpromOneFadeDuration = 60; // tempo in minuti alba tramonto canale uno
EEPROMVar<int> EpromTwoStartHour = 9;
EEPROMVar<int> EpromTwoStartMinute = 10;
EEPROMVar<int> EpromTwoStopHour = 21;
EEPROMVar<int> EpromTwoStopMinute = 50;
EEPROMVar<int> EpromTwoMax = 100;
EEPROMVar<int> EpromTwoFadeDuration = 60;
EEPROMVar<int> EpromThreeStartHour = 9;
EEPROMVar<int> EpromThreeStartMinute = 0;
EEPROMVar<int> EpromThreeStopHour = 21;
EEPROMVar<int> EpromThreeStopMinute = 0;
EEPROMVar<int> EpromThreeMax = 100;
EEPROMVar<int> EpromThreeFadeDuration = 60;
EEPROMVar<int> EpromTimeLcd= 100; // tempo massimo retroilluminazione LCD
EEPROMVar<int> EpromMaxOpenPlafo = 100; // luminosità massima con plafo aperta
// Le variabili sottoelencate possono essere usate se si ha bisogno di
// controllare più di tre canali
//EEPROMVar<int> EpromFourStartHour = 9;
//EEPROMVar<int> EpromFourStartMinute = 5;
//EEPROMVar<int> EpromFourStopHour = 20;
//EEPROMVar<int> EpromFourStopMinute = 55;
//EEPROMVar<int> EpromFourMax = 100;
//EEPROMVar<int> EpromFourFadeDuration = 60;
//EEPROMVar<int> EpromFiveStartHour = 9;
//EEPROMVar<int> EpromFiveStartMinute = 10;
//EEPROMVar<int> EpromFiveStopHour = 21;
//EEPROMVar<int> EpromFiveStopMinute = 50;
//EEPROMVar<int> EpromFiveMax = 100;
//EEPROMVar<int> EpromFiveFadeDuration = 60;
// variabili di tempo da collegare a quelle in memoria EEPROM
int oneStartHour;
int oneStopHour;
int oneStartMinute;
int oneStopMinute;
int twoStartHour;
int twoStopHour;
int twoStartMinute;
int twoStopMinute;
int threeStartHour;
int threeStopHour;
int threeStartMinute;
int threeStopMinute;
int oneMinFade;
int twoMinFade;
int threeMinFade;
//int fourStartHour;
//int fourStopHour;
//int fourStartMinute;
//int fourStopMinute;
//int fiveStartHour;
//int fiveStopHour;
//int fiveStartMinute;
//int fiveStopMinute;
//int sixStartHour;
//int sixStopHour;
//int sixStartMinute;
//int sixStopMinute;
//int fourMinFade;
//int fiveMinFade;
//int sixMinFade;
//# Variabili di tempo per gestione accensione spegnimento e fading
long oneStartSeconds; // Ora accensione canale uno in secondi
long onePhotoPeriod; // durata foto periodo canale uno
int oneMax; // luminosità massima canale uno
long oneFadeDuration; // durata alba tramonto canale uno
long twoStartSeconds; // Ora accensione canale due in secondi
long twoPhotoPeriod; // durata foto periodo canale due
int twoMax; // luminosità massima canale due
long twoFadeDuration; // durata alba tramonto canale due
long threeStartSeconds; // Ora accensione canale tre in minuti
long threePhotoPeriod; // durata foto periodo canale tre
int threeMax; // luminosità massima canale tre
long threeFadeDuration; // durata alba tramonto canale tre
//le variabili sottostanti possono essere usate se si ha
// bisogno di controllare più di tre canali
//long fourStartSeconds; // Ora accensione canale quattro
//long fourPhotoPeriod; // durata foto periodo canale quattro
//int fourMax; // luminosità massima canale quattro
//long fourFadeDuration; // durata alba tramonto canale quattro
//long fiveStartSeconds; // Ora accensione canale cinque
//long fivePhotoPeriod; // durata foto periodo canale cinque
//int fiveMax; // luminosità massima canale cinque
//long fiveFadeDuration; // durata alba tramonto canale cinque
//long sixStartSeconds; // Ora accensione canale sei
//long sixPhotoPeriod; // durata foto periodo canale sei
//int sixMax; // luminosità massima canale sei
//long sixFadeDuration; // durata alba tramonto canale sei
int max1; // variabile collegata a oneMax
int max2; // variabile collegata a twoMax
int max3; // variabile collegata a threeMax
int ora; // variabile ora corrente
int minuti; // variabile minuto corrente
int giorno; // variabile giorno corrente
int mese; // variabile mese corrente
int anno; // variabile anno corrente
// variabili controllo LED
long secondCounter = 0; // contatore che si resetta alla emzzanotte
long oldSecondCounter = 0; // contatore che si resetta alla mezzanotte
int oneVal; // valore corrente luminosità canale uno
int twoVal; // valore corrente luminosità canale due
int threeVal; // valore corrente luminosità canale tre
// variabili da usare se servono più di tre canali di controllo
//int fourVal; // valore corrente luminosità canale quattro
//int fiveVal; // valore corrente luminosità canale cinque
//int sixVal; // valore corrente luminosità canale sei
int setting = 0; // variabile di controllo modalità settaggi valori
long tempo_home = 0, back_home = 50000;
long tempo;
long tempo_barra;
int stepper_bar = 2;
int colonna = 0;
boolean on_off_light= false; // variabile di controllo stato accensione-spegnimento plafo
boolean LCD_time_on= true;
boolean blinker; // variabile booleana per settare o no il blink sull'LCD
long timeLcd; // tempo retroilluminazione LCD
int maxOpenPlafo; // luminosità residua palfoniera aperta
int control_light_stop = 0;
int cursorPosition = 0;
int buttonPress = 0;
float tempC;
int reading;
byte outValOne; // variabile controllo valore uscita in modalità accensione manuale
byte outValTwo;
byte outValThree;
const byte rowMessage = 2; // numero della riga del display dove appaiono i valori da modificare
byte firstStepTemp = 40; // max temperatura primo step abbassamento luminosità LED del 10%
byte secondStepTemp = 45; // max temperatura secondo step abbassamento luminosità LED del 40%
byte thirdStepTemp = 50; // max temperatura terzo step spegnimento LED
//# Creazione caratteri personali
//# ==================================
uint8_t arrow_up[8] = { // freccia su
0x4,0xE,0x15,0x4,0x4,0x4,0x0};
uint8_t arrow_down[8] = { // freccia giù
0x0,0x4,0x4,0x4,0x15,0xE,0x4};
//uint8_t light_on[8] = {
// 0x0,0x15,0xA,0x1F,0xA,0x15,0x0}; // plafo accesa
uint8_t punto[8] = {
0xC,0xC,0x0,0x0,0x0,0x0,0x0}; // punto gradi centigradi
uint8_t one_bar[8] = {
0x10,0x10,0x10,0x10,0x10,0x10,0x10}; // una barra verticale
uint8_t two_bar[8] = {
0x18,0x18,0x18,0x18,0x18,0x18,0x18}; // due barre verticali
uint8_t tree_bar[8] = {
0x1C,0x1C,0x1C,0x1C,0x1C,0x1C,0x1C}; // tre barre verticali
uint8_t four_bar[8] = {
0x1E,0x1E,0x1E,0x1E,0x1E,0x1E,0x1E}; // quattro barre verticali
uint8_t five_bar[8] = {
0x1F,0x1F,0x1F,0x1F,0x1F,0x1F,0x1F}; // cinque barre verticali
//# Classes
//# ==================================
LiquidCrystal_I2C lcd(0x20,_LCD_cols,_LCD_rows); // set the LCD address to 0x20 for a 16 chars and 2 line display
//LiquidCrystal lcd(2,3,4,5,6,7); // Neuste Version, RW wird nicht mehr gebraucht
Menu top("Root");
// menu, lcd, rows, cols, arrow_up_pos, arrow_down_pos
LCDMenu2 Root(top, lcd , _LCD_rows, _LCD_cols, 0, 1);
//# Buttons
//# ==================================
//UP,DOWN,ENTER,LEFT,RIGHT
int but[5]= {
_BUTTON_up,_BUTTON_down,_BUTTON_enter,_BUTTON_left,_BUTTON_right};
//Previous States of buttons
boolean pbut[5]={
_BUTTON_prestat,_BUTTON_prestat,_BUTTON_prestat,_BUTTON_prestat,_BUTTON_prestat};
//# Button Enter
//# ==================================
int button_press_enter = 0;
unsigned long g_button_press_time = millis();
// creazione voci del menu e sottomenu..è possibile sostituirle cone voci proprie
// senza superare il numero massimo di colonne - 1 del dislplay LCD impiegato
char strMenuInit[] = "Menu";
char strMenuDate[] = "Imp. Data/Ora";
char strMenuTime[] = "Imp. Tempi on/off";
char strMenuFade[] = "Imp. Alba/Tramonto";
char strMenuLux[] = "Imp. Luminosita'";
char strMenuManualOn[] = "On/Off Manuale";
char strMenuLcdTime[] = "Imp. Tempo LCD";
char strMenuOpenPlafo[] = "Lum. Plafo aperta";
char strMenuTimeOne[] = "Imp. Tempo Warm";
char strMenuTimeTwo[] = "Imp. Tempo Cool";
char strMenuTimeThree[] = "Imp. Tempo Red";
//char strMenuFadeOne[] = "Imp. Fading Warm";
//char strMenuFadeTwo[] = "Imp. Fading Cool";
//char strMenuFadeThree[] = "Imp. Fading Red";
//char strMenuLuxOne[] = "Imp. Lum. Warm";
//char strMenuLuxTwo[] = "Imp. Lum. Cool";
//char strMenuLuxThree[] = "Imp. Lum. Red";
// voci del menu relative ai canali dal 3 al 6 da utilizzare se servono
//char strMenuTimeFour[] = "";
//char strMenuTimeFive[] = "";
//char strMenuTimeSix[] = "";
//char strMenuFadeFour[] = "";
//char strMenuFadeFive[] = "";
//char strMenuFadeSix[] = "";
//char strMenuLuxFour[] = "";
//char strMenuLuxFive[] = "";
//char strMenuLuxSix[] = "";
//# Menu
//# ==================================
Menu Item1(strMenuInit);
Menu Item12(strMenuDate);
Menu Item13(strMenuTime);
Menu Item14(strMenuFade);
Menu Item15(strMenuLux);
Menu Item16(strMenuManualOn);
Menu Item17(strMenuLcdTime);
Menu Item18(strMenuOpenPlafo);
Menu Item131(strMenuTimeOne);
Menu Item132(strMenuTimeTwo);
Menu Item133(strMenuTimeThree);
//Menu Item134(strMenuTimeFour);
//Menu Item135(strMenuTimeFive);
//Menu Item136(strMenuTimeSix);
//Menu Item141(strMenuFadeOne);
//Menu Item142(strMenuFadeTwo);
//Menu Item143(strMenuFadeThree);
//Menu Item144(strMenuFadeFour);
//Menu Item145(strMenuFadeFive);
//Menu Item146(strMenuFadeSix);
//Menu Item151(strMenuLuxOne);
//Menu Item152(strMenuLuxTwo);
//Menu Item153(strMenuLuxThree);
//Menu Item154(strMenuLuxFour);
//Menu Item155(strMenuLuxFive);
//Menu Item156(strMenuLuxSix);
//# ==================================
//## Menu Init
void menuinit()
{
top.addChild(Item1);
Item1.addChild(Item12);
Item1.addChild(Item13);
Item1.addChild(Item14);
Item1.addChild(Item15);
Item1.addChild(Item16);
Item1.addChild(Item17);
Item1.addChild(Item18);
Item13.addChild(Item131);
Item13.addChild(Item132);
Item13.addChild(Item133);
// Item13.addChild(Item134);
// Item13.addChild(Item135);
// Item13.addChild(Item136);
// Item14.addChild(Item141);
// Item14.addChild(Item142);
// Item14.addChild(Item143);
// Item14.addChild(Item144);
// Item14.addChild(Item145);
// Item14.addChild(Item146);
// Item15.addChild(Item151);
// Item15.addChild(Item152);
// Item15.addChild(Item153);
// Item15.addChild(Item154);
// Item15.addChild(Item155);
// Item15.addChild(Item156);
Root.display();
}
//## Button
void button(int which, char select='z')
{
if(which == _BUTTON_up || select == 'w') {
//UP
switch (setting) {
case 0:
Root.goUp();
//Serial.println("'up'");
break;
default:
selectSet(which);
break;
}
}
else if(which == _BUTTON_down || select == 's') {
//DOWN
switch (setting) {
case 0:
Root.goDown();
//Serial.println("'down'");
break;
default:
selectSet(which);
}
}
else if(which == _BUTTON_left || select == 'l') {
//LEFT
if (cursorPosition >= 1) {
cursorPosition--;
}
switch (setting) {
case 0:
cursorPosition = 0;
goBack();
break;
default:
selectSet(which);
break;
}
}
else if(which == _BUTTON_right || select == 'r') {
//RIGHT
if(cursorPosition < 5){
cursorPosition++;
}
switch (setting) {
case 0:
Root.goEnter();
button_press_enter = 1;
break;
default:
selectSet(which);
break;
}
}
else if(which == _BUTTON_enter || select == 'e') {
//ENTER
if (setting != 0)
{
save_data();
blinker = false;
print_save_date();
Root.goEnter();
setting = 0;
control_light_stop = 0;
}
set_reset_value();
}
}
//## Button Check
void buttoncheck()
{
for (int i=0;i<=4;i++)
{
if (digitalRead(but[i])) {
if (pbut[i]==0 && (millis()-g_button_press_time) >= _BUTTON_press_time) {
button(but[i]);
buttonPress = but[i];
//pbut[i]=1;
g_button_press_time = millis();
if(timeLcd < 100){
analogWrite(LCD_LIGHT,255);
}
tempo_home = millis();
}
}
else {
pbut[i]=0;
//buttonPress=0;
if( millis() - tempo_home > back_home )
{
Root.goBack();
Root.goBack();
lcd.noBlink();
set_reset_value();
setting = 0;
cursorPosition = 0;
control_light_stop = 0;
LCD_time_on = true;
}
if(timeLcd < 100){
if( millis() - tempo_home > (timeLcd * 1000) )
{
analogWrite(LCD_LIGHT,20);
//tempo_home = millis();
}
}
}
}
//if(Serial.available()) {
// char c = Serial.read();
// button(-1,c);
//}
}
//## Function Check
void funccheck(int button)
{
int x;
if(button_press_enter == 1) {
button_press_enter = 0;
if(Root.curfuncname == strMenuInit) {
//Serial.println("Function: Controller LED");
setting = 0;
LCD_time_on = false;
}
else if(Root.curfuncname == strMenuDate) { // menu impostazione data e ora generale
setting = 1;
//Serial.println("Function: Imp. data ora");
ora = RTC.get(DS1307_HR, true);
minuti = RTC.get(DS1307_MIN, true);
giorno = RTC.get(DS1307_DATE, true);
mese = RTC.get(DS1307_MTH, true);
anno = RTC.get(DS1307_YR, true);
lcd.clear();
print_text(0,0, strMenuDate);
cursorPosition= 1;
print_time_date(2);
setDateHour(button);
// set_month(mese);
// set_year(anno);
// set_hour(ora);
// set_minute(minuti);
// set_day(0);
}
else if(Root.curfuncname == strMenuTimeOne) { // menu impostazione tempi accensione canale uno
Serial.println("Function: Imp. tempi canale uno");
setting = 2;
lcd.clear();
print_text(0,0, strMenuTimeOne);
printStartStopTime(oneStartHour, oneStartMinute, oneStopHour, oneStopMinute);
cursorPosition= 1;
setTimeOne(button);
// set_on_light_minute(led_on_minute);
// set_off_light_hour(led_off_hour);
// set_off_light_minute(led_off_minute);
// set_on_light_hour(led_on_hour);
}
else if(Root.curfuncname == strMenuTimeTwo) { // menu impostazione tempi accensione canale due
setting = 3;
lcd.clear();
print_text(0,0, strMenuTimeTwo);
printStartStopTime(twoStartHour, twoStartMinute, twoStopHour, twoStopMinute);
cursorPosition= 1;
setTimeTwo(button);
}
else if(Root.curfuncname == strMenuTimeThree) { // menu impostazione tempi accensione canale tre
setting = 4;
lcd.clear();
print_text(0,0, strMenuTimeThree);
printStartStopTime(threeStartHour, threeStartMinute, threeStopHour, threeStopMinute);
cursorPosition= 1;
setTimeThree(button);
}
else if(Root.curfuncname == strMenuFade) { // menu impostazione alba tramonto
setting = 5;
lcd.clear();
print_text(0,0, strMenuFade);
print_text(0,1,"Warm Cool Red");
print_text(0,rowMessage,"Min: Min: Min:");
setFadeTime(button, oneMinFade, 4);
setFadeTime(button, twoMinFade, 11);
setFadeTime(button, threeMinFade, 18);
//
// print_value(4,rowMessage, oneMinFade);
// print_value(11,rowMessage, twoMinFade);
// print_value(18,rowMessage, threeMinFade);
cursorPosition= 1;
setFade(button);
}
else if(Root.curfuncname == strMenuLux) { // menu impostazione luminosità LED singoli canali
setting = 6;
control_light_stop = 1;
lcd.clear();
print_text(0,0,strMenuLux);
print_text(1,1,"Warm Cool Red");
setMaxLux(button, oneMax, ONE_LED, 1); // SCRIVE I VALORI DEI CANALI
setMaxLux(button, twoMax, TWO_LED, 7);
setMaxLux(button, threeMax, THREE_LED, 14);
cursorPosition = 1;
setLux(button);
}
else if(Root.curfuncname == strMenuManualOn) { // menu accensione manuale singoli canali
setting = 7;
control_light_stop = 1;
lcd.clear();
print_text(0,0,strMenuManualOn);
print_text(1,1,"Warm Cool Red");
outValOne = 0;
outValTwo = 0;
outValThree = 0;
manualOn(button, outValOne, ONE_LED, 1);
manualOn(button, outValTwo, TWO_LED, 7);
manualOn(button, outValThree, THREE_LED, 14);
cursorPosition= 1;
setManualOn(button);
/* manual_on_off_cool(on_off_light);
manual_on_off_red(on_off_light);
manual_on_off_warm(on_off_light);*/
}
else if(Root.curfuncname == strMenuLcdTime) { // menu impostazione tempo accesnione backlight dell'LCD
setting = 8;
lcd.clear();
print_text(0,0,strMenuLcdTime);
print_text(0,rowMessage,"Secondi:");
setLcdTime(button);
}
else if(Root.curfuncname == strMenuOpenPlafo) { // menu impostazione luce residua LED a plafo aperta
setting = 9;
lcd.clear();
blinker = true;
print_text(0,0,strMenuOpenPlafo);
print_text(0,rowMessage,"Luminosita':");
setLuxOpenPlafo(button);
}
}
}
//# Setup
//# ==================================
void setup()
{
lcd.begin(_LCD_rows,_LCD_cols);
lcd.createChar(0, arrow_up);
lcd.createChar(1, arrow_down);
//lcd.createChar(2, light_on);
lcd.createChar(2, punto);
lcd.createChar(3, one_bar);
lcd.createChar(4, two_bar);
lcd.createChar(5, tree_bar);
lcd.createChar(6, four_bar);
lcd.createChar(7, five_bar);
lcd.init();
//lcd.home();
analogReference(INTERNAL);
pinMode(OPEN_PLAFO, INPUT);
pinMode(ONE_LED, OUTPUT);
pinMode(TWO_LED, OUTPUT);
pinMode(THREE_LED, OUTPUT);
pinMode(FOUR_LED, OUTPUT);
pinMode(FIVE_LED, OUTPUT);
pinMode(LCD_LIGHT, OUTPUT);
pinMode(TEMP_INPUT, INPUT);
analogWrite(LCD_LIGHT,20);
set_reset_value();
tempo = millis();
menuinit();
Serial.begin(9600);
}
//# LOOP
//# ==================================
void loop()
{
buttoncheck();
funccheck(buttonPress);
reading = analogRead(TEMP_INPUT);
tempC = reading / 9.31;
//tempC = (5.0 * reading * 100.0)/1024.0;
controlTempLed(byte(tempC));
Serial.println("Setting:");
Serial.println(setting);
Serial.println("Cursor position");
Serial.println(cursorPosition);
Serial.println("Button Press");
Serial.println(buttonPress);
Serial.println(Root.curfuncname);
Serial.println("Tempo LCD");
Serial.println(timeLcd);
Serial.println("Temperatura");
Serial.println(tempC);
//control_led_lights();
oldSecondCounter = secondCounter;
secondCounter = (long) RTC.get(DS1307_HR,true) * 3600 + (long) RTC.get(DS1307_MIN,false)* 60 + (long) RTC.get(DS1307_SEC,false);
// controlla e setta la durata del fading
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;
}
//setta le uscite
oneVal = setLed(secondCounter, ONE_LED, oneStartSeconds, onePhotoPeriod, oneFadeDuration, oneMax);
twoVal = setLed(secondCounter, TWO_LED, twoStartSeconds, twoPhotoPeriod, twoFadeDuration, twoMax);
threeVal = setLed(secondCounter, THREE_LED, threeStartSeconds, threePhotoPeriod, threeFadeDuration, threeMax);
if(oneVal > 0 || twoVal > 0 || threeVal > 0)
{ on_off_light= true;}
else
{ on_off_light= false;}
Serial.println("Oneval");
Serial.println(oneVal);
Serial.println("twoval");
Serial.println(twoVal);
Serial.println("threeval");
Serial.println(threeVal);
Serial.println(secondCounter);
Serial.println(oneStartSeconds);
Serial.println(onePhotoPeriod);
Serial.println(oneFadeDuration);
Serial.println("Control light stop");
Serial.println(control_light_stop);
offPlafo();
if (timeLcd == 100){
analogWrite(LCD_LIGHT,255);
}
if (LCD_time_on == true)
{
printTemp(int(tempC));
print_time_date(3);
}
//delay(500);
}
//Funzione per settare accensione
//e spegnimento dei singoli canali LED
//con gestione effetto alba tramonto
int setLed(long Seconds, // tempo corrente in secondi
int ledPin, // numero di pin del canale LED
long start, // tempo di partenza accensione del canale LED
long period, // Periodo di accensione del canale LED
long fade, // durata alba tramonto canale LED
int ledMax // luminosità massima canale LED
)
{
// controlla che non si sia in modalità settaggio luminosità,
// on/off manuale o il coperchio alzato in quel caso esce dalla funzione
int val;
if (control_light_stop == 0){
// fade up...ossia gestione alba
if (Seconds > start || Seconds <= start + fade) {
val = map(Seconds - start, 0, fade, 0, ledMax * 2.55);
}
// fade down...gestione tramonto
if (Seconds > start + period && Seconds <= start + period + fade) {
val = map(Seconds - (start + period), 0, fade, ledMax * 2.55, 0);
}
// off or post-midnight run spegnimento o partenza dopo mezzanotte
if (Seconds <= start || Seconds > start + period + fade) {
if((start + period + fade)%86400 < start && (start + period + fade)%86400 > Seconds)
{
val = map((start + period + fade - Seconds)%86400,0,fade,0,ledMax * 2.55);
}
else {
val = 0;
}
}
if (val > ledMax * 2.55) {
val = ledMax * 2.55;
}
if (val < 0) {
val = 0;
}
analogWrite(ledPin, val); // map(val, 0, 100, 0, 255));
return val;
}
}
//* Funzione print time_date
//* mostra data e ora sul display
void print_time_date(byte row)
{
int ora;
int minuti;
int secondi;
int giorno;
int mese;
int anno;
ora = RTC.get(DS1307_HR, true);
minuti = RTC.get(DS1307_MIN, true);
secondi = RTC.get(DS1307_SEC, true);
giorno = RTC.get(DS1307_DATE, true);
mese = RTC.get(DS1307_MTH, true);
anno = RTC.get(DS1307_YR, true);
blinker = false;
if (giorno < 10 && giorno > 0) {
print_value(0,row,0);
print_value(1,row,giorno);
}
else {
print_value(0,row,giorno);
}
print_text(2,row,"-");
if (mese < 10 && mese > 0) {
print_value(3,row,0);
print_value(4,row,mese);
}
else {
print_value(3,row,mese);
}
print_text(5,row,"-");
print_value(6,row,anno);
if (ora < 10 && ora >= 0) {
print_text(11,row," ");
print_value(12,row,ora);
}
else {
print_value(11,row,ora);
}
print_text(13,row,":");
if (minuti < 10 && minuti >= 0) {
print_value(14,row,0);
print_value(15,row,minuti);
}
else {
print_value(14,row,minuti);
}
print_text(16,row,":");
if (secondi < 10 && secondi >= 0) {
print_value(17,row,0);
print_value(18,row,secondi);
}
else {
print_value(17,row,secondi);
}
}
// funzione di settaggio data e ora corrente
void setDateHour(int button)
{
print_text(16,rowMessage," "); // rende non visibili i secondi
switch (cursorPosition) {
case 0:
case 1:
set_day(button);
break;
case 2:
set_month(button);
break;
case 3:
set_year(button);
break;
case 4:
set_hour(button);
break;
case 5:
set_minute(button);
break;
default:
cursorPosition = 5;
break;
}
}
//* settaggio giorno
void set_day(int button)
{
blinker = true;
// controlla quale bottone è stato premuto
if (button == _BUTTON_up) {
if(giorno >= 1 && giorno < 32){
giorno++;
}
if(giorno == 32){
giorno = 1;
}
}
if (button == _BUTTON_down) {
if(giorno > 0 && giorno <= 31){
giorno--;
}
if(giorno == 0){
giorno = 31;
}
}
if (giorno < 10 && giorno > 0) {
print_value(0,rowMessage,0);
print_value(1,rowMessage,giorno);
}
else {
print_value(0,rowMessage,giorno);
}
print_text(2,rowMessage,"-");
lcd.setCursor(1,rowMessage);
}
//* settaggio mese
void set_month(int button)
{
blinker = true;
// controlla quale bottone è stato premuto
if (button == _BUTTON_up) {
if(mese >= 1 && mese < 13){
mese++;
}
if(mese == 13){
mese = 1;
}
}
if (button == _BUTTON_down) {
if(mese > 0 && mese <= 12){
mese--;
}
if(mese == 0){
mese = 12;
}
}
if (mese < 10 && mese > 0) {
print_value(3,rowMessage,0);
print_value(4,rowMessage,mese);
}
else {
print_value(3,rowMessage,mese);
}
print_text(5,rowMessage,"-");
lcd.setCursor(4,rowMessage);
}
//* settaggio anno
void set_year(int button)
{
blinker = true;
if (button == _BUTTON_up) {
anno++;
}
if (button == _BUTTON_down) {
anno--;
}
print_value(6,rowMessage,anno);
lcd.setCursor(9,rowMessage);
}
//* settaggio ora
void set_hour(int button)
{
blinker = true;
// controlla quale bottone è stato premuto
if (button == _BUTTON_up) {
if(ora >= 0 && ora < 24){
ora++;
}
if(ora == 24){
ora = 0;
}
}
if (button == _BUTTON_down) {
if(ora > -1 && ora <= 23){
ora--;
}
if(ora == -1){
ora = 23;
}
}
if (ora < 10 && ora >= 0) {
print_value(11,rowMessage,0);
print_value(12,rowMessage,ora);
}
else {
print_value(11,rowMessage,ora);
}
print_text(13,rowMessage,":");
lcd.setCursor(12,rowMessage);
}
//* settaggio minuti
void set_minute(int button)
{
blinker = true;
// controlla quale bottone premuto
if (button == _BUTTON_up) {
if(minuti >= 0 && minuti < 60){
minuti++;
}
if(minuti == 60){
minuti = 0;
}
}
if (button == _BUTTON_down) {
if(minuti > -1 && minuti <= 59){
minuti--;
}
if(minuti == -1){
minuti = 59;
}
}
if (minuti < 10 && minuti >= 0) {
print_value(14,rowMessage,0);
print_value(15,rowMessage,minuti);
}
else {
print_value(14,rowMessage,minuti);
}
lcd.setCursor(15,rowMessage);
}
// setta accensione e spegnimento canale uno
void setTimeOne(int button)
{
switch (cursorPosition) {
case 0:
case 1:
setStartHour(button, oneStartHour);
break;
case 2:
setStartMinute(button, oneStartMinute);
break;
case 3:
setStopHour(button, oneStopHour);
break;
case 4:
setStopMinute(button, oneStopMinute);
break;
default:
cursorPosition = 4;
break;
}
}
// setta accensione e spegnimento canale due
void setTimeTwo(int button)
{
switch (cursorPosition) {
case 0:
case 1:
setStartHour(button, twoStartHour);
break;
case 2:
setStartMinute(button, twoStartMinute);
break;
case 3:
setStopHour(button, twoStopHour);
break;
case 4:
setStopMinute(button, twoStopMinute);
break;
default:
cursorPosition = 4;
break;
}
}
// setta accensione e spegnimento canale tre
void setTimeThree(int button)
{
switch (cursorPosition) {
case 0:
case 1:
setStartHour(button, threeStartHour);
break;
case 2:
setStartMinute(button, threeStartMinute);
break;
case 3:
setStopHour(button, threeStopHour);
break;
case 4:
setStopMinute(button, threeStopMinute);
break;
default:
cursorPosition = 4;
break;
}
}
//* settaggio ora accensione LED
void setStartHour(int button, int &led_on_hour)
{
blinker = true;
if (button == _BUTTON_up) {
if(led_on_hour >= 0 && led_on_hour < 24){
led_on_hour++;
}
if(led_on_hour == 24){
led_on_hour = 0;
}
}
if (button == _BUTTON_down) {
if(led_on_hour > -1 && led_on_hour <= 23){
led_on_hour--;
}
if(led_on_hour == -1){
led_on_hour = 23;
}
}
if (led_on_hour < 10 && led_on_hour >= 0) {
print_value(4,rowMessage,0);
print_value(5,rowMessage,led_on_hour);
}
else {
print_value(4,rowMessage,led_on_hour);
}
print_text(6,rowMessage,":");
lcd.setCursor(5,rowMessage);
}
//* settaggio minuto accensione LED
void setStartMinute(int button, int &led_on_minute)
{
blinker = true;
// controlla quale bottone premuto
if (button == _BUTTON_up) {
if(led_on_minute >= 0 && led_on_minute < 60){
led_on_minute++;
}
if(led_on_minute == 60){
led_on_minute = 0;
}
}
if (button == _BUTTON_down) {
if(led_on_minute > -1 && led_on_minute <= 59){
led_on_minute--;
}
if(led_on_minute == -1){
led_on_minute = 59;
}
}
if (led_on_minute < 10 && led_on_minute >= 0) {
print_value(7,rowMessage,0);
print_value(8,rowMessage,led_on_minute);
}
else {
print_value(7,rowMessage,led_on_minute);
}
lcd.setCursor(8,rowMessage);
}
//* settaggio ora spegnimento LED
void setStopHour(int button, int &led_off_hour)
{
blinker = true;
if (button == _BUTTON_up) {
if(led_off_hour >= 0 && led_off_hour < 24){
led_off_hour++;
}
if(led_off_hour == 24){
led_off_hour = 0;
}
}
if (button == _BUTTON_down) {
if(led_off_hour > -1 && led_off_hour <= 23){
led_off_hour--;
}
if(led_off_hour == -1){
led_off_hour = 23;
}
}
if (led_off_hour < 10 && led_off_hour >= 0) {
print_value(14,rowMessage,0);
print_value(15,rowMessage,led_off_hour);
}
else {
print_value(14,rowMessage,led_off_hour);
}
print_text(16,rowMessage,":");
lcd.setCursor(15,rowMessage);
}
//* settaggio minuti spegnimento LED
void setStopMinute(int button, int &led_off_minute)
{
blinker = true;
// controlla quale bottone premuto
if (button == _BUTTON_up) {
if(led_off_minute >= 0 && led_off_minute < 60){
led_off_minute++;
}
if(led_off_minute == 60){
led_off_minute = 0;
}
}
if (button == _BUTTON_down) {
if(led_off_minute > -1 && led_off_minute <= 59){
led_off_minute--;
}
if(led_off_minute == -1){
led_off_minute = 59;
}
}
if (led_off_minute < 10 && led_off_minute >= 0) {
print_value(17,rowMessage,0);
print_value(18,rowMessage,led_off_minute);
}
else {
print_value(17,rowMessage,led_off_minute);
}
lcd.setCursor(18,rowMessage);
}
void setFade(int button){ // settaggio alba tramonto dei canali
switch (cursorPosition) {
case 0:
case 1:
setFadeTime(button, oneMinFade, 4);
break;
case 2:
setFadeTime(button, twoMinFade, 11);
break;
case 3:
setFadeTime(button, threeMinFade, 18);
break;
default:
cursorPosition = 3;
break;
}
}
//* settaggio tempo alba/tramonto
void setFadeTime(int button,int &varFade, byte chrPos)
{
blinker = true;
// controlla quale bottone premuto
if (button == _BUTTON_up) {
if(varFade >= 0 && varFade <= 60){
varFade++;
}
if(varFade == 61){
varFade = 0;
}
}
if (button == _BUTTON_down) {
if(varFade > -1 && varFade <= 60){
varFade--;
}
if(varFade == -1){
varFade = 60;
}
}
if (varFade < 10 && varFade >=0){
print_value(chrPos,rowMessage,0);
print_value(chrPos+1,rowMessage,varFade);
}
else {
print_value(chrPos,rowMessage,varFade);
}
lcd.setCursor(chrPos+1,rowMessage);
}
void setLux(int button){
switch (cursorPosition) {
case 0:
case 1:
setMaxLux(button, oneMax, ONE_LED, 1);
break;
case 2:
setMaxLux(button, twoMax, TWO_LED, 7);
break;
case 3:
setMaxLux(button, threeMax, THREE_LED, 14);
default:
cursorPosition = 3;
break;
}
}
//* settaggio luminosità massima dei vari canali
void setMaxLux(int button, int &varLux, byte PIN_LED, byte chrPos){
// controlla quale bottone premuto
if (button == _BUTTON_up) {
if(varLux >= 0 && varLux < 100){
varLux++;
}
}
if (button == _BUTTON_down) {
if(varLux > 0 && varLux <= 100){
varLux--;
}
}
int bright = (varLux * 2.55);
//Serial.println(lux);
analogWrite(PIN_LED, bright);
blinker = true;
if (varLux < 10) {
lcd.setCursor(chrPos,rowMessage);
lcd.print(' ');
lcd.setCursor(chrPos+1,rowMessage);
lcd.print(' ');
print_value(chrPos+2,rowMessage,varLux);
}
else if (varLux >= 10 && varLux <= 99){
lcd.setCursor(chrPos,rowMessage);
lcd.print(' ');
print_value(chrPos+1,rowMessage,varLux);
}
else {
print_value(chrPos,rowMessage,varLux);
}
lcd.print("%");
}
void setManualOn(int button){ //setta on off manualmente i singoli canali
switch (cursorPosition) {
case 0:
case 1:
manualOn(button, outValOne, ONE_LED, 1);
break;
case 2:
manualOn(button, outValTwo, TWO_LED, 7);
break;
case 3:
manualOn(button, outValThree, THREE_LED, 14);
default:
cursorPosition = 3;
break;
}
}
//* accensione manuale dei canali
void manualOn(int button, byte &Val, byte PIN_LED, byte chrPos)
{
blinker = true;
if (button == _BUTTON_up) {
Val = 255;
//analogWrite(PIN_LED, Val);
}
if (button == _BUTTON_down) {
Val = 0;
//analogWrite(PIN_LED, Val);
}
if(Val > 0)
{
print_text(chrPos + 1,rowMessage,"On ");
lcd.setCursor(chrPos,rowMessage);
}
else
{
print_text(chrPos + 1,rowMessage,"Off");
lcd.setCursor(chrPos,rowMessage);
}
analogWrite(PIN_LED, Val);
}
void setLcdTime(int button){ //settaggio del tempo di illuminazione dell'LCD
blinker = true;
if (button == _BUTTON_up) {
if(timeLcd >= 0 && timeLcd <= 90){
timeLcd = timeLcd + 10;
}
}
if (button == _BUTTON_down) {
if(timeLcd > 10 && timeLcd <= 100){
timeLcd = timeLcd -10;
}
}
if (timeLcd <= 90){
print_value(9,rowMessage,timeLcd);
}
else{
print_text(9,rowMessage,"On");
}
}
void setLuxOpenPlafo(int button){ // settaggio minima luminosità led a plafo aperta
blinker = true;
if (button == _BUTTON_up) {
if(maxOpenPlafo >= 0 && maxOpenPlafo <= 99){
maxOpenPlafo++;
}
}
if (button == _BUTTON_down) {
if(maxOpenPlafo > 1 && maxOpenPlafo <= 100){
maxOpenPlafo--;
}
}
if(maxOpenPlafo > 9 && maxOpenPlafo < 100){
print_text(12,rowMessage," ");
print_value(13,rowMessage,maxOpenPlafo);
}
if(maxOpenPlafo < 10){
print_text(12,rowMessage," ");
print_value(14,rowMessage,maxOpenPlafo);
}
}
//* Funzione per la stampa su LCD di valori numerici
void print_value(int col, int row, int value)
{
lcd.setCursor(col,row);
lcd.print(value);
if (blinker == true) {
lcd.blink();
}
else {
lcd.noBlink();
}
}
//* Funzione per la stampa su LCD di valori testo
void print_text(int col, int row, char* text)
{
lcd.setCursor(col,row);
lcd.print(text);
if (blinker == true) {
lcd.blink();
}
else {
lcd.noBlink();
}
}
//* Funzione di salvataggio dei dati nella eeprpom relativi a
// data corrente, ora corrente, orari di accensione e spegnimento
// della plafo, tempo di alba-tramonto, luminosità singoli canali
void save_data()
{
if (setting == 1)
{
RTC.stop();
RTC.set(DS1307_MIN,minuti); //setta i minuti
RTC.set(DS1307_HR,ora); //setta l'ora
RTC.set(DS1307_DATE,giorno); //setta la data
RTC.set(DS1307_MTH,mese); //setta il mese
RTC.set(DS1307_YR,(anno-2000)); //setta l'anno
RTC.start();
}
if (setting ==2 || setting == 3 || setting == 4)
{
EpromOneStartHour = oneStartHour;
EpromOneStartMinute = oneStartMinute;
EpromOneStopHour = oneStopHour;
EpromOneStopMinute = oneStopMinute;
EpromTwoStartHour = twoStartHour;
EpromTwoStartMinute = twoStartMinute;
EpromTwoStopHour = twoStopHour;
EpromTwoStopMinute = twoStopMinute;
EpromThreeStartHour = threeStartHour;
EpromThreeStartMinute = threeStartMinute;
EpromThreeStopHour = threeStopHour;
EpromThreeStopMinute = threeStopMinute;
}
if( setting == 5 )
{
EpromOneFadeDuration = oneMinFade;
EpromTwoFadeDuration = twoMinFade;
EpromThreeFadeDuration = threeMinFade;
}
if( setting == 6 )
{
EpromOneMax = oneMax;
EpromTwoMax = twoMax;
EpromThreeMax = threeMax;
}
if( setting == 8 )
{
EpromTimeLcd = timeLcd;
}
if( setting == 9 )
{
EpromMaxOpenPlafo = maxOpenPlafo;
}
}
//* mostra su LCD la scritta dati salvati lampeggiante
void print_save_date()
{
for (int i=0; i <= 3; i++){
print_text(0,3,"Dati salvati");
delay(500);
print_text(0,3," ");
delay(500);
}
}
// funzione di lettura delle memorie all'avvio del programma
// chiamata da setup e ad ogni salvataggio dei dati
// alla prima chiamata controlla se le memorie sono fuori range e
// corregge i dati
void set_reset_value()
{
oneMax = EpromOneMax;
twoMax = EpromTwoMax;
threeMax = EpromThreeMax;
max1 = oneMax;
max2 = twoMax;
max3 = threeMax;
oneStartHour = EpromOneStartHour;
oneStartMinute = EpromOneStartMinute;
oneStartSeconds = (long) oneStartHour * 3600 + (long) oneStartMinute* 60;
twoStartHour = EpromTwoStartHour;
twoStartMinute = EpromTwoStartMinute;
twoStartSeconds = (long) twoStartHour * 3600 + (long) twoStartMinute * 60;
threeStartHour = EpromThreeStartHour;
threeStartMinute = EpromThreeStartMinute;
threeStartSeconds = (long) threeStartHour * 3600 + (long) threeStartMinute * 60;
oneStopHour = EpromOneStopHour;
oneStopMinute = EpromOneStopMinute;
onePhotoPeriod = ((long) oneStopHour * 3600 + (long) oneStopMinute * 60) - oneStartSeconds;
twoStopHour = EpromTwoStopHour;
twoStopMinute = EpromTwoStopMinute;
twoPhotoPeriod = ((long)twoStopHour * 3600 + (long)twoStopMinute * 60) - twoStartSeconds;
threeStopHour = EpromThreeStopHour;
threeStopMinute = EpromThreeStopMinute;
threePhotoPeriod = ((long) threeStopHour * 3600 + (long) threeStopMinute * 60) - threeStartSeconds;
oneMinFade = EpromOneFadeDuration;
twoMinFade = EpromTwoFadeDuration;
threeMinFade = EpromThreeFadeDuration;
oneFadeDuration = (long) oneMinFade * 60;
twoFadeDuration = (long) twoMinFade * 60;
threeFadeDuration = (long) threeMinFade * 60;
timeLcd = EpromTimeLcd;
maxOpenPlafo = EpromMaxOpenPlafo;
// analogWrite(ONE_LED, 0);
// analogWrite(TWO_LED, 0);
// analogWrite(THREE_LED, 0);
}
void offPlafo()
{
if (setting != 7){
if(digitalRead(OPEN_PLAFO)== HIGH){
if(on_off_light == true) {
control_light_stop = 1;
analogWrite(ONE_LED, maxOpenPlafo);
analogWrite(TWO_LED, maxOpenPlafo);
analogWrite(THREE_LED, maxOpenPlafo);
}
}
if(digitalRead(OPEN_PLAFO)== LOW) {
control_light_stop = 0;
}
}
}
void goBack()
{
lcd.noBlink();
Root.goBack();
setting = 0;
if(Root.curfuncname == "Root"){
LCD_time_on = true;
}
}
void goEnter()
{
lcd.noBlink();
Root.goEnter();
setting = 0;
control_light_stop = 0;
}
void printStartStopTime(int startHour,
int startMinute,
int stopHour,
int stopMinute
)
{
print_text(0,rowMessage," On: Off:");
if (startHour < 10 && startHour >= 0) {
print_value(4,rowMessage,0);
print_value(5,rowMessage,startHour);
}
else {
print_value(4,rowMessage,startHour);
}
print_text(6,rowMessage,":");
if (startMinute < 10 && startMinute >= 0) {
print_value(7,rowMessage,0);
print_value(8,rowMessage,startMinute);
}
else {
print_value(7,rowMessage,startMinute);
}
if (stopHour < 10 && stopHour >= 0) {
print_text(14,rowMessage," ");
print_value(15,rowMessage,stopHour);
}
else {
print_value(14,rowMessage,stopHour);
}
print_text(16,rowMessage,":");
if (stopMinute < 10 && stopMinute >= 0) {
print_value(17,rowMessage,0);
print_value(18,rowMessage,stopMinute);
}
else {
print_value(17,rowMessage,stopMinute);
}
}
void selectSet(int which) //funzione di selezioni dei vari settaggi alla pressione dei tasti
{
switch (setting) {
case 1:
if(which == _BUTTON_up || which == _BUTTON_down || which == _BUTTON_right){
setDateHour(which);
}
else{
if (cursorPosition == 0){
goEnter();
}
else {
setDateHour(which);
}
}
break;
case 2:
if(which == _BUTTON_up || which == _BUTTON_down || which == _BUTTON_right){
setTimeOne(which);
}
else{
if (cursorPosition == 0){
goEnter();
}
else {
setTimeOne(which);
}
}
break;
case 3:
if(which == _BUTTON_up || which == _BUTTON_down || which == _BUTTON_right){
setTimeTwo(which);
}
else{
if (cursorPosition == 0){
goEnter();
}
else {
setTimeTwo(which);
}
}
break;
case 4:
if(which == _BUTTON_up || which == _BUTTON_down || which == _BUTTON_right){
setTimeThree(which);
}
else{
if (cursorPosition == 0){
goEnter();
}
else {
setTimeThree(which);
}
}
break;
case 5:
if(which == _BUTTON_up || which == _BUTTON_down || which == _BUTTON_right){
setFade(which);
}
else{
if (cursorPosition == 0){
goEnter();
}
else {
setFade(which);
}
}
break;
case 6:
if(which == _BUTTON_up || which == _BUTTON_down || which == _BUTTON_right){
setLux(which);
}
else{
if (cursorPosition == 0){
goEnter();
}
else {
setLux(which);
}
}
break;
case 7:
if(which == _BUTTON_up || which == _BUTTON_down || which == _BUTTON_right){
setManualOn(which);
}
else{
if (cursorPosition == 0){
goEnter();
}
else {
setManualOn(which);
}
}
break;
case 8:
if(which == _BUTTON_up || which == _BUTTON_down || which == _BUTTON_right){
setLcdTime(which);
}
else{
if (cursorPosition == 0){
goEnter();
}
else {
setLcdTime(which);
}
}
break;
case 9:
if(which == _BUTTON_up || which == _BUTTON_down || which == _BUTTON_right){
setLuxOpenPlafo(which);
}
else{
if (cursorPosition == 0){
goEnter();
}
else {
setLuxOpenPlafo(which);
}
}
break;
}
}
void printTemp(int temp)
{
print_text(8,0,"Temp.");
print_value(14, 0, temp);
lcd.write(2);
print_text(17,0,"C");
}
void controlTempLed(byte tempC)
{
if(tempC < firstStepTemp)
{oneMax = max1;
twoMax = max2;
threeMax = max3;
}
else if(tempC >= firstStepTemp && tempC < secondStepTemp)
{oneMax = max1 - (max1/10);
twoMax = max2 - (max2/10);
threeMax = max3 - (max3/10);
}
else if(tempC >= secondStepTemp && tempC < thirdStepTemp)
{oneMax = max1 - (max1/3);
twoMax = max2 - (max2/3);
threeMax = max3 - (max3/3);
}
else if(tempC >= thirdStepTemp)
{oneMax = 0;
twoMax = 0;
threeMax = 0;
}
}
//void barra_up()
//{
// if (millis() - tempo_barra >= quoziente_barra)
// {
// if (stepper_bar == 7)
// {
// ++colonna;
// stepper_bar = 2;
// }
// if (colonna < 20)
// {
// lcd.setCursor(colonna,2);
// ++stepper_bar;
// lcd.write(stepper_bar);
// }
// tempo_barra = millis();
// }
//}
Modalità lineare
