AcquaPortal Forum Acquario Dolce e Acquario Marino - Aquarduino: libreria "base" gestione plafoniera AGGIORNATA al 19/07/2013

AcquaPortal Forum Acquario Dolce e Acquario Marino (http://www.acquariofilia.biz/forum.php)

- Fai da te marino (http://www.acquariofilia.biz/forumdisplay.php?f=60)

- - Aquarduino: libreria "base" gestione plafoniera AGGIORNATA al 19/07/2013 (http://www.acquariofilia.biz/showthread.php?t=418418)

Aquarduino: libreria "base" gestione plafoniera AGGIORNATA al 19/07/2013

Ricarico il mio progetto con arduino sperando che possa essere di aiuto a chiunque voglia cimentarsi nell'utilizzo di questa scheda.

L'obiettivo è quello di creare un controller, basato su arduino, per automatizzare la gestione del mio futuro acquario.
Al progetto ho voluto dare il nome "Aquarduino".

Per cominciare ho acquistato:
- Arduino Mega 2560 R3 rev3 ATmega2560-16AU USB Board & Free USB Cable
- Breadboard 760 Point Solderless &65pcs Jumper Cable Wire Kit for Arduino/PIC/ARM
- New Arduino I2C RTC DS1307 AT24C32 Real Time Clock Module For AVR ARM PIC
- NEW DIY IR Remote Control Kit For Arduino MCU PIC Infrared
- 1PCS 12864 Blue Backlight 128X64 Dots Graphic Matrix LCD Module Display LCM (controller ST7920)

http://imageshack.us/a/img443/9089/arduinop.png

Ho anche acquistato un adattatore della digole per interfacciare LCD tramite il protocollo seriale I2C ma, purtroppo, non ne ha voluto sapere di funzionare.
Fortunatamente LCD con controller ST7920 supporta il protocollo SPI e me la sono cavata con soli tre pin.

http://imageshack.us/a/img22/7705/lcdricevitorertc.jpg

Display
Protocollo: SPI
Pins: SCK = en = 52, MOSI = RW = 51, CS = RS = di = SS = 53
Backlight: pin 46 (PWM per effetto fade tramite mosfet). L'idea è quella di illuminare lo schermo solo quando sarà rilevato un movimento nella stanza.
Libreria: U8glib

RTC
Protocollo: I2C
Pins: SDA = 20, SCL = 21
Vi segnalo un interessante articolo per gestire le momoria interna del chip DS1307.

Ricevitore telecomando
Pin: 47
Libreria: IRremote

Prossimo passo: costruzione e dimerazione plafoniera a led.
Ho già provato il driver BZ 1000mA Switching che lavora benissimo con l'uscita PWM di arduino.

http://imageshack.us/a/img20/7308/drivereled.png

#28#28#28

Libreria "base" gestione plafoniera aggiornata al 19/07/2013

Ho buttato giù due righe di codice creando la libreria per gestire la plafoniera che sto costruendo.

La libreria fornisce le funzioni "essenziali" che potrete facilmente estendere in base alle vostre necessità.
L'effetto alba e tramonto, qualora sia impostato, viene automaticamente regolato proporzionalmente ai secondi trascorsi in relazione all'ora di accensione e spegnimento del canale.
Per ogni canale basta impostare l'ora di accensione e spegnimento, eventuali minuti iniziali/finali di durata effetto alba/tramonto, il valore massimo pwm e il pin del canale.

Interfaccia (scheda denominata Plafo.h)

codice:

//  Created by Niko Furioso on 15/07/13.



#ifndef __PLAFO_H__

#define __PLAFO_H__



#include <arduino.h>



enum Channels{

  blue=0,

  white=1,

  uv=2,

  moon=3

};

const byte channelsCount=4;



class Plafo {



public:

  //Costruttore

  Plafo();



  void setChannel(const int channel,const byte startHour,const byte startMinute,const byte endHour,const byte endMinute,const unsigned int fadeLen,const byte maxPWM,const byte pin);

  void perform(const byte nowHour,const byte nowMinute,const byte nowSecond);



private:

  void performChannel(void* channel,const byte nowHour,const byte nowMinute,const byte nowSecond);

  unsigned long elapsedTimeToSecond(const byte startHour,const byte startMinute,const byte startSecond,const byte endHour,const byte endMinute,const byte endSecond);



};



#endif

Implementazione (scheda denominata Plafo.cpp)

codice:

//  Created by Niko Furioso on 15/07/13.



#include "Plafo.h"



struct Channel{

  byte startHour,startMinute,maxPWM,lastPWM,pin;

  unsigned long lightLen,fadeLen;

};

Channel *channels[channelsCount];



byte lastSecond;



//Costruttore

Plafo::Plafo(){

  //Creazione canali

  for (byte idx=0;idx<channelsCount;idx++){

    channels[idx]= new Channel();

  }



  lastSecond=60;

}



//Metodi publici

void Plafo::setChannel(const int channel,const byte startHour,const byte startMinute,const byte endHour,const byte endMinute,const unsigned int fadeLen,const byte maxPWM,const byte pin){

  //Configurazione canale

  channels[channel]->startHour=startHour;

  channels[channel]->startMinute=startMinute;

  channels[channel]->lightLen=elapsedTimeToSecond(startHour,startMinute,0,endHour,endMinute,0);

  channels[channel]->fadeLen=(unsigned long)fadeLen*60;

  channels[channel]->maxPWM=maxPWM;

  channels[channel]->pin=pin;



  //Impostazione pin canale in uscita

  pinMode(channels[channel]->pin,OUTPUT);

}



void Plafo::perform(const byte nowHour,const byte nowMinute,const byte nowSecond){ 

  //Aggiornamento stato plafoniera

  if (lastSecond!=nowSecond){

    lastSecond=nowSecond;



    for (byte idx=0;idx<channelsCount;idx++){

      performChannel(channels[idx],nowHour,nowMinute,nowSecond);

    }

  }

}



//Metodi privati

void Plafo::performChannel(void* channel,const byte nowHour,const byte nowMinute,const byte nowSecond){

  Channel *workCnl=(Channel*)channel;



  //In base al valore massimo del canale determina se il pin è pwm o digitale

  boolean isDigitalPin=workCnl->maxPWM==HIGH;



  //Calcolo secondi trascorsi tra l'ora di accensione del canale e l'ora attuale

  unsigned long elapsedSecond=elapsedTimeToSecond(workCnl->startHour,workCnl->startMinute,0,nowHour,nowMinute,nowSecond);



  byte pwmValue=(isDigitalPin) ? LOW : 0;



  //Verifica se il canale è acceso

  if (elapsedSecond<=workCnl->lightLen){

    //Verifica se alba 

    if (elapsedSecond<workCnl->fadeLen){

      //Calcolo valore PWM in relazione ai secondi trascorsi dall'ora di inizio

      pwmValue=(elapsedSecond*workCnl->maxPWM)/workCnl->fadeLen;



    }//Verifica se tramonto

    else if (elapsedSecond>workCnl->lightLen-workCnl->fadeLen){

      //Calcolo valore PWM in relazione ai secondi mancanti all'ora di fine

      pwmValue=((workCnl->lightLen-elapsedSecond)*workCnl->maxPWM)/workCnl->fadeLen;



    }//Luce piena

    else{

      pwmValue=workCnl->maxPWM;

    }

  }



  //Aggiorna lo stato del pin solo se il valore è effettivamente cambiato

  if (workCnl->lastPWM!=pwmValue){

    workCnl->lastPWM=pwmValue;



    if (isDigitalPin){

      digitalWrite(workCnl->pin,pwmValue);

    }

    else{

      analogWrite(workCnl->pin,pwmValue);

    }

  }

}



unsigned long Plafo::elapsedTimeToSecond(const byte startHour,const byte startMinute,const byte startSecond,const byte endHour,const byte endMinute,const byte endSecond){

  //Calcolo secondi tra ora di inizio e ora di fine

  int elapsedHour;

  elapsedHour=endHour-startHour;

  if (elapsedHour<0)elapsedHour=24-startHour+endHour;



  unsigned int elapsedMinute;

  elapsedMinute=(unsigned int)elapsedHour*60 + endMinute-startMinute;



  return (unsigned long)elapsedMinute*60 + endSecond-startSecond;

}

Per utilizzarla non resta che importarla nel vostro progetto, ad esempio:

codice:

#include "Plafo.h"



Plafo plafo;



void setup(void) {

  //Channel,startHour,startMinute,endHour,endMinute,fadeLen,maxPWM,pin

  plafo.setChannel(blue,18,0,4,0,30,180,7);//Dalle 18.00 alle 4.00, alba/tramonto 30 minuti, pwm massimo 180, pin 7  

  plafo.setChannel(white,18,15,3,45,75,180,5);//Dalle 18.15 alle 3.45, alba/tramonto 75 minuti

  plafo.setChannel(uv,19,30,2,30,0,HIGH,22);//Dalle 19.30 alle 2.30, accensione immediata, pin 22 (digitale)

  plafo.setChannel(moon,4,10,7,0,0,HIGH,23);//Dalle 4.10 alle 7.00

}



void loop(void) {

  //Sostituire "hour","minute", "second" con le variabili dichiarate sul vostro progetto, che contengono rispettivamente l'ora, i minuti e i secondi correnti.

  plafo.perform(hour,minute,second);



}

Per modificare, eliminare o aggiugere nuovi canali basta modificare "enum Channels" e la costante "channelsCount" presenti sull'interfaccia.

Spero che questa libreria vi possa essere di aiuto, naturalmente sono ben accetti consigli o segnalazioni di bug.

--------------AGGIORNAMENTI
19/07/2013 - i canali venivano ricreati ogni qualvolta venivano configurati

Complimenti per il progetto Niko....

Niko il codice è fantastico, montato su un arduino uno e finziona una bellezza.
ho messo su un display 20x4 i2c con un I2C RTC DS1307.
riesco a far funzionare l'ora sul display ma non so dove trovare il valore pwm di un determonato pin sul tuo codice. ho visto che sono nelle lib ma non so come portarlo nel void loop().
il mio prossimo passo è installare un rotary per cambiare i valori. ho già messo le variabili al posto dei numeri. comunque grande...

Aggiornata libreria di gestione plafoniera.
Modificata l'implementazione.

Porca pupazza, ho comprato arduino per curiosita ma non ci capisco na mazza porca pupazza, pero sto post mi stuzzica....mo ce provo.......

Quote:

Originariamente inviata da lionfish (Messaggio 1062078915)

Grazie, mi fa piacere che la libreria ti è tornata utile.

Ciò che ti serve è la proprietà "lastPWM" del canale.
Per ottenerla devi esporla tramite una funzione pubblica in lettura da inserire sull'interfaccia ("Plafo.h"). Ad esempio:

codice:

byte lastPWMChannel(const int channel);

Per poi implementarla (su "plafo.cpp"):

codice:

byte Plafo::lastPWMChannel(const int channel){

  return channels[channel]->lastPWM;

}

Per richiamare la funzione dal tuo progetto basterà quindi inserire ad esempio:

codice:

byte pwmValue=plafo.lastPWMChannel(white);

Ciao

codice:

byte lastPWMChannel(const int channel);

Per poi implementarla (su "plafo.cpp"):

codice:

byte Plafo::lastPWMChannel(const int channel){

  return channels[channel]->lastPWM;

}

Per richiamare la funzione dal tuo progetto basterà quindi inserire ad esempio:

codice:

byte pwmValue=plafo.lastPWMChannel(white);

Ciao[/QUOTE]

Niko Grazie, sei un grande veramente.

domani provo i codici e ti faccio sapere.
più che utile! ho sostituito le mie centinaia di righe con le tue semplicissime ( nel numero di righe ) librerie. ieri ho implementato il rotary, un LCD 20x4 con un'interfaccia i2C ed un RTC sempre I2C. risparmiando pin sull'uno. ora implemento il menù ed il primo passo è fatto.
Grazie ancora Niko!!
a disposizione per qualunque cosa ( nel mio piccolo)

Già il fatto che rendi pubblico il tuo progetto di programmazione con arduino TANTO DI CAPPELLO!!! Sarà che personalmente mi sono arenato da diversi mesi con la mia programmazione con arduino.. Che tu sappia questo potrebbe funzionare anche arduino 2009?!? Mi agevolerebbe molto la mia assoluta inesperienza.. Grazie

Ciao, complimenti per il lavoro.
Quali dimmer (marca e modello) utilizzi per pilotare alba e tramonto con il PWM?
grazie ciao