I2C case using SHT3x-DIS temperature and humidity sensor

To learn more about open source, please visit:

​​51CTO Open Source Basic Software Community​​

​​https://ost..com​​

Preface

This article will introduce the relevant knowledge of the I2C bus, SHT3x DIS temperature sensor, and how to use OpenHarmony's HDF driver and NAPI framework.

1. I2C bus principle

The I2C bus is a bidirectional two-wire synchronous serial bus developed by Philips. Only two wires are needed to transmit information between devices connected to the bus. I2C communication is point-to-point communication, and there are master devices and slave devices. The master and slave devices communicate through two wires, SDA and SCL, where SDA is the data line and SCL is the clock line.

The master device is used to start the bus to transmit data and generate a clock to open the device for transmission. At this time, any addressed device is considered a slave device. The relationship between the master and the slave, the send and receive on the bus is not constant, but depends on the data transmission direction at this time. If the host wants to send data to the slave device, the host first addresses the slave device, then actively sends data to the slave device, and finally the host terminates the data transmission; if the host wants to receive data from the slave device, the master device first addresses the slave device. Then the host receives the data sent by the slave device, and finally the host terminates the receiving process. In this case, the host is responsible for generating a timing clock and terminating data transmission.

The communication process includes acknowledgment and response, and clock synchronization. There are certain requirements for the format of the transmitted data bytes. Each byte must be 8 bits. The number of bytes sent each time is not limited, and each byte must be followed by a check bit. Acknowledgment and response: data transmission must have a response, which is generated by the host. In the response, the transmitter pulls the clock line level high, and the receiver pulls the level low to maintain a stable voltage difference; clock synchronization: data transmission only occurs during the high level of the clock signal, so the clock signals of both parties need to be synchronized to ensure the accuracy of the data;

2. Sensor SHT3X DIS

Sensirion SHT3x-DIS humidity and temperature sensors are based on CMOSens® sensor chips, making them smarter, more reliable and more accurate. The SHT3x-DIS features enhanced signal processing capabilities, two unique user-selectable I2C addresses, and communication speeds up to 1MHz. The SHT35-DIS has a typical relative humidity (RH) accuracy of ±1.5% and a typical temperature accuracy of ±0.1°C. The SHT3x-DIS has a footprint of 2.5mm x 2.5mm x 0.9mm (L x W x H) and a supply voltage range of 2.4V to 5.5V.

(1) Characteristics

• Fully calibrated, linearized and temperature compensated digital output
• I2C interface, communication speed up to 1MHz, with two user-selectable addresses
• The typical accuracy of the SHT35 is +/-1.5% RH and +/-0.1°C
• Extremely fast startup and measurement speed
• Wide supply voltage range from 2.15V to 5.5V
• Small 8-pin DFN package

(2) Pin introduction

Main pins SDA, SCL, VCC, GND.

(3) Communication process

• Start measuring

Before starting measurement, the master device must first send a measurement start signal to the sensor. The signal sent is called an I2C write header, which consists of a 7-bit I2C device address and a 0 (0 for writing, 1 for reading), plus a 16-bit measurement command. When the sensor receives the signal, it will pull the SDA signal low first and respond with the ACK signal. At the eighth falling edge of the clock signal, it indicates that the sensor has received the signal from the master device and started measuring.

• model

There are various sensor data collection modes. We can choose different ways to measure to meet different application scenarios. This is the last two bytes of the write header mentioned above, which represent the measurement command. There are two major collection modes.

• Single data acquisition mode

• Periodic data collection mode

• Other commands

In addition, other commands are set in the sensor, which can be viewed in the sensor documentation.

• data

When the measurement starts, the master device can receive the signal, and the header should use the read header to change 0 to 1. The last six bytes returned by the sensor are the measured temperature and relative humidity data. Among the six bytes, the upper three bits are two temperatures and one check bit, and the lower three bits are two relative humidity and one check bit, using CRC check.

The data conversion formula is as follows:

3. Simple Implementation

