Francenanorecif

Bienvenue, Invité
Nom d'utilisateur : Mot de passe : Se souvenir de moi

SUJET : Librairie éclairage progressif soleil/lune (v1.05)

Re: Librairie éclairage progressif soleil/lune (v1.05) 18 Juil 2013 16:16 #400902

  • cyberwater
  • Portrait de cyberwater
  • Hors Ligne
  • Membre
  • Messages : 984
  • Remerciements reçus 18
la fonction de lissage pour les nuages ne se fait que si le coefMeteo est différent de 1 car le temps max est de 20sec par nuages
sinon mise a jour de l'éclairage toutes les minutes et j'ai supprimé la valeur intermediaire

float AquaLight::LisserRampeLED(int heures,int minutes, float coefMeteo)
{
	float minuteActuelle;
	int      secDelta;
    
	if (_moonmode==0)
		{
		minuteActuelle=heures * 60 + minutes;
		}
	else
		{
		minuteActuelle=GetMinutesDepuisMidi(heures,minutes);
		}
	If(coefMeteo==1)
	{
	//Calcul toutes les minutes des valeurs
        if (minutes!=_led.minuteprec)
        {  
         _led.minuteprec = minutes;
         _led.valeur_actuelle = _led.valeur_suivante;
         _led.valeur_lissee = _led.valeur_actuelle;
         if(millis() < 2000){_led.valeur_actuelle = CalculValeurLED(minuteActuelle);}
         _led.valeur_suivante = CalculValeurLED((minuteActuelle + 1));
    	 _led.pasvaleur = (_led.valeur_suivante - _led.valeur_actuelle);
         _millisPrecedent = millis();
        }
                                                                                                                                                       
		if ((_led.valeur_lissee == 255) && (_pwmmode==PWM10)) // Pour éviter le soucis ˆ 255 
		{                                                                                                                                                           
		 _led.valeur_lissee = 254;                                                                                               
		}   
		_led.valeur_lissee=_led.valeur_lissee;
		analogWrite(_pin, _led.valeur_lissee);                                                                                      
		return _led.valeur_lissee;
	}
	else
	{
		_led.valeur_lissee=_led.valeur_lissee*coefMeteo;
		if ((_led.valeur_lissee == 255) && (_pwmmode==PWM10)) // Pour éviter le soucis ˆ 255 
			{                                                                                                                                                           
			  _led.valeur_lissee = 254;                                                                                               
			}   
		analogWrite(_pin,_led.valeur_lissee);                                                                                      
		return _led.valeur_lissee;
	}
}
L'administrateur a désactivé l'accès en écriture pour le public.

Re: Librairie éclairage progressif soleil/lune (v1.05) 18 Juil 2013 16:19 #400903

  • cyberwater
  • Portrait de cyberwater
  • Hors Ligne
  • Membre
  • Messages : 984
  • Remerciements reçus 18
j'ai fait un objet pour les nuages
je n'ai pas de compliateur donc j'ai pas vérifié si il y a des erreurs
nuage.h :
#ifndef nuage_h
#define nuage_h

#include "Arduino.h"
#include <Time.h>

// Constructeur
class nuage
{
  //MŽthodes publiques
public:
    nuage();
    bool SunOrRain(tmElements_t RTC_datas);
	float CalculCoefNuage();
private:
    int calculate_ydn(tmElements_t RTC_datas)
    void LancerNuage();   
    bool _jourNuageux;
    bool _nuageEnCours;
    bool _nouveauNuage;
    float _dureeDuNuage;
    float _dureeRampeDuNuage;
    long _demarrageNuage;
    long _millisPrecedent;
    float _valeurCoefNuage;
    float _coefMeteo;
}
;

#endif


et nuage.cpp
#include "nuage.h"


