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 (projet KiCAD) : Fichier:I2L-2025-Carte-G6.zip
Carte routée (intervenant)
Vous utiliserez la carte avec batterie.
Composants (intervenant)
Carte réalisée (intervenant)
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>
#endifCode 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 :
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