Cambridge, Royaume-Uni, automne 2012. Dans un petit bureau de la Fondation Raspberry Pi, Eben Upton tient entre ses doigts un rectangle de plastique vert pas plus grand qu’une carte de crédit. Son obsession : donner à chaque enfant du monde un véritable ordinateur, programmable, hackable, à un prix qui ne soit pas un obstacle. Trois ans plus tard, en novembre 2015, la fondation crée la stupéfaction en commercialisant le Raspberry Pi Zero à 5 dollars. Une machine Linux complète, dans un format de 65×30 mm, distribuée gratuitement avec le magazine MagPi. Aujourd’hui en Tunisie, cette même philosophie continue de transformer des projets de PFE, des FabLabs et des startups IoT. Plongeons dans l’univers du plus petit géant de l’informatique embarquée.

Histoire de la Fondation Raspberry Pi : éducation avant tout

Quand Eben Upton et ses collègues du laboratoire informatique de l’Université de Cambridge fondent la Raspberry Pi Foundation en 2008, le constat est inquiétant : le niveau des étudiants en informatique chute, les enfants ne touchent plus à de vraies machines, ils ne font que consommer. Le mantra devient « a computer for kids ». L’objectif n’est pas de vendre du matériel pour faire du chiffre — la Fondation est une organisation caritative — mais de fournir un outil pédagogique abordable, ouvert, hackable.

Le premier Raspberry Pi modèle B sort en février 2012. En 6 ans, plus de 25 millions d’unités sont écoulées. En novembre 2015, la fondation pousse l’idée jusqu’à l’extrême avec le Pi Zero : un SoC BCM2835, 512 Mo de RAM, le tout pour 5$. La machine est tellement demandée qu’elle devient introuvable pendant des mois. Aujourd’hui en Tunisie, le Pi Zero W (avec WiFi/Bluetooth) et le Pi Zero 2 W (quad-core) sont les références pour tout projet IoT à faible coût.

La famille Zero : v1.3 vs Zero W vs Zero 2 W

Avant d’acheter, il faut comprendre les trois versions qui cohabitent. Le tableau ci-dessous compare les caractéristiques clés :

Spécifications comparées

• Pi Zero v1.3 — SoC BCM2835, ARM1176JZF-S mono-cœur à 1 GHz, 512 Mo RAM LPDDR2, pas de WiFi, pas de Bluetooth, mini HDMI, micro USB OTG, connecteur caméra CSI. Idéal pour des projets où la connectique n’est pas critique (data logger SD card, robot autonome).
• Pi Zero W / WH — Même SoC BCM2835, mais on ajoute la puce Cypress CYW43438 qui apporte le WiFi 2.4 GHz et le Bluetooth 4.1. La version WH a les pins GPIO pré-soudés (gain de temps énorme pour prototypage rapide). C’est le modèle le plus polyvalent pour 95% des projets IoT.
• Pi Zero 2 W — Sortie fin 2021. Saut de performance majeur : SoC BCM2710A1 quad-core ARM Cortex-A53 à 1 GHz, soit la même puce que le Pi 3. Toujours 512 Mo de RAM (la limitation principale), mais avec 4× plus de cœurs CPU, on parle de gain réel de 3 à 4× sur les charges parallélisables. WiFi 2.4 GHz + Bluetooth 4.2 inclus.

Lequel choisir ?

Pour un projet web (serveur Flask, dashboard, REST API), le Zero 2 W est obligatoire — le mono-cœur du Zero W étrangle Python sous Flask en quelques requêtes. Pour un data logger lent (lecture I2C toutes les 5 minutes), le Zero W suffit largement. Pour un projet hors ligne sans réseau (capteur GPS, enregistreur SD), le Zero v1.3 économique fait l’affaire.

GPIO 40 pins : compatibilité Pi 3/4 et le piège du 3.3V

Tous les Pi Zero partagent le même connecteur 40 pins GPIO que les Pi 3, Pi 4 et Pi 5. C’est une décision d’ingénierie majeure : un projet conçu sur Pi 4 peut être miniaturisé sur Zero sans réécrire une ligne de code. Le brochage standard inclut :

• 2× UART (TX/RX) pour communiquer avec Arduino, modules GPS ou modems
• 1× SPI principal (MOSI/MISO/SCLK + 2 CE) pour écrans TFT rapides ou ADC MCP3008
• 1× I2C principal (SDA1/SCL1) pour capteurs BME280, OLED, RTC DS3231
• 4× canaux PWM hardware pour moteurs et LED
• 5V (2 pins), 3.3V (2 pins), GND (8 pins)

Installation Raspberry Pi OS et SSH headless

L’installation moderne passe exclusivement par Raspberry Pi Imager (téléchargeable sur raspberrypi.com). C’est l’outil officiel qui a remplacé NOOBS depuis 2020. Voici la procédure complète pour un setup headless (sans écran ni clavier) :