nuage::nuage()
{
   _jourNuageux         = 0;
   _nuageEnCours        = 0;
   _nouveauNuage        = 0;
   _dureeDuNuage        = 0;
   _dureeRampeDuNuage   = 0;
   _demarrageNuage      = 0;
   _millisPrecedent     = 0;
   _valeurCoefNuage     = 0.0;
   _coefMeteo           = 1.0;
}
//*******************
bool nuage::SunOrRain(tmElements_t RTC_datas)
{
    float chanceDePluie;
    int DayOfYear;
    
    DayOfYear=calculate_ydn(RTC_datas);

    if (DayOfYear < 183)
    {
      chanceDePluie = 80.0 / (1.0 + exp(-(13.0/250.0)*(91.0 - DayOfYear)))+ 10;      
    }
    else
    {
      chanceDePluie = 80.0/(1.0 + exp((-(13.0/250.0)*(DayOfYear - 271.0))))+10;      
    }
 
    if(chanceDePluie > random(0,100))  
    {
	     _jourNuageux = 1;
         return 1;         
    }
    else
    {
	     _jourNuageux = 0;
         return 0;          
    }
}
//*******************
void nuage::LancerNuage()
{
    if(_jourNuageux && !nuageEnCours)                      // Si c'est un jour nuageux et qu'un nuage n'est pas en train de passer
    {
         if (random(0,1000) > 995)                          //On lance un tirage pour nuage ou pas
         {
             _nuageEnCours = 1;                            //Nouveau nuage 
             _dureeDuNuage =  random(5.0, 20.0) * 1000.0;  //Calcul aléatoire de la duree du nuage
             _dureeRampeDuNuage = _dureeDuNuage * 0.3;      //Calcul du temps de diminution et de remontée
             _demarrageNuage = millis();                   //Point de repère du début du nuage
             _millisPrecedent = _demarrageNuage;
             _valeurCoefNuage = float(random(10,40))/100.0;
         }
    }    
}
//*******************
float nuage::CalculCoefNuage()
{
LancerNuage();
    if(_nuageEnCours)
    {
        if(millis() >= _demarrageNuage && millis() < _demarrageNuage + (_dureeRampeDuNuage))
        {
            _coefMeteo = 1.0 - ((float(millis()-_demarrageNuage)/(_dureeRampeDuNuage))  *  _valeurCoefNuage);   
			return _coefMeteo
        }
        else if(millis() >= (_demarrageNuage + _dureeDuNuage - _dureeRampeDuNuage) && millis() <= _demarrageNuage + (_dureeDuNuage))
        {
            _coefMeteo = (1 - _valeurCoefNuage) + (((float(millis()- (_demarrageNuage + (_dureeDuNuage) - (_dureeRampeDuNuage)))) / (_dureeRampeDuNuage)) * _valeurCoefNuage);
			return _coefMeteo
        }
        else
        {
            _coefMeteo = 1 - _valeurCoefNuage;
			return _coefMeteo
        }
        
        if(millis() > (_demarrageNuage + (_dureeDuNuage))) 
        {
            _coefMeteo = 1.0;
            _nuageEnCours = 0;  
			return _coefMeteo
        }
    }
}
//*******************
int nuage::calculate_ydn(tmElements_t RTC_datas)
{
  uint8_t tmp1; 
  uint16_t tmp2;
  tmp1 = 0;
  if ( RTC_datas.Month >= 3 )
    tmp1++;
  tmp2 = RTC_datas.Month;
  tmp2 +=2;
  tmp2 *=611;
  tmp2 /= 20;
  tmp2 += RTC_datas.Day;
  tmp2 -= 91;
  tmp1 <<=1;
  tmp2 -= tmp1;
  if ( tmp1 != 0 )
    tmp2 += is_leap_year(RTC_datas.Year);
  return tmp2;
}
L'administrateur a désactivé l'accès en écriture pour le public.

Re: Librairie éclairage progressif soleil/lune (v1.05) 20 Juil 2013 21:10 #401101

  • Ghator
  • Portrait de Ghator
  • Hors Ligne
  • Membre
  • Messages : 171
  • Remerciements reçus 4
Petite parenthèse, je vois que tu prévois le code pour du 16 bits également.
Je n'arrive pas à trouver de contrôleur correspondant, l'arduino étant en 8 bits.
Si vous connaissez un contrôleur en 16bits ou une manière d'avoir du vrai 16 bits avec un arduino, je suis preneur.
L'administrateur a désactivé l'accès en écriture pour le public.

