Nom : Schéma rampe mathieu.png Affichages : 3991 Taille : 261,2 Ko

Bonjour,
Voilà mon projet :
Réaliser une simulation de lever/coucher de soleil sur un aquarium eau de mer.

2 canaux d’éclairage :
– 1 gérant les LED bleues
– 1 gérant les LED blanches

Le principe est assez simple, les led bleues s’allument en premier, progressivement sur un délai d’environ 1 heure pour atteindre environ 60% de leur puissance max au zénith, idem pour les led blanches mais en décalage d’1 heure par rapport aux bleues.
La fonction « dimmable » est assurée par des driver MeanWell LDD-1000H reliés aux sorties PWM de l’arduino Nano.
Le soir c’est la même chose mais en sens inverse. (intensité des blanche commence à diminuer en premier puis les bleues).

Voici le code de mon programme

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
 
#include <RTClib.h>
#include <Wire.h>
#include <LiquidCrystal.h>
 
#define DS1307_I2C_ADDRESS 0x68
#define LCD_WIDTH 16
#define LCD_HEIGHT 2
 
#define ARRAYSTEP 15
#define WHITE_LED 11
#define BLUE_LED 10
 
char lcdbuf[LCD_WIDTH];
char lcdbufb[LCD_WIDTH];
 
int DsHour , DsMin , DsSec;
 
//LiquidCrystal lcd(30, 31, 32, 36, 37, 38, 39);
LiquidCrystal lcd(30, 31, 32, 26, 27, 22, 23);
 
RTC_DS1307 rtc;
 
int lcdw, lcdwb;
 
static unsigned long LastTimer ;
 
byte whiteled[96] = {
  0, 0, 0, 0, 0, 0, 0, 0,  //0 - 1h45
  0, 0, 0, 0, 0, 0, 0, 0,  //2 - 3h45
  0, 0, 0, 0, 0, 0, 0, 0,  //4 - 5h45
  0, 0, 0, 0, 0, 0, 0, 0,  //6 - 7h45
  0, 0, 0, 0, 1, 16, 32, 55,  //8 - 9h45
  80, 110, 140, 153, 153, 153, 153, 153,  //10 - 11h45
  153, 153, 153, 153, 153, 153, 153, 153,  //12 - 13h45
  153, 153, 153, 153, 153, 153, 153, 153,  //14 - 15h45
  153, 153, 153, 153, 153, 153, 153, 153,  //16 - 17h45
  153, 153, 153, 153, 153, 153, 153, 140,  //18 - 19h45
  110, 90,  70,  55,  40 ,  20,  10,   8, //20 - 21h45
  6  , 3 ,   3,   1,   1,    1,   0,   0  //22 - 23h45
};
 
byte blueled[96] = {
  0, 0, 0, 0, 0, 0, 0, 0,  //0 - 1h45
  0, 0, 0, 0, 0, 0, 0, 0,  //2 - 3h45
  0, 0, 0, 0, 0, 0, 0, 0,  //4 - 5h45
  0, 0, 0, 0, 0, 0, 0, 0,  //6 - 7h45
  1, 16, 32, 55, 80, 110, 140, 153,  //8 - 9h45
  179, 179, 179, 179, 179, 179, 179, 179,  //10 - 11h45
  179, 179, 179, 179, 179, 179, 179, 179,  //12 - 13h45
  179, 179, 179, 179, 179, 179, 179, 179,  //14 - 15h45
  179, 179, 179, 179, 179, 179, 179, 179,  //16 - 17h45
  179, 179, 179, 179, 179, 179, 153, 140,  //18 - 19h45
  110, 90,  70,  55,  40 ,  20,  10,   8, //20 - 21h45
  6  , 3 ,   3,   1,   1,    1,   0,   0  //22 - 23h45
};
 
void setup(void)
{
 
  pinMode(WHITE_LED, OUTPUT);
  pinMode(BLUE_LED, OUTPUT);
 
  Serial.begin(9600);
  Serial.println("Entrée dans Setup()");
 
  Wire.begin();
  rtc.begin();
 
  lcd.begin(LCD_WIDTH, LCD_HEIGHT, 1);
 
  if (! rtc.isrunning()) {
    Serial.println("Module RTC non initialisé !");
    //Si le DS1307 ne tourne pas (changement de pile et pas d'alim, montage tout neuf, on le règle avec la date/l'heure de la compilation
    rtc.adjust(DateTime(__DATE__, __TIME__));
  }
 
  lcd.clear();
 
  LastTimer  = 0;
 
}
 
