1. Vue d'ensemble du système et fonctionnalités clés

1.1 Positionnement

Ce système de pointage repose sur un cycle complet : acquisition des empreintes, identification de l'individu, enregistrement horodaté de la présence, et gestion centralisée des données. Il exploite un capteur d'empreintes pour une authentification rapide, couplé à une horloge temps réel (RTC) pour horodater les présences. Il supporte le stockage local, la consultation et l'envoi de données vers des serveurs distants, s'adaptant aux besoins des entreprises, écoles ou usines pour automatiser le suivi des présences.

1.2 Modules fonctionnels principaux

2. Architecture matérielle

2.1 Sélection des composants

2.2 Conception des circuits

Câblage fondamental

• Système minimal STM32 : Quartz externe de 8MHz, quartz 32.768kHz pour la RTC, connecteur de débogage SWD, circuit de réinitialisation.
• Capteur AS608 : Alimentation 3.3V, masses communes, lignes TX/RX croisées avec le STM32 (PA2/PA3), option d'interruption (INT).
• RTC DS3231 : Alimentation 3.3V, bus I2C (PB6, PB7), sortie d'interruption optionnelle, support de pile bouton.
• EEPROM AT24C256 : Alimentation 3.3V, partage du bus I2C avec la RTC (adresse différente : 0x50 contre 0x68 pour le DS3231).

Conception pour la robustesse

• Isolation d'alimentation : Utilisation d'une perle de ferrite entre l'alimentation du capteur d'empreintes et celle du microcontrôleur pour atténuer les perturbations.
• Filtrage des signaux série : Condensateurs de filtrage (10pF) sur les lignes UART du capteur pour réduire les erreurs de communication.
• Disposition sur PCB : Eloigner le capteur d'empreintes des sources de bruit (moteurs, relais). Tracer les lignes I2C de longueur égale et les entourer d'un plan de masse pour l'immunité au bruit.

3. Conception logicielle

3.1 Architecture du système (planification multitâche avec FreeRTOS)

Le système utilise un système d'exploitation temps réel (RTOS) pour organiser le travail en 5 tâches principales, hiérarchisées par priorité décroissante :

1. Tâche de traitement des empreintes (priorité haute) : Communication UART avec l'AS608 pour l'acquisition, l'identification et la gestion des modèles.
2. Tâche de gestion du temps (priorité moyenne-haute) : Lecture périodique de l'heure depuis le DS3231 et mise à jour de l'horloge système.
3. Tâche d'interface utilisateur (priorité moyenne) : Gestion des entrées (boutons), mise à jour de l'affichage (OLED), signaux sonores.
4. Tâche de stockage (priorité moyenne) : Écriture des enregistrements de pointage dans la mémoire EEPROM ou sur carte SD.
5. Tâche de communication (priorité basse) : Envoi périodique ou sur événement des données de pointage vers le cloud via l'ESP8266.

3.2 Exemples de code (basé sur la bibliothèque HAL)

Pilote du capteur d'empreintes (communication UART avec AS608)

#include "as608_driver.h"
#include "stm32f1xx_hal.h"

// Commandes pour le module AS608 (extrait)
#define CMD_CAPTURE_IMAGE   0x01
#define CMD_GENERATE_CHAR   0x02
#define CMD_SEARCH_FINGER   0x04
#define CMD_ENROLL_MODEL    0x05
#define CMD_STORE_MODEL     0x06

// Envoi d'une trame de commande au capteur
void AS608_TransmitFrame(uint8_t *payload, uint16_t size) {
    HAL_UART_Transmit(&huart2, payload, size, 200);
}

// Réception et analyse de la réponse du capteur
HAL_StatusTypeDef AS608_WaitForResponse(uint8_t *buffer, uint16_t buffer_size) {
    // Réception des octets un par un jusqu'à obtenir une trame complète
    // Vérification du préambule (0xEF01) et de la longueur attendue
    // Validation du champ de contrôle (checksum)
    // Retourne HAL_OK si la trame est valide, HAL_ERROR sinon
    // (Logique détaillée omise pour la concision)
    return HAL_OK;
}