Re: Librairie éclairage progressif soleil/lune (v1.05) 21 Juil 2013 18:28 #401130

  • the_ccm
  • Portrait de the_ccm
  • Hors Ligne
  • Administrateur Technique
  • Messages : 1197
  • Remerciements reçus 25
Tu parles de 16 bits pour quelle fonction ?
L'administrateur a désactivé l'accès en écriture pour le public.

Re: Librairie éclairage progressif soleil/lune (v1.05) 21 Juil 2013 20:18 #401135

  • Ghator
  • Portrait de Ghator
  • Hors Ligne
  • Membre
  • Messages : 171
  • Remerciements reçus 4
Pour le PWM.
L'administrateur a désactivé l'accès en écriture pour le public.

Re: Librairie éclairage progressif soleil/lune (v1.05) 22 Juil 2013 05:48 #401153

  • billyboyk
  • Portrait de billyboyk
  • Hors Ligne
  • Chargé de Rédaction
  • Messages : 2257
  • Remerciements reçus 58
On utilise l'Arduino sur 10bits dans ce programme ;)
L'administrateur a désactivé l'accès en écriture pour le public.

Re: Librairie éclairage progressif soleil/lune (v1.05) 22 Juil 2013 08:08 #401164

  • cyberwater
  • Portrait de cyberwater
  • Hors Ligne
  • Membre
  • Messages : 984
  • Remerciements reçus 18
salut
j'ai un probleme avec la librairy Time
je l'ai ajouter dans la bibliotèque mais lorsque je l'insère
ça me met un ligne vide au lieu de
#include <Time.h>

je fais la meme manipulation avec DS1307RTC
et la ligne insèrer est bien #include <DS1307RTC.h>
ps : j'utilise la dernière version 1.0.5
L'administrateur a désactivé l'accès en écriture pour le public.

Re: Librairie éclairage progressif soleil/lune (v1.05) 22 Juil 2013 08:28 #401171

  • cyberwater
  • Portrait de cyberwater
  • Hors Ligne
  • Membre
  • Messages : 984
  • Remerciements reçus 18
c'est bon je l'ai fait a la mano
ça passe bien

j'ai corrigé les érreurs sur la class nuage.h
et modifier aqualight pour qu'elle puisses utiliser nuage
Dernière édition: 22 Juil 2013 08:31 par cyberwater.
L'administrateur a désactivé l'accès en écriture pour le public.

Re: Librairie éclairage progressif soleil/lune (v1.05) 22 Juil 2013 12:02 #401182

  • cyberwater
  • Portrait de cyberwater
  • Hors Ligne
  • Membre
  • Messages : 984
  • Remerciements reçus 18
version corriger et modifier
nuage.h
#ifndef nuage_h
#define nuage_h

#include "Arduino.h"
#include <Time.h>

// Constructeur
class nuage
{
  //M�thodes publiques
public:
    nuage();
    bool SunOrRain(tmElements_t RTC_datas); //ne s'executera automatiquement que UNE fois par jour
    float CalculCoefNuage();                //ne s'executera automatiquement que si c'est une journée de pluie
private:
    int calculate_ydn(tmElements_t RTC_datas);
    uint8_t is_leap_year(uint16_t y);
    void LancerNuage();   
    bool _jourNuageux;
    bool _nuageEnCours;
    bool _nouveauNuage;
    float _dureeDuNuage;
    float _dureeRampeDuNuage;
    long _demarrageNuage;
    long _millisPrecedent;
    uint8_t _jourLastScan;
    float _valeurCoefNuage;
    float _coefMeteo;
}
;

#endif

nuage.cpp
#include "nuage.h"