The following code simply demonstrates how to use the sensor without excessive specification requirements.

(1) Interface definition

 int SendCMD ( char * devName , char addr , uint16_t command )
 {
 int fd = - 1 ;
 uint8_t cmdBuf [ 2L ] = { 0 };
 struct i2c_rdwr_ioctl_data i2c_data ;
 fd = open ( devName , O_RDWR ); //Get the I2C device handle
 i2c_data . nmsgs = 1 ;
 i2c_data . msgs = ( struct i2c_msg * ) malloc ( i2c_data . nmsgs * sizeof ( struct
 i2c_msg ));
 ioctl ( fd , I2C_TIMEOUT , 1 );
 ioctl ( fd , I2C_RETRIES , 2L );
 cmdBuf [ 0 ] = command >> 8L ; //Process the high and low eight bits of the command data
 cmdBuf [ 1 ] = command & 0xFF ;
 i2c_data . msgs [ 0 ]. len = 2L ;
 i2c_data.msgs [ 0 ] .addr = addr ;
 i2c_data.msgs [ 0 ].flags = 0 ;
 i2c_data.msgs [ 0 ] .buf = cmdBuf ;
 ioctl ( fd , I2C_RDWR , ( unsigned long ) & i2c_data ); //Write data for transmission
 free ( i2c_data . msgs );
 close ( fd );
 return 0 ;
 }
 // Define some data conversion functions and validation functions. Simple data conversion is ignored.
 int ConvertTH ( uint8_t tempRH , float * rawTemp , float * rawHum );
 ...

(2) Main function

 int main ( int argc , char * argv [])
 {
 char * dev_name = "/dev/i2c-5" ;
 SendCMD ( dev_name , ADDR , 0x3093 ) // Restart
 usleep ( 50L * 1000L );
 SendCMD ( dev_name , ADDR , 0x202F ) // Start measurement
 usleep ( 50L * 1000L );
 int fd = - 1 ;
 struct i2c_rdwr_ioctl_data i2c_data ;
 uint8_t rawData [ 6L ] = { 0 };
 float rawTemp = 0 , rawHum = 0 ;
 fd = open ( devName , O_RDWR );
 i2c_data . nmsgs = 1 ;
 i2c_data . msgs = ( struct i2c_msg * ) malloc ( i2c_data . nmsgs * sizeof ( struct
 i2c_msg ));
 i2c_data . msgs [ 0 ]. len = 6L ;
 i2c_data.msgs [ 0 ] .addr = addr ;
 i2c_data.msgs [ 0 ] .flags = 1 ;
 i2c_data.msgs [ 0 ] .buf = rawData ;
 ioctl ( fd , I2C_RDWR , ( unsigned long ) & i2c_data );
 free ( i2c_data . msgs );
 close ( fd );
 ConvertTH ( rawData , & rawTemp , & rawHum );
 printf ( "Temp: %.2f°C\nHum: %.2f°F" , rawTemp , rawHum );
 return 0 ;
 }

4. Using standard system HDF driver implementation

Used: Jiulian Technology unionpi_tiger development board, SHT3x-DIS temperature and humidity sensor, OpenHarmony source code.

(1) Configure the product driver (generally, manufacturers will have configured it. If not, you can jump to the official document to view detailed tutorials)

Instantiate driver entry:

• Instantiate the HdfDriverEntry structure members.
• Call HDF_INIT to register the HdfDriverEntry instantiated object with the HDF framework.

Configuration properties file:

• Add deviceNode description in device_info.hcs file.

 //device_info.hcs configuration reference
 root {
 device_info {
 match_attr = "hdf_manager" ;
 device_i2c :: device {
 device0 :: deviceNode {
 policy = 2 ;
 priority = 50 ;
 permission = 0644 ;
 moduleName = "HDF_PLATFORM_I2C_MANAGER" ;
 serviceName = "HDF_PLATFORM_I2C_MANAGER" ;
 deviceMatchAttr = "hdf_platform_i2c_manager" ;
 }
 device1 :: deviceNode {
 policy = 0 ; // equal to 0, no need to publish services
 priority = 55 ; //Driver startup priority
 permission = 0644 ; // Driver creates device node permission
 moduleName = "hi35xx_i2c_driver" ;
 //【Required】Used to specify the driver name, which must be consistent with the moduleName in the expected driver entry;
 serviceName = "HI35XX_I2C_DRIVER" ; //【Required】The name of the service released by the driver, must be unique
 deviceMatchAttr =
 "hisilicon_hi35xx_i2c" ; //【Required】Used to configure the controller private data, which should be consistent with the corresponding controller in i2c_config.hcs
 // Specific controller information is in i2c_config.hcs
 }
 }
 }
 } 

 // i2c_config.hcs configuration reference (needs to be configured according to the development board used)
 root {
 platform
 i2c_config {
 match_attr =
 "hisilicon_hi35xx_i2c" ; //【Required】Needs to be consistent with the deviceMatchAttr value in device_info.hcs
 template i2c_controller { //Template common parameters. If the node inheriting this template uses the default value in the template, the node field can be default.
 bus = 0 ; //【Required】i2c identification number
 reg_pbase = 0x120b0000 ; //【Required】Physical base address
 reg_size = 0xd1 ; //【Required】Register width
 irq = 0 ; //【Optional】Use according to manufacturer's needs
 freq = 400000 ; // [Optional] Use according to manufacturer's needs
 clk = 50000000 ; //【Optional】Use according to manufacturer's needs
 }
 controller_0x120b0000 :: i2c_controller {
 bus = 0 ;
 }
 controller_0x120b1000 :: i2c_controller {
 bus = 1 ;
 reg_pbase = 0x120b1000 ;
 }
 ...
 }
 }
 }

Instantiate the I2C controller object:

Initialize the I2cCntlr member.

Instantiate the I2cCntlr members I2cMethod and I2cLockMethod.

ps The Jiulian development board used has relevant configurations, and the above configurations do not need to be changed or added.

(2) One structure and three interfaces

I2cMsg structure: used to transmit data carrier, composed of address addr, buffer buf, buffer length len, and signal flag flags.

 struct I2cMsg {
 /** Address of the I2C device */
 uint16_t addr ;
 /** Address of the buffer for storing transferred data */
 uint8_t * buf ;
 /** Length of the transferred data */
 uint16_t len ;
 /**
 * Transfer Mode Flag | Description
 *------------| -----------------------
 * I2C_FLAG_READ | Read flag
 * I2C_FLAG_ADDR_10BIT | 10-bit addressing flag
 * I2C_FLAG_READ_NO_ACK | No-ACK read flag
 * I2C_FLAG_IGNORE_NO_ACK | Ignoring no-ACK flag
 * I2C_FLAG_NO_START | No START condition flag
 * I2C_FLAG_STOP | STOP condition flag
 */
 uint16_t flags ;
 };

The three interfaces are I2cOpen(), I2cClose(), and I2cTransfer().

 //number refers to the bus number mounted by I2C
 DevHandle I2cOpen ( int16_t number );
 //handle is the device handle returned by I2cOpen()
 void I2cClose ( DevHandle handle );
 //msgs is the data structure to be transmitted, count is the size of the transmission structure
 int32_t I2cTransfer ( DevHandle handle , struct I2cMsg * msgs , int16_t
 count );

(3) Code

• Header Files

 #include //Standard input and output
 #include //Use usleep() process suspend function
 #include "i2c_if.h" //HDF i2c interface
 #include "hdf_log.h" //Log print header file

