SLKOR Micro Semicon Co., Ltd., ha le sue basi tecniche provenienti dalla Tsinghua University e dalla Yonsei University in Corea del Sud. Guida lo sviluppo dell'azienda con nuovi materiali, nuovi processi e nuovi prodotti e ha padroneggiato la tecnologia avanzata a livello internazionale dei dispositivi di potenza in carburo di silicio semiconduttore di terza generazione relativamente presto.

 

SLKOR è un'impresa high-tech che integra la progettazione, lo sviluppo, la produzione e la vendita di prodotti elettronici. Fornisce ai clienti prodotti affidabili e servizi tecnici corrispondenti. Il marchio "SLKOR" si è progressivamente sviluppata fino a diventare un'azienda di fama internazionale, offrendo prodotti e soluzioni a oltre 10,000 clienti in tutto il mondo.

 

Nel tentativo di fornire ai clienti una gamma completa di prodotti complementari, SLKOR ha lanciato una serie di manuali utente per le schede dimostrative dei progetti di applicazioni di misurazione della temperatura senza contatto tramite termopila digitale a infrarossi.

 

1.1 nome: Manuale d'uso per SLKOR Scheda dimostrativa per la progettazione dell'applicazione di misurazione della temperatura senza contatto con termopila digitale a infrarossi

Applicazioni 1.2: Dispositivi indossabili intelligenti, smartphone, monitoraggio della temperatura industriale, misurazione della temperatura superficiale del corpo umano senza contatto, rilevamento e controllo intelligenti della temperatura e altri dispositivi di piccole dimensioni per la misurazione della temperatura a corto raggio.

Scheda demo serie 1.3 SL-W-TRS-5.5Dx:

Viene utilizzato per la valutazione e il test di vari tipi di sensori. I risultati della misurazione verranno visualizzati sullo schermo e possono essere stampati sul software di debug della porta seriale sul PC tramite USB alla porta seriale. Descrizione del pulsante: il pulsante sinistro è per il reset e il pulsante destro può controllare l'avvio e la pausa del programma.

 

2. Progettazione hardware della serie SL-W-TRS-5.5Dx

 

I pin del chip includono alimentazione e bus I2C, con un totale di 4 pin. L'intervallo consentito di tensione di alimentazione è 2.3 - 3.6 V. Il sensore stesso ha un consumo energetico molto basso. Un condensatore da 0.1 uF tra la massa dell'alimentazione è sufficiente. Se il sensore è relativamente lontano dalla parte dell'alimentazione, può essere preso in considerazione un condensatore aggiuntivo da 10 uF per garantire un'alimentazione stabile e ridurre il rumore.

 

 

 

3. Descrizione della scheda demo della serie SL-W-TRS-5.5Dx

 

3.1 La scheda demo è alimentata da una presa Type-C e la tensione di alimentazione per la scheda demo è di 5 V. Quando è in uso, collega la scheda demo al PC tramite Type-C, quindi puoi visualizzare i risultati sullo schermo. Se hai bisogno di visualizzare i dati tramite la porta seriale, devi installare il programma driver WCH CH340 e quindi utilizzare il software di debug della porta seriale per funzionare. Le impostazioni di comunicazione della porta seriale sono le seguenti: Baud rate: 9600, Bit di dati: 8, Bit di stop: 1 e nessun controllo di parità.

 

3.2 La visualizzazione sullo schermo della scheda demo dall'alto verso il basso è la seguente: temperatura ambiente (tamb), tensione di uscita del sensore (vtp_cor), temperatura dell'oggetto (superficie) (tobj) e temperatura del corpo umano (tbdy). L'unità dei valori di temperatura sopra indicati è °C e l'unità di tensione è μV. Tra questi, i primi tre valori sono gli output originali del dispositivo. Il valore della temperatura corporea è calcolato in base ai valori originali utilizzando l'algoritmo della nostra azienda ed è solo di riferimento. Gli utenti possono elaborare i dati utilizzando i propri algoritmi di temperatura corporea in base alle proprie esigenze. 

 

Effetto di visualizzazione della porta seriale

 

 2. Esempio di programma della scheda demo della serie SL-W-TRS-5.5Dx

 

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

 // principale.c

 //////

 #definisci PER_CLIENTE

 #ifdef PER_CLIENTE

 #include "drv_uart.h"

 

#include "drv_i2c.h"

#include "drv_key.h"

#include "oled/oled.h"

#include "trs55d.h"

 

extern void SystemCoreClockupdate(void);

esterno void delay_ms(int cnt);

 int main (void)

{

chiave uint8_t;

 uint8_t esecuzione = 0x01;

 Aggiornamento orologio di sistema ();

se (SysTick_Config(SystemCoreClock / 1000))

mentre(1);

 {NS} è un'estensione del file uartInit.

drv_i2c_init();

drv_key_init();

 

OLED_Init();

 Aggiorna OLED();

OLED_Clear();

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

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

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

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

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

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

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

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

Aggiorna OLED();

uartInviaString("SL-W-Programma dimostrativo TRS-5.5Dx ");

mentre(1) {

chiave = drv_key_read();

mentre(drv_key_read());

se (chiave) {

 correre = (correre)?0:1;

}

se (esegui) {

 TRS55D_read();

Aggiorna OLED();

}

ritardo_ms(20);

}

}

 

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

 //trs55d.h

 //////