nuage::nuage()
{
   _jourNuageux         = 0;
   _nuageEnCours        = 0;
   _nouveauNuage        = 0;
   _dureeDuNuage        = 0;
   _dureeRampeDuNuage   = 0;
   _demarrageNuage      = 0;
   _millisPrecedent     = 0;
   _valeurCoefNuage     = 0.0;
   _coefMeteo           = 1.0;
};
//*******************
bool nuage::SunOrRain(tmElements_t RTC_datas)
{
 if ( (RTC_datas.Day !=  _jourLastScan) )
   {
      _jourLastScan = RTC_datas.Day;
      float chanceDePluie;
      int DayOfYear;
    
      DayOfYear=calculate_ydn(RTC_datas);

      if (DayOfYear < 183)
        {
        chanceDePluie = 80.0 / (1.0 + exp(-(13.0/250.0)*(91.0 - DayOfYear)))+ 10;      
        }
      else
        {
        chanceDePluie = 80.0/(1.0 + exp((-(13.0/250.0)*(DayOfYear - 271.0))))+10;      
        }
 
      if(chanceDePluie > random(0,100))  
        {
	_jourNuageux = 1;
        return 1;         
        }
      else
        {
	_jourNuageux = 0;
        return 0;          
        }
   }
};
//*******************
uint8_t nuage::is_leap_year(uint16_t y)
{
   if ( 
          ((y % 4 == 0) && (y % 100 != 0)) || 
          (y % 400 == 0) 
      )
      return 1;
   return 0;
};
//*******************
void nuage::LancerNuage()
{
    if(_jourNuageux && !_nuageEnCours)                      // Si c'est un jour nuageux et qu'un nuage n'est pas en train de passer
    {
         if (random(0,1000) > 995)                          //On lance un tirage pour nuage ou pas
         {
             _nuageEnCours = 1;                            //Nouveau nuage 
             _dureeDuNuage =  random(5.0, 20.0) * 1000.0;  //Calcul al�atoire de la duree du nuage
             _dureeRampeDuNuage = _dureeDuNuage * 0.3;      //Calcul du temps de diminution et de remont�e
             _demarrageNuage = millis();                   //Point de rep�re du d�but du nuage
             _millisPrecedent = _demarrageNuage;
             _valeurCoefNuage = float(random(10,40))/100.0;
         }
    }    
};
//*******************
float nuage::CalculCoefNuage()
{
LancerNuage();
    if(_nuageEnCours)
    {
        if(millis() >= _demarrageNuage && millis() < _demarrageNuage + (_dureeRampeDuNuage))
        {
            _coefMeteo = 1.0 - ((float(millis()-_demarrageNuage)/(_dureeRampeDuNuage))  *  _valeurCoefNuage);   
			return _coefMeteo;
        }
        else if(millis() >= (_demarrageNuage + _dureeDuNuage - _dureeRampeDuNuage) && millis() <= _demarrageNuage + (_dureeDuNuage))
        {
            _coefMeteo = (1 - _valeurCoefNuage) + (((float(millis()- (_demarrageNuage + (_dureeDuNuage) - (_dureeRampeDuNuage)))) / (_dureeRampeDuNuage)) * _valeurCoefNuage);
  	    return _coefMeteo;
        }
        else
        {
            _coefMeteo = 1 - _valeurCoefNuage;
	    return _coefMeteo;
        }
        
        if(millis() > (_demarrageNuage + (_dureeDuNuage))) 
        {
            _coefMeteo = 1.0;
            _nuageEnCours = 0;  
	    return _coefMeteo;
        }
    }
};
//*******************
int nuage::calculate_ydn(tmElements_t RTC_datas)
{
  uint8_t tmp1; 
  uint16_t tmp2;
  tmp1 = 0;
  if ( RTC_datas.Month >= 3 )
    tmp1++;
  tmp2 = RTC_datas.Month;
  tmp2 +=2;
  tmp2 *=611;
  tmp2 /= 20;
  tmp2 += RTC_datas.Day;
  tmp2 -= 91;
  tmp1 <<=1;
  tmp2 -= tmp1;
  if ( tmp1 != 0 )
    tmp2 += is_leap_year(RTC_datas.Year);
  return tmp2;
};
L'administrateur a désactivé l'accès en écriture pour le public.

