u8g.drawStr(0, 40, "L: "); u8g.setPrintPos(15, 40); u8g.print((String) photocellReading);} void setup(void) {
byte BROCHE_CAPTEUR=A1;
/* Initialisation du port série */
Serial.begin(115200);
Serial.println(F("Demo DHT11 et DHT22"));
//float temperature, humidity;
/* Place la broche du capteur en entrée avec pull-up */
pinMode(BROCHE_CAPTEUR, INPUT_PULLUP);
analogWrite(backlight_pin, 50); /* Set the Backlight intensity */
}
void loop(void) {mesurerTemperatureHumidite();
mesurerLumiere();
// picture loop
//appel de foncton
u8g.firstPage();
do {
//draw(temperature, humidity);
draw();
} while( u8g.nextPage() );
/* Pas plus d'une mesure par seconde */
// N.B. Avec le DHT22 il est possible de réaliser deux mesures par seconde
delay(1000);
}
void mesurerLumiere(void) {photocellReading = analogRead(photocellPin);
Serial.print("Analog reading = ");
Serial.print(photocellReading); // the raw analog reading
// We'll have a few threshholds, qualitatively determined
if (photocellReading < 10) {
Serial.println(" - Noir"); Lumiere= "Noir";
} else if (photocellReading < 200) {
Serial.println(" - Sombre"); Lumiere= "Sombre";
} else if (photocellReading < 500) {
Serial.println(" - Lumiere"); Lumiere= "lumiere";
} else if (photocellReading < 800) {
Serial.println(" - Lumineux"); Lumiere= "lumineux";
} else {
Serial.println(" - Tres lumineux"); Lumiere= "tres lumineux";
}
//delay(500);
}
##############fonction qui mesure la réponse du capteur de la température et de l'humidité #########
void mesurerTemperatureHumidite() {
N.B. Remplacer readDHT11 par readDHT22 en fonction du capteur utilisé !
switch (readDHT11(BROCHE_CAPTEUR, &temperature, &humidity)) {
case DHT_SUCCESS:
Serial.print(F(“Humidite (%): ”));
Serial.println(humidity, 2);
Serial.print(F(“Temperature (^C): ”));
Serial.println(temperature, 2);
break;
case DHT_TIMEOUT_ERROR:
Serial.println(F(“Pas de reponse !”));
break;
case DHT_CHECKSUM_ERROR:
Serial.println(F(“Pb de communication !”));
break;
}
N.B. Avec le DHT22 il est possible de réaliser deux mesures par seconde
delay(1000);
}
byte readDHT11(byte pin, float* temperature, float* humidity) {
byte data[5];
byte ret = readDHTxx(pin, data, 18, 1000);
if (ret != DHT_SUCCESS)
return ret;
*humidity = data[0];
*temperature = data[2];
return DHT_SUCCESS;
}
byte readDHT22(byte pin, float* temperature, float* humidity) {
byte data[5];
byte ret = readDHTxx(pin, data, 1, 1000);
if (ret != DHT_SUCCESS)
return ret;
int fh = data[0];
fh *= 256.0;
fh += data[1];
fh *= 0.1;
*humidity = (float) fh * 0.1;
int ft = data[2] & 0x7f;
ft *= 256;
ft += data[3];
ft *= 0.1;
if (data[2] & 0x80) {
ft *= -1;
}
*temperature = (float) ft;
return DHT_SUCCESS;
}
byte readDHTxx(byte pin, byte* data, unsigned long start_time, unsigned long timeout) {
data[0] = data[1] = data[2] = data[3] = data[4] = 0;
start_time est en millisecondes
timeout est en microsecondes
uint8_t bit = digitalPinToBitMask(pin);
uint8_t port = digitalPinToPort(pin);
volatile uint8_t *ddr = portModeRegister(port); Registre MODE (INPUT / OUTPUT)
volatile uint8_t *out = portOutputRegister(port); Registre OUT (écriture)
volatile uint8_t *in = portInputRegister(port); Registre IN (lecture)
unsigned long max_cycles = microsecondsToClockCycles(timeout);
*out |= bit; PULLUP
*ddr &= ~bit; INPUT
delay(100); Laisse le temps à la résistance de pullup de mettre la ligne de données à HIGH
*ddr |= bit; OUTPUT
*out &= ~bit; LOW
delay(start_time); Temps d'attente à LOW causant le réveil du capteur
N.B. Il est impossible d'utilise delayMicroseconds() ici car un délai
de plus de 16 millisecondes ne donne pas un timing assez précis.
noInterrupts();
*out |= bit; PULLUP
delayMicroseconds(40);
*ddr &= ~bit; INPUT
timeout = 0;
while(!(*in & bit)) {
if (++timeout == max_cycles) {
interrupts();
return DHT_TIMEOUT_ERROR;
}
}
timeout = 0;
while(*in & bit) {
if (++timeout == max_cycles) {
interrupts();
return DHT_TIMEOUT_ERROR;
}
}
for (byte i = 0; i < 40; ++i) {
unsigned long cycles_low = 0;
while(!(*in & bit)) {
if (++cycles_low == max_cycles) {
interrupts();
return DHT_TIMEOUT_ERROR;
}
}
unsigned long cycles_high = 0;
while(*in & bit) {
if (++cycles_high == max_cycles) {
interrupts();
return DHT_TIMEOUT_ERROR;
}
}
data[i / 8] «= 1;
if (cycles_high > cycles_low) {
data[i / 8] |= 1;
}
}
interrupts();
byte checksum = (data[0] + data[1] + data[2] + data[3]) & 0xff;
if (data[4] != checksum)
return DHT_CHECKSUM_ERROR;
else
return DHT_SUCCESS;
delay(5000); Delay of 5sec before accessing DHT11 (min - 2sec)
}
</code>
===== 'Pour le circuit avec la sonde PH' ======
'voici les références :'
circuit-phmetre.pdf
les plus intéressantes :
en anglais : http://scidle.com/how-to-use-a-ph-sensor-with-arduino/
en français : https://matdomotique.wordpress.com/2017/07/17/utilisation-dun-module-chinois-de-mesure-de-ph/
https://forum.arduino.cc/index.php?topic=390751.0
'voici le code'
<code>
const int analogInPin = A0;
int sensorValue = 0;
unsigned long int avgValue;
float b;
int buf[10],temp;
void setup() {
Serial.begin(9600);
}
void loop() {
for(int i=0;i<10;i++)
{
buf[i]=analogRead(analogInPin);
Serial.print(buf[i]);
Serial.print('\n');
delay(10);
}
for(int i=0;i<9;i++)
{
for(int j=i+1;j<10;j++)
{
if(buf[i]>buf[j])
{
temp=buf[i];
buf[i]=buf[j];
buf[j]=temp;
}
}
}
avgValue=0;
for(int i=2;i<8;i++)
avgValue+=buf[i];
float pHVol=(float)avgValue*5.0/1024/6;
float phValue = -5.70 * pHVol + 21.34;
Serial.print(“sensor = ”);
Serial.println(phValue);
delay(20);
}
</code>