I2L 2025 Groupe6

Proposition de système (étudiants)

L’idée de mon projet est de créer un système de contrôle par détection de mouvement pour la sécurité de ma maison. Une LED clignotera en rouge en cas de détection (sur une certaine portée) et un signal sonore sera émis par un haut-parleur pendant une durée déterminée ; ce signal pourra être arrêté par un bouton tout géré par le microcontrôleur. Éventuellement, la maison (Type T3 donc 4 Leds pour les chambres, salon et la douche complet) pourra aussi être contrôlée pour allumer/éteindre les lumières par claquement de doigts et/ou par un bouton.

• Chaque chambre sera représentée par une LED pour allumer/éteindre
• Le salon et la douche pareille
• UN écran LCD pour afficher les informations (alarme déclenchée/éteinte et pareil pour la maison)

Contre-proposition (intervenant)

La carte doit pouvoir fonctionner avec la batterie en mode autonome (si les capteurs peuvent être alimentés en 3,3V).

Pour le mode connecté au PC par USB les informations de présence et de contrôle de l'éclairage doivent être remontées au PC (classe USB "vendeur"). Le PC affiche un plan de la maison (un seul étage) avec les indications de détection de présence et d'éclairage allumé ou éteint dans les différentes pièces.

Proposition définitive (étudiants)

Le système utilisera un microcontrôleur alimenté par batterie (3,3V ou 5V) en mode autonome, avec :

• Capteur PIR HC-SR501 → détection de mouvement et déclenchement LED rouge + alarme sonore.
• Bouton poussoir → arrêt manuel de l’alarme.
• Simulation d’un T3 avec 4 LEDs pour les pièces (chambres, salon, douche) contrôlables par boutons et capteur sonore (claquement de doigts).
• Écran LCD pour afficher les états : présence détectée, alarme ON/OFF, éclairage ON/OFF.

En mode USB connecté au PC (classe USB type "vendor") :

• Les informations de présence et d’éclairage sont envoyées au PC.

Le PC affiche un plan simple de la maison avec indication en temps réel des pièces éclairées ou détectées.

Répartition du travail (étudiants)

Les les tâches sont repartie pour moi et donc seront divisé comme suit :

• Tester la carte, allumer une LED et tester un bouton aussi

• Allumer et éteindre les chambres avec les boutons
• Allumer les informations dans l'écran LCD
• Bouton pour arrêter l'alarme
• Contrôler la maison avec le claquement de doigt pour allumer tout les chambres ou les éteindre.
• Attaque pour les détecteurs de mouvements par chambre pour la maison
• Partie graphique en python pour afficher la maison avec différents couleurs pour différencier les chambres et salon

Carte

Schéma initial (étudiants)

Schéma de la carte

• schéma (projet KiCAD) : Fichier:I2L-2025-Carte-G6.zip

Carte routée (intervenant)

Vous utiliserez la carte avec batterie.

Carte réalisée (intervenant)

Photo de la carte

La carte est entiérement soudée à l'exception d'un connecteur 16 broches pour l'écran (effectué le 10 octobre 2025).

A noter : les détecteurs de mouvement sont sur les mêmes lignes que les boutons. Il faut donc faire des tests pour arriver à distinguer la pression sur un bouton et la détection d'un mouvement (si possible).

Travaux (étudiants)

Séance 13/10/2025 :

• Lecteur en USB avec lsusb pour voir sur le terminal si la carte est connecté ou pas.

• Prise en contact avec le matériel en particulier la Carte
• Allumer une LED et actionner un bouton poussoir
• Allumer une LED avec l'Horloge avec le changement F_CPU à 8Mgh (8000000UL): Exemple : 5s en ON et 5s en OFF

Séance du 16/10/2025 :

Nous avons allumer les 4 Leds qui représente la maison avec un bouton qui allume et éteint un Led qui représente la chambre ou la douche ou salon.

Le but est de faire en sorte que chaque pièce possède son propre interrupteur.

Remarque : avec l'utilisation des capteurs de mouvements, on va basculer à un bouton général qui allume les chambres vis à vis de nombre de poussoirs et on supprime pour le fait que chaque boutons doit allumer une pièce.

Taches effectuées pendant cette séance :

• Allumer les pièces avec les différents boutons (voir code ci-dessous) => Cette option est supprimer à la suite du projet à cause des détecteur de mouvement
• Allumer maintenant les chambres avec un seul bouton et les éteindre avec le bouton général (B1 liée à PB3 et une résistance R41)
• Allumer la pièce 1 avec le contrôle du détecteur de mouvement nommée PIR1 (Allumer et l’éteindre pendant 5s)
• Problème et à résoudre: L’écran LCD toujours pas en marche et le bouton-General ne contrôle plus les actions (Allumer/éteindre) du Led1 mais il peut l'allumer => à revoir pour le code