// Séquence d'enregistrement d'une nouvelle empreinte (ID de 0 à 999)
uint8_t AS608_ExecuteEnrollment(uint16_t target_id) {
    uint8_t cmd_buffer[16];
    uint8_t rsp_buffer[16];
    HAL_StatusTypeDef status;

    // 1. Acquisition de la première image
    // Construction et envoi de la commande CMD_CAPTURE_IMAGE
    status = AS608_WaitForResponse(rsp_buffer, sizeof(rsp_buffer));
    if (status != HAL_OK) return 1; // Erreur de communication

    // 2. Génération du premier modèle (caractéristiques)
    // Construction et envoi de la commande CMD_GENERATE_CHAR avec buffer 1
    status = AS608_WaitForResponse(rsp_buffer, sizeof(rsp_buffer));
    if (status != HAL_OK) return 1;

    // 3. Répétition des étapes 1 & 2 pour la deuxième image (buffer 2)
    // ...

    // 4. Fusion des deux modèles
    // Construction et envoi de la commande CMD_ENROLL_MODEL
    status = AS608_WaitForResponse(rsp_buffer, sizeof(rsp_buffer));
    if (status != HAL_OK) return 1;

    // 5. Stockage du modèle fusionné à l'ID cible
    // Construction et envoi de la commande CMD_STORE_MODEL
    status = AS608_WaitForResponse(rsp_buffer, sizeof(rsp_buffer));
    return (status == HAL_OK) ? 0 : 1; // 0 = succès, 1 = échec
}

Pilote de l'horloge RTC (DS3231 via I2C)

#include "rtc_ds3231.h"
#include "stm32f1xx_hal.h"

// Structure pour stocker la date et l'heure
typedef struct {
    uint8_t year;   // Année (00-99)
    uint8_t month;  // Mois (01-12)
    uint8_t day;    // Jour (01-31)
    uint8_t hour;   // Heure (00-23)
    uint8_t minute; // Minute (00-59)
    uint8_t second; // Seconde (00-59)
} DateTime_t;

// Lecture de l'heure depuis le DS3231
void DS3231_GetCurrentTime(DateTime_t *dt) {
    uint8_t raw_data[7];
    // Lecture des 7 registres à partir de 0x00 (secondes)
    HAL_I2C_Mem_Read(&hi2c1, (0x68 << 1), 0x00, I2C_MEMADD_SIZE_8BIT, raw_data, 7, 100);

    // Conversion des valeurs BCD en décimal
    dt->second = ((raw_data[0] >> 4) * 10) + (raw_data[0] & 0x0F);
    dt->minute = ((raw_data[1] >> 4) * 10) + (raw_data[1] & 0x0F);
    dt->hour   = ((raw_data[2] >> 4) * 10) + (raw_data[2] & 0x0F);
    dt->day    = ((raw_data[4] >> 4) * 10) + (raw_data[4] & 0x0F);
    dt->month  = ((raw_data[5] >> 4) * 10) + (raw_data[5] & 0x0F);
    dt->year   = ((raw_data[6] >> 4) * 10) + (raw_data[6] & 0x0F);
}

Sauvegarde des enregistrements de pointage (EEPROM AT24C256)

#include "storage_eeprom.h"
#include "stm32f1xx_hal.h"
#include "rtc_ds3231.h"

#define EEPROM_ADDR   0x50
#define RECORD_SIZE   8  // Octets par enregistrement

// Écriture d'un enregistrement de pointage
void Storage_WriteAttendanceRecord(uint16_t user_id, const DateTime_t *timestamp) {
    uint8_t record_data[RECORD_SIZE];
    // Encodage compact de la date et de l'ID dans le buffer
    record_data[0] = timestamp->year;
    record_data[1] = timestamp->month;
    record_data[2] = timestamp->day;
    record_data[3] = timestamp->hour;
    record_data[4] = timestamp->minute;
    record_data[5] = (user_id >> 8) & 0xFF; // Octet fort de l'ID
    record_data[6] = user_id & 0xFF;        // Octet faible de l'ID
    record_data[7] = 0xFF; // Octet de statut ou de remplissage

    // Calcul de l'adresse de destination (gestion circulaire)
    static uint16_t current_write_address = 0x0000;
    if (current_write_address + RECORD_SIZE > 0x7FFF) {
        current_write_address = 0x0000; // Retour au début
    }

    // Écriture I2C
    HAL_I2C_Mem_Write(&hi2c1, (EEPROM_ADDR << 1), current_write_address, I2C_MEMADD_SIZE_16BIT, record_data, RECORD_SIZE, 100);
    current_write_address += RECORD_SIZE;
}

Cadre principal du programme (initialisation et lancement des tâches FreeRTOS)

