SLKOR jest przedsiębiorstwem high-tech integrującym projektowanie, rozwój, produkcję i sprzedaż produktów elektronicznych. Dostarcza klientom niezawodne produkty i odpowiednie usługi techniczne. Marka „SLKOR„ stopniowo rozwinęła się w firmę o międzynarodowej renomie, oferującą produkty i rozwiązania ponad 10,000 XNUMX klientów na całym świecie.

Starając się zapewnić klientom pełną gamę produktów uzupełniających, SLKOR wprowadziła na rynek serię podręczników użytkownika dotyczących płytek demonstracyjnych do projektowania aplikacji do bezkontaktowego pomiaru temperatury za pomocą cyfrowych czujników termoelektrycznych na podczerwień.

1.1 Imię: Instrukcja obsługi dla SLKOR Cyfrowy termopilowy czujnik podczerwieni do bezkontaktowego pomiaru temperatury Projekt płytki demonstracyjnej

1.2 Aplikacje:Inteligentne urządzenia noszone na ciele, smartfony, przemysłowy monitoring temperatury, bezdotykowy pomiar temperatury powierzchni ludzkiego ciała, inteligentne wykrywanie i kontrola temperatury oraz inne urządzenia małych rozmiarów do pomiaru temperatury krótkiego zasięgu.

1.3 Płytka demonstracyjna serii SL-W-TRS-5.5Dx:

Służy do oceny i testowania różnych typów czujników. Wyniki pomiarów będą wyświetlane na ekranie i mogą być drukowane w oprogramowaniu do debugowania portu szeregowego na komputerze przez USB do portu szeregowego. Opis przycisku: Lewy przycisk służy do resetowania, a prawy przycisk może sterować uruchomieniem i wstrzymaniem programu.

2. Projekt sprzętu serii SL-W-TRS-5.5Dx

Piny układu obejmują zasilanie i magistralę I2C, łącznie 4 piny. Dopuszczalny zakres napięcia zasilania wynosi 2.3 - 3.6 V. Sam czujnik ma bardzo niskie zużycie energii. Wystarczający jest kondensator 0.1 uF między masą zasilania. Jeśli czujnik znajduje się stosunkowo daleko od części zasilającej, można rozważyć dodatkowy kondensator 10 uF, aby zapewnić stabilne zasilanie i zmniejszyć szum.

3. Opis płyty demonstracyjnej serii SL-W-TRS-5.5Dx

3.1 Płytka demonstracyjna jest zasilana przez gniazdo typu C, a napięcie zasilania płytki demonstracyjnej wynosi 5 V. Podczas użytkowania podłącz płytkę demonstracyjną do komputera przez gniazdo typu C, a następnie możesz wyświetlić wyniki na ekranie. Jeśli chcesz wyświetlić dane przez port szeregowy, musisz zainstalować program sterownika WCH CH340, a następnie użyć oprogramowania do debugowania portu szeregowego. Ustawienia komunikacji portu szeregowego są następujące: Szybkość transmisji: 9600, Bity danych: 8, Bity stopu: 1 i brak kontroli parzystości.

3.2 Wyświetlacz ekranu płyty demonstracyjnej od góry do dołu wygląda następująco: temperatura otoczenia (tamb), napięcie wyjściowe czujnika (vtp_cor), temperatura obiektu (powierzchni) (tobj) i temperatura ciała człowieka (tbdy). Jednostką powyższych wartości temperatury jest °C, a jednostką napięcia jest μV. Spośród nich pierwsze trzy wartości to oryginalne wyjścia urządzenia. Wartość temperatury ciała jest obliczana na podstawie oryginalnych wartości przy użyciu algorytmu naszej firmy i służy wyłącznie jako odniesienie. Użytkownicy mogą przetwarzać dane przy użyciu własnych algorytmów temperatury ciała zgodnie ze swoimi potrzebami. 

