Sonda del sensor de temperatura (Diseño de circuito funcional de DS18B20 y PT100)

Comparación entre Sensor de temperatura PT100 sonda y Módulo DS18B20
1) Principio básico de adquisición de señales.
① La resistencia del PT100 cambia proporcionalmente con la temperatura. (cuanto mayor sea la temperatura, cuanto mayor sea la resistencia), pero el cambio de resistencia es muy pequeño, acerca de 0.385 Oh / grado;
② El rango de medición de temperatura del PT100 es -200 ℃ -200 ℃, y a 0 ℃, la resistencia es exactamente igual a 100 Oh;
③ La corriente de funcionamiento del PT100 debe ser inferior a 5 mamá;
④ Aunque la resistencia del PT100 cambia proporcionalmente con la temperatura, su tasa de cambio (eso es, Valor K Valor K Valor K) es diferente en diferentes rangos de temperatura.

2) Tabla de cambio de resistencia de temperatura PT100

3. Circuito de accionamiento PT100

Circuito de accionamiento PT100

1) Mediante el método de división de voltaje., AD recopila voltaje PT100 para obtener el valor de resistencia para calcular la temperatura
El valor de resistencia de PT100 en agua a temperatura ambiente. (25℃25℃25℃) se trata de 109.89 Oh.
El microcontrolador genera un voltaje de 3,3 V., y el voltaje dividido por PT100 es aproximadamente:
109.89 ∗ 0.005 = 0.54945 V

El valor AD convertido según la fórmula de conversión AD es aproximadamente:
0.54945 / 3.3 ∗ 4096 = 681.98 ≈ 682

Cuando la temperatura sube un grado, suponiendo que la resistencia del PT100 simplemente aumenta en 0.385 Oh, el valor de cambio del voltaje dividido es aproximadamente igual a:
0.385 ∗ 0.005 = 0.001925 V

El valor AD convertido según la fórmula de conversión AD es aproximadamente:
0.001925 / 3.3 ∗ 4096 = 2.39 ≈ 2

en el experimento, se descubrió que debido al voltaje inestable de 3,3 V de la fuente de alimentación stm32, el ADC recopiló fluctuaciones de voltaje del PT100 y el error de división de voltaje fue grande. La solución de optimización es diseñar un circuito fuente de corriente constante.. Recopilando el voltaje de PT100 y la corriente de la fuente de corriente constante, Se puede obtener la resistencia de PT100., y luego se puede obtener el valor de la temperatura.

2) Circuito de fuente de corriente constante basado en regulador LDO (MD5333)
Hay muchos circuitos de conducción para probar el PT100 en Internet., como circuito puente CC, Circuito de fuente de corriente constante basado en un amplificador operacional., etc.. El autor también dedicó mucho tiempo a seleccionar el circuito de conducción., considerando la dificultad de hacer la placa y la cantidad de componentes, y finalmente eligió el circuito de fuente de corriente constante basado en el regulador LDO (MD5333). El diagrama del circuito es el siguiente.:

Circuito de fuente de corriente constante del regulador LDO (MD5333)

En este punto, la selección de hardware se ha completado básicamente. La placa de desarrollo utilizada es la placa Elite Zhengdian Atom F10ZET6.

Módulo DS18B20
Para probar la temperatura en tiempo real y la comparación de temperatura PT100, Se agrega el módulo DS18B20 para la prueba de comparación de calibración.

1) Introducción a DS18B20
DS18B20 es un sensor de temperatura de bus único con un rango de temperatura de prueba de -55~+125℃ y una precisión de ±0,5℃. La temperatura de campo se transmite directamente de forma digital con un solo bus., lo que mejora en gran medida la capacidad antiinterferencia del sistema. Puede leer directamente la temperatura medida., y puede realizar un método de lectura de valores digitales de 9 ~ 12 bits mediante una programación simple de acuerdo con los requisitos reales. Su rango de voltaje de funcionamiento es de 3 ~ 5,5 V., y utiliza una variedad de formas de embalaje, haciendo que la configuración del sistema sea flexible y conveniente. La resolución establecida y la temperatura de alarma establecida por el usuario se almacenan en la EEPROM y aún se guardan después de un corte de energía..

Diseño de circuito DS18B20

2) Introducción al tiempo de trabajo DS18B20
Todos los dispositivos de bus único requieren una sincronización estricta de la señal para garantizar la integridad de los datos.. DS18B20 tiene 6 tipos de señal: restablecer el pulso, pulso de respuesta, escribir 0, escribir 1, leer 0 y leer 1. Todas estas señales, excepto el pulso de respuesta, Son señales sincrónicas enviadas por el host.. Y todos los comandos y datos se envían primero con el bit bajo del byte..

DS18B20 pulso de reinicio y pulso de respuesta

