Raspberry Pi
& IoT

# 1. Flash avec Raspberry Pi Imager
#    → Raspberry Pi OS Lite (sans bureau) pour IoT
#    → Configurer SSH + WiFi dans l'imager

# 2. Connexion SSH (première connexion)
ssh pi@raspberrypi.local
# ou avec IP : ssh pi@192.168.1.xx

# 3. Mise à jour
sudo apt update && sudo apt upgrade -y

# 4. Activer les interfaces (raspi-config)
sudo raspi-config
# → Interface Options → I2C → Enable
# → Interface Options → SPI → Enable
# → Interface Options → Serial Port → Enable

# Environnement virtuel recommandé
python3 -m venv venv
source venv/bin/activate

# GPIO
pip install gpiozero RPi.GPIO

# I2C
pip install smbus2 adafruit-circuitpython-busdevice

# SPI
pip install spidev

# UART / Serial
pip install pyserial

# Capteurs courants (Adafruit)
pip install adafruit-circuitpython-dht   # DHT11/22
pip install adafruit-circuitpython-bmp280 # BMP280
pip install adafruit-circuitpython-mcp3xxx # MCP3008

# Vérifier I2C
sudo i2cdetect -y 1

from gpiozero import LED, Button
from signal import pause

led    = LED(17)     # GPIO17 = broche 11
bouton = Button(2)  # GPIO2 = broche 3

# Allumer / éteindre
led.on()
led.off()
led.toggle()
led.blink(on_time=0.5, off_time=0.5)

# Réagir au bouton
bouton.when_pressed  = led.on
bouton.when_released = led.off

pause()  # attendre les événements

from gpiozero import PWMLED, DistanceSensor, MCP3008

# LED gradable (PWM)
led_pwm = PWMLED(18)
led_pwm.value = 0.5   # 50% intensité

# Capteur ultrasonique HC-SR04
capteur = DistanceSensor(echo=24, trigger=23)
print(f"Distance: {capteur.distance * 100:.1f} cm")

# ADC MCP3008 (via SPI)
adc = MCP3008(channel=0)
print(f"Tension: {adc.value * 3.3:.2f} V")

import RPi.GPIO as GPIO
import time

GPIO.setmode(GPIO.BCM)          # numérotation BCM
GPIO.setup(17, GPIO.OUT)        # sortie
GPIO.setup(27, GPIO.IN, pull_up_down=GPIO.PUD_UP) # entrée

try:
    while True:
        GPIO.output(17, GPIO.HIGH)
        time.sleep(0.5)
        GPIO.output(17, GPIO.LOW)
        time.sleep(0.5)
finally:
    GPIO.cleanup()  # TOUJOURS appeler cleanup

import smbus2
import bmp280

bus = smbus2.SMBus(1)        # bus I2C 1
capteur = bmp280.BMP280(i2c_dev=bus)

# Lecture
temp   = capteur.get_temperature()  # °C
pression = capteur.get_pressure()   # hPa
print(f"Temp: {temp:.1f}°C  Pression: {pression:.1f} hPa")

import smbus2

bus = smbus2.SMBus(1)
ADDR = 0x76  # adresse BMP280

# Lire 1 octet depuis le registre 0xD0 (chip_id)
chip_id = bus.read_byte_data(ADDR, 0xD0)
print(f"Chip ID: {chip_id:#04x}")  # 0x60 = BMP280

# Lire 2 octets depuis registre
data = bus.read_i2c_block_data(ADDR, 0xF7, 3)
print(data)  # [msb, lsb, xlsb]

import spidev

spi = spidev.SpiDev()
spi.open(0, 0)           # bus 0, CE0
spi.max_speed_hz = 1350000

def lire_canal(canal: int) -> float:
    """Lit un canal ADC, retourne 0.0–1.0"""
    assert 0 <= canal <= 7
    r = spi.xfer2([1, (8 + canal) << 4, 0])
    valeur = ((r[1] & 3) << 8) + r[2]
    return valeur / 1023.0