Étapes Raspberry Pi Imager

1. Insérer une carte microSD de 16 Go minimum (classe A1 recommandée — SanDisk Ultra ou Samsung EVO Plus)
2. Lancer Imager, choisir « Raspberry Pi Zero 2 W » (ou la version Zero)
3. OS recommandé : Raspberry Pi OS Lite (64-bit) pour Zero 2 W, 32-bit pour Zero W
4. Cliquer sur l’icône engrenage ⚙ pour ouvrir les options avancées

Configuration avancée à remplir impérativement

# Dans Raspberry Pi Imager > Settings :

Hostname           : pi-zero-iot.local
Enable SSH         : ✓ Use password authentication
Username           : didactico
Password           : un_mot_de_passe_fort_24_caracteres

Configure wireless LAN :
  SSID             : VotreReseauWiFi
  Password         : motdepasseWiFi
  Country          : TN (très important pour les canaux 2.4GHz légaux)

Locale settings    :
  Time zone        : Africa/Tunis
  Keyboard layout  : fr (azerty)

Une fois ces champs validés, écrivez l’image. Insérez la SD dans le Pi Zero, alimentez via micro USB (5V/2A minimum). Au bout de 90 secondes, le Pi rejoint votre WiFi.

Première connexion SSH depuis Windows/Mac/Linux

# Sur votre machine :
ssh didactico@pi-zero-iot.local

# Si .local ne résout pas (Windows ancien sans Bonjour) :
ping pi-zero-iot.local           # Récupérer l'IP
ssh didactico@192.168.1.42       # Connexion directe par IP

# Mise à jour immédiate :
sudo apt update && sudo apt full-upgrade -y
sudo apt install -y python3-pip python3-venv git vim htop
sudo reboot

Projet 1 — Caméra surveillance MotionEyeOS avec Pi Camera v3

Le Pi Zero W + Pi Camera v3 constitue une caméra de surveillance autonome à moins de 80 dinars de matériel. MotionEyeOS est une distribution Linux préconfigurée qui transforme le Pi en NVR (Network Video Recorder) avec détection de mouvement.

Matériel nécessaire

• Pi Zero W ou Zero 2 W (35-55 DT chez Didactico)
• Pi Camera Module v3 ou v2 (90 DT)
• Câble nappe CSI 22 pins (le Zero a un connecteur plus petit que le Pi 4)
• microSD 32 Go classe A1
• Alimentation 5V/2A micro USB
• Boîtier 3D imprimé (Bambu Lab A1 mini ou P1S, PLA noir)

Installation MotionEyeOS

# Sur Raspberry Pi OS Lite déjà installé :
sudo apt install -y motion ffmpeg v4l-utils

# Activer la caméra :
sudo raspi-config
  > Interface Options > Camera > Enable

# Tester :
libcamera-hello --timeout 5000
libcamera-jpeg -o test.jpg

# Configurer motion (édition fichier) :
sudo nano /etc/motion/motion.conf

# Paramètres clés à modifier :
#   daemon on
#   width 1280
#   height 720
#   framerate 15
#   threshold 2000
#   on_event_start /usr/local/bin/notify.sh

sudo systemctl enable motion
sudo systemctl start motion

Détection de mouvement avec masque et webhook Telegram

