1. Système de contrôle de température pour four à résistance

1.1 Exigences du projet

Composants requis :
Microcotnrôleur principal : STM32F103C8T6
Écran d'affichage : LCD1602
Boutons : 2 boutons indépendants
Alarme sonore et visuelle : Buzzer + LED
Alimentation : Connecteur DC002 + interruptuer à verrouillage
Relais *2 (pour chauffage et refroidisssement)
Capteur de température DS18B20
Module Bluetooth

Fonctionnalités principales :

1. Mesure en temps réel de la température du four
2. Activation du refroidissement et déclenchement de l'alarme lorsque la température dépasse le seuil
3. Activation du chauffage lorsque la température est inférieure au seuil
4. Consultation des données et modification des seuils via Bluetooth

1.2 Approche conceptuelle

Le microcontrôleur STM32F103C8T6 est sélectionné comme unité de traitement principale, couramment utilisé dans les projets STM32.

Pour l'affichage, un écran LCD1602 est choisi plutôt qu'un OLED. Dans la simulation Proteus, il faut rechercher LM016L pour le LCD1602. La broche 3 peut être connectée à un potentiomètre de 10kΩ pour ajuster les problèmes de visibilité, mais en simulation, une mise à la terre directe peut suffire.

Deux boutons indépendants permettent de régler les seuils de température. L'alarme combine un buzzer et une LED. L'alimentation comprend un connecteur DC002 et un interrupteur à verrouillage, avec une régulation de tension LDO de 5V à 3,3V.

Les relais sont pilotés par des transistors NPN pour contrôler l'activation. Le refroidissement est simulé avec un moteur représentant un ventilateur, et le chauffage avec une LED rouge en continu.

Le capteur DS18B20 mesure la température. Le Bluetooth est simulé via un terminal virtuel et des outils de débogage série.

1.3 Simulation du circuit

États de simulation :

• Avant démarrage : simulation inactive
• Démarrage : affichage de la température actuelle et des seuils sur l'écran, activation du chauffage si la température est basse
• Activation du refroidissement lorsque la température dépasse le seuil
• Modification des seuils via les boutons
• Consultation et réglage des paramètres via Bluetooth

1.4 Programme de simulation

1.4.1 Description du programme

Microcontrôleur : STM32F103C8
Horloge HSI : 64 MHz
Systick : 1 ms

Configuration des broches :

• Boutons : KEY1 (PA0), KEY2 (PA1)
• Capteur DS18B20 : DAT (PA4)
• Refroidissement : RELAY1 (PA6)
• Chauffage : RELAY2 (PA7)
• Simulation Bluetooth (Uart1) : 9600 bauds (PA9 : tx1, PA10 : rx1)
• Alarme : BUZZER (PA15)
• Écran LCD1602 : D0-D7 (PB0-PB7), EN (PB10), RW (PB11), RS (PB12)

Protocole série : commandes pour configurer les seuils (ex. *Temp50) ou lire les données (ex. *Read).

1.4.2 Programme principal

/* Inclusions ------------------------------------------------------------------*/
#include "Drv_UserSystem.h"
#include "stdio.h"
#include "stdlib.h"
#include "string.h"
/**
  * @brief  Fonction principale.
  * @param  aucun
  * @retval aucun
  */
int main(void)
{
    InitialisationSystemeUtilisateur(); // Initialisation des configurations utilisateur		
    while (1)
    {			
        if(stTempsSysteme.indicateur._10ms + DIX_MILLISECONDES < MillisecondesActuelles()) // 10ms
        {
            stTempsSysteme.indicateur._10ms = MillisecondesActuelles();
            BalayageBoutons(); // Scan des boutons				
        }			
        if(stTempsSysteme.indicateur._100ms + MEILLEURE_MILLISECONDE < MillisecondesActuelles()) // 100ms
        {
            stTempsSysteme.indicateur._100ms = MillisecondesActuelles();					
            CollecteDonneesDS18B20(); // Acquisition des données de température DS18B20	
            GestionAffichageLCD1602(); // Affichage sur LCD1602				
            GestionPrealarme(); // Fonction d'alerte préventive  				
            GestionReceptionDonnees(); // Traitement des données reçues 				
            ReinitialisationCompteurIWDG(); // Réinitialisation du watchdog 				
        }	
    }
}