① Pulso de reinicio y pulso de respuesta
Todas las comunicaciones en el bus único comienzan con una secuencia de inicialización.. El host genera un nivel bajo y lo mantiene durante al menos 480us para generar un pulso de reinicio.. Entonces el anfitrión suelta el autobús., y la resistencia pull-up de 4.7K eleva el bus único, con un tiempo de retraso de 15~60us, y entra en modo de recepción (receta). Luego, DS18B20 baja el bus durante 60 ~ 240us para generar un pulso de respuesta de bajo nivel..

Temporización de escritura DS18B20

② Escribir tiempo
El tiempo de escritura incluye escritura. 0 sincronizar y escribir 1 momento. Todos los tiempos de escritura requieren al menos 60us, y se requiere al menos 1us de tiempo de recuperación entre dos tiempos de escritura independientes. Ambos tiempos de escritura comienzan con el host bajando el bus.. Escribir 1 momento: el host genera un nivel bajo, retrasos para 2us, y luego suelta el autobús, retrasando 60us. Escribir 0 momento: el host genera un nivel bajo, retrasos por 60us, y luego suelta el autobús con un retraso de 2us.

DS18B20 Temporización de lectura

③ Leer el tiempo
Los dispositivos de bus único transmiten datos al host solo cuando el host emite un tiempo de lectura. Por lo tanto, después de que el host emite un comando de lectura de datos, Se debe generar un tiempo de lectura inmediatamente para que el esclavo pueda transmitir datos.. Todos los tiempos de lectura requieren al menos 60 us, y se requiere al menos 1us de tiempo de recuperación entre dos tiempos de lectura independientes. Cada tiempo de lectura es iniciado por el host., que detiene el autobús durante al menos 1 us. El host debe liberar el bus durante el tiempo de lectura y muestrear el estado del bus dentro de los 15 us posteriores al inicio del tiempo.. El proceso típico de sincronización de lectura es: el host genera un retardo de bajo nivel de 2us, luego el host cambia al modo de entrada con un retardo de 12us, luego lee el nivel actual del bus único, y luego se retrasa 50us.

DS18B20 abre el puerto serie para imprimir información de temperatura

Después de comprender el horario del autobús único, echemos un vistazo al proceso típico de lectura de temperatura del DS18B20. El proceso típico de lectura de temperatura del DS18B20 es: restablecer → enviar SKIPROM (0xCC) → enviar comando de inicio de conversión (0x44) → retrasar → restablecer → enviar comando SKIPROM (0xCC) → enviar comando de memoria (0xBE) → leer dos bytes de datos (es decir. temperatura) continuamente → fin.

3) Diagrama esquemático y configuración de CUBEMAX.
Del diagrama esquemático, Se puede ver que DS18B20 está habilitado por el puerto PG11 para abrir el puerto serie para imprimir información de temperatura.

Esquema DS18B20 y configuración CUBEMAX

Interfaz del sensor de temperatura y humedad DS18B20

4) Parte del código
La parte del código trasplanta la biblioteca ds18b20 de Zhengdian Atom y realiza ligeras modificaciones.

#ifndef __DS18B20_H
#definir __DS18B20_H

#incluir “tim.h”
/***********************************************************************************/
/* Definición de pines DS18B20 */

#definir DS18B20_DQ_GPIO_PORT GPIOG
#definir DS18B20_DQ_GPIO_PIN GPIO_PIN_11
#definir DS18B20_DQ_GPIO_CLK_ENABLE() hacer{ __HAL_RCC_GPIOG_CLK_ENABLE(); }mientras(0) /* Habilitación del reloj del puerto PG */

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

/* Función de operación IO */
#definir DS18B20_DQ_OUT(X) hacer{ 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); \
}mientras(0) /* Salida del puerto de datos */
#definir DS18B20_DQ_IN HAL_GPIO_ReadPin(DS18B20_DQ_GPIO_PORT, DS18B20_DQ_GPIO_PIN) /* Entrada del puerto de datos */

uint8_t ds18b20_init(vacío); /* Inicializar DS18B20 */
uint8_t ds18b20_check(vacío); /* Compruebe si existe DS18B20 */
corto ds18b20_get_temperature(vacío);/* Obtener temperatura */

#endif

5. Módulo de control remoto por infrarrojos
1) Protocolo de codificación de módulo inalámbrico

Los métodos de codificación más utilizados para el control remoto por infrarrojos son: Protocolo NEC de PWM (modulación de ancho de pulso) y protocolo RC-5 de Philips PPM (modulación de posición del pulso). El control remoto que viene con la placa de desarrollo utiliza el protocolo NEC, que tiene las siguientes características:

1. 8-dirección de bits y longitud de instrucción de 8 bits;

