SLKOR ist ein High-Tech-Unternehmen, das Design, Entwicklung, Produktion und Vertrieb elektronischer Produkte integriert. Es bietet seinen Kunden zuverlässige Produkte und entsprechende technische Dienstleistungen. Die Marke "SLKOR" hat sich allmählich zu einem international renommierten Unternehmen entwickelt, das Produkte und Lösungen für mehr als 10,000 Kunden weltweit anbietet.

Um unseren Kunden eine umfassende Palette ergänzender Produkte anbieten zu können, SLKOR hat eine Reihe von Benutzerhandbüchern für die Demoboards von Anwendungsdesigns zur berührungslosen digitalen Infrarot-Thermosäulen-Temperaturmessung auf den Markt gebracht.

1.1 Name: Benutzerhandbuch für SLKOR Digitale Infrarot-Thermosäule - berührungslose Temperaturmessung - Anwendungsdesign-Demoboard

1.2-Anwendungen: Intelligente tragbare Geräte, Smartphones, industrielle Temperaturüberwachung, berührungslose Messung der Oberflächentemperatur des menschlichen Körpers, intelligente Temperaturerfassung und -steuerung und andere kleine Geräte zur Temperaturmessung im Nahbereich.

1.3 Demoboard der SL-W-TRS-5.5Dx-Serie:

Es wird zur Auswertung und Prüfung verschiedener Sensortypen verwendet. Die Messergebnisse werden auf dem Bildschirm angezeigt und können über USB an die serielle Schnittstelle an die Debugging-Software auf dem PC gesendet werden. Tastenbeschreibung: Die linke Taste dient zum Zurücksetzen und die rechte Taste steuert den Start und die Pause des Programms.

2. Hardware-Design der SL-W-TRS-5.5Dx-Serie

Die Chip-Pins umfassen Stromversorgung und I2C-Bus, insgesamt also 4 Pins. Der zulässige Versorgungsspannungsbereich liegt zwischen 2.3 und 3.6 V. Der Sensor selbst hat einen sehr geringen Stromverbrauch. Ein 0.1 uF-Kondensator zwischen der Stromversorgungsmasse ist ausreichend. Wenn der Sensor relativ weit vom Stromversorgungsteil entfernt ist, kann ein zusätzlicher 10 uF-Kondensator in Betracht gezogen werden, um eine stabile Stromversorgung zu gewährleisten und Rauschen zu reduzieren.

3. Beschreibung des Demoboards der Serie SL-W-TRS-5.5Dx

3.1 Die Stromversorgung der Demoplatine erfolgt über eine Type-C-Buchse und die Versorgungsspannung für die Demoplatine beträgt 5 V. Schließen Sie die Demoplatine bei Verwendung über Type-C an den PC an und sehen Sie sich die Ergebnisse auf dem Bildschirm an. Wenn Sie Daten über den seriellen Anschluss anzeigen müssen, müssen Sie das Treiberprogramm WCH CH340 installieren und dann eine Debugging-Software für den seriellen Anschluss verwenden. Die Kommunikationseinstellungen für den seriellen Anschluss sind wie folgt: Baudrate: 9600, Datenbits: 8, Stoppbits: 1 und keine Paritätsprüfung.

3.2 Die Bildschirmanzeige der Demoplatine ist von oben nach unten wie folgt: Umgebungstemperatur (tamb), Sensorausgangsspannung (vtp_cor), Objekttemperatur (Oberflächentemperatur) (tobj) und menschliche Körpertemperatur (tbdy). Die Einheit der obigen Temperaturwerte ist °C und die Einheit der Spannung ist μV. Davon sind die ersten drei Werte die ursprünglichen Ausgaben des Geräts. Der Körpertemperaturwert wird basierend auf den Originalwerten unter Verwendung des Algorithmus unseres Unternehmens berechnet und dient nur als Referenz. Benutzer können die Daten entsprechend ihren Anforderungen mit ihren eigenen Körpertemperaturalgorithmen verarbeiten. 

Anzeigeeffekt der seriellen Schnittstelle

 2. Demoboard-Programmbeispiel der SL-W-TRS-5.5Dx-Serie

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

 // main.c

 //////

 #define FÜR_KUNDEN

 #ifdef FÜR_KUNDE

 #include "drv_uart.h"

#include "drv_i2c.h"

#include "drv_key.h"

#include "oled/oled.h"

#include "trs55d.h"

extern void SystemCoreClockupdate(void);

extern void delay_ms(int cnt);

 int Haupt (leer)