Voici les différents code qui fait fonctionner ça :

// Fichier config pour definir les Leds et les Boutons 
#ifndef CONFIG_H
#define CONFIG_H

#define F_CPU 8000000UL

// LEDs
#define LED1 PB1
#define LED2 PB2
#define LED3 PB7
#define LED4 PE6

// Boutons
#define B1 PB3
#define B2 PC6
#define B3 PC7
#define B4 PF1
#define B5 PF4

#include <avr/io.h>
#include <util/delay.h>

#endif

Code Voici le code qui gérer les Boutons et leur délectations pour définir leur fonctions vis à vis des bits aussi

# Code pour gerer les boutons 
#ifndef BOUTONS_H
#define BOUTONS_H

#include "config.h"

void boutons_init();
uint8_t bouton_is_pressed(volatile uint8_t *pin_reg, uint8_t pin);

#endif

#include "../include/boutons.h"

// Configure les boutons en entrée avec Pull-up activée
void boutons_init() {
    DDRB &= ~(1 << B1);  PORTB |= (1 << B1);  // B1 sur PB3
    DDRC &= ~(1 << B2);  PORTC |= (1 << B2);  // B2 sur PC6
    DDRC &= ~(1 << B3);  PORTC |= (1 << B3);  // B3 sur PC7
    DDRF &= ~(1 << B4);  PORTF |= (1 << B4);  // B4 sur PF4
}

// Retourne 1 si bouton pressé (actif bas)
uint8_t bouton_is_pressed(volatile uint8_t *pin_reg, uint8_t pin) {
    if (!(*pin_reg & (1 << pin))) {
        _delay_ms(50); // Anti-rebond
        if (!(*pin_reg & (1 << pin))) {
            return 1;
        }
    }
    return 0;

}

Code

• pour la partie Leds :

#ifndef LCD_H
#define LCD_H

#include <avr/io.h>
#include <util/delay.h>

// Définir les ports pour le LCD
#define LCD_PORT PORTB
#define LCD_DDR  DDRB

#define LCD_RS 0
#define LCD_E  1
#define LCD_D4 2
#define LCD_D5 3
#define LCD_D6 4
#define LCD_D7 5

void lcd_init(void);
void lcd_clear(void);
void lcd_set_cursor(uint8_t row, uint8_t col);
void lcd_write_char(char c);
void lcd_write_string(const char* str);

#endif

#include "../include/leds.h"

// Initialise les broches des LEDs en sortie
void leds_init() {
    DDRB |= (1 << LED1) | (1 << LED2) | (1 << LED3); // LEDs sur PORTB
    DDRE |= (1 << LED4); // LED4 sur PORTE
}

// Allume une LED
void led_on(uint8_t port, uint8_t pin) {
    if (port == 'B') PORTB |= (1 << pin);
    else if (port == 'E') PORTE |= (1 << pin);
}

// Éteint une LED
void led_off(uint8_t port, uint8_t pin) {
    if (port == 'B') PORTB &= ~(1 << pin);
    else if (port == 'E') PORTE &= ~(1 << pin);
}

// Inverse l'état d'une LED
void led_toggle(uint8_t port, uint8_t pin) {
    if (port == 'B') PORTB ^= (1 << pin);
    else if (port == 'E') PORTE ^= (1 << pin);

}

Code

• Main pour Allumer les pièces avec les différents boutons :

#include "../include/config.h"
#include "../include/leds.h"
#include "../include/boutons.h"
#include "../include/lcd.h"