2. La dirección y el comando se transmiten dos veces. (para garantizar la confiabilidad);

3. Modulación de posición de pulso PWM, con el ciclo de trabajo de la portadora de infrarrojos transmitida que representa “0” y “1”;

4. La frecuencia portadora es de 38Khz.;

5. El tiempo de bits es de 1,125 ms o 2,25 ms.;

En el protocolo NEC, cómo configurar los datos en el protocolo para ‘0’ o '1'? Aquí, El receptor de infrarrojos y el transmisor de infrarrojos están separados..

Transmisor de infrarrojos: Enviar datos de protocolo '0' = 560us de transmisión de señal portadora + 560nosotros sin transmisión de señal portadora

Enviar datos de protocolo '1' = 560us de transmisión de señal portadora + 1680nosotros sin transmisión de señal portadora

La definición de bits del transmisor de infrarrojos se muestra en la siguiente figura.

Receptor de infrarrojos: Recibir datos de protocolo '0' = 560us nivel bajo + 560nosotros de alto nivel

Recibir datos de protocolo '1' = 560us nivel bajo + 1680nosotros de alto nivel

El formato de datos del comando de control remoto NEC es: terminal de sincronización, código de dirección, código inverso de dirección, código de control, controlar el código inverso. El código de sincronización consta de un nivel bajo de 9 ms y un nivel alto de 4,5 ms.. El código de dirección, código inverso de dirección, código de control, y el código inverso de control son todos formatos de datos de 8 bits. Se envían en el orden de bit bajo primero y bit alto al final.. El código inverso se utiliza para aumentar la confiabilidad de la transmisión..

Por lo tanto, La captura de entrada se puede utilizar para medir el ancho del pulso del nivel alto para lograr la decodificación del control remoto..
2) Diagrama esquemático y configuración de CUBEMAX.

Del diagrama esquemático, Podemos ver que el módulo inalámbrico se habilita a través del pin PB9 y recoge a través del 4 canales de TIM4:

El pin predeterminado de TIM4_CH4 no es PB9, por lo que debe configurarse manualmente, y la configuración de interrupción se activa al mismo tiempo

3) Parte del código
Capture el flanco ascendente a través de la función de devolución de llamada de tim

En este momento, La señal decodificada se puede obtener.:

En este momento, los datos son más complejos y pueden procesarse ligeramente:

El efecto es el siguiente:
Los dos últimos dígitos son el código decodificado y su inverso.. En este momento, Se puede definir como una macro para ajustar el umbral de temperatura.:

El efecto es el siguiente:

Código de pieza infrarrojo:

/* CÓDIGO DE USUARIO COMENZAR Encabezado */
/**
******************************************************************************
* @archivo : principal.c
* @breve : Cuerpo principal del programa
******************************************************************************
* @atención
*
* <h2><centro>&Copiar; Derechos de autor (do) 2024 STMicroelectrónica.
* Reservados todos los derechos.</centro></h2>
*
* Este componente de software tiene licencia de ST según la licencia BSD de 3 cláusulas.,
* el “Licencia”; No puede utilizar este archivo excepto de conformidad con las
* Licencia. Puede obtener una copia de la Licencia en:
* opensource.org/licenses/BSD-3-Clause
*
******************************************************************************
*/
/* Encabezado FINAL DEL CÓDIGO DE USUARIO */
/* Incluye ——————————————————————*/
#incluir “principal.h”
#incluir “tim.h”
#incluir “usart.h”
#incluir “gpio.h”

/* Privado incluye ———————————————————-*/
/* CÓDIGO DE USUARIO COMENZAR Incluye */
#incluir “stdio.h”
#incluir “cadena.h”
#definir MAXUP 157
#definir MAXDOWN 87
#definir minup 221
#definir la mente 61
/* FINAL CÓDIGO DE USUARIO Incluye */

/* definición de tipo privado ———————————————————–*/
/* CÓDIGO DE USUARIO COMENZAR PTD */

/* CÓDIGO DE USUARIO FINAL PTD */

/* definición privada ————————————————————*/
/* CÓDIGO DE USUARIO COMENZAR PD */
/* CÓDIGO DE USUARIO FINAL PD */

/* Macro privada ————————————————————-*/
/* CÓDIGO DE USUARIO COMIENZO PM */

/* CÓDIGO DE USUARIO FIN PM */

/* variables privadas ———————————————————*/

/* CÓDIGO DE USUARIO COMIENZO PV */
uint32_t upCount=0;
uint16_t ValorArriba=0;
uint16_t ValorAbajo=0;
uint8_t isUpCapt=1;
uint16_t ancho=0;
búfer uint16_t[128]={0};
uint16_t bufferId=0;
uint8_t rcvFalg=0;
/* CÓDIGO DE USUARIO FINAL PV */