// renvoie la valeur intermédiaire
byte average( byte *pt1, byte *pt2, int lstep)
{
 
  byte result;
 
  float fresult;
 
  // Les 2 valeurs des indices sont égales donc on ne change rien
  if (*pt1 == *pt2) {
    result = *pt1; // Pas de changement
  }
 
  // Cas 1 on augmente la luminosité
  else if (*pt1 < *pt2)
    // Calcul de la valeur intermédiaire (cf Tuto)
  { fresult = ((float(*pt2 - *pt1) / 15.0) * float(lstep)) + float(*pt1);
    result = byte(fresult);
  }
  else
    // Cas 2 on diminue la luminosité
  {
    fresult = -((float(*pt1 - *pt2) / 15.0) * float(lstep)) + float(*pt1);
    result = byte(fresult);
  }
 
  return result;
}
 
void SetPWMForLed()
{
 
  int indice, sstep, t1, t2, min_cnt, pwmmod, pwmmodb;
 
  Serial.println("Entrée SetPWMForLed");
 
  min_cnt = (DsHour * 60) + DsMin;
 
  // on calcule l'indice ((heure * 60) + minute) divisé par le pas du tableau
  indice = min_cnt / ARRAYSTEP;
  // Fonction modulo qui donne la partie décimale du calcul ci dessus (donc valeur entre 0 et le pas soit entre 0 et 15)  .
  sstep = min_cnt % ARRAYSTEP;
 
  t1 = indice;
 
  // cas où l'indice est le dernier du tableau, le suivant est donc le premier !
  if (t1 == 95) {
    t2 = 0;
  }
 
  // sinon indice suivant
  else {
    t2 = t1 + 1;
  }
 
  // on est tombé sur un indice entier (multiple de 1/4h), donc on envoie directement la valeur
  if (sstep == 0)
  {
    pwmmod = whiteled[t1];
    pwmmodb = blueled[t1];
  }
  else
  {
    pwmmod = average(&whiteled[t1], &whiteled[t2], sstep);
    pwmmodb = average(&blueled[t1], &blueled[t2], sstep);
  }
 
  Serial.print("pwmmod:");
  Serial.println(pwmmod);
 
  Serial.print("pwmmodb:");
  Serial.println(pwmmodb);
 
  analogWrite(WHITE_LED, pwmmod);
  analogWrite(BLUE_LED, pwmmodb);
  lcdw = pwmmod;
  lcdwb = pwmmodb;
}
 
void GetTimeFromRTC()
{
  DateTime now = rtc.now();
 
  DsHour = now.hour();
  DsMin = now.minute();
  DsSec = now.second();
}
 
void FlushLCD()
{
  lcd.setCursor(0, 1);
 
  // Ex: Blanc : 32%
  sprintf(lcdbuf, "Blanc : %d%%", lcdw * 100 / 255);
  lcd.print(lcdbuf);
 
  lcd.setCursor(0, 0);
 
  sprintf(lcdbuf, "%.2d:%.2d:%.2d", DsHour, DsMin, DsSec);
  lcd.print(lcdbuf);
 
  // BLEU
  sprintf(lcdbufb, "Bleu : %d%%", lcdwb * 100 / 255);
  lcd.print(lcdbufb);
 
  lcd.setCursor(1, 0);
 
  sprintf(lcdbufb, "%.2d:%.2d:%.2d", DsHour, DsMin, DsSec);
  lcd.print(lcdbufb);
 
}
 
void loop(void)
{
 
  GetTimeFromRTC();
 
  if ( (long)( millis() - LastTimer ) >= 0)
  {
    SetPWMForLed();
    LastTimer += 60000;
  }
 
  Serial.print("Heure RTC : ");
  Serial.println(lcdbuf);
  Serial.println(lcdbufb);
 
  FlushLCD();
 
  delay(900);
 
}
La chose qui me pose souci c’est que ce code est fait pour fonctionner avec un écran branché avec les 16 broches alors que j’ai un écran fonctionnant avec le module I²C. Sachant que , tel quel, le programme se compile bien sans erreur.
Est ce qu’en rajoutant simplement la librairie « LiquidCrystal_I2C.h » et en déclarant l’adresse de mon écran (0x3F) ça fonctionnerait où faut-il modifier autre chose dans le programme ?
Voyez-vous des erreurs dans le programme ou sur le schéma ?

P.S. : les numéros de pin des led sont différents sur le schéma et sur le code, je le rectifierai avant de téléverser.

Merci de votre aide.