Sonde de capteur de température (Conception de circuits fonctionnels du DS18B20 et du PT100)

Comparaison entre Capteur de température PT100 sonde et Module DS18B20
1) Principe de base de l'acquisition du signal
① La résistance du PT100 change proportionnellement à la température (plus la température est élevée, plus la résistance est grande), mais le changement de résistance est très faible, à propos 0.385 Oh / degré;
② La plage de mesure de température du PT100 est de -200 ℃ -200 ℃, et à 0℃, la résistance est exactement égale à 100 Oh;
③ Le courant de fonctionnement du PT100 doit être inférieur à 5 mA;
④ Bien que la résistance du PT100 change proportionnellement à la température, son taux de changement (c'est, Valeur K Valeur K Valeur K) est différent dans différentes plages de température.

2) Tableau de changement de résistance à la température PT100

3. Circuit de commande PT100

Circuit de commande PT100

1) Grâce à la méthode de division de tension, AD collecte la tension PT100 pour obtenir la valeur de résistance afin de calculer la température
La valeur de résistance du PT100 dans l'eau à température ambiante (25℃25℃25℃) il s'agit de 109.89 Oh.
Le microcontrôleur produit une tension de 3,3 V, et la tension divisée par PT100 est d'environ:
109.89 * 0.005 = 0.54945 V

La valeur AD convertie selon la formule de conversion AD est d'environ:
0.54945 / 3.3 * 4096 = 681.98 ≈ 682

Quand la température monte d'un degré, en supposant que la résistance du PT100 augmente simplement de 0.385 Oh, la valeur de changement de la tension divisée est approximativement égale à:
0.385 * 0.005 = 0.001925 V

La valeur AD convertie selon la formule de conversion AD est d'environ:
0.001925 / 3.3 * 4096 = 2.39 ≈ 2

Dans l'expérience, il a été constaté qu'en raison de la tension instable de 3,3 V de l'alimentation stm32, l'ADC a collecté les fluctuations de tension PT100 et l'erreur de division de tension était importante. La solution d'optimisation consiste à concevoir un circuit source de courant constant. En collectant la tension du PT100 et le courant de la source de courant constant, la résistance du PT100 peut être obtenue, puis la valeur de la température peut être obtenue.

2) Circuit source de courant constant basé sur un régulateur LDO (MD5333)
Il existe de nombreux circuits de conduite pour tester le PT100 sur Internet, tel qu'un circuit en pont CC, circuit source de courant constant basé sur un amplificateur opérationnel, etc.. L'auteur a également passé beaucoup de temps à sélectionner le circuit de conduite., compte tenu de la difficulté de fabrication de la carte et du nombre de composants, et finalement choisi le circuit source de courant constant basé sur le régulateur LDO (MD5333). Le schéma de circuit est le suivant:

Circuit source de courant constant du régulateur LDO (MD5333)

À ce point, la sélection du matériel est pratiquement terminée. La carte de développement utilisée est la carte Zhengdian Atom F10ZET6 Elite

Module DS18B20
Afin de tester la température en temps réel et la comparaison de température PT100, le module DS18B20 est ajouté pour le test de comparaison d'étalonnage

1) Présentation du DS18B20
DS18B20 est un capteur de température à bus unique avec une plage de température de test de -55 ~ + 125 ℃ et une précision de ± 0,5 ℃.. La température du champ est directement transmise de manière numérique à un seul bus, ce qui améliore considérablement la capacité anti-interférence du système. Il peut lire directement la température mesurée, et peut réaliser une méthode de lecture de valeur numérique de 9 à 12 bits grâce à une programmation simple selon les exigences réelles. Sa plage de tension de fonctionnement est de 3 à 5,5 V, et il utilise une variété de formes d'emballage, rendant le réglage du système flexible et pratique. La résolution définie et la température d'alarme définie par l'utilisateur sont stockées dans l'EEPROM et sont toujours enregistrées après une panne de courant..

Conception de circuits DS18B20

2) Introduction au timing de travail DS18B20
Tous les appareils à bus unique nécessitent une synchronisation stricte des signaux pour garantir l'intégrité des données.. DS18B20 a 6 types de signaux: réinitialiser le pouls, impulsion de réponse, écrire 0, écrire 1, lire 0 et lire 1. Tous ces signaux, sauf l'impulsion de réponse, sont des signaux synchrones envoyés par l'hôte. Et toutes les commandes et données sont envoyées avec le bit faible de l'octet en premier.

DS18B20 impulsion de réinitialisation et impulsion de réponse