Efekt wyświetlania portu szeregowego

 2. Przykład programu płyty demonstracyjnej serii SL-W-TRS-5.5Dx

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

 // główny.c

 //////

 #define DLA_KLIENTA

 #ifdef DLA_KLIENTA

 #include "drv_uart.h"

#include "drv_i2c.h"

#include "drv_key.h"

#include "oled/oled.h"

#dołącz "trs55d.h"

zewnętrzna void SystemCoreClockupdate(void);

zewnętrzny void delay_ms(int cnt);

 int main (void)

{

uint8_t klucz;

 uint8_t uruchom = 0x01;

 Aktualizacja SystemCoreClockupdate();

jeśli (SysTick_Config(SystemCoreClock / 1000))

podczas gdy(1);

 uartInit();

drv_i2c_init();

drv_key_init();

OLED_Init();

 Odświeżanie OLED();

OLED_Wyczyść();

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

OLED_ShowString(8,16, "Wskaźnik:", 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);

Odświeżanie OLED();

uartSendString("SL-W-Program demonstracyjny TRS-5.5Dx ");

podczas gdy(1) {

klucz = drv_key_read();

podczas gdy(drv_key_read());

jeśli (klucz) {

 biegnij = (biegnij)?0:1;

}

jeśli (uruchom) {

 TRS55D_odczyt();

Odświeżanie OLED();

}

opóźnienie_ms(20);

}

}

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

 //trs55d.h

 //////

#jeśli_TRS55D_H_

#zdefiniuj _TRS55D_H_

#zawierać

#zdefiniuj TRS55D_NORMAL_Tobj_MSB_R 0x10

#zdefiniuj TRS55D_NORMAL_Tobj_CSB_R 0x11

#zdefiniuj TRS55D_NORMAL_Tobj_LSB_R 0x12

 #zdefiniuj TRS55D_NORMAL_TEMP_MSB_R 0x16

#zdefiniuj TRS55D_NORMAL_TEMP_CSB_R 0x17

#zdefiniuj TRS55D_NORMAL_TEMP_LSB_R 0x18

 #zdefiniuj TRS55D_NORMAL_DATA1_MSB_R 0x19

#zdefiniuj TRS55D_NORMAL_DATA1_CSB_R 0x1A

 #zdefiniuj TRS55D_NORMAL_DATA1_LSB_R 0x1B

 #zdefiniuj TRS55D_NORMAL_DATA2_MSB_R 0x1C

 #zdefiniuj TRS55D_NORMAL_DATA2_CSB_R 0x1D

#zdefiniuj TRS55D_NORMAL_DATA2_LSB_R 0x1E

 #zdefiniuj TRS55D_RAW_DATA1_MSB_R 0x22

 #zdefiniuj TRS55D_RAW_DATA1_CSB_R 0x23

#zdefiniuj TRS55D_RAW_DATA1_LSB_R 0x24

 #zdefiniuj TRS55D_RAW_DATA2_MSB_R 0x25

 #zdefiniuj TRS55D_RAW_DATA2_CSB_R 0x26

 #zdefiniuj TRS55D_RAW_DATA2_LSB_R 0x27

 #zdefiniuj TRS55D_RAW_TEMP_MSB_R 0x28

 #zdefiniuj TRS55D_RAW_TEMP_CSB_R 0x29

#zdefiniuj TRS55D_RAW_TEMP_LSB_R 0x2A

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

 #define _STATUS_DRDY_ 0x01 void TRS55D_read(void);

#endif

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

// trs55d.c

//////

#zawierać

 #include "drv_i2c.h"

 #dołącz "trs55d.h"

 #include "body_temp.h"

 zewnętrzny uint8_t uartSendString(const char* buf);

zewnętrzny void OLED_ShowString(uint8_t x,uint8_t y, const char *chr,uint8_t size1,uint8_t mode);

 zewnętrzna void OLED_ShowBNum(uint8_t x,uint8_t y,float num,uint8_t len,

uint8_t rozmiar2,uint8_t tryb); uint8_t TRS55D_IIC_Read(uint8_t adres_dev, uint8_t adres_reg,

uint8_t *buf, uint16_t liczba)