Re: Librairie éclairage progressif soleil/lune (v1.05) 22 Juil 2013 12:04 #401184

  • cyberwater
  • Portrait de cyberwater
  • Hors Ligne
  • Membre
  • Messages : 984
  • Remerciements reçus 18
aqualight.h
#include <DS1307RTC.h>

#ifndef AquaLight_h
#define AquaLight_h

#include "Arduino.h"
#include <Time.h>

// Constantes Mode 8 ou 10 bits
#define PWM8 0
#define PWM10 1

// La rampe est en mode Lune
#define DAYLIGHTMODE 0
#define MOONMODE 1

// les Nuages sont activ� ou pas
#define NUAGE_ON 1
#define NUAGE_OFF 0

// Strucutre principale pour gestion des valeurs
typedef struct  {
  float duree_totale;
  float duree_rampe;
  float max;
  float zenith;
  float minuteprec;
  int valeur_actuelle;
  int valeur_lissee; 
  float valeur_suivante;
  float pasvaleur;

}   parametres_led;


// Constructeur
class AquaLight
{
  //M�thodes publiques
public:
    AquaLight(int pin);
    AquaLight(int pin,int pwmmode,int moonmode);
    int minutesDepuisMinuit;
    int minutes;
    int LedValue;
   // float LisserRampeLED(float minuteActuelle);
    float LisserRampeLED(int heures,int minutes);
    float LisserRampeLED(int heures,int minutes,float coef);
    void SetParams(int duree_totale,int duree_rampe,int max,int zenith);
    parametres_led GetParams();
    void SetLuneMax(int jourActuel,int moisActuel,int anneeActuel); 
    void SetLuneMax(time_t RTCTime);
  // M�thodes priv�es
private:
   parametres_led _led;
   int _pin;
   int _moonmode;
   int _nuageMode;
   int _pwmmode;

   int _dureeEntreMilieux;
   unsigned long _millisPrecedent;
   float CalculValeurLED(float minuteActuelle);
   float GetMinutesDepuisMidi(int heuresActuelle, int minutesActuelle);
//   int GetMinutesDepuisMidi(int heuresActuelles, int minutesActuelles);

}
;

#endif

aqualight.cpp
/*
 AquaLight.h - Librairie Arduino - Gestion d'un �clairage "Terrestre" en fonction de l'ann�e 
  
 v1.0 Juillet 2012 pour FNR
  
 Code Original par billyboyk (Thread : http://www.francenanorecif.fr/index.php?option=com_kunena&func=view&catid=45&id=322523&Itemid=500069&lang=fr)
 Remerciements � hugonnep (http://www.francenanorecif.fr)  pour les id�es apport�es et � la r�alisation de ce code, Courbes de Gauss, Loi de Nakagami
 Adaptation en Librairie par The_CCM (arduino_dev@slbel.fr)
   
 Cette librairie est libre : vous pouvez la redistribuer ou la modifier selon les termes de la GNU 
 General Public License tels que publi�s par la Free Software Foundation : 
 � votre choix, soit la version 3 de la licence,soit une version ult�rieure quelle qu'elle soit.

 Ce programme est distribu� dans l'espoir qu'il sera utile, mais SANS AUCUNE GARANTIE ; sans m�me la garantie implicite de
 QUALIT� MARCHANDE ou D'AD�QUATION � UNE UTILISATION PARTICULI�RE. 
 Pour plus de d�tails, reportez-vous � la GNU General Public License.

 Vous devez avoir re�u une copie de la GNU General Publi License avec ce programme. Si ce n'est pas le cas, consultez
 <http://www.gnu.org/licenses/>

v1.01 11/10/2012 : patch du bug pour la valeur 255 en mode PWM 10 Bits (reste � trouver pourquoi)
v1.02 29/10/2012 : Correction de la fonction SetLuneMax
v1.03 04/11/2012 : compatibilit� Atmega 168P/328P
v1.04 09/01/2013 : Possibilit� d'appeler SetLuneMax avec une structure "time_t"
		       Renommage dans le fichier exemple

v1.05 07/07/2013 : Ajout de la fonction SunOrRain, qui permet de d�terminer s'il pleut, ou s'il fait beau
		   Correction par Gerdel de FNR de la fonction LisserRampeLed : En phase descendante, pas de lissage dans la m�me minute
*/


