224 réponses à ce sujet

[michel]

bonsoir Sandro,

ça a l'air de fonctionner j'ai même afficher angle au lieu de alfa_1 et pour aujourd'hui cela affiche 160° au lieu de 360X13/29= 161.37931

du coup pour l'affichage j'ai également pris u8g.drawLine(x2,y2, x2+r2*sin(1*angle*2*3.14/360), y2-r2*cos(1*angle*2*3.14/360));

comme cela ça correspond .

pour la library j'ai trouver cela il faut quel prenne en compte stepPin et dirPin

merci encore bonne soirée.

 
#include <AccelStepper.h>
//Define stepper motor connections
#define dirPin 11
#define stepPin 10
//Create stepper object
AccelStepper stepper(8,stepPin,dirPin); //motor interface type must be set to 1 when using a driver

[michel]

bonjour mike118,

je pense que tu m'a oublier concernent le rapport de pignon.

couronne de 140 dents SUR LE TURNTABLE  j'aimerai savoir combien de dents je dois mettre sur le pignon moteur .

1 tour de moteur = 1 tour de plateau .

d'avance merci .

j'aimerai savoir s'il te plait comment je pourrais faire pour influencer une pwm qui incremente une rampe de led par mon programme qui en fonction de la pression ferais baisser la luminosité de la pwm de la rampe .

un peu comme dans la nature les nuages font baisser la luminosité .

j'ai fait un switch case qui en fonction de la pression (#include <Adafruit_BME280.h>)

influence la pwm

j'espére avoir etais assez clair .

merci d'avance merci aussi pour ce forum trop bien .

 
/* Select Icon */
  switch (sel) {
    case 1: // Soleil
    u8g.setFont(u8g_font_04b_03);
    u8g.setPrintPos(25,51);
    if(frame==0)
    u8g.drawXBMP(22, 48,u8g_logo_width, u8g_logo_height, u8g_Sun_1_bits );
    else if (frame == 1)
    u8g.drawXBMP(22, 48,u8g_logo_width, u8g_logo_height,u8g_Sun_2_bits  );
    //u8g.print("Soleil     ");
    //u8g.drawXBMP( 22, 48,u8g_logo_width, u8g_logo_height, u8g_sun_3_bits);
    analogWrite(pwm2,255);// 100%  
      break;
    case 2: // Ensoleillee
    u8g.setFont(u8g_font_04b_03);
    u8g.setPrintPos(25,51);
    //u8g.print("Ensoleillee");
    u8g.drawXBMP( 22, 48,u8g_logo_width, u8g_logo_height, u8g_ensoleillee_bits);
    analogWrite(pwm2,191);// 75%     
      break;
    case 3:// Nuageux
    u8g.setFont(u8g_font_04b_03);
    u8g.setPrintPos(25,51);
    //u8g.print("Nuageux    ");
    u8g.drawXBMP( 22, 48,u8g_logo_width, u8g_logo_height, u8g_nuageux_bits);
    analogWrite(pwm2,128);// 50%    
      break;
    case 4:// Pluie
    u8g.setFont(u8g_font_04b_03);
    u8g.setPrintPos(25,51);
    //u8g.print("Pluie      ");
    u8g.drawXBMP( 22, 48,u8g_logo_width, u8g_logo_height, u8g_pluie_bits);
    analogWrite(pwm2,128);// 50%     
       break;
    case 5:// Tempete
    u8g.setFont(u8g_font_04b_03);
    u8g.setPrintPos(25,51);
    //u8g.print("Orageux    ");
    u8g.drawXBMP( 22, 48,u8g_logo_width, u8g_logo_height, u8g_orageux_bits);
    analogWrite(pwm2,64);// 25%    
     } // .end Switch Select
}

[Sandro]

Bonjour,

couronne de 140 dents SUR LE TURNTABLE  j'aimerai savoir combien de dents je dois mettre sur le pignon moteur .

1 tour de moteur = 1 tour de plateau .

