Manual de usuario de la placa de demostración de termopila infrarroja digital SL-W-TRS-5.5Dx

SLKOR es una empresa de alta tecnología que integra el diseño, desarrollo, producción y venta de productos electrónicos. Proporciona a los clientes productos confiables y los servicios técnicos correspondientes. La marca "SLKOR" se ha convertido gradualmente en una empresa de renombre internacional, que ofrece productos y soluciones a más de 10,000 clientes en todo el mundo.

En un esfuerzo por ofrecer a los clientes una gama completa de productos complementarios, SLKOR ha lanzado una serie de manuales de usuario para las placas de demostración de diseños de aplicaciones de medición de temperatura sin contacto mediante termopila infrarroja digital.

1.1 nombre: Manual de usuario para SLKOR Placa de demostración de diseño de aplicación de medición de temperatura sin contacto con termopila infrarroja digital

Aplicaciones 1.2:Dispositivos portátiles inteligentes, teléfonos inteligentes, monitoreo de temperatura industrial, medición de temperatura de la superficie del cuerpo humano sin contacto, detección y control de temperatura inteligente y otros dispositivos de tamaño pequeño para medición de temperatura de corto alcance.

Placa de demostración de la serie 1.3 SL-W-TRS-5.5Dx:

Se utiliza para evaluar y probar varios tipos de sensores. Los resultados de la medición se mostrarán en la pantalla y se pueden imprimir en el software de depuración del puerto serie de la PC a través de USB al puerto serie. Descripción del botón: El botón izquierdo es para reiniciar y el botón derecho puede controlar el inicio y la pausa del programa.

2. Diseño de hardware de la serie SL-W-TRS-5.5Dx

Los pines del chip incluyen la fuente de alimentación y el bus I2C, con un total de 4 pines. El rango permitido de voltaje de suministro es de 2.3 a 3.6 V. El sensor en sí tiene un consumo de energía muy bajo. Un condensador de 0.1 uF entre la toma de tierra de la fuente de alimentación es suficiente. Si el sensor está relativamente lejos de la parte de la fuente de alimentación, se puede considerar un condensador adicional de 10 uF para garantizar una fuente de alimentación estable y reducir el ruido.

3. Descripción de la placa de demostración de la serie SL-W-TRS-5.5Dx

3.1 La placa de demostración se alimenta mediante un conector tipo C y el voltaje de la fuente de alimentación para la placa de demostración es de 5 V. Cuando esté en uso, conecte la placa de demostración a la PC mediante el conector tipo C y luego podrá ver los resultados en la pantalla. Si necesita mostrar datos a través del puerto serie, deberá instalar el programa controlador WCH CH340 y luego utilizar el software de depuración del puerto serie para operar. La configuración de comunicación del puerto serie es la siguiente: Velocidad en baudios: 9600, bits de datos: 8, bits de parada: 1 y sin verificación de paridad.

3.2 La pantalla de visualización de la placa de demostración de arriba a abajo es la siguiente: temperatura ambiente (tamb), voltaje de salida del sensor (vtp_cor), temperatura del objeto (superficie) (tobj) y temperatura del cuerpo humano (tbdy). La unidad de los valores de temperatura anteriores es °C y la unidad de voltaje es μV. Entre ellos, los primeros tres valores son las salidas originales del dispositivo. El valor de la temperatura corporal se calcula en función de los valores originales utilizando el algoritmo de nuestra empresa y es solo para referencia. Los usuarios pueden procesar los datos utilizando sus propios algoritmos de temperatura corporal según sus necesidades. 

Efecto de visualización del puerto serie

 2. Ejemplo de programa de placa de demostración de la serie SL-W-TRS-5.5Dx

/////////////////////////////////////////////////// /////////////////////////////////////////////////// //

 // principal.c

 //////

 #define PARA_CLIENTE

 #ifdef PARA_CLIENTE

 #incluir "drv_uart.h"

#incluir "drv_i2c.h"

#include "drv_key.h"

#include "oled/oled.h"

#incluye "trs55d.h"

externo void SystemCoreClockupdate(void);

externo void delay_ms(int cnt);

 int principal (vacío)