• Structure and interface

 // Redefine the structure for easy use
 typedef struct
 {
 struct I2cMsg * i2cMsg ;
 uint8_t msgLen ; //length of i2cMsg
 } I2cMessage ;
 //Define the command sending function
 int32_t SendCMD ( DevHandle handle , uint16_t command )
 {
 int32_t ret ;
 I2cMessage i2cMessage ;
 i2cMessage . msgLen = 1 ;
 i2cMessage.i2cMsg = new I2cMsg [ 1 ] ; //Apply for memory
 uint8_t cmdBuf [ 2L ] = { 0 };
 cmdBuf [ 0 ] = command >> 8L ; // Split the command into high and low bits and save them separately
 cmdBuf [ 1 ] = command & 0xFF ;
 i2cMessage . i2cMsg [ 0 ]. len = 2L ;
 i2cMessage.i2cMsg [ 0 ] .addr = ADDR ;
 i2cMessage . i2cMsg [ 0 ]. flags = WRITE_FLAGS ;
 i2cMessage.i2cMsg [ 0 ] .buf = cmdBuf ;
 ret = I2cTransfer ( handle , i2cMessage . i2cMsg , i2cMessage . msgLen );
 if ( ret < 0 ) {
 LOGE ( "%s: SendCommend failed" , __func__ );
 delete i2cMessage . i2cMsg ;
 return - 1 ;
 }
 delete i2cMessage . i2cMsg ; //Release memory
 usleep ( 50L * 1000L ); //Wait for sending to complete
 return 1 ;
 }

• Main function

 int main ( int argc , char ** argv )
 {
 /**
 * Data initialization
 */
 DevHandle i2cHandle ;
 /**
 * Get the handle
 */
 i2cHandle = I2cOpen ( BUSID );
 if ( i2cHandle == NULL ) {
 LOGE ( "%s:get handle failed" , __func__ );
 I2cClose ( i2cHandle );
 return 0 ;
 }
 /**
 * Send command
 */
 SendCMD ( i2cHandle , 0x3093 ); //Disable reset command
 SendCMD ( i2cHandle , 0x202F ); //Send command repeatability=Low mps=0.5
 /**
 * Receive data
 */
 I2cMessage i2cMessage ;
 i2cMessage . msgLen = 1 ;
 i2cMessage . i2cMsg = new I2cMsg [ 1 ];
 uint8_t regData [ 6L ] = { 0 };
 i2cMessage . i2cMsg [ 0 ]. len = 6L ;
 i2cMessage.i2cMsg [ 0 ] .addr = ADDR ;
 i2cMessage . i2cMsg [ 0 ]. flags = READ_FLAGS ;
 i2cMessage.i2cMsg [ 0 ] .buf = regData ;
 I2cTransfer ( i2cHandle , i2cMessage . i2cMsg , i2cMessage . msgLen );
 delete i2cMessage . i2cMsg ;
 /**
 * Data processing
 */
 uint16_t value = 0 ;
 value = regData [ 0 ] << 8 ;
 value = value | regData [ 1 ];
 printf ( "Temperature: %.2f C\n" , 175.0f * ( float ) value / 65535.0f - 45.0f );
 value = 0 ;
 value = regData [ 3 ] << 8 ;
 value = value | regData [ 4 ];
 printf ( "Humidity: %.2f H\n" , 100.0f * ( float ) value / 65535.0f );
 /**
 * Turn off the device
 */
 I2cClose ( i2cHandle );
 return 0 ;
 }

So far, the sensor value has been successfully obtained through OpenHarmony's HDF driver.

5. Implementing NAPI

(1) Module definition and registration

 /**
 * Module definition
 */
 static napi_module i2cHDF_demoModule = {
 . nm_version = 1 ,
 . nm_flags = 0 ,
 . nm_filename = nullptr ,
 . nm_register_func = registerI2cHDF_DemoApis ,
 . nm_modname = "i2chdf_demo" ,
 . nm_priv = (( void * ) 0 ),
 . reserved = { 0 },
 };
 /**
 * Module registration
 */
 extern "C" __attribute__ (( constructor )) void RegisterI2cHDFoModule ( void )
 {
 napi_module_register ( & i2cHDF_demoModule );
 }

