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
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
|
//***************************************************
// VERANDA 2021-11-30 V2
// Carte Arduino Pro ou Pro-mini 3.3v
//***************************************************
#define DEBUG
//#include <Vcc.h>
#include <Adafruit_Sensor.h>
/////// DHT22 //////////////////////////////////////////
#include <DHT.h>
#define brocheDeBranchementDHT 3 // La ligne de communication du DHT22 sera donc branchée sur la pin D3 de l'Arduino
#define typeDeDHT DHT22
DHT dht(brocheDeBranchementDHT, typeDeDHT);
float dhtt,dhth;
unsigned long previousMillis = 0; // stockera la dernière température lue
const long interval = 2000; // intervalle auquel lire le capteur
/////////////////////////////////////////////////////////////////////////
#include <SPI.h> // bibliothèque pour le fonctionnement du bus SPI
#include "nRF24L01.h" // bibliothèque de modules radio
#include "RF24.h" // plus de bibliothèque de modules radio
#include "LowPower.h"
byte address[][6] = {"1Node", "2Node", "3Node", "4Node", "5Node", "6Node"}; //nombre de tuyaux possibles
RF24 radio(9, 10); // "créer" un module sur les broches 9 et 10 pour Mini Pro
//************************************************************************************************
const float VccMin = 3.2; // Niveau minimum attendu de Vcc, en Volts.
const float VccMax = 4.2; // Niveau maximum attendu de Vcc, en Volts.
const float VccCorrection = 0.99; // Vcc mesuré par le multimètre divisé par le Vcc rapporté
const float VccEchelle = VccMax - VccMin; // Vcc mesuré par le multimètre divisé par le Vcc rapporté
//Vcc vcc(VccCorrection);
const byte BROCHE_CAPTEUR_VIN = A0;
const float COEFF_PONT_DIVISEUR_VIN = 4.0;
//*************************************************
int tt ;
int hh ;
int pp ;
String kod="25UTH;"; // Outdoor Temp et Humidite
//--------------------------------------------------
// SETUP
//--------------------------------------------------
void setup()
{
Serial.begin(115200);
//dht.setup(2, DHTesp::DHT22); // Connect DHT sensor to GPIO4 ou D2
dht.begin(); // Connect DHT sensor D3
///////////////////////////////////////////////
radio.begin(); //activer le module
radio.setAutoAck(0); // mode d'accusé de réception, 1 on 0 off
radio.setRetries(0, 15); //(délai entre les tentatives d'accès, nombre de tentatives)
radio.enableAckPayload(); //activation de l'envoi de données en réponse à un signal entrant
radio.setPayloadSize(32); //taille du paquet, en octets
radio.openWritingPipe(address[1]); //nous sommes le tuyau 0, ouvrons le canal pour la transmission de données
radio.setChannel(0x60); //sélectionner le canal (dans lequel il n'y a pas de bruit !)
radio.setPALevel (RF24_PA_MAX); //niveau de puissance de l'émetteur. Sélectionnable RF24_PA_MIN, RF24_PA_LOW, RF24_PA_HIGH, RF24_PA_MAX
radio.setDataRate (RF24_250KBPS); //taux de change. Sélectionnable RF24_2MBPS, RF24_1MBPS, RF24_250KBPS
// doit être le même sur le récepteur et l'émetteur !// doit être le même sur le récepteur et l'émetteur !
//à la vitesse la plus basse ont la sensibilité et la portée les plus élevées ! !!
radio.powerUp(); //démarrer le travail
radio.stopListening(); //pas d'écoute des ondes, nous sommes un émetteur
}
//-----------------------------------------------
// LOOP
//-----------------------------------------------
void loop()
{
do_read_dht();
do_vcc();
for (int i=0; i <= 30; i++)
{
if (i<25)
{
if (tt!=-127)
send_th(kod);
else
send_th("ER_T;");
}
else
send_th("ENDD;");
delay(150);
}
delay(2000);
////// avant de dormir
byte etatSPI = SPCR;
SPCR = 0;
digitalWrite(13,LOW);
////////////////////////////////////////////////
for (int i = 0; i < 5 ; i++) { // 30mn de sommeil //
LowPower.powerDown(SLEEP_8S, ADC_OFF, BOD_OFF);
}
//// on remet l'état
SPCR = etatSPI;
}
//*****************************************
void send_th(String kod)
{
String str=kod+String(tt+200)+";"+String(hh+200)+";"+String(pp+200)+";" ;
byte str_len=str.length()+1;
char buf[str_len];
str.toCharArray(buf,str_len);
radio.write(&buf, sizeof(buf)); // envoyer des données à l'autre Arduino. sizeof(TEST)))-indiquer combien d'octets nous voulons envoyer)(Le récepteur envoie un signal d'accusé de réception de données à l'émetteur (sans changer le mode de fonctionnement).
#ifdef DEBUG
Serial.print("buf=");
Serial.println(buf);
#endif
}
//***********************************************************
void do_read_dht()
{
//float hum = dht.getHumidity();
//float temp= dht.getTemperature();
float hum = dht.readHumidity(); // Lecture du taux d'humidité (en %)
float temp = dht.readTemperature(); // Lecture de la température, exprimée en degrés Celsius
// Vérification si données bien reçues
if (isnan(hum) || isnan(temp)) {
Serial.println("Aucune valeur retournée par le DHT22. Est-il bien branché ?");
delay(2000);
return; // Si aucune valeur n'a été reçue par l'Arduino, on attend 2 secondes, puis on redémarre la fonction loop()
}
float correction = 0 ;
tt=(round(temp)-correction);
hh=round(hum);
// Check if any reads failed and exit early (to try again).
if (isnan(tt) || isnan(hh)) {
Serial.println("Impossible de lire la sonde DHT!");
return;
}
Serial.print("Humidite: ");
Serial.println(hh);
Serial.print("Temperature: ");
Serial.println(tt);
}
//***********************************************************
void do_vcc()
{
/*
float v = vcc.Read_Volts();
Serial.print("VCC = ");
Serial.print(v);
Serial.println(" Volts");
float p = vcc.Read_Perc(VccMin, VccMax);
pp = round(p);
Serial.print("VCC = ");
Serial.print(pp);
Serial.println(" %");
delay(2000);
*/
/* Mesure la tension en RAW et la référence interne à 1.1 volts */
unsigned int raw_vin = analogRead(BROCHE_CAPTEUR_VIN)*VccCorrection;
unsigned int raw_ref = analogReadReference();
/* Calcul de la tension réel avec un produit en croix */
float v = ((raw_vin * 1.1) / raw_ref) * COEFF_PONT_DIVISEUR_VIN;
Serial.print("VCC = ");
Serial.print(v);
Serial.println(" Volts");
float p =((v-VccMin)/(VccEchelle))*100 ;
pp = round(p);
if (pp>100){ // max
pp = 100 ;
} else if (pp<0) {
pp = 0 ;
}
Serial.print("VCC = ");
Serial.print(pp);
Serial.println(" %");
delay(2000);
}
//************************************************************
/** Mesure la référence interne à 1.1 volts */
unsigned int analogReadReference(void) {
/* Elimine toutes charges résiduelles */
#if defined(__AVR_ATmega328P__)
ADMUX = 0x4F;
#elif defined(__AVR_ATmega2560__)
ADCSRB &= ~(1 << MUX5);
ADMUX = 0x5F;
#elif defined(__AVR_ATmega32U4__)
ADCSRB &= ~(1 << MUX5);
ADMUX = 0x5F;
#endif
delayMicroseconds(5);
/* Sélectionne la référence interne à 1.1 volts comme point de mesure, avec comme limite haute VCC */
#if defined(__AVR_ATmega328P__)
ADMUX = 0x4E;
#elif defined(__AVR_ATmega2560__)
ADCSRB &= ~(1 << MUX5);
ADMUX = 0x5E;
#elif defined(__AVR_ATmega32U4__)
ADCSRB &= ~(1 << MUX5);
ADMUX = 0x5E;
#endif
delayMicroseconds(200);
/* Active le convertisseur analogique -> numérique */
ADCSRA |= (1 << ADEN);
/* Lance une conversion analogique -> numérique */
ADCSRA |= (1 << ADSC);
/* Attend la fin de la conversion */
while(ADCSRA & (1 << ADSC));
/* Récupère le résultat de la conversion */
return ADCL | (ADCH << 8);
} |
