Manual do usuário para placa de demonstração de termopilha infravermelha digital SL-W-TRS-5.5Dx

SLKOR é uma empresa de alta tecnologia que integra o design, desenvolvimento, produção e vendas de produtos eletrônicos. Ela fornece aos clientes produtos confiáveis ​​e serviços técnicos correspondentes. A marca "SLKOR" gradualmente se tornou uma empresa de renome internacional, oferecendo produtos e soluções para mais de 10,000 clientes em todo o mundo.

Em um esforço para oferecer aos clientes uma gama completa de produtos complementares, SLKOR lançou uma série de manuais do usuário para placas de demonstração de projetos de aplicações de medição de temperatura sem contato de termopilhas infravermelhas digitais.

1.1 Nome: Manual do usuário para SLKOR Placa de demonstração de design de aplicação de medição de temperatura sem contato de termopilha infravermelha digital

Aplicações 1.2: Dispositivos vestíveis inteligentes, smartphones, monitoramento de temperatura industrial, medição de temperatura da superfície do corpo humano sem contato, detecção e controle inteligente de temperatura e outros dispositivos de pequeno porte para medição de temperatura de curto alcance.

Placa de demonstração da série 1.3 SL-W-TRS-5.5Dx:

É usado para avaliação e teste de vários tipos de sensores. Os resultados da medição serão exibidos na tela e podem ser impressos no software de depuração da porta serial no PC via USB para porta serial. Descrição do botão: O botão esquerdo é para reset, e o botão direito pode controlar o início e a pausa do programa.

2. Projeto de hardware da série SL-W-TRS-5.5Dx

Os pinos do chip incluem fonte de alimentação e barramento I2C, com um total de 4 pinos. A faixa permitida de tensão de alimentação é de 2.3 a 3.6 V. O sensor em si tem consumo de energia muito baixo. Um capacitor de 0.1 uF entre o aterramento da fonte de alimentação é suficiente. Se o sensor estiver relativamente longe da parte da fonte de alimentação, um capacitor adicional de 10 uF pode ser considerado para garantir uma fonte de alimentação estável e reduzir o ruído.

3. Descrição da placa de demonstração da série SL-W-TRS-5.5Dx

3.1 A placa de demonstração é alimentada por um soquete Tipo C, e a tensão de alimentação para a placa de demonstração é de 5 V. Quando em uso, conecte a placa de demonstração ao PC via Tipo C, e então você pode ver os resultados na tela. Se você precisar exibir dados através da porta serial, você precisa instalar o programa de driver WCH CH340 e então usar o software de depuração da porta serial para operar. As configurações de comunicação da porta serial são as seguintes: Taxa de transmissão: 9600, Bits de dados: 8, Bits de parada: 1, e sem verificação de paridade.

3.2 A exibição da tela da placa de demonstração de cima para baixo é a seguinte: temperatura ambiente (tamb), tensão de saída do sensor (vtp_cor), temperatura do objeto (superfície) (tobj) e temperatura do corpo humano (tbdy). A unidade dos valores de temperatura acima é °C, e a unidade de tensão é μV. Entre eles, os três primeiros valores são as saídas originais do dispositivo. O valor da temperatura corporal é calculado com base nos valores originais usando o algoritmo da nossa empresa e é apenas para referência. Os usuários podem processar os dados usando seus próprios algoritmos de temperatura corporal de acordo com suas necessidades. 

Efeito de exibição da porta serial

 2. Exemplo de programa de placa de demonstração da série SL-W-TRS-5.5Dx

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

 // principal.c

 //////

 #define PARA_CLIENTE

 #ifdef PARA_CLIENTE

 #incluir "drv_uart.h"

#incluir "drv_i2c.h"

#incluir "drv_key.h"

#incluir "oled/oled.h"

#incluir "trs55d.h"

externo void SystemCoreClockupdate(void);

externo void delay_ms(int cnt);

 int main (void)

{

chave uint8_t;

 uint8_t executar = 0x01;

 SystemCoreClockupdate();

se (SysTick_Config(SystemCoreClock / 1000))

enquanto(1);

 uartInit();

drv_i2c_init();

drv_key_init();

OLED_Init();

 Atualização_OLED();

OLED_Limpar();

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

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

 OLED_ShowChinês(8,32,0,16,1);

OLED_ShowChinês(24,32,2,16,1);

OLED_ShowChinês(40,32,3,16,1);

OLED_ShowChinês(8,48,1,16,1);

 OLED_ShowChinês(24,48,2,16,1);

OLED_ShowChinês(40,48,3,16,1);

Atualização_OLED();

uartEnviarString("SL-W-Programa de demonstração TRS-5.5Dx ");

enquanto(1) {

chave = drv_key_read();

enquanto(drv_key_read());

se (chave) {

 correr = (correr)?0:1;

}

se (executar) {

 TRS55D_ler();

Atualização_OLED();

}

delay_ms (20);

}

}

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

 //trs55d.h

 //////