#ifndef_TRS55D_H_

#definisci _TRS55D_H_

#includere

#definisci TRS55D_NORMAL_Tobj_MSB_R 0x10

#definisci TRS55D_NORMAL_Tobj_CSB_R 0x11

#definisci TRS55D_NORMAL_Tobj_LSB_R 0x12

 #definisci TRS55D_NORMAL_TEMP_MSB_R 0x16

#definisci TRS55D_NORMAL_TEMP_CSB_R 0x17

#definisci TRS55D_NORMAL_TEMP_LSB_R 0x18

 #definisci TRS55D_NORMAL_DATA1_MSB_R 0x19

#definisci TRS55D_NORMAL_DATA1_CSB_R 0x1A

 #definisci TRS55D_NORMAL_DATA1_LSB_R 0x1B

 #definisci TRS55D_NORMAL_DATA2_MSB_R 0x1C

 #definisci TRS55D_NORMAL_DATA2_CSB_R 0x1D

#definisci TRS55D_NORMAL_DATA2_LSB_R 0x1E

 #definisci TRS55D_RAW_DATA1_MSB_R 0x22

 #definisci TRS55D_RAW_DATA1_CSB_R 0x23

#definisci TRS55D_RAW_DATA1_LSB_R 0x24

 #definisci TRS55D_RAW_DATA2_MSB_R 0x25

 #definisci TRS55D_RAW_DATA2_CSB_R 0x26

 #definisci TRS55D_RAW_DATA2_LSB_R 0x27

 #definisci TRS55D_RAW_TEMP_MSB_R 0x28

 #definisci TRS55D_RAW_TEMP_CSB_R 0x29

#definisci TRS55D_RAW_TEMP_LSB_R 0x2A

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

 #define _STATUS_DRDY_ 0x01 void TRS55D_read(void);

#endif

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

// trs55d.c

//////

#includere

 #include "drv_i2c.h"

 #include "trs55d.h"

 #include "body_temp.h"

 esterno 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);

 esterno void OLED_ShowBNum(uint8_t x,uint8_t y,float num,uint8_t len,

uint8_t dimensione2,uint8_t modalità); uint8_t TRS55D_IIC_Read(uint8_t addr_dev, uint8_t addr_reg,

uint8_t *buf, uint16_t conteggio)

{

uint8_t ret;

uint8_t flag di riconoscimento;

uint16_t i = 0;

drv_i2c_start();

drv_i2c_select_dev(addr_dev,DRV_I2C_OPWR);

 

drv_i2c_writebyte(indirizzo_reg);

 drv_i2c_start();

drv_i2c_select_dev(addr_dev,DRV_I2C_OPRD);

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

 = drv_i2c_readbyte(flag di conferma);

 }

drv_i2c_stop();

 ritorno ret;

 }

 

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

 {

 uint16_t i = 0;

drv_i2c_start();

drv_i2c_select_dev(addr_dev,DRV_I2C_OPWR);

drv_i2c_writebyte(indirizzo_reg);

 per (i = 0; i < conteggio; i ++)

 { drv_i2c_writebyte(buf[i]);

}

drv_i2c_stop();

}

 unione di tipo{

int16_t i16;

## ...

struttura {

= uint8_t = u8l;

= uint8_t = u8h;

 }un;

}uu16_t;

 

unione di tipo{

int32_t i32;

struttura {

Il valore di uint8_t è uguale a u8b0;

Il valore di uint8_t è uguale a u8b1;

Il valore di uint8_t è uguale a u8b2;

Il valore di uint8_t è uguale a u8b3;

}un;

 }uu32_t;

 

buffer di caratteri statico[264];

 uu32_t di tobj, tamb_cal;

 

uu32_t vtp_cor;

numero di virgola mobile = 0.0;

numero di virgola mobile = 0.0;

il numero di serie è 0.0; il numero di serie è 0.0;

 numero di ordine decimale = 0.0;

 annullare TRS55D_read(annullamento)

{

il valore di uint8_t rbuf[4];

uint8_t raddr,rdat;

 Il valore di uint8_t è 0x0, il valore di wdat è 0x0;

int timeout=0;

 

waddr = 0x30;

il valore specificato è 0x09;

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

 //avvia la conversione delay_ms(100);

 

// attendere la conversione

raddr = 0x03;

fare {

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

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

raddr = 0x02;

 fare {

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

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

 

 // valore della tensione dopo la calibrazione

raddr = TRS55D_NORMAL_DATA1_MSB_R;

TRS55D_IIC_Leggi (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;

}altro {

Il codice sorgente è 8x3;

// vtp dopo la correzione

}

vtp_cor_f = (float)vtp_cor.i32/524288.0;

vtp_cor_f *= 1000;

// valore della temperatura ambiente dopo la calibrazione

 raddr = TRS55D_NORMAL_TEMP_MSB_R;

TRS55D_IIC_Leggi (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 dell'oggetto (superficie) dopo la calibrazione

raddr = TRS55D_NORMAL_Tobj_MSB_R;

TRS55D_IIC_Leggi (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 dell'oggetto (superficie)

 

// ottieni la temperatura corporea

tbdyf = get_body_temp(tambf,tobjf); // ottieni la temperatura corporea

 

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

 

// visualizza su oled

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

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

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

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

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

OLED_ShowBNum (64, 48, vals[3], 4, 16, 1); // Da consegnare

}