int main(void)
{
    MCUCR |= (1<<JTD);
    MCUCR |= (1<<JTD) ;
    // Configuration horloge 8 MHz sans diviseur
    CLKPR = 0x80;   // Autoriser modification
    CLKPR = 0x00;   // Pas de division

    // Initialiser LEDs et boutons
    leds_init();
    boutons_init();
    lcd_init();

    lcd_set_cursor(0, 0);
    lcd_write_string("Systeme Embarque");
    lcd_set_cursor(1, 0);
    lcd_write_string("Projet 2024");

    // États des LEDs
    uint8_t state_led1 = 0;
    uint8_t state_led2 = 0;
    uint8_t state_led3 = 0;
    uint8_t state_led4 = 0;

    while(1)
    {
        // Bouton B1 → LED1 (PB3 → PB1)
        if (bouton_is_pressed(&PINB, B1)) {
            state_led1 = !state_led1;
            if (state_led1) {
                led_on('B', LED1);
                 lcd_set_cursor(1, 0) ;
                 lcd_write_string("Chambre 1 : allumer");
            }
            else led_off('B', LED1);
            while(! (PINB & (1 << B1))); // Attendre relâchement
        }

        // Bouton B2 → LED2 (PC6 → PB2)
        if (bouton_is_pressed(&PINC, B2)) {
            state_led2 = !state_led2;
            if (state_led2) led_on('B', LED2);
            else led_off('B', LED2);
            while(! (PINC & (1 << B2)));
        }

        // Bouton B3 → LED3 (PC7 → PB7)
        if (bouton_is_pressed(&PINC, B3)) {
            state_led3 = !state_led3;
            if (state_led3) led_on('B', LED3);
            else led_off('B', LED3);
            while(! (PINC & (1 << B3)));
        }

        // Bouton B4 → LED4 (PF4 → PE6)
        if (bouton_is_pressed(&PINF, B4)) {
            state_led4 = !state_led4;
            if (state_led4) led_on('E', LED4);
            else led_off('E', LED4);
            while(! (PINF & (1 << B4)));
        }
    }

}

Code

• pour allumer et éteindre les pièces avec le même bouton : Contrôle général de la maison

#include "../include/config.h"
#include "../include/leds.h"
#include "../include/bouton_general.h"
#include "../include/lcd.h"

int main(void)
{
    MCUCR |= (1<<JTD);
    MCUCR |= (1<<JTD) ;
    // Configuration horloge 8 MHz sans diviseur
    CLKPR = 0x80;   // Autoriser modification
    CLKPR = 0x00;   // Pas de division

    // Initialiser LEDs et boutons
    leds_init();
    bouton_general_init();
    // lcd_init();

    // lcd_set_cursor(0, 0);
    // lcd_write_string("Systeme Embarque");
    // lcd_set_cursor(1, 0);
    // lcd_write_string("Projet 2024");

    // États des LEDs
    uint8_t state_home = 0;
    

    while(1)
    {
        // Bouton B1 → LED1 (PB3 → PB1)
        if (bouton_general_is_pressed()) {

            state_home = !state_home;

            if (state_home) {
                led_on('B', LED1);
                led_on('B', LED2);
                led_on('B', LED3);
                led_on('E', LED4);
        
            }
            else{
                led_off('B', LED1);
                led_off('B', LED2);
                led_off('B', LED3);
                led_off('E', LED4);
            }
            while (!(PINB & (1 << BTN_ALL))); // Attente relâchement
        }
       
    }

}

Code PIR1 :

// Gestion LED1 avec capteur PIR1
        if(pir1_is_active()){
                led_on('B', LED1);
                //room1_light = 1;

            }
            else {
                led_off('B', LED1);
               // room1_light = 0;
            }
            _delay_ms(50);
    }

Image pour allumer avec les boutons :

Séances du 13/11/2025 :

étapes réalisés :

- Mise en place du code et test des détecteurs de mouvements

- Ecrans LCD et les messages correspondants

- Les interruptions pour gérer les PIRs et le bouton général.

1-Gestion écran LCD :

Dans ce projet, j'ai programmé un écran LCD 16×2 basé sur un contrôleur HD44780.

Le LCD est utilisé pour afficher en temps réel l’état des quatre pièces (CH1 à CH4) ainsi que différents messages système comme "Maison ALLUMÉE", "Maison ÉTEINTE"

Nous avons configuré le LCD en mode 4 bits, ce qui permet d’économiser des broches d’E/S sur le microcontrôleur. Une série de fonctions a été codée pour gérer l’écriture de commandes, l’affichage de caractères, le positionnement du curseur, l’effacement de l’écran et la mise à jour automatique de l’affichage.

Le LCD est mis à jour à chaque changement d’état d’une pièce ou lors de l’appui sur le bouton général. L’écran reflète toujours l’état interne du système.

2- Gestion du bouton général et mode manuel

Le système comporte un bouton général placé sur l’entrée PB3.

J'ai programmé un anti-rebond logiciel pour éviter les déclenchements parasites.

Chaque appui sur ce bouton permet de basculer entre deux modes :

• Maison ALLUMÉE : toutes les LEDs des quatre chambres s’allument, les PIR sont ignorés et le clap est désactivé.
• Maison ÉTEINTE : le système repasse en mode automatique, où les PIR et le clap peuvent contrôler les LEDs.