/*------------------------------------------------------------
 * 
 * TODO : 
 * Typage des variables (float ....)
 * Compatibilit� IDE Arduino < 1.0
 * Gestion plus propre des heures/minutes
 * Int�grer GetMinutesDepuisMidi
------------------------------------------------------------*/

#include "Arduino.h"
#include "AquaLight.h"


AquaLight::AquaLight(int pin,int pwmmode,int moonmode)
{
  _pin = pin;
 _pwmmode =  pwmmode;
 _millisPrecedent = millis();
 if (moonmode==DAYLIGHTMODE) {_moonmode=0;}
 if (moonmode==MOONMODE) {_moonmode=1;}
 
  pinMode(_pin, OUTPUT);
  
 //Passage des PWM des LED en mode 10 bit
 if (pwmmode==PWM10)
   {
 
#if defined(__AVR_ATmega640__) || defined(__AVR_ATmega1280__) || defined(__AVR_ATmega1281__) || defined(__AVR_ATmega2560__) || defined(__AVR_ATmega2561__)

	 switch (_pin)
	 {
	
	 case 2:
	 case 3:
	 case 5: 
		 TCCR3A |= (1 << WGM30);    //PWM du timer 3 PIN 2,3,5
		 TCCR3A |= (1 << WGM31);    
		 TCCR3B &= ~(1 << WGM33);    
		 TCCR3B |=  (1 << WGM32);  
		 break;
	 case 6:
	 case 7:
	 case 8:
		 TCCR4A |= (1 << WGM40);    //PWM du timer 4   120Hz, PIN 6,7,8 
		 TCCR4A |= (1 << WGM41);    
		 TCCR4B &= ~(1 << WGM43);    
		 TCCR4B |=  (1 << WGM42);
		 break;
	 case 11:
	 case 12:
	 case 13:
		 TCCR1A |= (1 << WGM10);    //PWM du timer 1  PIN 11,12,13 
		 TCCR1A |= (1 << WGM11);    
		 TCCR1B &= ~(1 << WGM13);    
		 TCCR1B |=  (1 << WGM12); 
		 break;
	 }
#elif defined(__AVR_ATmega48__) || defined(__AVR_ATmega88__) || defined(__AVR_ATmega88P__) || defined(__AVR_ATmega168__) || defined(__AVR_ATmega168P__) || defined(__AVR_ATmega328__) || defined(__AVR_ATmega328P__)
switch (_pin)
	 {
	
	 case 9:
	 case 10:
		 TCCR1A |= (1 << WGM10);    //PWM du timer 1  PIN 9 et 10  
		 TCCR1A |= (1 << WGM11);    
		 TCCR1B &= ~(1 << WGM13);    
		 TCCR1B |=  (1 << WGM12); 
		 break;
	 }
#endif
  }	
};

AquaLight::AquaLight(int pin)
{
  pinMode(pin, OUTPUT);
  _pin = pin;
};

parametres_led AquaLight::GetParams()
{
return _led;
};

void AquaLight::SetParams(int duree_totale,int duree_rampe,int max,int zenith)
{
_led.duree_totale=duree_totale;
_led.duree_rampe=duree_rampe;
_led.max=max;
_led.zenith=zenith;
};


void AquaLight::SetLuneMax(int jourActuel, int moisActuel, int anneeActuel)
{   
    int aa,mm;
    long K1,K2,K3,J,V;
    int valeurPWM;

    aa = anneeActuel -((12 - moisActuel) / 10);
    mm = moisActuel + 9;
    if (mm >= 12) mm -= 12;
    K1 = 365.25 * (aa + 4712);
    K2 = 30.6 * mm + .5;
    K3 = int(int((aa/100)+49)*.75)-38;
    
    J = K1 + K2 + jourActuel + 59 - K3;
    
   
    V = (J-2451550.1)/0.29530588853;
    
    V -= int(V/100)*100;
    V = abs(V-50);
    
	
    if (_pwmmode==PWM10)
    {
	    valeurPWM = 4*5.1*abs(50-V); 
	    if (valeurPWM < 40) valeurPWM = 0; //Pour une "vraie" nouvelle lune

    }
    else
    {
	    valeurPWM = 5.1*abs(50-V); 
	    if (valeurPWM < 10) valeurPWM = 0; //Pour une "vraie" nouvelle lune
	    
    }
    
    _led.max=valeurPWM;
  //  return valeurPWM;  
};