{

uint8_t clave;

 uint8_t ejecutar = 0x01;

 Actualización del reloj del núcleo del sistema();

si (SysTick_Config(SystemCoreClock / 1000))

mientras(1);

 uartInit();

drv_i2c_init();

drv_key_init();

OLED_Init();

 OLED_Refresh();

OLED_Borrar();

OLED_ShowString(8,0,"Tamb:",16,1);

OLED_ShowString(8,16,"Vtp:",16,1);

 OLED_ShowChinese(8,32,0,16,1);

OLED_ShowChinese(24,32,2,16,1);

OLED_ShowChinese(40,32,3,16,1);

OLED_ShowChinese(8,48,1,16,1);

 OLED_ShowChinese(24,48,2,16,1);

OLED_ShowChinese(40,48,3,16,1);

OLED_Refresh();

uartSendString("SL-W-Programa de demostración TRS-5.5Dx ");

mientras(1) {

clave = drv_key_read();

mientras(drv_key_read());

si (clave) {

 correr = (correr)?0:1;

}

si (ejecutar) {

 TRS55D_read();

OLED_Refresh();

}

delay_ms (20);

}

}

/////////////////////////////////////////////////// /////////////////////////////////////////////////// //

 //trs55d.h

 //////

#ifndef _TRS55D_H_

#define _TRS55D_H_

#incluir

#define TRS55D_NORMAL_Tobj_MSB_R 0x10

#define TRS55D_NORMAL_Tobj_CSB_R 0x11

#define TRS55D_NORMAL_Tobj_LSB_R 0x12

 #define TRS55D_TEMPERATURA NORMAL_MSB_R 0x16

#define TRS55D_TEMPERATURA_NORMAL_CSB_R 0x17

#define TRS55D_TEMPERATURA_NORMAL_LSB_R 0x18

 #define TRS55D_DATOS_NORMAL1_MSB_R 0x19

#define TRS55D_DATOS_NORMAL1_CSB_R 0x1A

 #define TRS55D_DATOS_NORMAL1_LSB_R 0x1B

 #define TRS55D_NORMAL_DATA2_MSB_R 0x1C

 #define TRS55D_DATOS_NORMAL2_CSB_R 0x1D

#define TRS55D_DATOS_NORMAL2_LSB_R 0x1E

 #define TRS55D_RAW_DATA1_MSB_R 0x22

 #define TRS55D_RAW_DATA1_CSB_R 0x23

#define TRS55D_RAW_DATA1_LSB_R 0x24

 #define TRS55D_RAW_DATA2_MSB_R 0x25

 #define TRS55D_RAW_DATA2_CSB_R 0x26

 #define TRS55D_RAW_DATA2_LSB_R 0x27

 #define TRS55D_RAW_TEMP_MSB_R 0x28

 #define TRS55D_RAW_TEMP_CSB_R 0x29

#define TRS55D_RAW_TEMP_LSB_R 0x2A

 #define ADDR_TRS55D 0xFE //(0x7F << 1)

 #define _STATUS_DRDY_ 0x01 void TRS55D_read(void);

#terminara si

/////////////////////////////////////////////////// /////////////////////////////////////////////////// //

// trs55d.c

//////

#incluir

 #incluir "drv_i2c.h"

 #incluye "trs55d.h"

 #include "temp_cuerpo.h"

 externo uint8_t uartSendString(const char* buf);

extern void OLED_ShowString(uint8_t x,uint8_t y, const char *chr,uint8_t tamaño1,uint8_t modo);

 void externo OLED_ShowBNum(uint8_t x,uint8_t y,número flotante,uint8_t len,

uint8_t tamaño2,uint8_t modo); uint8_t TRS55D_IIC_Read(uint8_t addr_dev, uint8_t addr_reg,

uint8_t *buf, uint16_t recuento)

{

uint8_t ret;

uint8_t bandera de reconocimiento;

uint16_ti = 0;

drv_i2c_start();

drv_i2c_select_dev(dirección_dev,DRV_I2C_OPWR);

drv_i2c_writebyte(dirección_reg);

 drv_i2c_start();

drv_i2c_select_dev(dirección_dev,DRV_I2C_OPRD);

para (i = 0; i < recuento; i ++) { ackflag = (i < (recuento-1)) ? 1:0; buf[i]

 = drv_i2c_readbyte(bandera de retroceso);

 }

drv_i2c_stop();

 volver ret;

 }

void TRS55D_IIC_Write(uint8_t addr_dev, uint8_t addr_reg, uint8_t *buf, uint16_t count)

 {

 uint16_ti = 0;

drv_i2c_start();

drv_i2c_select_dev(dirección_dev,DRV_I2C_OPWR);

drv_i2c_writebyte(dirección_reg);

 para (i = 0; i < conteo; i ++)

 { drv_i2c_writebyte(buf[i]);

}

drv_i2c_stop();

}

 tipo de unión definido