# /usr/local/bin/notify.sh
#!/bin/bash
# Envoyer une photo Telegram dès qu'un mouvement est détecté
TOKEN="votre_bot_token"
CHAT_ID="votre_chat_id"
IMG=$(ls -t /var/lib/motion/*.jpg | head -1)

curl -s -F chat_id=${CHAT_ID} 
     -F photo=@${IMG} 
     -F caption="🚨 Mouvement détecté $(date '+%H:%M:%S')" 
     https://api.telegram.org/bot${TOKEN}/sendPhoto

Pour éviter les fausses alertes (oiseaux, ombres), MotionEye permet de définir un masque PNG où les zones noires ignorent les mouvements. Très utile pour exclure une rue passante ou un arbre qui bouge au vent.

Projet 2 — Station météo BME280 + BH1750 + OLED + Grafana

Voici une station météo complète qui mesure température, humidité, pression barométrique, luminosité, affiche les valeurs sur OLED et envoie tout vers InfluxDB + Grafana pour des courbes magnifiques 24h/7j/30j.

Câblage I2C (4 fils partagés)

Tous les capteurs partagent le bus I2C — c’est la beauté du protocole :

• BME280 (température/humidité/pression) — adresse 0x76
• BH1750 (luminosité en lux) — adresse 0x23
• OLED 0.96″ SSD1306 — adresse 0x3C
• VCC → 3.3V, GND → GND, SDA → GPIO2, SCL → GPIO3

Code Python complet

#!/usr/bin/env python3
"""Station météo Pi Zero — Lecture I2C et push InfluxDB."""
import time
from datetime import datetime
import board
import busio
import adafruit_bme280.advanced as bme280
import adafruit_bh1750
from luma.core.interface.serial import i2c
from luma.oled.device import ssd1306
from luma.core.render import canvas
from influxdb_client import InfluxDBClient, Point
from influxdb_client.client.write_api import SYNCHRONOUS

# Initialisation I2C
i2c_bus = busio.I2C(board.SCL, board.SDA)
bme = bme280.Adafruit_BME280_I2C(i2c_bus, address=0x76)
bh = adafruit_bh1750.BH1750(i2c_bus)
oled = ssd1306(i2c(port=1, address=0x3C))

# Calibration altitude Sfax (3 m)
bme.sea_level_pressure = 1013.25

# InfluxDB cloud ou local
client = InfluxDBClient(
    url="http://localhost:8086",
    token="votre_token",
    org="didactico"
)
write_api = client.write_api(write_options=SYNCHRONOUS)

def mesurer():
    """Retourne un dict avec les 4 valeurs mesurées."""
    return {
        "temperature": bme.temperature,
        "humidite": bme.relative_humidity,
        "pression": bme.pressure,
        "luminosite": bh.lux,
        "ts": datetime.utcnow()
    }

def afficher_oled(data):
    """Dessine les 4 valeurs sur l'écran 128x64."""
    with canvas(oled) as draw:
        draw.text((0, 0),  f"T: {data['temperature']:.1f} C", fill="white")
        draw.text((0, 16), f"H: {data['humidite']:.0f} %",    fill="white")
        draw.text((0, 32), f"P: {data['pression']:.0f} hPa", fill="white")
        draw.text((0, 48), f"L: {data['luminosite']:.0f} lx", fill="white")

def pousser_influx(data):
    """Envoie un Point à InfluxDB."""
    point = (Point("meteo")
             .tag("location", "sfax")
             .field("temperature", data["temperature"])
             .field("humidite", data["humidite"])
             .field("pression", data["pression"])
             .field("luminosite", data["luminosite"])
             .time(data["ts"]))
    write_api.write(bucket="meteo", record=point)

if __name__ == "__main__":
    while True:
        try:
            d = mesurer()
            afficher_oled(d)
            pousser_influx(d)
            print(f"{d['ts']} | {d['temperature']:.1f}°C | {d['humidite']:.0f}%")
        except Exception as e:
            print(f"Erreur : {e}")
        time.sleep(60)  # mesure toutes les minutes

Dashboard Grafana

Dans Grafana, créez un dashboard avec 4 panneaux (Time series) : Température, Humidité, Pression, Luminosité. La query Flux ressemble à :

from(bucket: "meteo")
  |> range(start: -24h)
  |> filter(fn: (r) => r._measurement == "meteo")
  |> filter(fn: (r) => r._field == "temperature")
  |> aggregateWindow(every: 5m, fn: mean)

Projet 3 — Serveur Flask DHT22 + API REST + Nginx

Transformons le Pi Zero 2 W en mini serveur API qui expose les mesures DHT22 sur HTTP, le tout déployé en production avec gunicorn, nginx en reverse proxy et systemd pour le démarrage automatique.

API Flask

# app.py — API REST minimaliste
import adafruit_dht
import board
from flask import Flask, jsonify
from datetime import datetime

app = Flask(__name__)
dht = adafruit_dht.DHT22(board.D4)

@app.route("/api/v1/health")
def health():
    return jsonify({"status": "ok", "ts": datetime.utcnow().isoformat()})

@app.route("/api/v1/sensor")
def sensor():
    try:
        return jsonify({
            "temperature_c": dht.temperature,
            "humidity_pct": dht.humidity,
            "ts": datetime.utcnow().isoformat()
        })
    except RuntimeError as e:
        # DHT22 échoue parfois — c'est normal, on retry
        return jsonify({"error": str(e)}), 503

if __name__ == "__main__":
    app.run(host="0.0.0.0", port=8000)

Déploiement production avec gunicorn + nginx + systemd

# /etc/systemd/system/dida-sensor.service
[Unit]
Description=Didactico Sensor API
After=network.target

[Service]
User=didactico
WorkingDirectory=/home/didactico/sensor-api
ExecStart=/home/didactico/sensor-api/venv/bin/gunicorn 
          --workers 2 --bind 127.0.0.1:8000 app:app
Restart=always

[Install]
WantedBy=multi-user.target

# /etc/nginx/sites-available/dida-sensor
server {
    listen 80;
    server_name pi-zero-iot.local;

    location / {
        proxy_pass http://127.0.0.1:8000;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
    }
}

# Activation :
sudo systemctl enable --now dida-sensor
sudo ln -s /etc/nginx/sites-available/dida-sensor /etc/nginx/sites-enabled/
sudo nginx -t && sudo systemctl reload nginx

Test depuis n’importe quel client du réseau :

curl http://pi-zero-iot.local/api/v1/sensor
# {"temperature_c":24.7,"humidity_pct":58.0,"ts":"2026-05-15T10:32:11"}

Alimentation, boîtier 3D et performances réelles

Alimentation : le piège qui tue 80% des projets débutants

Le Pi Zero consomme peu (150-300 mA), mais la qualité de l’alimentation est cruciale. Une alim chinoise « 5V/1A » non régulée délivre 4.7V sous charge → l’icône éclair jaune apparaît, la SD card se corrompt, le WiFi se déconnecte aléatoirement.

• Recommandé : alim officielle Raspberry Pi 5V/2.5A ou Anker PowerPort 12W
• USB PD : un chargeur de téléphone moderne fonctionne, mais préférez un câble micro USB court (< 1 m) et gros calibre (24 AWG)
• Pas de PoE sur Pi Zero — pour PoE, il faut un Pi 4 + HAT PoE+

Boîtier 3D imprimé

Pour un boîtier sur mesure, deux options : impression FDM (PLA, PETG) sur Bambu Lab A1 mini ou P1S pour la précision et la rapidité, ou impression résine sur Elegoo Saturn si vous voulez des détails ultra-fins (textes en relief, joints toriques). Les fichiers STL gratuits abondent sur Printables et Thingiverse. Comptez 4-8 g de filament soit moins de 200 millimes de matière.

Performances réelles : Zero W vs Zero 2 W vs Pi 4

• Pi Zero W (BCM2835, mono 1GHz) — Suffisant pour : data logger I2C, GPIO simples, MotionEye SD basse résolution. Insuffisant pour : Flask sous charge, recompilation Python, OpenCV temps réel.
• Pi Zero 2 W (BCM2710A1, quad 1GHz) — Environ 4× plus rapide qu’un Zero W sur charge parallélisable. Tient un Flask + nginx + InfluxDB sans broncher. OpenCV en 640×480 fluide.
• Pi 4 4GB — 8-10× plus rapide encore. Indispensable si : vous faites du traitement vidéo HD, Home Assistant + 30 intégrations, ou un NAS avec disque USB 3.0.

Cas d’usage industriels en Tunisie

Au-delà des projets éducatifs, le Pi Zero trouve sa place dans plusieurs secteurs en Tunisie :

Compteurs d’eau communicants

Plusieurs startups tunisiennes utilisent un Pi Zero W + module LoRa SX1276 + capteur à effet Hall pour transformer des compteurs d’eau classiques en compteurs intelligents. Coût matériel : ~120 DT par point de mesure. Données remontées toutes les 15 minutes via LoRaWAN The Things Network.

Caméras agricoles oliveraies

Dans la région de Sfax (capitale de l’huile d’olive), des oléiculteurs déploient des Pi Zero W + Pi Camera + panneau solaire 10W + batterie LiFePO4 12V pour surveiller les vergers contre le vol et la mouche de l’olive. Le Zero consomme si peu que 5W de solaire suffit en moyenne annuelle.

Kiosques tactiles et signalétique

Pour de l’affichage dynamique en boutique (menu restaurant, vitrine), un Pi Zero 2 W + écran HDMI 7″ + Chromium en kiosk-mode revient à moins de 250 DT vs 800-1500 DT pour une solution Android propriétaire.

Projets étudiants ENIT / INSAT / ISBS / ISET

Le Pi Zero est devenu le standard de facto des PFE (Projets de Fin d’Études) en IoT et systèmes embarqués des écoles tunisiennes. Sur le FabLab Sfax, on croise régulièrement des prototypes de drones, robots, stations environnementales basés sur Zero W et Zero 2 W. Didactico fournit la majorité de ces composants avec livraison 24-48h partout en Tunisie.

FAQ Raspberry Pi Zero

Conclusion

Le Raspberry Pi Zero incarne une vision rare dans la tech : maximiser la valeur éducative au minimum de coût. En Tunisie, il est devenu le compagnon des FabLabs, des PFE étudiants et des startups IoT. Le Zero 2 W avec son quad-core ARM Cortex-A53 et son WiFi intégré offre aujourd’hui un rapport puissance/prix imbattable pour 95% des projets embarqués. Que vous fabriquiez une caméra de surveillance, une station météo connectée ou un serveur Flask domestique, ce petit board délivre Linux complet dans 65×30 mm de PCB.

Pour aller plus loin, consultez notre guide des 5 projets Raspberry Pi pour débutants et passez commande sur didactico.tn pour recevoir votre Pi Zero W ou Zero 2 W en 24-48h partout en Tunisie depuis notre entrepôt de Sfax.