{

uint8_t ret;

uint8_t flaga potwierdzenia;

uint16_t i = 0;

drv_i2c_start();

drv_i2c_select_dev(adres_dev,DRV_I2C_OPWR);

drv_i2c_writebyte(adres_reg);

 drv_i2c_start();

drv_i2c_select_dev(adres_dev,DRV_I2C_OPRD);

dla(i = 0; i < liczba; i ++) { flaga_potwierdzenia = (i < (liczba-1)) ? 1:0; buf[i]

 = drv_i2c_readbyte(flaga awaryjna);

 }

drv_i2c_stop();

 powrót powrót;

 }

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

 {

 uint16_t i = 0;

drv_i2c_start();

drv_i2c_select_dev(adres_dev,DRV_I2C_OPWR);

drv_i2c_writebyte(adres_reg);

 dla (i = 0; i < liczba; i ++)

 { drv_i2c_writebyte(buf[i]);

}

drv_i2c_stop();

}

 unia typedef{

int16_t i16;

uint16_t u16;

struktura {

uint8_t u8l;

uint8_t u8h;

 }nie;

}uu16_t;

unia typedef{

int32_t i32;

struktura {

uint8_t u8b0;

uint8_t u8b1;

uint8_t u8b2;

uint8_t u8b3;

}nie;

 }uu32_t;

bufor statyczny char[264];

 uu32_t tobj, tamb_cal;

uu32_t vtp_cor;

liczba zmiennoprzecinkowa vtp_uv_f = 0.0;

liczba zmiennoprzecinkowa vtp_cor_f = 0.0;

liczba zmiennoprzecinkowa tambf = 0.0; liczba zmiennoprzecinkowa tobjf = 0.0;

 liczba zmiennoprzecinkowa tbdyf = 0.0;

 pusta TRS55D_read(pustka)

{

uint8_t rbuf[4];

uint8_t raddr,rdat;

 uint8_t waddr = 0x0, wdat = 0x0;

int limit czasu=0;

waddr = 0x30;

wdat = 0x09;

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

 //rozpocznij konwersję delay_ms(100);

// czekaj na zakończenie konwersji

raddr = 0x03;

zrobić {

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

} podczas gdy(((rdat == 0xFF) || (!(rdat & 0x30))) && limit czasu++ < 200);

raddr = 0x02;

 zrobić {

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

} podczas gdy(((rdat == 0xFF) || (!(rdat & 0x0B))) && limit czasu++ < 200);

 // wartość napięcia po kalibracji

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

 jeśli (vtp_cor.un.u8b2 & 0x80) { vtp_cor.un.u8b3 = 0xFF;

} else {

vtp_cor.un.u8b3 = 0x00;

// vtp po poprawieniu

}

vtp_cor_f = (liczba zmiennoprzecinkowa)vtp_cor.i32/524288.0;

vtp_cor_f *= 1000;

// wartość temperatury otoczenia po kalibracji

 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 otoczenia

// temperatura obiektu (powierzchni) po kalibracji

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 obiektu(powierzchni)

// pobierz temperaturę ciała

tbdyf = get_body_temp(tambf,tobjf); // pobierz temperaturę ciała

// wyświetl na uart sprintf(buffer, "tamb = %.2f, vtp_cor = %.2f, tobj = %.2f, tbdy = %.2f ", tambf, vtp_cor_f, tobjf, tbdyf); uartSendString(buffer);

// wyświetl na oled

 wartości float [4] = {tambf, vtp_cor_f, tobjf, tbdyf+0.05};

 OLED_ShowBNum (64, 0, wartości [0], 4, 16, 1); // Tamb

OLED_ShowBNum (48, 16, wartości[1], 6, 16, 1); // vtp

Wyświetlanie OLED_ShowString(112,16, "uv",16, 1);

OLED_ShowBNum (64, 32, wartości[2], 4, 16, 1); // Tobj

OLED_ShowBNum (64, 48, wartości[3], 4, 16, 1); // Tbdy

}