Lors du basculement, un message est affiché sur le LCD ("Maison ALLUMEE" ou "Maison ETEINTE"), puis l’écran revient automatiquement à l’état normal des chambres (CH1–CH4).

L’idée est de donner à l’utilisateur un mode manuel prioritaire qui surclasse les capteurs.

3 - Gestion des PIR et interruptions

En mode automatique (maison éteinte), le comportement des quatre chambres est entièrement contrôlé par leurs capteurs PIR respectifs.

Chaque PIR active sa chambre lors d’une détection de mouvement.

J'ai utilisé une interruption Timer0 configurée pour générer un “tick” toutes les 1 ms, permettant de gérer les durées sans bloquer le programme.

Grâce à ce chronomètre, chaque chambre reste allumée pendant 5 secondes après la dernière détection. Si aucun mouvement n’est détecté dans l’intervalle, la LED correspondante s’éteint automatiquement.

Chaque changement d’état déclenche une mise à jour de l’affichage LCD.

Les interruptions assurent ainsi une gestion fluide et précise du temps, sans bloquer la boucle principale, ce qui garantit que les PIR, le bouton général et les autres événements restent réactifs en permanence.

Code écran LCD :

#include "lcd_private.h"
#include "lcd.h"

static void lcd_write_nibble(uint8_t nibble) {
    LCD_EN_PORT &= ~(1 << LCD_EN_PIN);
    
    if (nibble & 0x08) LCD_D7_PORT |= (1 << LCD_D7_PIN);
    else LCD_D7_PORT &= ~(1 << LCD_D7_PIN);
    
    if (nibble & 0x04) LCD_D6_PORT |= (1 << LCD_D6_PIN);
    else LCD_D6_PORT &= ~(1 << LCD_D6_PIN);
    
    if (nibble & 0x02) LCD_D5_PORT |= (1 << LCD_D5_PIN);
    else LCD_D5_PORT &= ~(1 << LCD_D5_PIN);
    
    if (nibble & 0x01) LCD_D4_PORT |= (1 << LCD_D4_PIN);
    else LCD_D4_PORT &= ~(1 << LCD_D4_PIN);
    
    _delay_us(1);
    LCD_EN_PORT |= (1 << LCD_EN_PIN);
    _delay_us(1);
    LCD_EN_PORT &= ~(1 << LCD_EN_PIN);
    _delay_us(100);
}

static void lcd_write_byte(uint8_t data) {
    lcd_write_nibble(data >> 4);
    lcd_write_nibble(data & 0x0F);
}

static void lcd_power_up_4bit(void) {
    _delay_ms(40);
    lcd_write_nibble(0x03);
    _delay_ms(5);
    lcd_write_nibble(0x03);
    _delay_us(100);
    lcd_write_nibble(0x03);
    _delay_us(50);
    lcd_write_nibble(0x02);
    _delay_us(50);
}

void lcd_init(void) {
    // Configuration des broches en sortie
    LCD_D4_DDR |= (1 << LCD_D4_PIN);
    LCD_D5_DDR |= (1 << LCD_D5_PIN);
    LCD_D6_DDR |= (1 << LCD_D6_PIN);
    LCD_D7_DDR |= (1 << LCD_D7_PIN);
    LCD_RS_DDR |= (1 << LCD_RS_PIN);
    LCD_RW_DDR |= (1 << LCD_RW_PIN);
    LCD_EN_DDR |= (1 << LCD_EN_PIN);
    
    // Initialisation à LOW
    LCD_D4_PORT &= ~(1 << LCD_D4_PIN);
    LCD_D5_PORT &= ~(1 << LCD_D5_PIN);
    LCD_D6_PORT &= ~(1 << LCD_D6_PIN);
    LCD_D7_PORT &= ~(1 << LCD_D7_PIN);
    LCD_RS_PORT &= ~(1 << LCD_RS_PIN);
    LCD_RW_PORT &= ~(1 << LCD_RW_PIN);
    LCD_EN_PORT &= ~(1 << LCD_EN_PIN);
    
    // Séquence d'initialisation
    lcd_power_up_4bit();
    _delay_ms(50);
    
    // Configuration du LCD - ENVOYER PLUSIEURS FOIS
    lcd_write_command(0x28); // 4 bits, 2 lignes, 5x8 points
    _delay_ms(5);
    lcd_write_command(0x28);
    _delay_us(100);
    lcd_write_command(0x28);
    _delay_us(50);
    
    lcd_write_command(LCD_ON); // Display ON, cursor off
    lcd_write_command(LCD_INCR_RIGHT); // Increment, no shift
    lcd_clear();
    _delay_ms(50);
}