int16_t i16;

uint16_t u16;

estructura {

uint8_t u8l;

uint8_t u8h;

 }Naciones Unidas;

}uu16_t;

tipo de unión definido

int32_t i32;

estructura {

uint8_t u8b0;

uint8_t u8b1;

uint8_t u8b2;

uint8_t u8b3;

}Naciones Unidas;

 }uu32_t;

buffer de caracteres estáticos[264];

 uu32_t también puede ser usado, tamb_cal;

uu32_t vtp_cor;

flotador vtp_uv_f = 0.0;

flotante vtp_cor_f = 0.0;

flotante tambf = 0.0; flotante tobjf = 0.0;

 flotante tbdyf = 0.0;

 vacío TRS55D_read(vacío)

{

uint8_t rbuf[4];

uint8_t nombre_de_usuario;

 uint8_t es un conjunto de caracteres que se pueden leer en formato .wdat.

int tiempo de espera=0;

waddr = 0x30;

wdat = 0x09;

TRS55D_IIC_Write(ADDR_TRS55D, waddr, &wdat,1);

 //iniciar conversión delay_ms(100);

//Esperar la conversión

raddr = 0x03;

hacer {

TRS55D_IIC_Read (ADDR_TRS55D, raddr, &rdat,1);

} mientras(((rdat == 0xFF) || (!(rdat & 0x30))) && tiempo de espera++ < 200);

raddr = 0x02;

 hacer {

TRS55D_IIC_Read (ADDR_TRS55D, raddr, &rdat,1);

} mientras(((rdat == 0xFF) || (!(rdat & 0x0B))) && tiempo de espera++ < 200);

 // valor de voltaje después de la calibración

raddr = TRS55D_DATOS_NORMAL1_MSB_R;

TRS55D_IIC_Read (ADDR_TRS55D, raddr,&rbuf[0],3);

vtp_cor.un.u8b2 = rbuf[0];

 vtp_cor.un.u8b1 = rbuf[1];

vtp_cor.un.u8b0 =rbuf[2];

 si (vtp_cor.un.u8b2 y 0x80) { vtp_cor.un.u8b3 = 0xFF;

}demás {

vtp_cor.un.u8b3 = 0x00;

// vtp después de corregido

}

vtp_cor_f = (flotante)vtp_cor.i32/524288.0;

vtp_cor_f *= 1000;

// valor de temperatura ambiente después de la calibración

 raddr = TRS55D_TEMPERATURA_NORMAL_MSB_R;

TRS55D_IIC_Read (ADDR_TRS55D,raddr,&rbuf[0],3);

 tamb_cal.un.u8b2 = rbuf[0];

tamb_cal.un.u8b1 =rbuf[1];

tamb_cal.un.u8b0 =rbuf[2];

tambf = (float)tamb_cal.i32 / 16384.0; // temperatura ambiente

// temperatura del objeto(superficie) después de la calibración

raddr = TRS55D_NORMAL_Tobj_MSB_R;

TRS55D_IIC_Read (ADDR_TRS55D,raddr,&rbuf[0],3);

 tobj.un.u8b2 = rbuf[0]; tobj.un.u8b1 = rbuf[1];

tobj.un.u8b0 =rbuf[2]; tobjf = (flotante)tobj.i32 / 16384.0;

// temperatura del objeto(superficie)

// obtener la temperatura corporal

tbdyf = obtener_temperatura_corporal(tambf,tobjf); // obtener la temperatura corporal

// mostrar en uart sprintf(buffer, "tamb = %.2f, vtp_cor = %.2f, tobj = %.2f, tbdy = %.2f ", tambf, vtp_cor_f, tobjf, tbdyf); uartSendString(buffer);

// pantalla en oled

 flotante vals[4] = {tambf, vtp_cor_f, tobjf, tbdyf+0.05};

 OLED_ShowBNum (64, 0, valores[0], 4, 16, 1); // Tambo

OLED_ShowBNum (48, 16, vals[1], 6, 16, 1); // vtp

OLED_ShowString(112,16, "uv",16, 1);

OLED_ShowBNum (64, 32, vals[2], 4, 16, 1); // Tobj

OLED_ShowBNum (64, 48, vals[3], 4, 16, 1); // Por confirmar

}