Dispositif IoT intelligent DIY : Construction avec ATmega32U4, ESP8266 et capteurs

Composants et fournitures

Microchip ATmega32U4	×	1
Espressif ESP8266 ESP-12E	×	1
Quartz 16 MHz	×	1
MOSFET canal N de puissance	×	4
Module régulateur de tension Digilent	×	1
Capteur température/humidité DHT11 (4 broches)	×	1
Thermomètre numérique 1-Wire DS18B20 Maxim Integrated	×	1
MikroE Water Detect click	×	1
Écran LCD Arduino	×	1
Photorésistance (LDR)	×	1

Outils et machines nécessaires

• Imprimante 3D (générique)
• Découpeuse laser (générique)

Applications et services en ligne

• Autodesk Fusion 360
• Arduino IDE

À propos du projet

Introduction

J'ai été grandement inspiré par le TED Talk sur l'agriculture numérique de Caleb Harper (directeur de l'Open Agriculture Initiative du MIT) : « This Computer Will Grow Your Food in the Future ». La question clé : Et si nous pouvions cultiver des aliments délicieux et riches en nutriments, en intérieur, n'importe où dans le monde ? L'idée est née !

Mon objectif : une boîte/incubateur créant les conditions climatiques idéales pour la croissance, fournissant exactement la lumière et les nutriments nécessaires. Un émulateur de lumière solaire, un système d'irrigation et un contrôleur climatique dans un design élégant et moderne.

Technologies prévues :

• Lumière LED de croissance : La chlorophylle répond principalement à 450 nm (bleu) et 650 nm (rouge). Combinaison LED rouge/bleue pour croissance végétative et floraison.
• Atomiseur ultrasons (brouillard) : Irrigation par aéroponie (FogPonics) – brume enrichie en engrais.
• Dosage automatique des nutriments : Apport précis au moment optimal.
• Système de détection d'eau : Capteurs pH et TDS (solides dissous totaux) pour pH équilibré et alertes de dosage.
• Système d'échange d'eau : Raccordement pour changements d'eau automatiques, pilotage par bouton.
• Contrôle de l'air : Contrôle précis température/humidité (au degré près) via capteur DHT22/DHT11 + ventilateur avec serpentin.
• Application mobile : Infos temps réel (pH, température, humidité, nutriments, ppm), graphiques historiques, partage réseaux sociaux, alertes intelligentes, pilotage des conditions climatiques.

Je ne suis pas le premier sur cette idée, mais la meilleure façon d'avoir une idée créative est d'améliorer les existantes !

Projets similaires sur le marché : avantages individuels mais inconvénients (trop grand, trop petit, trop cher, une seule culture à la fois). Après analyse approfondie, je vise un nouveau système open source avancé, réduisant les défauts et intégrant le meilleur.

Ambitieux ? Tentons le coup !

Expérimentations

Les plantes demandent du temps (semaines à mois). Il faut s'y prendre à l'avance.

Premier test : comparer brume nutritive + LED de croissance vs sol + soleil naturel. Théoriquement supérieur, mais je veux le vérifier.

Expérience en 4 groupes :

• (Sol + Soleil) : conditions naturelles, rebord de fenêtre
• (Brouillard + Soleil) : conteneur avec brume nutritive, même rebord
• (Sol + LED croissance) : sol, lumière artificielle
• (Brouillard + LED croissance) : GROUPE HÉROS – combinaison cible de mon système futur

Graines d'herbes mélangées achetées chez Kaufland (Allemagne).

Première plantation : germination sur papier humide dans boîte plastique fermée (≈100% humidité). 1,5 semaine plus tard : quasi toutes germées !

Sélection des meilleures (tiges épaisses). Repiquage dans pastilles de coco (Amazon) – s'hydratent x6. Boîte à compartiments (2€) pour organisation. Mini-serrière avec couvercle transparent.

Une semaine plus tard : croissance visible !

Apparition des racines → transplantation en billes d'argile et sol, début tests brouillard.

Conception de godets (net cups) pendant la semaine CAO.

Conteneur plastique percé pour les godets.

Système de test assemblé.

Résultats perfectibles : peu de plantes ont survécu en système brouillard. Cause probable : milieu de culture (billes d'argile, sol) pas assez maintenues humides par la brume.

Pause de Pâques

Pendant les vacances, labo fermé, système éteint → toutes plantes mortes.

Nouveau système avec nouveau milieu : Laine de roche (Rock Wool) (IKEA). Nouvelles graines IKEA.

Germination 1 semaine en laine de roche. Un type réussi, l'autre non. Continué avec les réussites.

Nouveau système brouillard avec temps de fonctionnement accru pour tester germination UNIQUEMENT PAR BROUILLARD.

Conception et fabrication électronique

Avant le PCB final, j'ai listé toutes les fonctionnalités et broches nécessaires pour choisir le microcontrôleur.

Choix entre satshakit (Daniele Ingrassia) et FABLEO (Jonathan Grinham).

Satshakit : 100% compatible Arduino IDE, fabricable, open source, version améliorée du Fabkit.

Améliorations principales du satshakit sur Fabkit :

• 16 MHz au lieu de 8 MHz
• Quartz au lieu de résonateur
• Coût réduit (7-9€ vs 13€)
• 100% compatible Arduino IDE par défaut (reconnu comme Arduino UNO)
• ADC6/7 connectés
• Espace plus grand pour soudure aisée

FabLeo a des caractéristiques similaires + USB matériel. Ayant déjà utilisé l'ATmega328p, j'ai voulu tester l'ATmega32u4 (FabLeo) comme base.

Ma « bible » : le brochage ATmega32u4.

Logiciel : EAGLE (Easily Applicable Graphical Layout Editor) – capture schématique, routage PCB, autorouteur, CAM. Populaire chez les makers (licence freeware, bibliothèques riches).

Deux fenêtres simultanées :

• Schéma (.sch) : composants logiques
• Routing (.brd) : PCB physique

Bibliothèque fab.lbr du réseau Fab Lab (mise à jour constante). Installation via menu Library > Use.

Placement composants, puis connexions via outil Net (lignes vertes). Démarrer depuis le trait sur la broche.

Utilisation de Labels pour éviter multiples connexions : clic droit > Name, même nom que la broche MCU → connexion logique.

Schéma final (logique, pas esthétique) :

Connecteurs AVRISP pour programmation.

Circuit USB + quartz :

Régulateur de tension (12V → 5V) :

4 circuits MOSFET : 3 sur entrée 12V, 1 sur régulateur step-up (24V pour atomiseur ultrasons).

Routing PCB

Generate/Switch to Board. Grille 0.01 pour précision.

Routage rapide malgré la complexité. Résultat :

Polygone GND autour des composants (clic droit > Name > GND) : gain de temps, place, effort.

Export PNG 1500 dpi, monochrome, mode fenêtre.

Édition GIMP : sélection rectangulaire, copie, nouveau depuis presse-papiers.

Outside Cut :

PCB double face → deux pièces à coller. Face bottom = miroir horizontal.

Fraisage CNC (Roland via FabModules)

Interface FabModules :

Paramètres : mod_lp.py /dev/usb/lp0 (send command), hostname machine (server). Coordonnées X,Y,Z. zjog toujours à 0. Bouton « move to xyz0 ».

Astuce : Multimètre pour vérifier contact outil/surface. Outil gravure : ≤0,2 mm ; coupe : 1 mm.

Réglages finaux :

Coupe extérieure : même réglages, Z différent (outil 1 mm).

Répétition pour face bottom.

Résultat face Top :

Face Bottom :

Soudure

Vérification multimètre (continuité) après chaque composant.

Erreur : court-circuit (déconnexion Arduino à la mise sous tension VCC/GND). Localisé au microscope (1h) : piste VCC/GND rapprochées.

Correction : grattage au cutter, augmentation isolation.

Régulateur step-up au dos du PCB.

Trous pré-percés pour fixation. Calibrage avant soudure : alimentation 12V fixe, mesure sortie multimètre, ajustage à 24V pour atomiseur.

Carte Wi-Fi (semaine Networking) aussi au dos.

LA BÊTE :

Photo « héroïque » pour ceux qui croient que tout s'est bien passé :

Fichiers à télécharger

• GIY Schematics (.sch)
• GIY Layout (.brd)
• Board#1 Internal Cut (.png)
• Board#1 External Cut (.png)
• Board#2 Internal Cut (.png)
• Board#2 External Cut (.png)

Câblage et programmation embarquée (Périphériques I/O)

Programmation via Arduino IDE. Arduino comme programmeur ISP :

• SCLK → Pin 13
• MOSI → Pin 11
• MISO → Pin 12
• VCC → VCC Arduino
• GND → GND Arduino
• RST → Pin 10

Outils > Carte : Arduino Leonardo. Programmeur : Arduino as ISP. Burn Bootloader → « Done Uploading » !

Test : exemple Blink → ÇA MARCHE !

Capteur DHT11 Température/Humidité

Basique, lent, mais idéal pour data logging hobby. Deux parties : capteur capacitif humidité + thermistance. Puce simple pour conversion analogique/numérique → signal numérique facile à lire.

• Coût ultra faible
• 3-5V alimentation et I/O
• 2,5 mA max pendant conversion
• Précision 5% (20-80% humidité), ±2°C (0-50°C)
• Échantillonnage max 1 Hz
• 4 broches, pas 0,1"

Câblage simple : VCC, GND, broche digitale (ici broche 2 prévue sur PCB).

// DHT11 Temperature and Humidity Sensors Example
#include "DHT.h"
#define DHTPIN 2
#define DHTTYPE DHT11
DHT dht(DHTPIN, DHTTYPE);

void setup() {
  Serial.begin(9600);
  dht.begin();
}

void loop() {
  float h = dht.readHumidity();
  float t = dht.readTemperature();
  Serial.print("Temperature = ");
  Serial.println(t, 2);
  Serial.print("Humidity = ");
  Serial.println(h, 2);
  delay(2000);
}

Résultat moniteur série :

Capteur DS18B20 - Température 1-Wire

Capteur numérique 1-Wire (Maxim IC). Précision 9-12 bits (-55 à +125°C, ±0,5°C). Numéro de série 64 bits unique → nombreux capteurs sur un bus.

Simple : alimentation, masse, 1 broche signal (broche digitale prévue). Résistance pull-up 4,7k entre signal et alimentation (oubliée sur PCB → soudée manuellement sur câbles).

Bibliothèques : OneWire.h, DallasTemperature.h

#include <OneWire.h>
#include <DallasTemperature.h>
#define ONE_WIRE_BUS 3
OneWire oneWire(ONE_WIRE_BUS);
DallasTemperature sensors(&oneWire);

void setup() {
  Serial.begin(9600);
  sensors.begin();
}

void loop() {
  sensors.requestTemperatures();
  Serial.print("Temperature is: ");
  Serial.print(sensors.getTempCByIndex(0));
  delay(1000);
}

Problème : capteur a cessé de fonctionner lors de l'intégration. Faute de temps, remplacement par un DS18B20 du stock FabLab, étanchéifié maison.

Rétractable pour isolation. « Mama ama engineer ! » :D

LDR - Photorésistance

Résistance passive variant selon intensité lumineuse. Obscurité : ~1MΩ ; lumière : quelques kΩ (10-20kΩ @ 10 lux, 2-4kΩ @ 100 lux).

Tension analogique proportionnelle à la lumière → broche analogique Arduino. ADC 10 bits (0-1023). Lumière suffisante → 800-1023.

int sensorPin = A0;
int sensorValue = 0;

void setup() {
  Serial.begin(9600);
}

void loop() {
  sensorValue = analogRead(sensorPin);
  Serial.print("LDR Value = ");
  Serial.print(sensorValue);
  if (sensorValue < 100) Serial.println(" (Dark)");
  else if (sensorValue < 200) Serial.println(" (Dim)");
  else if (sensorValue < 500) Serial.println(" (Light)");
  else if (sensorValue < 800) Serial.println(" (Bright)");
  else Serial.println(" (Very bright)");
  delay(3000);
}

Capteur de niveau d'eau

Besoin d'alarme si réservoir vide. Pas de capteur en stock → fabrication maison avec capteur d'humidité sol (même principe : conductivité électrique).

Calibrage : hors eau = 0, bout immergé = 800. Sketch test :

void setup() { Serial.begin(9600); }
void loop() { Serial.println(analogRead(A4)); delay(100); }

Seuils : EMPTY ! (0), LOW (~800), FULL (>900).

Écran LCD graphique 128×64

LCD classiques = beaucoup de broches. Solution : 3 broches digitales seulement via interface série. Broches prévues sur PCB.

Bibliothèque U8glib. Pins déclarées : U8GLIB_ST7920_128X64 u8g(4, 12, 6, U8G_PIN_NONE)

#include "U8glib.h"
U8GLIB_ST7920_128X64 u8g(4, 12, 6, U8G_PIN_NONE);

void draw(void) {
  u8g.setFont(u8g_font_unifont);
  u8g.setPrintPos(0, 20);
  u8g.print("GIY Project v1.0!");
}

void setup() {
  // u8g.setRot180(); // si inversion nécessaire
}

void loop() {
  u8g.firstPage();
  do { draw(); } while(u8g.nextPage());
  delay(500);
}

Résultat :

Idée : afficher logo FabLab au démarrage. Format .bmp → bitmap.

1. Logo FabLab .png → réduction taille (service en ligne)
2. Conversion .bmp (service en ligne)
3. Outil LCD Assistant : File > Load Image. Vérifier 128x64 px, orientation Horizontal, Little Endian.
4. File > Save output → fichier texte avec tableau HEX.

Capteur pH

Capteur le plus délicat (logo pH sensor v1.1). Documentation rare → description détaillée ici.

Sonde = mini-pile dans le liquide. Selon pH, tension positive/négative de quelques mV. Trop faible + impédance → inutilisable direct avec Arduino. Nécessite un « op amp » (carte fournie) convertissant mV en 0-5V pour Arduino.

3 solutions tampon courantes : pH 4,01 ; 6,86 ; 9,18. Poudre préférable (moins chère, conservation longue, non contaminable). Contenu sachet dans 250ml eau (pH 6-8) → saturation au pH cible. Eau du robinet (pH 7,4) OK. Solutions instables dans le temps (pas de stockage semaines/mois).

Brochage capteur pH v1.1 :

• Pin To : Température (non fonctionnel chez moi)
• Pin Po : Signal analogique entrée
• Pin Do : Seuil Haut/Bas 3,3V ajustable
• Pin G/GND : Masse sonde (utile si masse liquide ≠ masse Arduino)
• Pin G/GND : Masse alimentation (directe carte)
• Pin V+/VCC : Alimentation 5V DC
• Potentiomètre bleu (près BNC) : offset pH
• Potentiomètre bleu (près broches) : réglage seuil

Calibrage offset :

GND (les deux) + VCC sur Arduino GND/5V. Sonde retirée, court-circuit entre trou BNC central et partie externe. Voltmètre (ou Arduino) entre GND et Po. Ajuster pot (près BNC) pour 2,5V sortie. Maintenant pH 7 = 2,5V exact (511 avec analogRead).

Calibrage pas (step) :

Sonde propre dans solution tampon (ex: pH 4,01), stabilisation 1 min (oscillation 3,04-3,05-3,03...). Noter tension (ex: 3,05V).

Calcul :

• PH_step = (voltage@pH7 - voltage@pH4) / (7 - 4) = (2,5 - 3,05) / 2,99 ≈ -0,1839 V/pH
• PH_probe = 7 - ((voltage@pH7 - voltage@sonde) / PH_step)

Code :

int ph_pin = A7;
void setup() { Serial.begin(9600); }
void loop() {
  int measure = analogRead(ph_pin);
  Serial.print("Measure: "); Serial.print(measure);
  double voltage = 5.0 / 1024.0 * measure;
  Serial.print("\tVoltage: "); Serial.print(voltage, 3);
  float Po = 7 + ((2.5 - voltage) / 0.18);
  Serial.print("\tPH: "); Serial.print(Po, 3);
  Serial.println();
  delay(2000);
}

Pas de magie, JUSTE DES MATHS !

Sorties MOSFET :

Bande LED RGB et atomiseur ultrasons sur sorties MOSFET (commandées par broches digitales). LED : digitalWrite(LED, HIGH) dans setup = allumée en permanence. Brouillard : fonction If selon niveau eau. Eau présente = ON, EMPTY = OFF.

Assemblage final : code complet

#include "dht.h"
#include "U8glib.h"
#include <OneWire.h>
#include <DallasTemperature.h>

#define DHT11_PIN 2
#define ONE_WIRE_BUS 3
#define WATER_LEVEL A4
#define LDR_PIN A3
#define PH_PIN A5
#define GROW_LIGHT 10
#define FOG_PUMP 13

int waterLevel, LightLevel, pH;
dht DHT;
OneWire oneWire(ONE_WIRE_BUS);
DallasTemperature waterTemp(&oneWire);
U8GLIB_ST7920_128X64 u8g(4, 12, 6, U8G_PIN_NONE);

const unsigned char logo[] PROGMEM = { /* ... tableau bitmap logo FabLab ... */ };

bool first;
float hum = 0.0;
double T = 0.0;

void dht_test(float *humPerc);

void setup(void) {
  waterTemp.begin();
  pinMode(GROW_LIGHT, OUTPUT);
  pinMode(FOG_PUMP, OUTPUT);
  digitalWrite(GROW_LIGHT, HIGH);
  first = true;
  if (u8g.getMode() == U8G_MODE_R3G3B2) u8g.setColorIndex(255);
  else if (u8g.getMode() == U8G_MODE_GRAY2BIT) u8g.setColorIndex(3);
  else if (u8g.getMode() == U8G_MODE_BW) u8g.setColorIndex(1);
  else if (u8g.getMode() == U8G_MODE_HICOLOR) u8g.setHiColorByRGB(255,255,255);
  u8g.firstPage();
  do { u8g.drawBitmapP(32, 0, 16, 64, logo); } while(u8g.nextPage());
  dht_test(&hum);
}

void RefreshDisplay(float *humPerc, double *T, int *WL, int *LL, int *pH_value) {
  u8g.setFont(u8g_font_fub11);
  u8g.setFontRefHeightExtendedText();
  u8g.setDefaultForegroundColor();
  u8g.setFontPosTop();
  u8g.drawStr(4, 0, "Hum%");
  u8g.setPrintPos(68, 0); u8g.print(*humPerc);
  u8g.drawStr(4, 15, "Temp");
  u8g.setPrintPos(68, 15); u8g.print(*T);
  u8g.drawStr(4, 30, "Wlvl");
  if (*WL == 0) {
    u8g.drawStr(68, 30, "EMPTY!");
    digitalWrite(FOG_PUMP, LOW);
  } else {
    if (*WL < 800) u8g.drawStr(68, 30, "LOW");
    else { digitalWrite(FOG_PUMP, HIGH); u8g.drawStr(68, 30, "HIGH"); }
  }
  if (*LL < 100) u8g.drawStr(68, 45, "Dark");
  else if (*LL < 200) u8g.drawStr(68, 45, "Dim");
  else if (*LL < 500) u8g.drawStr(68, 45, "Light");
  else if (*LL < 800) u8g.drawStr(68, 45, "Bright");
  else u8g.drawStr(68, 45, "2Bright");
  double voltage = 5.0 / 1024.0 * (*pH_value);
  float Po = 7 + ((2.5 - voltage) / 0.18);
  u8g.drawStr(4, 45, "pH");
  u8g.setPrintPos(28, 45); u8g.print(Po);
}

void loop(void) {
  waterTemp.requestTemperatures();
  T = waterTemp.getTempCByIndex(0);
  waterLevel = analogRead(WATER_LEVEL);
  LightLevel = analogRead(LDR_PIN);
  pH = analogRead(PH_PIN);
  int chk = DHT.read11(DHT11_PIN);
  hum = DHT.humidity;
  dht_test(&hum);
  if (first) { first = false; }
  else {
    u8g.firstPage();
    do { RefreshDisplay(&hum, &T, &waterLevel, &LightLevel, &pH); } while(u8g.nextPage());
  }
}

void dht_test(float *humPerc) { delay(1000); }

Fichiers à télécharger

• GIY Final Code (.ino)

Conception 3D et impression 3D

Utilisation intensive de conception/impression 3D. Deux imprimantes, nombreux réglages.

Logiciel CAO : Fusion 360 (mon préféré). Détails sur création formes/extrusion : semaines CAO et Impression 3D/Scan 3D.

Défi : système esthétique (« SEXY !!! ») ET fonctionnel, assemblable, intégrant compétences (impression 3D, fraisage CNC, découpe laser).

Croquis papier initial :

Design 3D final :

Mon système sexy :D

Conteneur d'eau

Fonctionnalités : espace plantes, trou central pour atomiseur ultrasons (niveau eau 2cm au-dessus = zéro gaspillage), passe-câbles capteurs, slot écran graphique façade, poignées pour retrait.

Section électronique avec couvercle, accès programmation/alimentation. Glissières fond pour fixation/retrait facile.

Impression conteneur (BigRep 3D Printer - 1m³)

Trancheur : Simplify3D (avancé, nombreuses options). Pas de « bonne » ou « mauvaise » méthode, juste essais/erreurs.

Réglages conteneur :

Aperçu avant impression :

Buse 205°C, plateau 70°C. Lancement job.

Modèle brut :

Retrait supports = GROSSE GALÈRE :D. Réglages imparfaits (trous près bords). Étanchéification prévue (section Moulage).

Godets (Net Pots)

Amélioration design précédent (semaine CAO) : espaces vides agrandis pour passage brouillard/racines. Congé sup pour transition douce. Bille fond (booléen soustraction) → courbure agréable.

Impression Ultimaker 2+ (PLA) :

Ma petite armée :D

Base du système (BigRep)

Mêmes réglages que conteneur. Aperçu :

Coins arrondis supérieurs (Ultimaker)

Recherche lissage surface maximal :

Fichiers 3D à télécharger

• GIY System Design (.f3d)
• Net Pot Design (.f3d)

Conception 2D et découpe laser

Pièces acryliques pour finition intérieure. Export sketches Fusion 360 en .dxf → édition avant découpe.

Paramétrique = alignement précis, modifiable ultérieurement.

Acrylique vert 5mm (aspect organique, 어울리는 plantes). Façade/arrière blanc (goût personnel).

Façade : trou pour LCD. Arrière : trou accès programmation/alimentation.

Toit : acrylique transparent (passage lumière). Découpes supplémentaires (poids, lumière). Largeur bandes LED mesurée pour fixation optimale (soleil + artificiel).

Découpe laser : Epilog Fusion 60W CO2 (1016×711 mm). Bois, carton, acrylique, plastiques. Même matériau = mêmes réglages.

Fichiers DXF à télécharger

• Façade / Arrière (.dxf)
• Support plantes (.dxf)
• Support LED (.dxf)

Fraisage CNC

Intégration de toutes compétences apprises. Pièce structurelle en contreplaqué 18mm. Export .dxf depuis Fusion 360.

Machine : e(sign Easy Worker MasterPro 2513 (portique CNC). Zone 2600×1400×300 mm, table dépression. Broche HSD 3,9kW 24000 tr/min (métaux possibles).

Édition design avant CAM :

HOME machine. Zéro X,Y ≈ coin plateau. Zéro Z via outil spécial sur plateau.

Gravure (premier job) :

Simulation (Calculate Toolpath) → pas de collision → sauvegarde GCode → lancement.

Coupe extérieure :

Résultat :

Autre pièce : moule pour étanchéification (section Moulage). Bois 10mm, 7 pièces à coller.

Fichiers CNC à télécharger

• Parois structure (.dxf)
• Moule (.dxf)

Moulage et coulée

Technique pour étanchéifier le conteneur d'eau : fine couche (conteneur plus petit) amovible.

Résultat fraisage moule (7 pièces identiques, trous référence, trou central 5 pièces du bas pour pompe à air/retrait facile).

Attente séchage colle → pièce plastique pour pompe (vissage sur moule, retrait aisé).

Moule prêt :

Thermoformage sous vide : Formech (machine manuelle). Problème : impossible de démouler sans casser. Solution : première couche fine, sans la retirer, coulée réelle par-dessus. Première couche glissante + spray silicone = démoulage facile.

Résultat :

Assemblage final

Outils prêts :

Animation assemblage :

Bandes LED RGB découpées (4 morceaux, longueurs mesurées), soudées.

Capteurs connectés, câblage géré, carte fixée dans section électronique.

LE SYSTÈME GIY ! Tout assemblé, système de culture esthétique et fonctionnel.

Photo héroïque en fonctionnement :

Vidéo de présentation finale

© 2017 Albot Dima. Tous droits réservés | Albot.Dumitru@hsrw.org

Licence Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International.

Pour plus de détails sur le projet, visitez la source officielle :

https://archive.fabacademy.org/2017/fablabkamplintfort/students/396/final.html

Code

GIY Board - CODE Arduino

// Code complet GIY (voir version originale pour tableau bitmap logo complet)
#include "dht.h"
#include "U8glib.h"
#include <OneWire.h>
#include <DallasTemperature.h>

#define DHT11_PIN 2
#define ONE_WIRE_BUS 3
#define WATER_LEVEL A4
#define LDR_PIN A3
#define PH_PIN A5
#define GROW_LIGHT 10
#define FOG_PUMP 13

int waterLevel, LightLevel, pH;
dht DHT;
OneWire oneWire(ONE_WIRE_BUS);
DallasTemperature waterTemp(&oneWire);
U8GLIB_ST7920_128X64 u8g(4, 12, 6, U8G_PIN_NONE);

const unsigned char logo[] PROGMEM = { /* ... 1024 octets bitmap ... */ };

bool first;
float hum = 0.0;
double T = 0.0;

void dht_test(float *humPerc);

void setup(void) {
  waterTemp.begin();
  pinMode(GROW_LIGHT, OUTPUT);
  pinMode(FOG_PUMP, OUTPUT);
  digitalWrite(GROW_LIGHT, HIGH);
  first = true;
  if (u8g.getMode() == U8G_MODE_R3G3B2) u8g.setColorIndex(255);
  else if (u8g.getMode() == U8G_MODE_GRAY2BIT) u8g.setColorIndex(3);
  else if (u8g.getMode() == U8G_MODE_BW) u8g.setColorIndex(1);
  else if (u8g.getMode() == U8G_MODE_HICOLOR) u8g.setHiColorByRGB(255,255,255);
  u8g.firstPage();
  do { u8g.drawBitmapP(32, 0, 16, 64, logo); } while(u8g.nextPage());
  dht_test(&hum);
}

void RefreshDisplay(float *humPerc, double *T, int *WL, int *LL, int *pH_value) {
  u8g.setFont(u8g_font_fub11);
  u8g.setFontRefHeightExtendedText();
  u8g.setDefaultForegroundColor();
  u8g.setFontPosTop();
  u8g.drawStr(4, 0, "Hum%");
  u8g.setPrintPos(68, 0); u8g.print(*humPerc);
  u8g.drawStr(4, 15, "Temp");
  u8g.setPrintPos(68, 15); u8g.print(*T);
  u8g.drawStr(4, 30, "Wlvl");
  if (*WL == 0) { u8g.drawStr(68, 30, "EMPTY!"); digitalWrite(FOG_PUMP, LOW); }
  else { if (*WL < 800) u8g.drawStr(68, 30, "LOW"); else { digitalWrite(FOG_PUMP, HIGH); u8g.drawStr(68, 30, "HIGH"); } }
  if (*LL < 100) u8g.drawStr(68, 45, "Dark");
  else if (*LL < 200) u8g.drawStr(68, 45, "Dim");
  else if (*LL < 500) u8g.drawStr(68, 45, "Light");
  else if (*LL < 800) u8g.drawStr(68, 45, "Bright");
  else u8g.drawStr(68, 45, "2Bright");
  double voltage = 5.0 / 1024.0 * (*pH_value);
  float Po = 7 + ((2.5 - voltage) / 0.18);
  u8g.drawStr(4, 45, "pH");
  u8g.setPrintPos(28, 45); u8g.print(Po);
}

void loop(void) {
  waterTemp.requestTemperatures();
  T = waterTemp.getTempCByIndex(0);
  waterLevel = analogRead(WATER_LEVEL);
  LightLevel = analogRead(LDR_PIN);
  pH = analogRead(PH_PIN);
  int chk = DHT.read11(DHT11_PIN);
  hum = DHT.humidity;
  dht_test(&hum);
  if (first) { first = false; }
  else {
    u8g.firstPage();
    do { RefreshDisplay(&hum, &T, &waterLevel, &LightLevel, &pH); } while(u8g.nextPage());
  }
}

void dht_test(float *humPerc) { delay(1000); }

GIY BOARD - LCD + LIGHT CODE Arduino

#include "U8glib.h"
int led = 10;
U8GLIB_ST7920_128X64 u8g(4, 12, 6, U8G_PIN_NONE);

void draw(void) {
  u8g.setFont(u8g_font_unifont);
  u8g.setPrintPos(0, 20);
  u8g.print("GIY Project v1.0!");
}

void setup(void) {
  pinMode(led, OUTPUT);
  digitalWrite(led, HIGH);
}

void loop(void) {
  u8g.firstPage();
  do { draw(); } while(u8g.nextPage());
  delay(500);
}

Schémas