① Réinitialiser l'impulsion et l'impulsion de réponse
Toutes les communications sur le bus unique commencent par une séquence d'initialisation. L'hôte émet un niveau bas et maintient le niveau bas pendant au moins 480 us pour générer une impulsion de réinitialisation.. Puis l'hôte libère le bus, et la résistance pull-up 4,7K tire le bus unique vers le haut, avec un temps de retard de 15 ~ 60us, et passe en mode réception (réception). Ensuite, le DS18B20 abaisse le bus pendant 60 à 240 us pour générer une impulsion de réponse de bas niveau..

Synchronisation d'écriture DS18B20

② Calendrier d'écriture
Le timing d'écriture inclut l'écriture 0 chronométrer et écrire 1 timing. Tous les délais d'écriture nécessitent au moins 60 us, et un temps de récupération d'au moins 1us est requis entre deux timings d'écriture indépendants. Les deux délais d'écriture commencent lorsque l'hôte arrête le bus.. Écrire 1 timing: l'hôte émet un niveau faible, retards pour 2us, puis libère le bus, retarder 60us. Écrire 0 timing: l'hôte émet un niveau faible, retards pour 60us, puis libère le bus avec un retard de 2us.

Synchronisation de lecture DS18B20

③ Lecture du timing
Les appareils à bus unique transmettent les données à l'hôte uniquement lorsque celui-ci émet un timing de lecture.. Donc, après que l'hôte a émis une commande de lecture de données, un timing de lecture doit être généré immédiatement pour que l'esclave puisse transmettre des données. Tous les timings de lecture nécessitent au moins 60us, et un temps de récupération d'au moins 1us est requis entre deux timings de lecture indépendants. Chaque timing de lecture est initié par l'hôte, qui abaisse le bus pendant au moins 1 us. L'hôte doit libérer le bus pendant la synchronisation de lecture et échantillonner l'état du bus dans les 15 us après le début de la synchronisation.. Le processus typique de synchronisation de lecture est: l'hôte émet un retard de faible niveau de 2us, puis l'hôte passe au mode d'entrée avec un délai de 12us, lit ensuite le niveau actuel du bus unique, puis retarde 50us.

DS18B20 ouvre le port série pour imprimer les informations de température

Après avoir compris le timing d'un seul bus, Jetons un coup d'œil au processus typique de lecture de la température du DS18B20. Le processus typique de lecture de la température du DS18B20 est: réinitialiser → envoyer SKIPROM (0xCC) → envoyer la commande de démarrage de la conversion (0x44) → retard → réinitialisation → envoyer la commande SKIPROM (0xCC) → envoyer la commande mémoire (0xBE) → lire deux octets de données (c'est à dire. température) en continu → fin.

3) Diagramme schématique et configuration CUBEMAX
À partir du diagramme schématique, on peut voir que le DS18B20 est activé par le port PG11 pour ouvrir le port série afin d'imprimer les informations de température

Schéma DS18B20 et configuration CUBEMAX

Interface de capteur de température et d'humidité DS18B20

4) Partie code
La partie code transplante la bibliothèque ds18b20 de Zhengdian Atom et apporte de légères modifications

#ifndef __DS18B20_H
#définir __DS18B20_H

#inclure “tim.h”
/***********************************************************************************/
/* Définition des broches DS18B20 */

#définir DS18B20_DQ_GPIO_PORT GPIOG
#définir DS18B20_DQ_GPIO_PIN GPIO_PIN_11
#définir DS18B20_DQ_GPIO_CLK_ENABLE() faire{ __HAL_RCC_GPIOG_CLK_ENABLE(); }alors que(0) /* Activation de l'horloge du port PG */

/**********************************************************************************************/

/* Fonction d'opération IO */
#définir DS18B20_DQ_OUT(X) faire{ X ? \
HAL_GPIO_WritePin(DS18B20_DQ_GPIO_PORT, DS18B20_DQ_GPIO_PIN, GPIO_PIN_SET) : \
HAL_GPIO_WritePin(DS18B20_DQ_GPIO_PORT, DS18B20_DQ_GPIO_PIN, GPIO_PIN_RESET); \
}alors que(0) /* Sortie du port de données */
#définir DS18B20_DQ_IN HAL_GPIO_ReadPin(DS18B20_DQ_GPIO_PORT, DS18B20_DQ_GPIO_PIN) /* Entrée du port de données */

uint8_t ds18b20_init(vide); /* Initialiser DS18B20 */
uint8_t ds18b20_check(vide); /* Vérifiez si DS18B20 existe */
court ds18b20_get_temperature(vide);/* Obtenir la température */

#fin

5. Module de télécommande infrarouge
1) Protocole de codage du module sans fil

Les méthodes de codage largement utilisées pour la télécommande infrarouge sont: Protocole NEC de PWM (modulation de largeur d'impulsion) et protocole RC-5 de Philips PPM (modulation de position d'impulsion). La télécommande fournie avec la carte de développement utilise le protocole NEC, qui présente les caractéristiques suivantes:

1. 8-adresse de bit et longueur d'instruction de 8 bits;

2. L'adresse et la commande sont transmises deux fois (pour garantir la fiabilité);

3. Modulation de position d'impulsion PWM, avec le rapport cyclique de la porteuse infrarouge transmise représentant “0” et “1”;

4. La fréquence porteuse est de 38 Khz;

5. Le temps de bit est de 1,125 ms ou 2,25 ms;

Dans le protocole NEC, comment définir les données dans le protocole pour ‘0’ ou '1'? Ici, le récepteur infrarouge et l'émetteur infrarouge sont séparés.

Émetteur infrarouge: Envoyer les données du protocole « 0 » = 560 us de transmission du signal porteur + 560nous n'avons aucune transmission de signal porteur

Envoyer les données du protocole « 1 » = 560 us de transmission du signal porteur + 1680nous n'avons aucune transmission de signal porteur

La définition des bits de l'émetteur infrarouge est indiquée dans la figure ci-dessous

Récepteur infrarouge: Recevoir les données du protocole « 0 » = niveau bas 560us + 560nous, haut niveau

Recevoir les données du protocole « 1 » = 560us niveau bas + 1680nous, haut niveau

Le format de données de la commande de télécommande NEC est: borne de synchronisation, code d'adresse, adresse code inverse, code de contrôle, code inverse de contrôle. Le code de synchronisation se compose d'un niveau bas de 9 ms et d'un niveau haut de 4,5 ms. Le code d'adresse, adresse code inverse, code de contrôle, et le code inverse de contrôle sont tous des formats de données 8 bits. Ils sont envoyés dans l'ordre du bit faible en premier et du bit élevé en dernier.. Le code inverse est utilisé pour augmenter la fiabilité de la transmission.

Donc, la capture d'entrée peut être utilisée pour mesurer la largeur d'impulsion du niveau haut afin de réaliser le décodage de la télécommande.
2) Diagramme schématique et configuration CUBEMAX

À partir du diagramme schématique, nous pouvons voir que le module sans fil est activé via la broche PB9 et collecte via le 4 canaux de TIM4:

La broche par défaut de TIM4_CH4 n'est pas PB9, il faut donc le régler manuellement, et le réglage d'interruption est activé en même temps

3) Partie code
Capturez le front montant via la fonction de rappel tim

A cette époque, le signal décodé peut être obtenu:

A cette époque, les données sont plus complexes et peuvent être légèrement traitées:

L'effet est le suivant:
Les deux derniers chiffres sont le décodé et son code inverse. A cette époque, il peut être défini comme une macro pour ajuster le seuil de température:

L'effet est le suivant:

Code pièce infrarouge:

/* CODE UTILISATEUR DÉBUT En-tête */
/**
******************************************************************************
* @déposer : main.c
* @bref : Corps principal du programme
******************************************************************************
* @attention
*
* <h2><centre>&copie; Droit d'auteur (c) 2024 STMicroélectronique.
* Tous droits réservés.</centre></h2>
*
* Ce composant logiciel est sous licence ST sous licence BSD 3-Clause,
* le “Licence”; Vous ne pouvez utiliser ce fichier qu'en conformité avec les
* Licence. Vous pouvez obtenir une copie de la licence à:
* opensource.org/licenses/BSD-3-Clause
*
******************************************************************************
*/
/* FIN DU CODE UTILISATEUR En-tête */
/* Comprend ——————————————————————*/
#inclure “main.h”
#inclure “tim.h”
#inclure “usart.h”
#inclure “gpio.h”

/* Les inclusions privées ———————————————————-*/
/* DÉBUT DU CODE UTILISATEUR Comprend */
#inclure “stdio.h”
#inclure “chaîne.h”
#définir MAXUP 157
#définir MAXDOWN 87
#définir MINUP 221
#définir MINDOWN 61
/* FIN DU CODE UTILISATEUR Comprend */

/* Typedef privé ———————————————————–*/
/* CODE UTILISATEUR DÉBUT PTD */

/* CODE UTILISATEUR FIN PTD */

/* Définition privée ————————————————————*/
/* CODE UTILISATEUR DÉBUT PD */
/* CODE UTILISATEUR FIN PD */

/* Macro privée ————————————————————-*/
/* CODE UTILISATEUR DÉBUT PM */

/* CODE UTILISATEUR FIN PM */

/* Variables privées ———————————————————*/

/* CODE UTILISATEUR DÉBUT PV */
uint32_t upCount=0;
uint16_t ValueUp=0;
uint16_t ValueDown=0;
uint8_t isUpCapt=1;
uint16_t largeur=0;
tampon uint16_t[128]={0};
uint16_t bufferId=0;
uint8_t rcvFalg=0;
/* CODE UTILISATEUR FIN PV */