void lcd_write_command(uint8_t command) {
    LCD_RS_PORT &= ~(1 << LCD_RS_PIN);
    LCD_RW_PORT &= ~(1 << LCD_RW_PIN);
    lcd_write_byte(command);
    _delay_us(50);
}

void lcd_write_data(uint8_t data) {
    LCD_RS_PORT |= (1 << LCD_RS_PIN);
    LCD_RW_PORT &= ~(1 << LCD_RW_PIN);
    lcd_write_byte(data);
    _delay_us(50);
}

void lcd_clear(void) {
    lcd_write_command(LCD_CLEAR);
    _delay_ms(5); // Délai augmenté à 5ms
}

void lcd_set_cursor(uint8_t row, uint8_t col) {
    uint8_t address;
    uint8_t row_offsets[] = {0x00, 0x40};
    
    if (row >= NB_ROWS) row = NB_ROWS - 1;
    if (col >= NB_COLS) col = NB_COLS - 1;
    
    address = row_offsets[row] + col;
    lcd_write_command(LCD_ADDRSET | address);
}

void lcd_write_char(char c) {
    lcd_write_data(c);
}

void lcd_write_string(const char* str) {
    while (*str) {
        lcd_write_char(*str++);
    }
}

void lcd_animation(const char *message) {
    lcd_clear();
    lcd_set_cursor(0, 0);
    lcd_write_string("Mouvement ->");
    lcd_set_cursor(1, 0);

    //animation du texte caractere par caractere
    for(uint8_t i = 0; message[i] != '\0'; i++) {
        lcd_write_char(message[i]);
        _delay_ms(1000);
    }
}

Code pour les détecteurs de Mouvements :

#include "../include/pir.h"

// Initialisation des 4 capteurs PIR
void pir_init(void) {
    // --- PIR1 -> PC6 ---
    DDRC &= ~(1 << PIR1);   // entrée
    PORTC |=  (1 << PIR1);  // pull-up activé

    // --- PIR2 -> PC7 ---
    DDRC &= ~(1 << PIR2);
    PORTC |=  (1 << PIR2);

    // --- PIR3 -> PF1 ---
    DDRF &= ~(1 << PIR3);
    PORTF |=  (1 << PIR3);

    // --- PIR4 -> PF4 ---
    DDRF &= ~(1 << PIR4);
    PORTF |=  (1 << PIR4);
}

// --- Fonctions de lecture des PIRs ---
// Renvoient 1 si détection (niveau haut), 0 sinon
uint8_t pir1_is_active(void) {
    return !(PINC & (1 << PIR1)) != 0;
}

uint8_t pir2_is_active(void) {
    return !(PINC & (1 << PIR2)) != 0;
}

uint8_t pir3_is_active(void) {
    return !(PINF & (1 << PIR3)) != 0;
}

uint8_t pir4_is_active(void) {
    return !(PINF & (1 << PIR4)) != 0;

}

Python et interface :

En complément du code embarqué, j'ai développé une interface Python permettant d’afficher l’état du système en temps réel et, dans certaines configurations, d’interagir avec la carte via USB (communication série).

L’interface Python a été construite avec Tkinter pour la partie graphique et PySerial pour la communication USB.

Elle représente les quatre chambres sous forme de blocs colorés :

• Vert lorsque la chambre est allumée,
• Noir lorsqu’elle est éteinte,
• Et elle affiche également le texte “CHx ON” ou “CHx OFF”.

L’objectif de cette interface est de fournir une visualisation simple et intuitive de l’état du système domotique, sans avoir besoin de regarder directement les LEDs physiques sur la carte.

La fenêtre Python reçoit régulièrement (en boucle) les informations envoyées depuis le microcontrôleur. Ces informations sont ensuite analysées et utilisées pour mettre à jour graphiquement l’état des chambres.

À terme, l’interface peut aussi intégrer des boutons permettant d’envoyer des commandes vers la carte, comme allumer ou éteindre une chambre ou activer le mode automatique.

Cette interface constitue donc un outil pratique pour le suivi du système, les tests et la démonstration du projet.

Rendus (étudiants)

Projet KiCAD : Fichier:I2L-2025-Carte-G6-final.zip

Programmes :

• microcontrôleur : Fichier:I2L-2025-Programmes-uC-G6.zip
• ordinateur Fichier:I2L-2025-Programmes-PC-G6.zip