#include "main.h"
#include "cmsis_os.h"
#include "as608_driver.h"
#include "rtc_ds3231.h"
#include "display_oled.h"
#include "storage_eeprom.h"

// Déclaration des handles de tâches
osThreadId fingerprintTaskHandle;
osThreadId rtcTaskHandle;
osThreadId uiTaskHandle;
osThreadId storageTaskHandle;
osThreadId commTaskHandle;

int main(void) {
    // Initialisation des périphériques HAL et du système
    HAL_Init();
    SystemClock_Config(); // Configuration de l'horloge à 72MHz
    MX_GPIO_Init();
    MX_USART1_UART_Init(); // Pour le module Wi-Fi
    MX_USART2_UART_Init(); // Pour le capteur d'empreintes
    MX_I2C1_Init();        // Pour la RTC, l'EEPROM et l'écran

    // Initialisation des modules applicatifs
    OLED_Initialize();
    DS3231_Initialize();
    AS608_Initialize();
    EEPROM_Initialize();

    // Création des tâches RTOS
    osThreadDef(Fingerprint, FingerprintTask, osPriorityAboveNormal, 0, 256);
    fingerprintTaskHandle = osThreadCreate(osThread(Fingerprint), NULL);

    osThreadDef(RTCTime, RTCTimeTask, osPriorityNormal, 0, 128);
    rtcTaskHandle = osThreadCreate(osThread(RTCTime), NULL);

    osThreadDef(UserInterface, UITask, osPriorityBelowNormal, 0, 128);
    uiTaskHandle = osThreadCreate(osThread(UserInterface), NULL);

    osThreadDef(DataStorage, StorageTask, osPriorityBelowNormal, 0, 128);
    storageTaskHandle = osThreadCreate(osThread(DataStorage), NULL);

    osThreadDef(WiFiComm, CommunicationTask, osPriorityLow, 0, 128);
    commTaskHandle = osThreadCreate(osThread(WiFiComm), NULL);

    // Démarrage du planificateur
    osKernelStart();
    while (1) { /* Ne devrait jamais être atteint */ }
}

4. Optimisations et aspects techniques

4.1 Amélioration de la reconnaissance

• Prétraitement d'image : Le capteur AS608 intègre des algorithmes pour améliorer la qualité de l'image (ajustement du contraste, binarisation), garantissant un bon taux de reconnaissance même avec des doigts secs ou humides.
• Gestion des modèles : Les gabarits d'empreintes sont stockés dans la mémoire flash interne du capteur. L'EEPROM externe sert uniquement à stocker les identifiants utilisateurs et les enregistrements de pointage.
• Ajustement des seuils : La sensibilité de la comparaison peut être configurée via des commandes du capteur pour équilibrer le taux de fausse acceptation (FAR) et le taux de faux rejet (FRR).

4.2 Gestion des données

• Stockage circulaire : Lorsque la mémoire EEPROM est pleine, les anciens enregistrements sont écrasés de manière cyclique. Une extension par carte SD (système de fichiers FatFS) permet un archivage plus important, éventuellement trié par date.
• Intégrité des données : Un code de contrôle (CRC) peut être ajouté aux enregistrements pour détecter les erreurs de stockage. Pour la transmission au cloud, l'utilisation de protocoles comme MQTT avec un niveau de service (QoS) 1 assure une livraison garantie des messages.

4.3 Conception économe en énergie

• Mode veille profonde : En l'absence d'activité, le microcontrôleur STM32 passe en mode STOP. L'écran et l'alimentation du capteur d'empreintes sont coupés. Le système se réveille via une interruption sur un bouton.
• Gestion dynamique de l'alimentation : Le capteur d'empreintes n'est alimenté que lors des opérations de lecture. Le module Wi-Fi est activé uniquement pour les transferts de données planifiés.

5. Débogage et extensions

5.1 Étapes de débogage

5.2 Pistes d'évolution

• Fusion biométrique : Intégration d'une caméra (ex: OV2640) pour ajouter une reconnaissnace faciale simple, nécessitant des algorithmes de traitement d'image supplémentaires.
• Détection de vivacité : Exploiter les fonctions anti-usurpation du capteur d'empreintes (si supportées par le modèle matériel) pour détecter les faux doigts.
• Interface d'administration Web : Développement d'un portail en ligne pour la consultation des rapports de pointage, l'exportation de données (par exemple au format Excel) et la gestion des droits d'accès utilisateurs.