#ifndef _TRS55D_H_

#definir _TRS55D_H_

#include

#define TRS55D_NORMAL_Tobj_MSB_R 0x10

#define TRS55D_NORMAL_Tobj_CSB_R 0x11

#define TRS55D_NORMAL_Tobj_LSB_R 0x12

 #define TRS55D_NORMAL_TEMP_MSB_R 0x16

#define TRS55D_NORMAL_TEMP_CSB_R 0x17

#define TRS55D_NORMAL_TEMP_LSB_R 0x18

 #define TRS55D_NORMAL_DATA1_MSB_R 0x19

#define TRS55D_NORMAL_DATA1_CSB_R 0x1A

 #define TRS55D_NORMAL_DATA1_LSB_R 0x1B

 #define TRS55D_NORMAL_DATA2_MSB_R 0x1C

 #define TRS55D_NORMAL_DATA2_CSB_R 0x1D

#define TRS55D_NORMAL_DATA2_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 vazio TRS55D_read(vazio);

#fim se

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

// trs55d.c

//////

#include

 #incluir "drv_i2c.h"

 #incluir "trs55d.h"

 #incluir "body_temp.h"

 externo uint8_t uartSendString(const char* buf);

externo void OLED_ShowString(uint8_t x,uint8_t y, const char *chr,uint8_t tamanho1,uint8_t modo);

 externo vazio OLED_ShowBNum(uint8_t x,uint8_t y,float num,uint8_t len,

uint8_t tamanho2,uint8_t modo); uint8_t TRS55D_IIC_Read(uint8_t addr_dev, uint8_t addr_reg,

uint8_t *buf, uint16_t contagem)

{

uint8_t ret;

uint8_t sinalizador de reconhecimento;

uint16_t i = 0;

drv_i2c_start();

drv_i2c_select_dev(desv_addr,DRV_I2C_OPWR);

drv_i2c_writebyte(endereço_reg);

 drv_i2c_start();

drv_i2c_select_dev(desv_addr,DRV_I2C_OPRD);

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

 = drv_i2c_readbyte(ackflag);

 }

drv_i2c_stop();

 retornar ret;

 }

vazio TRS55D_IIC_Write(uint8_t addr_dev, uint8_t addr_reg, uint8_t *buf, uint16_t contagem)

 {

 uint16_t i = 0;

drv_i2c_start();

drv_i2c_select_dev(desv_addr,DRV_I2C_OPWR);

drv_i2c_writebyte(endereço_reg);

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

 { drv_i2c_writebyte(buf[i]);

}

drv_i2c_stop();

}

 typedef união{

int16_t i16;

uint16_t u16;

estrutura {

uint8_t u8l;

uint8_t u8h;

 }un;

}uu16_t;

typedef união{

int32_t i32;

estrutura {

uint8_t u8b0;

uint8_t u8b1;

uint8_t u8b2;

uint8_t u8b3;

}un;

 }uu32_t;

buffer de caracteres estático[264];

 uu32_t tobj, tamb_cal;

uu32_t vtp_cor;

flutuar vtp_uv_f = 0.0;

flutuar vtp_cor_f = 0.0;

flutuar tambf = 0.0; flutuar tobjf = 0.0;

 flutuar tbdyf = 0.0;

 vazio TRS55D_read(vazio)

{

uint8_t rbuf[4];

uint8_t raddr,rdat;

 uint8_t waddr = 0x0, wdat = 0x0;

int tempo limite=0;

waddr = 0x30;

wdat = 0x09;

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

 //iniciar conversão delay_ms(100);

// aguarde a conversão

raddr = 0x03;

fazer {

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

} enquanto(((rdat == 0xFF) || (!(rdat & 0x30))) && tempo limite++ < 200);

raddr = 0x02;

 fazer {

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

} enquanto(((rdat == 0xFF) || (!(rdat & 0x0B))) && tempo limite++ < 200);

 // valor de tensão após calibração

raddr = TRS55D_NORMAL_DATA1_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];

 se (vtp_cor.un.u8b2 & 0x80) { vtp_cor.un.u8b3 = 0xFF;

}senão {

vtp_cor.un.u8b3 = 0x00;

// vtp depois corrigido

}

vtp_cor_f = (flutuante)vtp_cor.i32/524288.0;

vtp_cor_f *= 1000;

// valor da temperatura ambiente após calibração

 raddr = TRS55D_NORMAL_TEMP_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 do objeto (superfície) após calibração

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 = (float)tobj.i32/16384.0;

// temperatura do objeto(superfície)

// obter temperatura corporal

tbdyf = get_body_temp(tambf,tobjf); // obter temperatura corporal

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

// exibir em oled

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

 OLED_ShowBNum (64, 0, vals[0], 4, 16, 1); //Também

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

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

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

OLED_ShowBNum (64, 48, valores[3], 4, 16, 1); // A confirmar

}