void AquaLight::SetLuneMax(time_t RTCTime)
{   

tmElements_t RTCtm;

SetLuneMax(RTCtm.Day,RTCtm.Month,RTCtm.Year);
	
};


float AquaLight::CalculValeurLED(float minuteActuelle)                 
{  
    float valeurLED = -1;
    
    _dureeEntreMilieux = _led.duree_totale - _led.duree_rampe;
    
    
    if (minuteActuelle <= _led.zenith)
    {
        valeurLED = _led.max / ( 1 + exp((-(13/_led.duree_rampe) * (minuteActuelle-(_led.zenith -(_dureeEntreMilieux/2))))));
    }
    if (minuteActuelle > _led.zenith)
    {
        valeurLED = _led.max / ( 1 + exp((-(13/_led.duree_rampe) * (_led.zenith + (_dureeEntreMilieux/2) - minuteActuelle) )));
    }  
 
    return valeurLED;
};


float AquaLight::LisserRampeLED(int heures,int minutes)
{
	float minuteActuelle;
	int      secDelta;
    
	if (_moonmode==0)
		{
		minuteActuelle=heures * 60 + minutes;
		}
	else
		{
		minuteActuelle=GetMinutesDepuisMidi(heures,minutes);
		}
	
	//Calcul toutes les minutes des valeurs
    if (minutes!=_led.minuteprec)
    {  
     _led.minuteprec = minutes;
     _led.valeur_actuelle = _led.valeur_suivante;
     _led.valeur_lissee = _led.valeur_actuelle;
    if(millis() < 2000){_led.valeur_actuelle = CalculValeurLED(minuteActuelle);}
        _led.valeur_suivante = CalculValeurLED((minuteActuelle + 1));
	_led.pasvaleur = (_led.valeur_suivante - _led.valeur_actuelle);
    _millisPrecedent = millis();
    }
    
    if (abs(_led.pasvaleur) > 1) //Calcul de valeurs interm�diaires                                   
    {                                                                                                                                                           
        secDelta = ((millis()-_millisPrecedent)/1000);                                                          
        _led.valeur_lissee = _led.valeur_actuelle + ((_led.pasvaleur * secDelta)/60);    
    }                                                                                                                                                           
    if ((_led.valeur_lissee == 255) && (_pwmmode==PWM10)) // Pour �viter le soucis � 255 
    {                                                                                                                                                           
        _led.valeur_lissee = 254;                                                                                               
    }                                                                                                                                                           
    analogWrite(_pin, _led.valeur_lissee);                                                                                      
    return _led.valeur_lissee;
    
};

float AquaLight::LisserRampeLED(int heures,int minutes, float coefMeteo)
{
	float minuteActuelle;
	int      secDelta;
    
	if (_moonmode==0)
		{
		minuteActuelle=heures * 60 + minutes;
		}
	else
		{
		minuteActuelle=GetMinutesDepuisMidi(heures,minutes);
		}
	if(coefMeteo==1)
	{
	//Calcul toutes les minutes des valeurs
        if (minutes!=_led.minuteprec)
          {  
           _led.minuteprec = minutes;
           _led.valeur_actuelle = _led.valeur_suivante;
           _led.valeur_lissee = _led.valeur_actuelle;
           if(millis() < 2000){_led.valeur_actuelle = CalculValeurLED(minuteActuelle);}
           _led.valeur_suivante = CalculValeurLED((minuteActuelle + 1));
    	   _led.pasvaleur = (_led.valeur_suivante - _led.valeur_actuelle);
           _millisPrecedent = millis();
          }
                                                                                                                                                       
	if ((_led.valeur_lissee == 255) && (_pwmmode==PWM10)) // Pour �viter le soucis � 255 
        		{                                                                                                                                                           
		 _led.valeur_lissee = 254;                                                                                               
		}   
		_led.valeur_lissee=_led.valeur_lissee;
		analogWrite(_pin, _led.valeur_lissee);                                                                                      
		return _led.valeur_lissee;
	}
	else
	{
		_led.valeur_lissee=_led.valeur_lissee*coefMeteo;
		if ((_led.valeur_lissee == 255) && (_pwmmode==PWM10)) // Pour �viter le soucis � 255 
			{                                                                                                                                                           
			  _led.valeur_lissee = 254;                                                                                               
			}   
		analogWrite(_pin, _led.valeur_lissee);                                                                                      
		return _led.valeur_lissee;
	}
};