(2) Interface definition and registration

 int32_t SendCMD ( DevHandle handle , uint16_t command )
 {
 int32_t ret ;
 struct I2cMsg * i2cMsg ;
 int msgLen = 1 ;
 i2cMsg = new I2cMsg [ msgLen ];
 uint8_t cmdBuf [ 2L ] = { 0 };
 cmdBuf [ 0 ] = command >> 8L ;
 cmdBuf [ 1 ] = command & 0xFF ;
 i2cMsg [ 0 ] .len = 2L ;
 i2cMsg [ 0 ] .addr = ADDR ;
 i2cMsg [ 0 ]. flags = WRITE_FLAGS ;
 i2cMsg [ 0 ] .buf = cmdBuf ;
 ret = I2cTransfer ( handle , i2cMsg , msgLen );
 delete i2cMsg ;
 usleep ( 50L * 1000L );
 return 1 ;
 }
 /**
 * Interface definition
 */
 static napi_value readI2cBuf ( napi_env env , napi_callback_info info )
 {
 napi_value ret ;
 DevHandle i2cHandle ;
 i2cHandle = I2cOpen ( BUSID );
 SendCMD ( i2cHandle , 0x3093 );
 SendCMD ( i2cHandle , 0x202F );
 struct I2cMsg * i2cMsg ;
 int msgLen = 1 ;
 i2cMsg = new I2cMsg [ msgLen ];
 uint8_t regData [ 6L ] = { 0 };
 i2cMsg [ 0 ] .len = 6L ;
 i2cMsg [ 0 ] .addr = ADDR ;
 i2cMsg [ 0 ]. flags = READ_FLAGS ;
 i2cMsg [ 0 ] .buf = regData ;
 I2cTransfer ( i2cHandle , i2cMsg , msgLen );
 delete i2cMsg ;
 uint16_t value = 0 ;
 double sHTTemp = 0 ;
 value = regData [ 0 ] << 8 ;
 value = value | regData [ 1 ];
 sHTTemp = 175.0f * ( double ) value / 65535.0f - 45.0f ;
 //The design idea is similar to the HDF above, except that the last obtained value is converted and then returned
 //Here we only process the returned temperature value for demonstration purposes
 NAPI_CALL ( env , napi_create_double ( env , sHTTemp , & ret ));
 return ret ;
 }
 /**
 * Interface registration
 */
 static napi_value registerI2cHDF_DemoApis ( napi_env env , napi_value
 exports )
 {
 napi_property_descriptor desc [] = {
 DECLARE_NAPI_FUNCTION ( "readI2cBuf" , readI2cBuf ), //NAPI name, the function above
 };
 NAPI_CALL ( env , napi_define_properties ( env , exports , sizeof ( desc ) / sizeof ( desc [ 0 ]), desc ));
 return exports ;
 }

(3) Northbound interface

• NAPI

 function readI2cBuf (): number ;

• Index.ets

 import i2chdf from '@ohos.i2chdf'
 @Entry
 @Component
 struct Index {
 @State message : string = 'Temperature: ' + i2chdf . readI2cBuf () . toFixed ( 2 ) +
 '°C' ;
 aboutToAppear (): void {
 var Id = setInterval (() => {
 this . message = 'Temperature: ' + i2chdf . readI2cBuf (). toFixed ( 2 ) + '°C' ;
 }, 1000 )
 }
 build () {
 Row () {
 Column () {
 Text ( this . message )
 .fontSize ( 50 )
 .fontWeight ( FontWeight.Bold )
 }
 .width ( '100%' )
 }
 . height ( '100%' )
 }
 }

(4) Effect demonstration

Summarize

The whole idea of ​​the case is centered around the I2C communication process and the SHT3x temperature sensor workflow. In the use of the HDF driver, we will find that we only need one number to get the device handle, which is simpler and clearer than the previous "/dev/i2c-5", which is also one of the characteristics of HDF. The implementation of NAPI connects the entire OpenHarmoy north-south direction, allowing the northbound program to access the temperature and humidity of the sensor through the local interface.

To learn more about open source, please visit:

​​51CTO Open Source Basic Software Community​​

​​https://ost..com​​