{

uint8_t-Schlüssel;

 uint8_t ausführen = 0x01;

 SystemCoreClockupdate();

wenn (SysTick_Config(SystemCoreClock / 1000))

während(1);

 uartInit();

drv_i2c_init();

drv_key_init();

OLED_Init();

 OLED_Aktualisieren();

OLED_Clear();

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_Aktualisieren();

uartSendString("SL-W-TRS-5.5Dx-Demoprogramm ");

während(1) {

Schlüssel = drv_key_read();

während(drv_key_read());

if (Schlüssel) {

 laufen = (laufen)?0:1;

}

wenn (ausführen) {

 TRS55D_read();

OLED_Aktualisieren();

}

Verzögerung_ms(20);

}

}

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

 //trs55d.h

 //////

#ifndef _TRS55D_H_

#define _TRS55D_H_

#einschließen

#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 void TRS55D_read(void);

#endif

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

// trs55d.c

//////

#einschließen

 #include "drv_i2c.h"

 #include "trs55d.h"

 #include "body_temp.h"

 extern uint8_t uartSendString(const char* buf);

extern void OLED_ShowString(uint8_t x,uint8_t y, const char *chr,uint8_t size1,uint8_t mode);

 extern void OLED_ShowBNum(uint8_t x,uint8_t y,float num,uint8_t länge,

uint8_t Größe2,uint8_t Modus); uint8_t TRS55D_IIC_Read(uint8_t Adresse_Gerät, uint8_t Adresse_Reg,

uint8_t *buf, uint16_t Anzahl)

{

uint8_t ret;

uint8_t ackflag;

uint16_t i = 0;

drv_i2c_start();

drv_i2c_select_dev(Adresse des Geräts,DRV_I2C_OPWR);

drv_i2c_writebyte(Adresse_Reg);

 drv_i2c_start();

drv_i2c_select_dev(Adresse des Geräts,DRV_I2C_OPRD);

für(i = 0; i < Anzahl; i++) { ackflag = (i < (Anzahl-1)) ? 1:0; buf[i]

 = drv_i2c_readbyte(Bestätigungsflag);

 }

drv_i2c_stop();

 Rückkehr ret;

 }

void TRS55D_IIC_Write(uint8_t Adresse_Gerät, uint8_t Adresse_Reg, uint8_t *buf, uint16_t Anzahl)

 {

 uint16_t i = 0;

drv_i2c_start();

drv_i2c_select_dev(Adresse des Geräts,DRV_I2C_OPWR);

drv_i2c_writebyte(Adresse_Reg);

 für (i = 0; i < Anzahl; i++)

 { drv_i2c_writebyte(buf[i]);

}

drv_i2c_stop();

}

 Typdefinition Union {

int16_t i16;

uint16_t u16;

strukturieren {

uint8_t u8l;

uint8_t u8h;

 }un;

}uu16_t;

Typdefinition Union {

int32_t i32;

strukturieren {

uint8_t u8b0;

uint8_t u8b1;

uint8_t u8b2;

uint8_t u8b3;

}un;

 }uu32_t;

statischer Zeichenpuffer[264];

 uu32_t tobj, tamb_cal;

uu32_t vtp_cor;

vtp_uv_f = 0.0;

vtp_cor_f = 0.0;

Gleitkommazahl tambf = 0.0; Gleitkommazahl tobjf = 0.0;

 Gleitkommazahl tbdyf = 0.0;

 ungültig TRS55D_read(void)

{

uint8_t rbuf[4];

uint8_t raddr,rdat;

 uint8_t waddr = 0x0, wdat = 0x0;

int Zeitüberschreitung = 0;

waddr = 0x30;

: wdat = 0x09;

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

 //Konvertierung starten delay_ms(100);

// warten, bis die Konvertierung abgeschlossen ist

raddr = 0x03;

tun

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

} während (((rdat == 0xFF) || (!(rdat & 0x30))) && timeout++ < 200);

raddr = 0x02;

 tun

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

} während (((rdat == 0xFF) || (!(rdat & 0x0B))) && timeout++ < 200);

 // Spannungswert nach der Kalibrierung

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];

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

} else {

vtp_cor.un.u8b3 = 0x00;

// vtp nach Korrektur

}

vtp_cor_f = (float)vtp_cor.i32/524288.0;

vtp_cor_f *= 1000;

// Umgebungstemperaturwert nach der Kalibrierung

 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; // Umgebungstemperatur

// Objekt(Oberflächen)temperatur nach der Kalibrierung

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;

// Objekt(Oberflächen)temperatur

// Körpertemperatur ermitteln

tbdyf = get_body_temp(tambf,tobjf); // Bodytemp abrufen

// auf UART anzeigen sprintf(Puffer, "tamb = %.2f, vtp_cor = %.2f, tobj = %.2f, tbdy = %.2f ", tambf, vtp_cor_f, tobjf, tbdyf); uartSendString(Puffer);

// Anzeige auf OLED

 Float-Werte[4] = {tambf, vtp_cor_f, tobjf, tbdyf+0.05};

 OLED_ShowBNum (64, 0, Werte[0], 4, 16, 1); // Tamb

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); // Wird noch bekannt gegeben

}