Si tu veux 1 tour du moteur = 1 tour du plateau, alors il te faut le même nombre de dents, donc 140. Du coup, ton pignon occupe exactement tout l'espace à l'intérieur de ta turntable.

Si cette solution ne te plais pas, tu peux très facilement prendre n'importe quel nombre de dents sur le pignon, il suffit ensuite de faire le calcul de l'angle que doit tourner le moteur pour faire tourner la turntable d'un angle donné.

A noter que si tu peux prendre un nombre de dents sur le pignon qui est un diviseur de 140 (ie 1, 2, 4, 5, 7, 10, 14, 20, 28, 35, 70 ou 140), ça aura l'avantage qu'un tour de turntable correspondra a un nombre entier de tours du moteur (ça n'a rien d'indispensable, mais facilite les calculs)

 

Pour la pression, si je comprends bien, tu veux juste une valeur qui baisse en fonction de la pression? (j'ai pas compris ce que tu entends par la rampe de LED : tu parles d'une seule laide ou d'une rangée de LEDs? Dans le second cas, toutes ont la même luminosité? Ou tu veux les éteindre successivement à mesure que la pression baisse?)

 

En tout cas, pour avoir une valeur pwm qui dépend de la pression, tu peux utiliser une formule du type :

pwm = valeur_de_base + coef*(pression - pression_reference)

où pression sera ta pression (par exemple en hPa, et pression_reference la pression pour laquelle tu garde la valeur_de_base (tu peux par exemple prendre pression_reference=1013.25 hPa ou 1000 hPa)
 

 

[michel]

Sandro ,

dans mon programme j'ai deux valeur qui commande la pwm alimenter par un demi pont en h .

une commande  et en digitalwrite qui alimente le pont et celle de la pression en pwm qui alimente la vitesse du pont .

je sais c'est absurde comme commande mais je ne savais pas comment commander la même Pin avec deux commandes .

depuis que tu m'a fait la course du soleil j'aimerai ajuster la pwm comme si il y avais un situation nuageuse avec mon capteur de pression c'est comme une station météo , soleil pwm 255 , nuageux 128 ,etc.......

par contre je ne sais pas comment faire pour mon turnetable en fonction du pignon je vais devoir augmenter les pas du coup tout le code est faux .

MERCI POUR TON AIDE .

[Sandro]

Pour la partie sur le pwm, je suis désolé, mais j'y ai rien compris.

Tu as quoi comme entrées et capteurs : le capteur de pression tout seul ou encore d'autre choses?

Tu as quoi comme sortie? La luminosité d'une LED? La position de la turntable?

Tu veux quoi comme comportement?

 

J'ai l'impression que tu t'imagine un résultat, que tu penses avoir une vague piste pour comment l'obtenir et que tu me décris cette vague piste plutôt que de me décrire le comportement que tu souhaite.

 

 

Pour le turntable, si le pignon a moins de dents que la turntable, il y aura quelques petites modifications à faire, mais rien de bien méchant. Je te propose qu'on attende pour s'occuper de ça que tu ait au moins choisi le pignon (car selon si le nombre de dents du pignon est un diviseur de 140 ou pas, le code sera un peu différent).

 

Bonne soirée

Sandro

 

PS : si à l'occasion tu pourrais faire une liste de quel matériel tu utilise et qu'est ce qui et branché sur quel pin, ça nous permettrait de nous refaire une idée du hardware que tu utilise

[michel]

bonjour Sandro,

je t'ai mis un schéma d'un pont en h .

moi j'ai utilisé le pont en h pour alimenter ma rampe de leds avec ces deux contacts (un digitalWrite pour le Sunset et Sunrise alimentation levée et couché et le deuxiéme contact analogWrite(pwm2,255);qui est relier au capteur de pression qui fait changer  la pwm voir # 142  CODE .

j’espère que je suis plus clair et du coup j'aimerai rajouter sur la course du soleil une fonction qui ajuste la luminosité en fonction de la pression.

incrémentation du soleil de 0 à 255 avec pression max ( beau temps ) et quand mauvais temps" Nuageux" diminuer à 198 .

bonne journée .

[Sandro]

Salut,

Si je comprends bien, tu veux quelque chose qui augmente tout au long de la journée de manière "continue" en fonction de l'heure, mais qui est plus bas selon un switch-case qui dépend de la pression?

 

Si oui, tu pourrais adopter le schéma suivant :

int valeur_max_d_apres_la_pression=0;
// ici ton switch case en fonction de la pression pour te donner la valeur de valeur_max_d_apres_la_pression
int valeur_du_soleil = ... ;// ta valeur d'après le soleil
int pwm = valeur_du_soleil * valeur_max_d_apres_la_pression / 255

 

Une autre variante, si tu veux quelque chose de continu en fonction de la pression :

int ma_pression= ...; //lire le capteur de pression
int heure = now.hour() ;
//int pwm = 256 * pression / pression_max * (heure - sunrise) / (sunset - sunrise) //utiliser la ligne suivante, qui est plus précise
int pwm = 256L * pression * (heure - sunrise) / ( 1L * (sunset - sunrise) * pression_max)

 

[michel]

bonjour Sandro,

je t'ai remis le code que tu m'avais fait pour la course du soleil .

si j'ai bien compris le mieux c'est ta premiere solution .

ajout d'une variable atténuation en valeur de 0 à 255.

incrémentation du soleil et atténuation sans nuageuse 255*255/255 = 255 .

incrémentation du soleil et atténuation nuageuse         255*128/255 = 128.

TimeMins = (now.hour() * 60) + now.minute();
    uint16_t time = now.hour() * 60 + now.minute();
    uint16_t angle =   map(time, Sunrise, Sunset, 0, 180);// Angle
    /*evite de depasser l'angle*/
    if(angle < 0)
      angle = 0;
    else if(angle > 180)
     angle = 180;
    margeAube = (Sunset - Sunrise)/180*6;            //calcul de la durer de uint16_t angle multiplier par 6° angle Aube Civil
    heureMidi = (Sunrise + Sunset)/2;
    margeCrepuscule =(Sunset - Sunrise)/180*6; //calcul de la durer de uint16_t angle multiplier par 6° angle Crepuscule Civil
    
    if(TimeMins < heureMidi ){
    pwm2 = map ( time, Sunrise - margeAube, heureMidi, 0, 255);
    }
    else {
    pwm2 = map ( time, heureMidi, Sunset + margeCrepuscule, 255, 0);
    }
    if(pwm2<0) {
        pwm2=0;
    }
    analogWrite(5,pwm2);// PIN 5 timer 8 bits

 

[michel]

pour le pignon je pense que 35 dents serais pas mal je ne sais pas ce que tu en pense .

140 dents pour la couronne et 35 dents pour le pignon moteur .

pour avoir le nombre de steps correspondant .

140 dents :35 dents = 4 tours de moteur .

degrés de pas du nema 17 =1.8°

degré moteur 1.8°: 4 tour = new angle 0.45°.

changer l'angle dans la variable float stepPerAngle = 1.8; et y mettre 0.45.

tu pourrais me dire si mon calcul est correct .

il me reste à trouver le pignon .

bonne journée .

[Sandro]

Bonjour,

dans ton premier post (#148), c'est exprès que tu ne prends pas en compte la pression?

Sinon, entre les deux propositions que je t'ai fait dans le post #147, il n'y en a pas une qui est "mieux" que l'autre, elles font juste des choses légèrement différentes : le premier code change le PWM que en fonction du "type" de météo (que tu détermine avec le switch case (d'ailleurs, je sais pas comment tu veux faire un switch case sur des valeurs continues, je pense que des if/else if seraient mieux adaptés) ), alors que le second code change le PWM en fonction de la pression (donc toute variation de pression, même petite, changera légèrement le PWM. Du coup, tout dépend du résultat que tu souhaite.

 

Pour ton second post, à première vue ça ne me semble pas aberrant, mais il me faudrait le code complet à jour pour vérifier (il est possible qu'il y ait d'autres endroit ou tu utilise des valeurs liés à l'angle d'un pas).

Pour le nombre de dents du pignon, vu que tu n'as ni de contrainte de couple ni de contraintes de vitesse, n'importe quel nombre de dents convient (les diviseurs de 140 simplifient un peu le code, mais ce n'est pas indispensable). Du coup, si tu trouve un pignon à 35 dents à un prix abordable, alors tu peux l'acheter (je sais pas si 35 est standard, et donc si tu en trouve facilement). Mais si tu en trouve moins cher ou plus facilement avec par exemple 20 dents, c'est tout aussi bien.

Juste une chose à faire attention lorsque tu achète ton pignon : il doit avoir le même module ou le même pas que le turntable (ie les dents doivent avoir la même taille)

 

Bonne journée

Sandro

[michel]

rebonjour,

c'est plus qu'un capteur de pression c'est une petite météo sur algorithme zambretti  , je ne sais pas si tu connais .

et le switch case à deux fonctions .

affiche des petits imoticones (soleil, nuageux ,nuage avec pluie , nuage avec tonnerre )

et la valeur pwm.

si tu a des idées je suis preneur .

déjà je vais gagner des  Pins ,car j'ai la même chose pour la lune .

phase de la lune qui agit sur la pwm et pareil levée et couché de la lune agit sur le digitalwrite .

merci grâce à toi moi code s'améliore de jour en jour .

bonne journée.

[Sandro]

Pour l'algo de météo, je connais pas.

 

Pour tes LEDs, j'ai un peu du mal à comprendre ce que tu fais.

En tout cas, il n'y a aucune raison d'utiliser plus qu'un pin par LED (si tu veux pouvoir varier la luminosité, il faut que ce soit un pin de type PWM (enfin, ça peut se faire avec du soft PWM, mais je le déconseille tant qu'il te reste des pins PWM)). Toute "logique" se gère de nos jours directement depuis le micro-controleur (Arduino), et pas par le hardware extérieur (la seule exception majeure sont des mesures de sécurité, où il n'est pas permises qu'elles ne s'exécutent pas si le programme plante).

Si tu utilise des LED "normales" (ie des LEDs de faible puissance, pas celles qui servent à l'éclairage), alors il est parfaitement inutile d'utiliser un pont en H : il suffit de brancher la LED, en série avec une résistance de 220 à 33 Ohms, sur un pin de l'arduino.

 

Si tu me donnes le code que tu utilise pour l'instant avec le PWM et le digitalwrite, je pourrais t'expliquer comment utiliser seulement un PWM. (en gros, si le enable est à 0, il suffit de mettre une valeur de 0 au PWM)

[michel]

bonsoir Sandro,

j'ai encore un petit soucis j'aimerai faire incrémenter la pin qui commande la lune .

entre rise et set  mais ça ne marche pas .

pourrais tu m'aider s'il te plait d'avance merci

int riseMin=(Rise_time[0]*60)+Rise_time[1];
      int setMin=(Set_time[0]*60)+Set_time[1];
      TimeMins = (now.hour() * 60) + now.minute();
      if(TimeMins>=riseMin&&TimeMins<setMin){  
      pwm1= map ( TimeMins, riseMin ,setMin, 0, 255);
      if(TimeMins>setMin&& TimeMins < riseMin){    
      pwm1 = map ( TimeMins, setMin ,riseMin, 255, 0);
      if(pwm1<0) {
        pwm1=0;
      }
      analogWrite(8,pwm1);
      EEPROM.update(21,pwm1);// info ecran
   }
 
 }

[Sandro]

Bonsoir,

est-ce que tu pourrais s'il te plait m'expliquer quel résultat tu veux obtenir exactement? (et pour info, on ne dit pas incrémenter une pin, on ne peut incrémenter qu'une variable (éventuellement le PWM qui commande la pin) ; de plus incrémenter signifie généralement ajouter 1).

 

Sinon, je te conseille vivement de bien faire attention à l'indentation du code (ie mettre des tabulations pour décaler tout le code contenu dans un bloc (if, for, while, fonction, ...) : ça rend le code beaucoup plus lisible et permet de voir très facilement les erreurs de fin de "if" aux mauvais endroit, comme ça semble être le cas ici.

 

Pour ton code, je vois au moins 2 erreurs :

- le second if est à l'intérieur du premier. Vu les conditions que tu mets pour les 2 premiers "if", le second ne peut pas être exécuté, car il contradit le premier (le premier nécessite TimeMins < setMin, et le deuxième TimeMins > setMin : les deux ne peuvent pas être vrai en même temps)

- la condition du second if est irréalisable : l'heure ne peut pas être à la fois après le coucher du soleil et avant le levé, vu que le levé est avant le coucher (à moins que TimeMins ne soit pas l'heure au sein de la journée mais le temps écoulé depuis une date et heure donnée (par exemple depuis le 1er janvier 1970 à 0h00)).

 

Sans savoir ce que tu veux obtenir, je ne peux que te donner quelques idées générales :

- si tu veux montrer où on est la lune dans sa course (montée en soirée, descente en fin de nuit), alors tu vas devoir introduire l'heure de "minuit" lunaire, et faire 2 cas (avant ou après minuit), plus un troisième pour quand il fait jour.

- si tu mets un second if à l'intérieur d'un premier if, il faut savoir que le contenu du second if ne sera exécuté que si les conditions des 2 if sont vérifiés (du coup, quand elles sont incompatibles, le contenu du second if n'est jamais exécuté

- n'hésite pas à utiliser des else et/ou des else if

- le contraire de A<=B && B<C est A>B || B>=C      ("||" signifie "ou", les barres utilisées se trouvent sur la touche du 6 sur un clavier AZERTY)

 

Bonne soirée

Sandro

PS : si j'ai le temps, je regarderais encore une fois ce soir ou demain matin, ensuite je n'aurais probablement pas l'occasion de répondre pendant une bonne semaine.

[michel]

je voulais juste allumé la led pwm1 ENTRE riseMin et setMin comme tu m'avais fait pour le soleil .

aprés je rajouterai l'atténuation pour la phase de la lune .

bonne soirée

[Sandro]

Du coup, essaye un code du genre :

int max_pwm_lune=255;   //tu peux remplacer 255 par une valeur qui dépend de la phase de la lune
int riseMin=(Rise_time[0]*60)+Rise_time[1];
int setMin=(Set_time[0]*60)+Set_time[1];
TimeMins = (now.hour() * 60) + now.minute();
int minuit_lunaire_Min=(riseMin+setMin)/2;  //nb : tu peux utiliser une autr formule plus "réaliste" si tu connais mieux pour calculer l'heure où la lune est au plus haut dans le ciel).
int pwm1=0;   //par défaut, la led est éteinte (ainsi, pas la peine de mettre explicitement le cas où il fait jour)
if(riseMin<=TimeMins && TimeMins<= minuit_lunaire_Min) {
    pwm1=map(TimeMins, riseMin, minuit_lunaire_Min,0,max_pwm_lune);
}
else if(minuit_lunaire_Min<TimeMins && TimeMins<= setMin) {
    pwm1=map(TimeMins, minuit_lunaire_Min, setMin,max_pwm_lune,0);
}
analogWrite(8,pwm1);

A noter, que j'interprète rise et set comme les heures de levé et de couché de la lune. Si c'est le levé et le couché du jour, alors il faut inverser (on fait alors l'hypothèse simplificatrice que la lune se lève quand le soleil se couche et vice versa).

 

 

A noter que je te déconseille d'utiliser l'EEPROM pour la valeur de pwm1 : en effet, tu vas changer la valeur 2*255=510 fois par jour. Hors, tu peux environ écrire 100 000 fois à un emplacement de l'EEPROM, ce qui correspond à un peu moins de 200 jours, soit un peu plus de 6 mois. Ensuite, cet emplacement dans l'EEPROM sera définitivement détruit.

Comme tu n'as aucun besoin de mémoriser cette valeur en cas de coupure de courant, rien ne justifie d'utiliser l'EEPROM : utilise une variable globale ou passe la valeur via le retour d'une fonction et/ou les paramètres d'une fonction

 

Bonne soirée

Sandro
 

[michel]

bonjour Sandro,

trop bien ton code je vais le tester cette après-midi.

je te joint photo des rampes led que je vais utiliser waterproof (une bleue pour la lune , rouge et blanc spécial croissance plantes et jaune pour simuler le soleil)j’attends la jaune

je t'ai mis également la photo du turnetable  écran et stepper comme tu vois sur la photo le moteur est au même angle que l’écran  .

j'ai commander le pignon sur TRI Distribution .

je te met également le code de algorithmique de la lune en digitalwrite  .

merci encore pour ton aide mon projet prend forme c'est grâce à ton aide .

pour les rampes de leds j'utilise des transistors MOSFET .[attachment=11215:IMG_1685.JPG][attachment=11216:IMG_1684.JPG]

je t'ai mis le code en ino je ne sais pas si c'est  bon .

[attachment=11217:sun_moon_relay_pwm_phase_on_off_test.ino]

j'ai déja fait le code pour l'arrosage avec flow water[attachment=11218:flow water.jpg]

je regle la quantité d'eau que je veux et avec moisture soil détection de l'humidité de la terre reglable également la pompe arrosage par contre j'aurais bien aimer quand tout sera régler que tu jette un coup d’œil j'aimerai avec flow water la possibilité de voir s'il y a de l'eau (si pas d'eau flow water ne tourne pas et coupe la pompe .

j'ai vu ça dans un programme .

bon week-end

[Sandro]

Bonjour

j'ai commander le pignon sur TRI Distribution .

Du coup, combien de dents?
 

je te met également le code de algorithmique de la lune en digitalwrite  .

...

je t'ai mis le code en ino je ne sais pas si c'est  bon .

sun_moon_relay_pwm_phase_on_off_test.ino

Ton code en digitalWrite est faux, pour la même raison qu'une des erreurs du code avec PWM : il n'est pas possible que l'heure soit avant le lever de la lune et simultanément après le coucher de la lune : le second if ne sera donc jamais exécuté.

Nb : je vois que dans le même code, tu utilise aussi des rise et set pour le soleil : du coup renomme explicitement ceux de la lune (moonRiseMin, moonSetMin)

 

Pour le fichier ino, pour des gros codes, ça me vas (ça évite des messages à ralonge sur le forum). Pour des codes courts, mieux vaut les mettre directement sur le forum, ça évite à avoir à télécharger le fichier.

 

 

 

pour les rampes de leds j'utilise des transistors MOSFET .IMG_1685.JPGIMG_1684.JPG

Vu la gueule des rampes de LED, ça doit consommer pas mal. Du coup, la solution directe avec juste une résistance ne marchera pas. Du coup, le MOSFET est probablement la meilleur solution.

 

 

j'ai déja fait le code pour l'arrosage avec flow waterflow water.jpg

je regle la quantité d'eau que je veux et avec moisture soil détection de l'humidité de la terre reglable également la pompe arrosage par contre j'aurais bien aimer quand tout sera régler que tu jette un coup d’œil j'aimerai avec flow water la possibilité de voir s'il y a de l'eau (si pas d'eau flow water ne tourne pas et coupe la pompe .

j'ai vu ça dans un programme .

Pour ça, je vois plusieurs approches possibles:

- si ton waterflow est un capteur de débit (et pas une pompe à débit réglable), alors si tu pompes mais que le débit mesuré est de beaucoup inférieur au débit que tu es sensé avoir, tu sais qu'il n'y a plus d'eau ou que c'est bouché quelque part

- si ta pompe supporte d'être hors de l'eau (pas le cas pour toutes), alors tu peux mesurer le courant de la pompe : s'il n'y a plus d'eau il devrait être plus faible que la normale

- tu peux acheter un capteur de présence d'eau

- tu peux acheter un capteur de pression submersible (attention à la précision) : si la précision est bonne, tu peux savoir exactement combien il te reste d'eau

- tu peux bricoler un capteur de présence d'eau à l'aide de deux électrodes (barres de métal ou de graphite) que tu plonge dans l'eau. Ces deux électrodes formeront une résistance qui dépendra du fait qu'elles soient imergées ou pas (et si tu n'isole pas tout sauf le bout, alors aussi de la profondeur d'immersion). Si tu les mets en série avec une autre résistance, tu forme un diviseur de tension : en mesurant la tension au point milieu tu peux savoir s'il y a de l'eau ou pas, et éventuellement combien (nb : dans ce dernier cas, il faut que l'eau soit toujours la même, car tu sera très dépendant de la tenneur en ions qui conditionne la conductivité)

 

 

Sinon, c'est quoi le rapport entre une station météo et un système d'arrosage automatique (ou c'est 2 projets indépendants?)

Tu comptes faire pousser quoi avec cet éclairage artificiel?

 

Bonne journée

Sandro

 

[michel]

bonjour Mike118,

voila j'ai un soucis avec ce code ?

j'ai ajouté attenuation et au départ cela fonctionne bien en fonction de l'angle la pwm_2 augmente et vers 47° j'ai une valeur  négative - 115 à la pwm_2

margeAube = (Sunset - Sunrise)/180*6;            //calcul de la durer de uint16_t angle multiplier par 6° angle Aube Civil
    heureMidi = (Sunrise + Sunset)/2;
    margeCrepuscule =(Sunset - Sunrise)/180*6; //calcul de la durer de uint16_t angle multiplier par 6° angle Crepuscule Civil
    pwm_2 = (pwm2*valeur_Sun)/255;//atténuation valeur_Sun en fonction d'un switch case #147,#142
    if(TimeMins < heureMidi ){
    pwm2 = map ( time, Sunrise - margeAube, heureMidi, 0, 255);
    
    }
    else {
    pwm2 = map ( time, heureMidi, Sunset + margeCrepuscule, 255, 0);
    
    }
    if(pwm2<0) {
        pwm2=0;
    }
    analogWrite(5,pwm_2);// PIN 5 timer 8 bits
  

[michel]

bonjour Sandro ,

j'ai trouver le code  qui fonctionne bien valeur _Sun provient du switch case de la météo (forescast algo)

comme tu vois sur la photo en fonction de la méteo valeur_Sun change .

/* Select Icon */
      switch (sel) {
    case 1: // Soleil
    valeur_Sun = 255;/*100%*/
      break;
    case 2: // Ensoleillee
    valeur_Sun = 191;/*75%*/     
      break;
    case 3:// Nuageux
    valeur_Sun = 128;/*50%*/    
      break;
    case 4:// Pluie
    valeur_Sun = 128;/*50%*/     
       break;
    case 5:// Tempete
    valeur_Sun = 64;/*25%*/    
     } // .end Switch Select
}

    /* pwm Sunrise/Sunset*/
    if(TimeMins < heureMidi ){
    pwm2 = map ( TimeMins, Sunrise - margeAube, heureMidi, 0, valeur_Sun);
    }
    else {
    pwm2 = map ( TimeMins, heureMidi, Sunset + margeCrepuscule, valeur_Sun, 0);
    }
    if(pwm2<0) {
        pwm2=0;
    }
    analogWrite(5,pwm2);
[attachment=11255:IMG_1688.JPG]