1.4.3 Programme d'affichage LCD1602

void AfficherChaineLCD1602(uint8_t ligne, uint8_t colonne, uint8_t *chaine, uint8_t compte)
{
    uint8_t index;
    ligne %= 2;
    colonne %= 40;
    EcrireCommandeLCD1602(0x80 + ligne * 0x40 + colonne);
    for (index = 0; chaine[index] != '\0' && compte > 0 && colonne < 40; index++, colonne++, compte--)
    {
        EcrireDonneesLCD1602(chaine[index]);
    }
}

/*******************************************************************************
 * Nom de fonction : GestionAffichageLCD1602
 * Description     : Affichage sur l'écran LCD1602
 * Entrée          : void
 * Sortie          : void
 * Appel           : toutes les 100ms
 * Remarques       :
 *******************************************************************************/
void GestionAffichageLCD1602(void)
{
    AfficherChaineLCD1602(0, 0, "TEMP:" , 5);	
    AfficherChaineLCD1602(0, 6, (uint8_t *)tampon_temp1, 2);
    AfficherChaineLCD1602(0, 8, "." , 1);		
    AfficherChaineLCD1602(0, 9, (uint8_t *)tampon_temp2, 1);		

    AfficherChaineLCD1602(1, 0, "Seuil:" , 6);	
    AfficherChaineLCD1602(1, 11, (uint8_t *)tampon_seuil, 2);			
}

1.4.4 Programme de réception série

/*******************************************************************************
 * Nom de fonction : TraiterCommande1
 * Description     : Configurer le seuil de température
 * Entrée          : void
 * Sortie          : void
 * Appel           : selon besoin
 * Remarques       : ex. envoi *Temp50 pour régler le seuil à 50°C
 *******************************************************************************/
void TraiterCommande1(void)
{
    uint8_t indice = 0; 
    variable_config = (ConversionAsciiVersHex(tampon_rx_uart1[indice+5])*10 + ConversionAsciiVersHex(tampon_rx_uart1[indice+6]));
    if((variable_config > 0) && (variable_config < 100))
    {
        Seuil_Temperature = variable_config;
        printf("Seuil de température configuré via mobile = %d\r\n", Seuil_Temperature);	
    }
    else
    {
        printf("Seuil de température hors plage valide\r\n");			
    }
}

/*******************************************************************************
 * Nom de fonction : TraiterCommande2
 * Description     : Lire la température actuelle et le seuil
 * Entrée          : void
 * Sortie          : void
 * Appel           : selon besoin
 * Remarques       :
 *******************************************************************************/
void TraiterCommande2(void)
{
    printf("Température=%d.%d°C Seuil=%d°C\r\n", Temperature_Actuelle_Haute, Temperature_Actuelle_Basse, Seuil_Temperature);
}

/*******************************************************************************
 * Fonction    : GestionReceptionDonnees
 * Description : Traitement des données reçues
 * Entrée      : aucune
 * Sortie      : aucune
 * Appel       : toutes les 100ms
 * Autres      :
 *******************************************************************************/
void GestionReceptionDonnees(void)
{
    uint8_t compteur = 0;
    if(reception_uart1_terminee)
    {	  
        for(compteur = 0; compteur < 20; compteur++)
        {
            if(tampon_rx_uart1[compteur] == '*')	
            {
                switch(tampon_rx_uart1[compteur+1])
                {
                    case 'T': TraiterCommande1(); break; // *TempXX		
                    case 'R': TraiterCommande2(); break; // *Read								
                    default: break;							
                }							
            }
        }
        reception_uart1_terminee = 0;	
        compteur_reception_uart1 = 0;
        memset(tampon_rx_uart1, 0, TAILLE_MAX_RX);				
    }	
}

2. Synthèse technique

Cette conception détaille un système de régulation de température pour un four à résistance basé sur le microcontrôleur STM32, intégrant des composants de capteur, d'affichage, de contrôle et de communication sans fil pour une gestion automatisée.