/* Prototipos de funciones privadas. ———————————————–*/
anular SystemClock_Config(vacío);
/* CÓDIGO DE USUARIO COMIENZO PFP */

/* CÓDIGO DE USUARIO FINALIZAR PFP */

/* código de usuario privado ———————————————————*/
/* CÓDIGO DE USUARIO COMENZAR 0 */
anular HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
recuento+++;
}
anular HAL_TIM_IC_CaptureCallback(TIM_HandleTypeDef *htim)
{
si(isUpCapt)//Si se trata de captura de borde ascendente
{
ValorUp=HAL_TIM_ReadCapturedValue(htim,TIM_CHANNEL_4);
isUpCapt=0;
__HAL_TIM_SET_CAPTUREPOLARITY(htim,TIM_CHANNEL_4,TIM_ICPOLARITY_FALLING);
recuento ascendente=0;
}
demás{
ValorDown=HAL_TIM_ReadCapturedValue(htim,TIM_CHANNEL_4);
isUpCapt=1;
__HAL_TIM_SET_CAPTUREPOLARITY(htim,TIM_CHANNEL_4,TIM_ICPOLARITY_RISING);
ancho=ValorAbajo+ConteoAscendente*65536-ValorArriba;
si(ancho>4400&&ancho<4600)
{
ID de búfer = 0;
buffer[ID de búfer++]= ancho;
}
más si(ID de búfer>0)
{
buffer[ID de búfer++]= ancho;
si(ID de búfer>32)
{
rcvFalg=1;
ID de búfer = 0;
}
}
}
}
bitBuffer2num vacío(número de carácter[])
{
número[0]=0;
número[1]=0;
número[2]=0;
número[3]=0;
para(entero i=0;i<32;yo ++)
{
si(buffer[yo+1]<1000)
{
número[i/8]=núm[i/8]<<1;
}
demás
{
número[i/8]=núm[i/8]<<1;
número[i/8]|=0x01;
}
}
}
/* FIN DEL CÓDIGO DE USUARIO 0 */

/**
* @brief El punto de entrada de la aplicación.
* @retvalint
*/
ent principal(vacío)
{
/* CÓDIGO DE USUARIO COMENZAR 1 */
impresión de carbón[128]={0};
número de carácter[4]={0};
clave de carácter = 0;
/* FIN DEL CÓDIGO DE USUARIO 1 */

/* Configuración de MCU——————————————————–*/

/* Restablecimiento de todos los periféricos., Inicializa la interfaz Flash y el Systick.. */
HAL_Inicio();

/* CÓDIGO DE USUARIO COMENZAR Inicio */

/* CÓDIGO DE USUARIO FINAL Iniciar */

/* Configurar el reloj del sistema */
SystemClock_Config();

/* CÓDIGO DE USUARIO COMENZAR SysInit */

/* CÓDIGO DE USUARIO FINAL SysInit */

/* Inicializar todos los periféricos configurados */
MX_GPIO_Init();
MX_TIM4_Init();
MX_USART1_UART_Init();
/* CÓDIGO DE USUARIO COMENZAR 2 */

/* FIN DEL CÓDIGO DE USUARIO 2 */

/* bucle infinito */
/* CÓDIGO DE USUARIO COMIENZA MIENTRAS */
HAL_GPIO_TogglePin(LED0_GPIO_Puerto,LED0_Pin);
HAL_TIM_Base_Start_IT(&htim4);//La actualización del temporizador genera una interrupción
HAL_TIM_IC_Inicio_IT(&htim4,TIM_CHANNEL_4);//
mientras (1)
{
si(rcvFalg)
{
para(entero i=0;i<4;yo ++)
{
bitBuffer2num(número);
sprintf(impresor,”0xx “,número[i]);
HAL_UART_Transmitir(&huart1,printbuff,fuerza(impresor),HAL_MAX_DELAY);
}
// sprintf(impresor,”%tu “,buffer[i]);
// HAL_UART_Transmitir(&huart1,printbuff,fuerza(impresor),HAL_MAX_DELAY);
// }
HAL_UART_Transmitir(&huart1,”\rn”,2,HAL_MAX_DELAY);
rcvFalg=0;
}
imprimirf(“%drn”,número[3]);
si(número[3]==157)
{
imprimirf(“111111\rn”);
}
HAL_Retraso(1000);
/* CÓDIGO DE USUARIO FINALIZA MIENTRAS */

/* CÓDIGO DE USUARIO COMENZAR 3 */
}
/* FIN DEL CÓDIGO DE USUARIO 3 */
}

/**
* @brief Configuración del reloj del sistema
* @retval Ninguno
*/
anular SystemClock_Config(vacío)
{
RCC_OscInitTypeDef RCC_OscInitStruct = {0};
RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};