/* Prototypes de fonctions privées ———————————————–*/
annuler SystemClock_Config(vide);
/* CODE UTILISATEUR DÉBUT PFP */

/* CODE UTILISATEUR FIN PFP */

/* Code utilisateur privé ———————————————————*/
/* DÉBUT DU CODE UTILISATEUR 0 */
annuler HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
nombreup++;
}
annuler HAL_TIM_IC_CaptureCallback(TIM_HandleTypeDef *htim)
{
si(estUpCapt)//S'il s'agit d'une capture de front montant
{
ValueUp=HAL_TIM_ReadCapturedValue(htim,TIM_CHANNEL_4);
estUpCapt=0;
__HAL_TIM_SET_CAPTUREPOLARITY(htim,TIM_CHANNEL_4,TIM_ICPOLARITY_FALLING);
upCount=0;
}
autre{
ValueDown=HAL_TIM_ReadCapturedValue(htim,TIM_CHANNEL_4);
estUpCapt=1;
__HAL_TIM_SET_CAPTUREPOLARITY(htim,TIM_CHANNEL_4,TIM_ICPOLARITY_RISING);
largeur = ValueDown + upCount * 65536-ValueUp;
si(largeur>4400&&largeur<4600)
{
ID tampon = 0;
tampon[ID tampon++]=largeur;
}
sinon si(ID tampon>0)
{
tampon[ID tampon++]=largeur;
si(ID tampon>32)
{
rcvFalg=1;
ID tampon = 0;
}
}
}
}
annuler bitBuffer2num(numéro de caractère[])
{
num[0]=0;
num[1]=0;
num[2]=0;
num[3]=0;
pour(entier je = 0;je<32;je++)
{
si(tampon[je+1]<1000)
{
num[je/8]=numéro[je/8]<<1;
}
autre
{
num[je/8]=numéro[je/8]<<1;
num[je/8]|=0x01;
}
}
}
/* FIN DU CODE UTILISATEUR 0 */

/**
* @brief Le point d'entrée de l'application.
* @retval int
*/
int principal(vide)
{
/* DÉBUT DU CODE UTILISATEUR 1 */
char printbuff[128]={0};
numéro de caractère[4]={0};
clé de caractère = 0;
/* FIN DU CODE UTILISATEUR 1 */

/* Configuration du microcontrôleur——————————————————–*/

/* Réinitialisation de tous les périphériques, Initialise l'interface Flash et le Systick. */
HAL_Init();

/* CODE UTILISATEUR DÉBUT Init */

/* FIN DU CODE UTILISATEUR Init */

/* Configurer l'horloge système */
SystemClock_Config();

/* CODE UTILISATEUR DÉBUT SysInit */

/* FIN DU CODE UTILISATEUR SysInit */

/* Initialiser tous les périphériques configurés */
MX_GPIO_Init();
MX_TIM4_Init();
MX_USART1_UART_Init();
/* DÉBUT DU CODE UTILISATEUR 2 */

/* FIN DU CODE UTILISATEUR 2 */

/* Boucle infinie */
/* CODE UTILISATEUR COMMENCER PENDANT */
HAL_GPIO_TogglePin(LED0_GPIO_Port,LED0_Broche);
HAL_TIM_Base_Start_IT(&htim4);//La mise à jour du minuteur génère une interruption
HAL_TIM_IC_Start_IT(&htim4,TIM_CHANNEL_4);//
alors que (1)
{
si(rcvFalg)
{
pour(entier je = 0;je<4;je++)
{
bitBuffer2num(num);
sprintf(tampon d'impression,”0xx “,num[je]);
HAL_UART_Transmission(&huart1, printbuff,stren(tampon d'impression),HAL_MAX_DELAY);
}
// sprintf(tampon d'impression,”%toi “,tampon[je]);
// HAL_UART_Transmission(&huart1, printbuff,stren(tampon d'impression),HAL_MAX_DELAY);
// }
HAL_UART_Transmission(&huart1,”\rn”,2,HAL_MAX_DELAY);
rcvFalg=0;
}
imprimer(“%drn”,num[3]);
si(num[3]==157)
{
imprimer(“111111\rn”);
}
HAL_Délai(1000);
/* FIN DU CODE UTILISATEUR PENDANT QUE */

/* DÉBUT DU CODE UTILISATEUR 3 */
}
/* FIN DU CODE UTILISATEUR 3 */
}

/**
* @brève configuration de l'horloge système
* @retval Aucun
*/
annuler SystemClock_Config(vide)
{
RCC_OscInitTypeDef RCC_OscInitStruct = {0};
RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};