SLKOR Micro Semicon Co., Ltd., L'Université Tsinghua et l'Université Yonsei de Corée du Sud ont fondé leur épine dorsale technique. L'entreprise a développé de nouveaux matériaux, de nouveaux procédés et de nouveaux produits, et a maîtrisé relativement tôt la technologie de pointe internationale des dispositifs de puissance à semi-conducteurs en carbure de silicium de troisième génération.

 

SLKOR est une entreprise de haute technologie intégrant la conception, le développement, la production et la vente de produits électroniques. Elle fournit aux clients des produits fiables et des services techniques correspondants. La marque "SLKOR" s'est progressivement développée pour devenir une entreprise de renommée internationale, offrant des produits et des solutions à plus de 10,000 XNUMX clients dans le monde entier.

 

Dans le but de fournir aux clients une gamme complète de produits complémentaires, SLKOR a lancé une série de manuels d'utilisation pour les cartes de démonstration des conceptions d'applications de mesure de température sans contact par thermopile infrarouge numérique.

 

1.1 Nom: Manuel d'utilisation pour SLKOR Carte de démonstration de conception d'application de mesure de température sans contact à thermopile infrarouge numérique

Applications 1.2:Appareils portables intelligents, téléphones intelligents, surveillance de la température industrielle, mesure de la température de surface du corps humain sans contact, détection et contrôle intelligents de la température et autres appareils de petite taille pour la mesure de la température à courte portée.

Carte de démonstration de la série 1.3 SL-W-TRS-5.5Dx :

Il est utilisé pour l'évaluation et le test de différents types de capteurs. Les résultats de mesure s'affichent à l'écran et peuvent être imprimés sur le logiciel de débogage du port série du PC via USB vers le port série. Description du bouton : Le bouton gauche sert à réinitialiser et le bouton droit peut contrôler le démarrage et la pause du programme.

 

2. Conception matérielle de la série SL-W-TRS-5.5Dx

 

Les broches de la puce comprennent l'alimentation et le bus I2C, avec un total de 4 broches. La plage de tension d'alimentation autorisée est de 2.3 à 3.6 V. Le capteur lui-même a une très faible consommation d'énergie. Un condensateur de 0.1 uF entre la masse de l'alimentation est suffisant. Si le capteur est relativement éloigné de la partie alimentation, un condensateur supplémentaire de 10 uF peut être envisagé pour assurer une alimentation stable et réduire le bruit.

 

 

 

3. Description de la carte de démonstration de la série SL-W-TRS-5.5Dx

 

3.1 La carte de démonstration est alimentée par une prise Type-C et la tension d'alimentation de la carte de démonstration est de 5 V. Lors de l'utilisation, connectez la carte de démonstration au PC via Type-C, puis vous pouvez afficher les résultats sur l'écran. Si vous devez afficher des données via le port série, vous devez installer le programme pilote WCH CH340, puis utiliser le logiciel de débogage du port série pour fonctionner. Les paramètres de communication du port série sont les suivants : débit en bauds : 9600, bits de données : 8, bits d'arrêt : 1 et aucun contrôle de parité.

 

3.2 L'écran de la carte de démonstration affiche de haut en bas la température ambiante (tamb), la tension de sortie du capteur (vtp_cor), la température de l'objet (surface) (tobj) et la température du corps humain (tbdy). L'unité des valeurs de température ci-dessus est le °C et l'unité de tension est le μV. Parmi elles, les trois premières valeurs sont les sorties d'origine de l'appareil. La valeur de la température corporelle est calculée sur la base des valeurs d'origine à l'aide de l'algorithme de notre société et est fournie à titre de référence uniquement. Les utilisateurs peuvent traiter les données à l'aide de leurs propres algorithmes de température corporelle en fonction de leurs besoins. 

 

Effet d'affichage du port série

 

 2. Exemple de programme de carte de démonstration de la série SL-W-TRS-5.5Dx

 

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

 // main.c

 //////

 #define POUR_CLIENT

 #ifdef POUR_CLIENT

 #include "drv_uart.h"

 

#include "drv_i2c.h"

