SE3Groupe2024-2

Description

Objectif

L'objectif de ce projet est de concevoir une station domotique capable de collecter et d'afficher des mesures provenant de capteurs. Elle devra également être capable d'activer des actionneurs, tels que des LEDs, des cadenas ou tout autre dispositif, en fonction des besoins.

Cahier des charges

La station domotique devra permettre l'affichage des informations suivantes concernant une pièce :

• Température ambiante ;
• Taux d'humidité ;
• Présence humaine (via capteur de mouvement) ;
• D'autres paramètres pourront être ajoutés en fonction de l'avancement du projet.

Elle devra aussi permettre de contrôler différents actionneurs dans la pièce, tels que :

• L'éclairage, en fonction de la présence d'une personne (via un capteur de mouvement) ;
• D'autres dispositifs pourront être intégrés en fonction des besoins.

Des capteurs et actionneurs supplémentaires pourront être ajoutés si le projet atteint ses objectifs initiaux.

Spécification techniques

• Microcontrôleur

Le projet nécessite un microcontrôleur, qui contiendra le programme, et qui communiquera avec les autres composants via les GPIOs.

Nous avons le choix entre plusieurs modèles de microcontrôleur : ATmega16u4, AT90USB1286, AT90USB1287.

Voici un tableau comparatif afin de sélectionner le plus adapté pour notre usage :

Caractéristiques	ATmega16U4	AT90USB1286	AT90USB1287
Architecture	AVR 8 bits	AVR 8 bits	AVR 8 bits
Mémoire Flash	16 KB	128 KB	128 KB
RAM (SRAM)	1.25 KB	4 KB	4 KB
EEPROM	512 Bytes	4 KB	4 KB
Fréquence d'horloge max.	16 MHz	16 MHz	16 MHz
Nombre de broches GPIO	26	48	48
Interfaces de communication	UART, SPI, I²C, USB 2.0	UART, SPI, I²C, USB 2.0	UART, SPI, I²C, USB 2.0
Contrôleur USB intégré	Oui (USB 2.0)	Oui (USB 2.0)	Oui (USB 2.0)
Taille des registres	8 bits	8 bits	8 bits
Nombre de broches	32	64	64
Différences principales	Conçu pour des applications compactes avec moins de mémoire et d'E/S	Plus de mémoire, adapté à des projets complexes nécessitant de nombreuses E/S et de la mémoire	Similaire au AT90USB1286 mais avec des fonctionnalités spécifiques pour certaines configurations USB (e.g., modes host/OTG).
Lien documentation	https://www.microchip.com/en-us/product/atmega16u4	https://www.microchip.com/en-us/product/at90usb1286	https://www.microchip.com/en-us/product/at90usb1287

Avec ce tableau, on constate que l'ATmega16U4 ne possède pas suffisamment de broches GPIOs. Cependant l'AT90USB1286 et son homologue l'AT90USB1287 dépassent notre cadre d'usage (utilisation mode USB spécifique HOST/OTG, etc... ).

Le compromis est donc d'opter pour un ATmega32u4 afin d'avoir suffisamment de broches et de mémoire.

Caractéristiques	ATmega32U4
Architecture	AVR 8 bits
Mémoire Flash	32 KB
RAM (SRAM)	2.5 KB
EEPROM	1 KB
Fréquence d'horloge max.	16 MHz
Nombre de broches GPIO	26
Interfaces de communication	UART, SPI, I²C, USB 2.0
Contrôleur USB intégré	Oui (USB 2.0)
Taille des registres	8 bits
Nombre de broches	32
Différences principales	Conçu pour des applications nécessitant un contrôleur USB intégré, avec une mémoire et un nombre de broches intermédiaires

Datasheet ATmega32u4 :

Datasheet du microcontroleur : ATMEGA32U4

• Communication

La station utilisera une puce NRF24L01 pour la communication sans fil entre les différents actionneurs et capteurs.

La communication entre le pc et la station se fera quant à elle en USB.

Datasheet NRF24L01 :

Datasheet module de communication : NRF24L01

• Énergie

La station sera alimentée de manière hybride, selon les scénarios suivants  : - Par un port USB, pour la programmation, les tests et la configuration avec affichage sur moniteur PC ; - Par une batterie Lithium, en mode autonome pour une utilisation prolongée (avec affichage écran LCD dans un second temps). Les capteurs/actionneurs seront alimentées de manière hybride, selon les scénarios suivants : - Par un port USB, pour la programmation, les tests et la configuration ; - Par une batterie Lithium, en mode autonome pour son usage définitif. Modèles de batterie à notre disposition :

• Batterie 3.7V 100 mAh, connecteur molex mâle ;
• Batterie 3.7V 300 mAh, connecteur molex mâle ;

Nous allons ajouter la possibilité de recharger notre batterie depuis notre carte via le composant MAX1811. La carte se rechargera lorsqu'elle sera branché en USB mais l'USB fournit du 5V, ce qui peut nuire à certains de nos composants... Pour proteger les composants, nous allons ajouter un régulateur de tension pour garder une tension de 3,3V sur l'ensemble de notre carte. Datasheet du chargeur et du régulateur :