float AquaLight::GetMinutesDepuisMidi(int heuresActuelle, int minutesActuelle)
{
    int nbMinutes = 0;

    if(heuresActuelle > 11 && heuresActuelle < 24)
    {
        nbMinutes = heuresActuelle * 60 + minutesActuelle - 720;
    }
    else
    {
        nbMinutes = heuresActuelle * 60 + minutesActuelle + 720;
    }

    return nbMinutes;
}
L'administrateur a désactivé l'accès en écriture pour le public.

Re: Librairie éclairage progressif soleil/lune (v1.05) 22 Juil 2013 13:47 #401194

  • cyberwater
  • Portrait de cyberwater
  • Hors Ligne
  • Membre
  • Messages : 984
  • Remerciements reçus 18
petite question
quel est la valeur max pour la lune que vous avez eu?
L'administrateur a désactivé l'accès en écriture pour le public.

Re: Librairie éclairage progressif soleil/lune (v1.05) 22 Juil 2013 15:53 #401213

  • gerdel
  • Portrait de gerdel
  • Hors Ligne
  • Membre
  • Messages : 52
Ouah, à mon retour de vacances, je vois que la bibliothèque évolue et que ça crépite d'idées :cheer: Super.

@Laurent,
EDIT: Attention à l'utilisation de millis() dans la librairie et ailleurs. C'est une valeur qui revient à 0 tous les 50 jours ce qui peut induire un bug. Bon le risque est faible mais bon
->> Pas de soucis si on utilise des variables non signées (unsigned !), même si pour un calcul de temps, on passe par zéro entre temps. ça marche si la variable résultat est également non signée. donc c'est bug free, mais attention quand même au typage des variables. Aucun soucis pour repasser ensuite en non signé (si la différences de temps est < 3 semaines, sinon faut pas utiliser millis() :woohoo: )

EDIT:
@Gathor,
Je n'arrive pas à trouver de contrôleur correspondant, l'arduino étant en 8 bits.
Si vous connaissez un contrôleur en 16bits ou une manière d'avoir du vrai 16 bits avec un arduino, je suis preneur.
J'utilise Aqualight avec Arduino MEGA en PWM 10 bits et un lissage < 5s, les créneaux ne sont perceptibles que pour des variations de luminosité
extrêmement faibles (i.e. passer de 0/1000 à 1/1000 : on voit la luminosité apparaître). Encore faut-il avoir un driver Led suffisamment performant pour gérer l'éclairage avec ce Delta :P (C'est lui qui fera l'orfèvre :whistle: )
Dernière édition: 22 Juil 2013 16:52 par gerdel.
L'administrateur a désactivé l'accès en écriture pour le public.
Modérateurs: unjall, tulottes
Temps de génération de la page : 0.210 secondes

Une bouteille à la mer

billyboyk - 17:19

20 kilos de PV avec du mou, ça tiendra 2 jours dans un bidon brassé/chauffé ;)

billyboyk - 08:22

:D Bonne année à tous !!! xD

habaqouq - 22:06

bonsoir comme insérer une image dans un post merci

delphizorglub - 18:08

Ouaou :p super

babe91800 - 12:18

Bonjour à tous :) petit come back après un moment d'absence

The shoutbox is unavailable to non-members