#include "drv_key.h"

#include "oled/oled.h"

#include "trs55d.h"

 

externe void SystemCoreClockupdate(void);

externe void delay_ms(int cnt);

 int main (vide)

{

clé uint8_t ;

 uint8_t exécuter = 0x01;

 SystemCoreClockupdate();

si (SysTick_Config(SystemCoreClock / 1000))

tandis que(1);

 uartInit();

drv_i2c_init();

drv_key_init();

 

OLED_Init();

 OLED_Refresh();

OLED_Clear();

OLED_ShowString(8,0,"Tampon :",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-Programme de démonstration TRS-5.5Dx ");

pendant que(1) {

clé = drv_key_read();

pendant que(drv_key_read());

si (clé) {

 exécuter = (exécuter)?0:1;

}

si (exécuter) {

 TRS55D_read();

OLED_Refresh();

}

délai_ms(20);

}

}

 

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

 //trs55d.h

 //////

#ifndef _TRS55D_H_

#define _TRS55D_H_

#comprendre

#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

//////

#comprendre

 #include "drv_i2c.h"

 #include "trs55d.h"

 #include "body_temp.h"

 externe 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 len,

uint8_t taille2, uint8_t mode); uint8_t TRS55D_IIC_Read(uint8_t addr_dev, uint8_t addr_reg,

uint8_t *buf, uint16_t compte)

{

uint8_t ret;

indicateur d'accusé de réception uint8_t;

uint16_t je = 0;

drv_i2c_start();

drv_i2c_select_dev(addr_dev,DRV_I2C_OPWR);

 

drv_i2c_writebyte(addr_reg);

 drv_i2c_start();

drv_i2c_select_dev(addr_dev,DRV_I2C_OPRD);

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

 = drv_i2c_readbyte(indicateur d'accusé de réception);

 }

drv_i2c_stop();

 retour à la retraite;

 }

 

void TRS55D_IIC_Write(uint8_t adresse_dev, uint8_t adresse_reg, uint8_t *buf, uint16_t nombre)

 {

 uint16_t je = 0;

drv_i2c_start();

drv_i2c_select_dev(addr_dev,DRV_I2C_OPWR);

drv_i2c_writebyte(addr_reg);

 pour (i = 0; i < nombre; i ++)

 { drv_i2c_writebyte(buf[i]);

}

drv_i2c_stop();

}

 typedef union{

int16_t i16;

uint16_t u16;

struct {

uint8_t u8l;

uint8_t u8h;

 }ONU;

}uu16_t;

 

typedef union{

int32_t i32;

struct {

uint8_t u8b0;

uint8_t u8b1;

uint8_t u8b2;

uint8_t u8b3;

}ONU;

 }uu32_t;

 

tampon de caractères statique[264];

 uu32_t à bj, tamb_cal;

 

uu32_t vtp_cor;

flotteur vtp_uv_f = 0.0;

flotteur vtp_cor_f = 0.0;

float tambf = 0.0; float tobjf = 0.0;

 flotteur tbdyf = 0.0;

 vide TRS55D_read(vide)

{

uint8_t rbuf[4];

uint8_t raddr, rdat;

 uint8_t waddr = 0x0, wdat = 0x0;

int délai d'attente = 0;

 

waddr = 0x30;

wdat = 0x09;

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

 //démarrer la conversion delay_ms(100);

 

// attendre la fin de la conversion

radar = 0x03;

faire {

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

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

radar = 0x02;

 faire {

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

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

 

 // valeur de tension après étalonnage

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

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

}autre {

vtp_cor.un.u8b3 = 0x00;

// vtp après correction

}

vtp_cor_f = (float)vtp_cor.i32/524288.0;

vtp_cor_f *= 1000;

// valeur de la température ambiante après étalonnage

 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; // température ambiante

 

// température de l'objet (surface) après étalonnage

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;

// objet(surface) température

 

// obtenir la température corporelle

tbdyf = get_body_temp(tambf,tobjf); // obtenir la température du corps

 

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

 

// affichage sur oled

 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); // 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); // À venir

}