Datasheet du chargeur : MAX1811

Datasheet du régulateur : LTC3531

• Affichage

Dans un premier temps, les informations seront remontées via la connexion USB à un programme sur PC (selon les exigences du cahier des charges).

Dans un second temps, un écran LCD sera utilisé pour afficher les données directement sur la station, offrant ainsi une solution autonome, sous réserve du temps disponible pour cette implémentation.

Datasheet de l'écran graphique utilisé :

Datasheet de l'écran : NHD‐C12832A1Z‐FSW‐FBW‐3V3

Pour programmer l'écran, les professeurs veulent qu'on reste sur du C pur. On a alors décidé de coder notre écran via l'API "glcd.h".

L'écran sera composé de menu permettant de naviguer parmis pleins de capteurs qui sont enregistrer pour permettre la consultation de la valeur renvoyé par celle selectionné.

Les boutons intégrés sur la carte permettent la navigation.

• Diverses

La carte comportera également une led afin d'indiquer son état d'alimentation ainsi que deux autres leds permettant de faire des tests de programmation.

Programmateur AVR

Cours / Tutoriel

https://rex.plil.fr/Enseignement/Systeme/Systeme.PSE/systeme063.html

Schématique

Notre schéma électriquea

Schéma électrique KICAD

Conception de notre schéma électrique

Document expliquant point par point le schéma réalisé sur KICAD

Documents relatifs à la conception du kicad de la carte

Datasheet ATMEGA8U2

AVR Hardware Design Considerations

Vue 3D

Fichier kicad

Fichier:2024-PSE-G2-Prog.zip

Brasure

Carte programmateur AVR - Vue avant

Carte programmateur AVR - Vue arrière

Programmation

Test leds et boutons

Afin de vérifier que notre carte fonctionne correctement après brasure, on code un programme permettant d'allumer une led périodiquement puis un autre programme allumant une led lorsqu'un bouton poussoir est pressé.

Afin de mettre le programme sur notre carte, on vérifie au préalable que notre carte est bien reconnue en tant que périphérique USB à l'aide de la commande lsusb.

Pour plus de détail sur notre périphérique usb branché on doit faire la commande " lsusb -s [bus]:[device] -v " :

cedricpayetsully@cedric-payet-computer:~$ lsusb -s 003:011 -v

Bus 003 Device 011: ID 03eb:2044 Atmel Corp. LUFA CDC Demo Application
Couldn't open device, some information will be missing
Device Descriptor:
  bLength                18
  bDescriptorType         1
  bcdUSB               1.10
  bDeviceClass            2 Communications
  bDeviceSubClass         0 
  bDeviceProtocol         0 
  bMaxPacketSize0         8
  idVendor           0x03eb Atmel Corp.
  idProduct          0x2044 LUFA CDC Demo Application
  bcdDevice            0.01
  iManufacturer           1 LUFA Library
  iProduct                2 LUFA CDC Demo
  iSerial               220 85932333737351C03260
  bNumConfigurations      1
  Configuration Descriptor:
    bLength                 9
    bDescriptorType         2
    wTotalLength       0x003e
    bNumInterfaces          2
    bConfigurationValue     1
    iConfiguration          0 
    bmAttributes         0xc0
      Self Powered
    MaxPower              100mA
    Interface Descriptor:
      bLength                 9
      bDescriptorType         4
      bInterfaceNumber        0
      bAlternateSetting       0
      bNumEndpoints           1
      bInterfaceClass         2 Communications
      bInterfaceSubClass      2 Abstract (modem)
      bInterfaceProtocol      1 AT-commands (v.25ter)
      iInterface              0 
      CDC Header:
        bcdCDC               1.10
      CDC ACM:
        bmCapabilities       0x06
          sends break
          line coding and serial state
      CDC Union:
        bMasterInterface        0
        bSlaveInterface         1 
      Endpoint Descriptor:
        bLength                 7
        bDescriptorType         5
        bEndpointAddress     0x82  EP 2 IN
        bmAttributes            3
          Transfer Type            Interrupt
          Synch Type               None
          Usage Type               Data
        wMaxPacketSize     0x0008  1x 8 bytes
        bInterval             255
    Interface Descriptor:
      bLength                 9
      bDescriptorType         4
      bInterfaceNumber        1
      bAlternateSetting       0
      bNumEndpoints           2
      bInterfaceClass        10 CDC Data
      bInterfaceSubClass      0 
      bInterfaceProtocol      0 
      iInterface              0 
      Endpoint Descriptor:
        bLength                 7
        bDescriptorType         5
        bEndpointAddress     0x04  EP 4 OUT
        bmAttributes            2
          Transfer Type            Bulk
          Synch Type               None
          Usage Type               Data
        wMaxPacketSize     0x0010  1x 16 bytes
        bInterval               5
      Endpoint Descriptor:
        bLength                 7
        bDescriptorType         5
        bEndpointAddress     0x83  EP 3 IN
        bmAttributes            2
          Transfer Type            Bulk
          Synch Type               None
          Usage Type               Data
        wMaxPacketSize     0x0010  1x 16 bytes
        bInterval               5