# Lire potentiomètre sur canal 0
tension = lire_canal(0) * 3.3
print(f"Tension: {tension:.2f} V")

spi.close()

import serial
import time

# Port UART du RPi
port = serial.Serial(
    port='/dev/ttyS0',   # ou /dev/ttyAMA0
    baudrate=9600,
    timeout=1.0
)

# Envoyer des données
port.write(b'Hello Arduino\r\n')

# Lire une ligne
ligne = port.readline().decode('utf-8').strip()
print(f"Reçu: {ligne}")

# Lire en continu
while True:
    if port.in_waiting > 0:
        data = port.readline().decode().strip()
        print(f"GPS: {data}")
    time.sleep(0.1)

port.close()

# capteurs/dht22.py — couche d'abstraction
class DHT22Sensor:
    def __init__(self, pin: int):
        import adafruit_dht, board
        self._dev = adafruit_dht.DHT22(
            getattr(board, f'D{pin}')
        )

    def read(self) -> dict:
        return {
            'temperature': self._dev.temperature,
            'humidity':    self._dev.humidity,
        }

# app.py — logique métier (testable)
class WeatherStation:
    def __init__(self, sensor):
        self.sensor = sensor   # injection dépendance

    def get_status(self) -> str:
        data = self.sensor.read()
        t = data['temperature']
        h = data['humidity']
        if   t > 30: return "Chaud"
        elif t < 10: return "Froid"
        else:        return "Tempéré"

import requests, time

def publier_mesure(temperature, humidite):
    try:
        r = requests.post(
            'https://api.monserveur.com/mesures',
            json={'temp': temperature, 'hum': humidite},
            headers={'Authorization': 'Bearer TOKEN'},
            timeout=5
        )
        r.raise_for_status()
    except requests.RequestException as e:
        print(f"Erreur réseau: {e}")

# MQTT avec paho-mqtt
import paho.mqtt.client as mqtt

client = mqtt.Client()
client.connect("broker.local", 1883)
client.publish("capteurs/temp", f"{temperature:.1f}")

import unittest
from unittest.mock import MagicMock, patch
from app import WeatherStation

class TestWeatherStation(unittest.TestCase):

    def test_chaud_au_dessus_30(self):
        sensor_mock = MagicMock()
        sensor_mock.read.return_value = {
            'temperature': 35,
            'humidity':    60
        }
        station = WeatherStation(sensor=sensor_mock)
        self.assertEqual(station.get_status(), "Chaud")

    def test_froid_en_dessous_10(self):
        sensor_mock = MagicMock()
        sensor_mock.read.return_value = {
            'temperature': 5,
            'humidity':    80
        }
        station = WeatherStation(sensor=sensor_mock)
        self.assertEqual(station.get_status(), "Froid")

from unittest.mock import patch, MagicMock

class TestBMP280(unittest.TestCase):

    @patch('smbus2.SMBus')
    def test_lecture_temperature(self, mock_bus_class):
        mock_bus = MagicMock()
        mock_bus_class.return_value = mock_bus

        # Simuler la réponse brute du registre
        mock_bus.read_i2c_block_data.return_value = [
            0x80, 0x00, 0x00  # données brutes BMP280
        ]

        from mon_capteur import LectureBMP280
        capteur = LectureBMP280(adresse=0x76)
        result = capteur.lire()

        # Vérifier que la lecture a bien été appelée
        mock_bus.read_i2c_block_data.assert_called_once_with(
            0x76, 0xF7, 3
        )

[Unit]
Description=Station météo IoT
After=network.target

[Service]
Type=simple
User=pi
WorkingDirectory=/home/pi/station
ExecStart=/home/pi/station/venv/bin/python app.py
Restart=always
RestartSec=10

[Install]
WantedBy=multi-user.target