Comme vu en cours, on revoit nos descripteurs ainsi que la description des interfaces de l'usb ainsi que d'autres données.Une fois notre carte détectée, on appuie sur le bouton HWB puis reset afin de mettre notre carte en mode DFU. On téléverse ensuite notre programme sur la carte à l'aide d'un makefile préalablement codé en tapant la commande make upload.

LUFA

Afin de pouvoir faire de notre carte un périphérique USB, nous allons utiliser la LUFA (Lightweight USB Framefork for AVRs).

• Tout d'abord, nous avons codé un programme permettant de voir si la lufa détecte bien les boutons-poussoirs de notre carte comme des points d'accès d'entrées en affichant sur le minicom quel bouton-poussoir était pressé par l'utilisateur. Notre code se trouve dans le répertoire se ci-dessous : https://gitea.plil.fr/ahouduss/se3_2024_B2/src/branch/main/01%20-%20Programmateur%20AVR/programmation/lufa-LUFA-210130-NSI/se/VirtualSerial

Pour écrire notre code, nous avons réutilisé l'exemple VirtualSerial récupéré au repertoire suivant :

LUFA/Demos/Device/LowLevel/VirtualSerial

• On place le programme dans notre carte à l'aide de la commande make upload. Pour ce faire, il faut modifier le makefile original par ceci :

#
#             LUFA Library
#     Copyright (C) Dean Camera, 2021.
#
#  dean [at] fourwalledcubicle [dot] com
#           www.lufa-lib.org
#
# --------------------------------------
#         LUFA Project Makefile.
# --------------------------------------

# Run "make help" for target help.

MCU          = atmega8u2
ARCH         = AVR8
BOARD        = NONE
F_CPU        = 16000000
F_USB        = $(F_CPU)
OPTIMIZATION = s
TARGET       = VirtualSerial
SRC          = $(TARGET).c Descriptors.c spi.c $(LUFA_SRC_USB)
LUFA_PATH    = ../../LUFA
CC_FLAGS     = -DUSE_LUFA_CONFIG_HEADER -IConfig/
LD_FLAGS     =
PROGRAMMER  = dfu-programmer

# Default target
all:

upload: $(TARGET).hex
	$(PROGRAMMER) $(MCU) erase
	$(PROGRAMMER) $(MCU) flash $(TARGET).hex
	$(PROGRAMMER) $(MCU) reset

clean:
	rm -f *.bin *.elf *.lss *.map *.sym *.eep

# Include LUFA-specific DMBS extension modules
DMBS_LUFA_PATH ?= $(LUFA_PATH)/Build/LUFA
include $(DMBS_LUFA_PATH)/lufa-sources.mk
include $(DMBS_LUFA_PATH)/lufa-gcc.mk

# Include common DMBS build system modules
DMBS_PATH      ?= $(LUFA_PATH)/Build/DMBS/DMBS
include $(DMBS_PATH)/core.mk
include $(DMBS_PATH)/cppcheck.mk
include $(DMBS_PATH)/doxygen.mk
include $(DMBS_PATH)/dfu.mk
include $(DMBS_PATH)/gcc.mk
include $(DMBS_PATH)/hid.mk
include $(DMBS_PATH)/avrdude.mk
include $(DMBS_PATH)/atprogram.mk

Le MCU à été changé afin de correspondre au nôtre. Une commande clean à été ajouté et la fréquence CPU augmenté à 16 MHz.

• on lance la commande minicom afin de voir si le bouton pressé est bien affiché via la liaison série. On configure le minicom au préalable.

sudo minicom -os

Ensuite nous entrons dans Serial port setup :

Il va falloir procéder à 3 changements :

1. Appuyer sur A et changer modem par l'emplacement de notre carte (ici ACM0) puis ENTRER
2. Appuyer sur E puis appuyer sur C pour configurer la vitesse de notre minicom puis ENTRER
3. Appuyer sur F puis ENTRER

Appuyer de nouveau sur ENTRER pour enregistrer la configuration et ensuite faite Exit.

On est maintenant prêt à recevoir les messages usb qu'on envoie lors d'un appuie :

• Nous avons ensuite implémenté un programme permettant d'allumer une led différente à chaque bouton-poussoir pressé.

Demonstration vidéo de notre programme utilisant la LUFA

Station

Schématique

Notre schéma électriques

Schéma électrique V1 KICAD

Comprendre notre schéma

Comprendre la schématique

Vue 3D

Carte station en 3D - Vue arrière

Carte station en 3D - Vue avant

Resources utilisés

Lien GIT : https://gitea.plil.fr/ahouduss/se3_2024_B2.git

Lien tutoriel utilisation de puces à distance : NRF24L01