SensorSFM3019 Class Reference

#include <driver_SFM3019.h>

Collaboration diagram for SensorSFM3019:

Public Member Functions
bool	Init (t_i2cdevices device, void *hw_handle)
bool	doMeasure (float *Flow, float *T)
float	GetIntegral ()
void	ResetIntegral ()

Private Member Functions
const char *	sfm_common_get_driver_version (void)
int16_t	sfm_common_probe (uint8_t i2c_address)
int16_t	sfm_common_read_product_identifier (uint8_t i2c_address, uint32_t *product_number, uint8_t(*serial_number)[8])
int16_t	sfm_common_read_scale_factor_offset_and_unit (const SfmConfig *sfm_config, SfmCmdStartContinuousMeasurement measurement_cmd, int16_t *flow_scale, int16_t *flow_offset, uint16_t *unit)
int16_t	sfm_common_convert_flow_float (const SfmConfig *sfm_config, int16_t flow_raw, float *flow)
float	sfm_common_convert_temperature_float (int16_t temperature_raw)
int16_t	sfm_common_start_continuous_measurement (SfmConfig *sfm_config, SfmCmdStartContinuousMeasurement measurement_cmd)
int16_t	sfm_common_read_measurement_raw (const SfmConfig *sfm_config, int16_t *flow_raw, int16_t *temperature_raw, uint16_t *status)
int16_t	sfm_common_stop_continuous_measurement (SfmConfig *sfm_config)
uint8_t	sensirion_common_generate_crc (uint8_t *data, uint16_t count)
int8_t	sensirion_common_check_crc (uint8_t *data, uint16_t count, uint8_t checksum)
int16_t	sensirion_i2c_general_call_reset (void)
uint16_t	sensirion_fill_cmd_send_buf (uint8_t *buf, uint16_t cmd, const uint16_t *args, uint8_t num_args)
int16_t	sensirion_i2c_read_words (uint8_t address, uint16_t *data_words, uint16_t num_words)
int16_t	sensirion_i2c_read_words_as_bytes (uint8_t address, uint8_t *data, uint16_t num_words)
int16_t	sensirion_i2c_write_cmd (uint8_t address, uint16_t command)
int16_t	sensirion_i2c_write_cmd_with_args (uint8_t address, uint16_t command, const uint16_t *data_words, uint16_t num_words)
int16_t	sensirion_i2c_delayed_read_cmd (uint8_t address, uint16_t cmd, uint32_t delay_us, uint16_t *data_words, uint16_t num_words)
int16_t	sensirion_i2c_read_cmd (uint8_t address, uint16_t cmd, uint16_t *data_words, uint16_t num_words)
int16_t	sfm3019_probe (void)
SfmConfig	sfm3019_create (void)
int16_t	sensirion_i2c_select_bus (uint8_t bus_idx)
void	sensirion_i2c_init (void)
void	sensirion_i2c_release (void)
int8_t	sensirion_i2c_read (uint8_t address, uint8_t *data, uint16_t count)
int8_t	sensirion_i2c_write (uint8_t address, const uint8_t *data, uint16_t count)
void	sensirion_sleep_usec (uint32_t useconds)

Private Attributes
uint8_t	i2c_address
t_i2cdevices	i2c_device
HW *	hwi
DebugIfaceClass *	dbg
float	Integral
bool	_initialized = false
SfmConfig	sfm3019

Detailed Description

Definition at line 32 of file driver_SFM3019.h.

Member Function Documentation

doMeasure()

bool SensorSFM3019::doMeasure	(	float *	Flow,
		float *	T
	)

Definition at line 461 of file driver_SFM3019.cpp.

{
    int16_t flow_raw;
    int16_t temperature_raw;
    uint16_t status;
    int16_t error;
    if (!_initialized) return false;
 
    error = sfm_common_read_measurement_raw(&sfm3019, &flow_raw,
        &temperature_raw, &status);
    if (error) {
        //Serial.println("Error while reading measurement");
        return false;
    }
    else {
        float flow;
        float temperature;
        error = sfm_common_convert_flow_float(&sfm3019, flow_raw, &flow);
        if (error) {
            //Serial.println("Error while converting flow");
            return false;
        }
        *T = sfm_common_convert_temperature_float(temperature_raw);
        *Flow = flow;
        Integral += flow;
        //Serial.println("Flow: " + String(flow)  + " flow_raw: " + String(flow_raw) + " T: " +String(temperature) + " Traw: " +String(temperature_raw) + " status: " + String(status));
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

GetIntegral()

float SensorSFM3019::GetIntegral

(

)

Definition at line 490 of file driver_SFM3019.cpp.

{
    return Integral;
}

Here is the caller graph for this function:

Init()

bool SensorSFM3019::Init	(	t_i2cdevices	device,
		void *	hw_handle
	)

Definition at line 389 of file driver_SFM3019.cpp.

{
 
    DriverContext* dc;
    dc = (DriverContext*)hw_handle;
    hwi = (HW*)dc->hwi;
    dbg = (DebugIfaceClass*)dc->dbg;
    i2c_address = 0x2e;
    i2c_device = device;
 
    _initialized = false;
    const char* driver_version = sfm_common_get_driver_version();
    if (driver_version) {
        dbg->DbgPrint(DBG_KERNEL, DBG_INFO, "SFM driver version " + String(driver_version));
    }
    else {
        dbg->DbgPrint(DBG_KERNEL, DBG_ERROR, "SFM fatal: Getting driver version failed");
        return false;
    }
 
    int16_t error;
    
    /* Reset all I2C devices */
    error = sensirion_i2c_general_call_reset();
    if (error) {
        dbg->DbgPrint(DBG_KERNEL, DBG_ERROR, "General call reset failed");
        return false;
    }
    /* Wait for the SFM3019 to initialize */
    sensirion_sleep_usec(SFM3019_SOFT_RESET_TIME_US*4);
 
    uint32_t timeout = millis();
    while (sfm3019_probe()) {
        dbg->DbgPrint(DBG_KERNEL, DBG_ERROR, "SFM sensor probing failed");
        if (millis() - timeout > 1000)
            return false;
        hwi->__delay_blocking_ms(10);
    }
 
    uint32_t product_number = 0;
    uint8_t serial_number[8] = {};
    error = sfm_common_read_product_identifier(i2c_address,
        &product_number, &serial_number);
    if (error) {
        dbg->DbgPrint(DBG_KERNEL, DBG_ERROR, "Failed to read product identifier");
        return false;
    }
    else {
        dbg->DbgPrint(DBG_KERNEL, DBG_WARNING, "Product: " + String(product_number));
        for (size_t i = 0; i < 8; ++i) {
            dbg->DbgPrint(DBG_KERNEL, DBG_WARNING, String(serial_number[i]));
        }
    }
 
    hwi->__delay_blocking_ms(1000);
    sfm3019 = sfm3019_create();
 
    error = sfm_common_start_continuous_measurement(
        &sfm3019, SFM3019_CMD_START_CONTINUOUS_MEASUREMENT_AIR);
    if (error) {
        dbg->DbgPrint(DBG_KERNEL, DBG_ERROR, "Failed to start measurement");
    }
 
    /* Wait for the first measurement to be available. Wait for
     * SFM3019_MEASUREMENT_WARM_UP_TIME_US instead for more reliable results */
    hwi->__delay_blocking_ms(100);
 
    _initialized = true;
    return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ResetIntegral()

void SensorSFM3019::ResetIntegral

(

)

Definition at line 494 of file driver_SFM3019.cpp.

{
    Integral = 0;
}

Here is the caller graph for this function:

sensirion_common_check_crc()

int8_t SensorSFM3019::sensirion_common_check_crc ( uint8_t *  data, uint16_t  count, uint8_t  checksum  )

private

Definition at line 97 of file driver_SFM3019.cpp.

                      {
    if (sensirion_common_generate_crc(data, count) != checksum)
        return STATUS_FAIL;
    return STATUS_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

sensirion_common_generate_crc()

uint8_t SensorSFM3019::sensirion_common_generate_crc ( uint8_t *  data, uint16_t  count  )

private

Definition at line 79 of file driver_SFM3019.cpp.

                                                                                  {
    uint16_t current_byte;
    uint8_t crc = CRC8_INIT;
    uint8_t crc_bit;
 
    /* calculates 8-Bit checksum with given polynomial */
    for (current_byte = 0; current_byte < count; ++current_byte) {
        crc ^= (data[current_byte]);
        for (crc_bit = 8; crc_bit > 0; --crc_bit) {
            if (crc & 0x80)
                crc = (crc << 1) ^ CRC8_POLYNOMIAL;
            else
                crc = (crc << 1);
        }
    }
    return crc;
}

Here is the caller graph for this function:

sensirion_fill_cmd_send_buf()

uint16_t SensorSFM3019::sensirion_fill_cmd_send_buf ( uint8_t *  buf, uint16_t  cmd, const uint16_t *  args, uint8_t  num_args  )

private

sensirion_fill_cmd_send_buf() - create the i2c send buffer for a command and a set of argument words. The output buffer interleaves argument words with their checksums. @buf: The generated buffer to send over i2c. Then buffer length must be at least SENSIRION_COMMAND_LEN + num_args * (SENSIRION_WORD_SIZE + CRC8_LEN). @cmd: The i2c command to send. It already includes a checksum. @args: The arguments to the command. Can be NULL if none. @num_args: The number of word arguments in args.

Returns

The number of bytes written to buf

Definition at line 110 of file driver_SFM3019.cpp.

                                            {
    uint8_t crc;
    uint8_t i;
    uint16_t idx = 0;
 
    buf[idx++] = (uint8_t)((cmd & 0xFF00) >> 8);
    buf[idx++] = (uint8_t)((cmd & 0x00FF) >> 0);
 
    for (i = 0; i < num_args; ++i) {
        buf[idx++] = (uint8_t)((args[i] & 0xFF00) >> 8);
        buf[idx++] = (uint8_t)((args[i] & 0x00FF) >> 0);
 
        crc = sensirion_common_generate_crc((uint8_t*)&buf[idx - 2],
            SENSIRION_WORD_SIZE);
        buf[idx++] = crc;
    }
    return idx;
}

Here is the call graph for this function:

Here is the caller graph for this function:

sensirion_i2c_delayed_read_cmd()

int16_t SensorSFM3019::sensirion_i2c_delayed_read_cmd ( uint8_t  address, uint16_t  cmd, uint32_t  delay_us, uint16_t *  data_words, uint16_t  num_words  )

private

sensirion_i2c_delayed_read_cmd() - send a command, wait for the sensor to process and read data back @address: Sensor i2c address @cmd: Command @delay: Time in microseconds to delay sending the read request @data_words: Allocated buffer to store the read data @num_words: Data words to read (without CRC bytes)

Returns

STATUS_OK on success, an error code otherwise

Definition at line 190 of file driver_SFM3019.cpp.

                        {
    int16_t ret;
    uint8_t buf[SENSIRION_COMMAND_SIZE];
 
    sensirion_fill_cmd_send_buf(buf, cmd, NULL, 0);
    ret = sensirion_i2c_write(address, buf, SENSIRION_COMMAND_SIZE);
    if (ret != STATUS_OK)
        return ret;
 
    if (delay_us)
        sensirion_sleep_usec(delay_us);
 
    return sensirion_i2c_read_words(address, data_words, num_words);
}

Here is the call graph for this function:

Here is the caller graph for this function:

sensirion_i2c_general_call_reset()

int16_t SensorSFM3019::sensirion_i2c_general_call_reset ( void  )

private

Send a general call reset.

Warning

This will reset all attached I2C devices on the bus which support general call reset.

Returns

STATUS_OK on success, an error code otherwise

Definition at line 104 of file driver_SFM3019.cpp.

                                                            {
    const uint8_t data = 0x06;
    hwi->I2CWrite(IIC_GENERAL_CALL_SENSIRION, (uint8_t *)&data, (uint16_t)sizeof(data), true);
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

sensirion_i2c_init()

void SensorSFM3019::sensirion_i2c_init ( void  )

private

Initialize all hard- and software components that are needed for the I2C communication.

sensirion_i2c_read()

int8_t SensorSFM3019::sensirion_i2c_read ( uint8_t  address, uint8_t *  data, uint16_t  count  )

private

Execute one read transaction on the I2C bus, reading a given number of bytes. If the device does not acknowledge the read command, an error shall be returned.

Parameters

address	7-bit I2C address to read from
data	pointer to the buffer where the data is to be stored
count	number of bytes to read from I2C and store in the buffer

Returns

0 on success, error code otherwise

Definition at line 216 of file driver_SFM3019.cpp.

                                                                                       {
    uint8_t readData[32];
    uint8_t rxByteCount = 0;
 
    
    hwi->I2CRead(i2c_device, readData, count,true);
  
    memcpy(data, readData, count);
 
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

sensirion_i2c_read_cmd()

int16_t SensorSFM3019::sensirion_i2c_read_cmd ( uint8_t  address, uint16_t  cmd, uint16_t *  data_words, uint16_t  num_words  )

private

sensirion_i2c_read_cmd() - reads data words from the sensor after a command is issued @address: Sensor i2c address @cmd: Command @data_words: Allocated buffer to store the read data @num_words: Data words to read (without CRC bytes)

Returns

STATUS_OK on success, an error code otherwise

Definition at line 207 of file driver_SFM3019.cpp.

                                              {
    return sensirion_i2c_delayed_read_cmd(address, cmd, 0, data_words,
        num_words);
}

Here is the call graph for this function:

Here is the caller graph for this function:

sensirion_i2c_read_words()

int16_t SensorSFM3019::sensirion_i2c_read_words ( uint8_t  address, uint16_t *  data_words, uint16_t  num_words  )

private

sensirion_i2c_read_words() - read data words from sensor

@address: Sensor i2c address @data_words: Allocated buffer to store the read words. The buffer may also have been modified on STATUS_FAIL return. @num_words: Number of data words to read (without CRC bytes)

Returns

STATUS_OK on success, an error code otherwise

Definition at line 157 of file driver_SFM3019.cpp.

                        {
    int16_t ret;
    uint8_t i;
 
    ret = sensirion_i2c_read_words_as_bytes(address, (uint8_t*)data_words,
        num_words);
    if (ret != STATUS_OK)
        return ret;
 
    for (i = 0; i < num_words; ++i)
        data_words[i] = be16_to_cpu(data_words[i]);
 
    return STATUS_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

sensirion_i2c_read_words_as_bytes()

int16_t SensorSFM3019::sensirion_i2c_read_words_as_bytes ( uint8_t  address, uint8_t *  data, uint16_t  num_words  )

private

sensirion_i2c_read_words_as_bytes() - read data words as byte-stream from sensor

Read bytes without adjusting values to the uP's word-order.

@address: Sensor i2c address @data: Allocated buffer to store the read bytes. The buffer may also have been modified on STATUS_FAIL return. @num_words: Number of data words(!) to read (without CRC bytes) Since only word-chunks can be read from the sensor the size is still specified in sensor-words (num_words = num_bytes * SENSIRION_WORD_SIZE)

Returns

STATUS_OK on success, an error code otherwise

Definition at line 130 of file driver_SFM3019.cpp.

                        {
    int16_t ret;
    uint16_t i, j;
    uint16_t size = num_words * (SENSIRION_WORD_SIZE + CRC8_LEN);
    uint16_t word_buf[SENSIRION_MAX_BUFFER_WORDS];
    uint8_t* const buf8 = (uint8_t*)word_buf;
 
    ret = sensirion_i2c_read(address, buf8, size);
    if (ret != STATUS_OK)
        return ret;
 
    /* check the CRC for each word */
    for (i = 0, j = 0; i < size; i += SENSIRION_WORD_SIZE + CRC8_LEN) {
 
        ret = sensirion_common_check_crc(&buf8[i], SENSIRION_WORD_SIZE,
            buf8[i + SENSIRION_WORD_SIZE]);
        if (ret != STATUS_OK)
            return ret;
 
        data[j++] = buf8[i];
        data[j++] = buf8[i + 1];
    }
 
    return STATUS_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

sensirion_i2c_release()

void SensorSFM3019::sensirion_i2c_release ( void  )

private

Release all resources initialized by sensirion_i2c_init().

sensirion_i2c_select_bus()

int16_t SensorSFM3019::sensirion_i2c_select_bus ( uint8_t  bus_idx )

private

Select the current i2c bus by index. All following i2c operations will be directed at that bus.

THE IMPLEMENTATION IS OPTIONAL ON SINGLE-BUS SETUPS (all sensors on the same bus)

Parameters

bus_idx

Bus index to select

Returns

0 on success, an error code otherwise

sensirion_i2c_write()

int8_t SensorSFM3019::sensirion_i2c_write ( uint8_t  address, const uint8_t *  data, uint16_t  count  )

private

Execute one write transaction on the I2C bus, sending a given number of bytes. The bytes in the supplied buffer must be sent to the given address. If the slave device does not acknowledge any of the bytes, an error shall be returned.

Parameters

address	7-bit I2C address to write to
data	pointer to the buffer containing the data to write
count	number of bytes to read from the buffer and send over I2C

Returns

0 on success, error code otherwise

Definition at line 228 of file driver_SFM3019.cpp.

                    {
  
 
    hwi->I2CWrite(i2c_device, (uint8_t*)data, count, true);
 
 
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

sensirion_i2c_write_cmd()

int16_t SensorSFM3019::sensirion_i2c_write_cmd ( uint8_t  address, uint16_t  command  )

private

sensirion_i2c_write_cmd() - writes a command to the sensor @address: Sensor i2c address @command: Sensor command

Returns

STATUS_OK on success, an error code otherwise

Definition at line 173 of file driver_SFM3019.cpp.

                                                                                {
    uint8_t buf[SENSIRION_COMMAND_SIZE];
 
    sensirion_fill_cmd_send_buf(buf, command, NULL, 0);
    return sensirion_i2c_write(address, buf, SENSIRION_COMMAND_SIZE);
}

Here is the call graph for this function:

Here is the caller graph for this function:

sensirion_i2c_write_cmd_with_args()

int16_t SensorSFM3019::sensirion_i2c_write_cmd_with_args ( uint8_t  address, uint16_t  command, const uint16_t *  data_words, uint16_t  num_words  )

private

sensirion_i2c_write_cmd_with_args() - writes a command with arguments to the sensor @address: Sensor i2c address @command: Sensor command @data: Argument buffer with words to send @num_words: Number of data words to send (without CRC bytes)

Returns

STATUS_OK on success, an error code otherwise

Definition at line 180 of file driver_SFM3019.cpp.

                        {
    uint8_t buf[SENSIRION_MAX_BUFFER_WORDS];
    uint16_t buf_size;
 
    buf_size = sensirion_fill_cmd_send_buf(buf, command, data_words, num_words);
    return sensirion_i2c_write(address, buf, buf_size);
}

Here is the call graph for this function:

Here is the caller graph for this function:

sensirion_sleep_usec()

void SensorSFM3019::sensirion_sleep_usec ( uint32_t  useconds )

private

Sleep for a given number of microseconds. The function should delay the execution approximately, but no less than, the given time.

When using hardware i2c: Despite the unit, a <10 millisecond precision is sufficient.

When using software i2c: The precision needed depends on the desired i2c frequency, i.e. should be exact to about half a clock cycle (defined in SENSIRION_I2C_CLOCK_PERIOD_USEC in sensirion_arch_config.h).

Example with 400kHz requires a precision of 1 / (2 * 400kHz) == 1.25usec.

Parameters

useconds

the sleep time in microseconds

Sleep for a given number of microseconds. The function should delay the execution for at least the given time, but may also sleep longer.

Parameters

useconds

the sleep time in microseconds

Definition at line 244 of file driver_SFM3019.cpp.

                                                          {
    hwi->__delay_blocking_ms((useconds / 1000) + 1);
}

Here is the caller graph for this function:

sfm3019_create()

SfmConfig SensorSFM3019::sfm3019_create ( void  )

private

Create a new SFM3019 instance

Definition at line 378 of file driver_SFM3019.cpp.

                                            {
    SfmConfig sfm_config = {
        i2c_address,
        0,
        0,
    };
    return sfm_config;
}

Here is the caller graph for this function:

sfm3019_probe()

int16_t SensorSFM3019::sfm3019_probe ( void  )

private

Detects if a sensor is connected by reading out the ID register. If the sensor does not answer or if the answer is not the expected value, the test fails.

Returns

0 if a sensor was detected

Definition at line 374 of file driver_SFM3019.cpp.

                                         {
    return sfm_common_probe(i2c_address);
}

Here is the call graph for this function:

Here is the caller graph for this function:

sfm_common_convert_flow_float()

int16_t SensorSFM3019::sfm_common_convert_flow_float ( const SfmConfig *  sfm_config, int16_t  flow_raw, float *  flow  )

private

Convert the raw flow ticks to slm.

Parameters

sfm_config	Pointer to the SFM object
flow_raw	Flow value as read by sfm_common_read_measurement_raw
flow	Out parameter to store the converted flow

Returns

0 on success, an error code otherwise

Definition at line 316 of file driver_SFM3019.cpp.

                                   {
    if (sfm_config->flow_scale == 0) {
        return -1;
    }
 
    *flow =
        (flow_raw - sfm_config->flow_offset) / (float)(sfm_config->flow_scale);
 
    return 0;
}

Here is the caller graph for this function:

sfm_common_convert_temperature_float()

float SensorSFM3019::sfm_common_convert_temperature_float ( int16_t  temperature_raw )

private

Convert the raw temperature ticks to degree Celsius.

Parameters

temperature_raw

Temperature value as read by sfm_common_read_measurement_raw

Returns

The temperature in degree Celsius

Definition at line 328 of file driver_SFM3019.cpp.

                                                                                 {
    return temperature_raw / 200.0f;
}

Here is the caller graph for this function:

sfm_common_get_driver_version()

const char * SensorSFM3019::sfm_common_get_driver_version ( void  )

private

Return the driver version

Returns

Driver version string

Definition at line 249 of file driver_SFM3019.cpp.

                                                             {
    return SFM_DRV_VERSION_STR;
}

Here is the caller graph for this function:

sfm_common_probe()

int16_t SensorSFM3019::sfm_common_probe ( uint8_t  i2c_address )

private

Detects if a sensor is connected by reading out the ID register. If the sensor does not answer or if the answer is not the expected value, the test fails.

Parameters

i2c_address

I2C address to probe

Returns

0 if a sensor was detected

Definition at line 253 of file driver_SFM3019.cpp.

                                                           {
    uint16_t buf[6];
    return sensirion_i2c_read_cmd(i2c_address, SFM_CMD_READ_PRODUCT_IDENTIFIER,
        buf, 6);
}

Here is the call graph for this function:

Here is the caller graph for this function:

sfm_common_read_measurement_raw()

int16_t SensorSFM3019::sfm_common_read_measurement_raw ( const SfmConfig *  sfm_config, int16_t *  flow_raw, int16_t *  temperature_raw, uint16_t *  status  )

private

Read results of a continuous measurement

Parameters

sfm_config	Pointer to the SFM object
flow_raw	Out parameter for the raw flow value
temperature_raw	Out parameter for the raw temperature value
status	Out parameter for the status word

Returns

0 on success, an error code otherwise

Definition at line 345 of file driver_SFM3019.cpp.

                      {
    uint16_t buf[3] = {};
    int16_t error = sensirion_i2c_read_words(sfm_config->i2c_address, buf, 3);
    if (error) {
        return error;
    }
    if (flow_raw) {
        *flow_raw = (int16_t)buf[0];
    }
    if (temperature_raw) {
        *temperature_raw = (int16_t)buf[1];
    }
    if (status) {
        *status = buf[2];
    }
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

sfm_common_read_product_identifier()

int16_t SensorSFM3019::sfm_common_read_product_identifier ( uint8_t  i2c_address, uint32_t *  product_number, uint8_t(*)  serial_number[8]  )

private

Read the product identifier, consisting of a product number and a serial number.

Parameters

i2c_address	I2C address to read the product identifier from
product_number	Out parameter to store the product number
serial_number	Out parameter to store the serial number in raw byte format

Returns

0 on success, an error code otherwise

Definition at line 259 of file driver_SFM3019.cpp.

                                {
    uint8_t buf[6 * 2];
    int16_t error =
        sensirion_i2c_write_cmd(i2c_address, SFM_CMD_READ_PRODUCT_IDENTIFIER);
    if (error) {
        return error;
    }
    error = sensirion_i2c_read_words_as_bytes(i2c_address, buf, 6);
    if (error) {
        return error;
    }
    if (product_number) {
        *product_number = ((uint32_t)buf[0] << 24) + ((uint32_t)buf[1] << 16) +
            ((uint32_t)buf[2] << 8) + (uint32_t)buf[3];
    }
    if (serial_number) {
        for (size_t i = 0; i < 8; ++i) {
            (*serial_number)[i] = buf[i + 4];
        }
    }
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

sfm_common_read_scale_factor_offset_and_unit()

int16_t SensorSFM3019::sfm_common_read_scale_factor_offset_and_unit ( const SfmConfig *  sfm_config, SfmCmdStartContinuousMeasurement  measurement_cmd, int16_t *  flow_scale, int16_t *  flow_offset, uint16_t *  unit  )

private

Read the scale factor, offset and unit for the given measurement type.

Parameters

sfm_config	Pointer to the SFM object
measurement_cmd	Measurement type to get the scale, offset and unit
flow_scale	Out parameter to store the flow scale
flow_offset	Out parameter to store the flow offset
unit	Out parameter to store the unit

Returns

0 on success, an error code otherwise

Definition at line 284 of file driver_SFM3019.cpp.

                                          {
 
    uint16_t measurement_cmd_word = (uint16_t)measurement_cmd;
 
    uint16_t buf[3];
    int16_t error = sensirion_i2c_write_cmd_with_args(
        sfm_config->i2c_address, SFM_CMD_READ_SCALE_FACTOR_OFFSET_AND_FLOW_UNIT,
        &measurement_cmd_word, 1);
    if (error) {
        return error;
    }
    error =
        sensirion_i2c_read_words(sfm_config->i2c_address, buf, ARRAY_SIZE(buf));
 
    if (error) {
        return error;
    }
    if (flow_scale) {
        *flow_scale = (int16_t)buf[0];
    }
    if (flow_offset) {
        *flow_offset = (int16_t)buf[1];
    }
    if (unit) {
        *unit = buf[2];
    }
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

sfm_common_start_continuous_measurement()

int16_t SensorSFM3019::sfm_common_start_continuous_measurement ( SfmConfig *  sfm_config, SfmCmdStartContinuousMeasurement  measurement_cmd  )

private

Starts a continuous measurement with the given gas configuration.

Parameters

sfm_config	Pointer to the SFM object
measurement_cmd	Select which gas or gas mix should be measured

Returns

0 on success, an error code otherwise

Definition at line 332 of file driver_SFM3019.cpp.

                                                                             {
 
    int16_t error = sfm_common_read_scale_factor_offset_and_unit(
        sfm_config, measurement_cmd, &sfm_config->flow_scale,
        &sfm_config->flow_offset, NULL);
    if (error) {
        return error;
    }
 
    return sensirion_i2c_write_cmd(sfm_config->i2c_address, measurement_cmd);
}

Here is the call graph for this function:

Here is the caller graph for this function:

sfm_common_stop_continuous_measurement()

int16_t SensorSFM3019::sfm_common_stop_continuous_measurement ( SfmConfig *  sfm_config )

private

Stops a continuous measurement.

Parameters

sfm_config

Pointer to the SFM object

Returns

0 on success, an error code otherwise

Definition at line 366 of file driver_SFM3019.cpp.

                                                                                   {
    sfm_config->flow_scale = 0;
    sfm_config->flow_offset = 0;
    return sensirion_i2c_write_cmd(sfm_config->i2c_address,
        SFM_CMD_STOP_CONTINUOUS_MEASUREMENT);
}

Here is the call graph for this function:

Member Data Documentation

_initialized

bool SensorSFM3019::_initialized = false

private

Definition at line 52 of file driver_SFM3019.h.

dbg

DebugIfaceClass* SensorSFM3019::dbg

private

Definition at line 49 of file driver_SFM3019.h.

hwi

HW* SensorSFM3019::hwi

private

Definition at line 48 of file driver_SFM3019.h.

i2c_address

uint8_t SensorSFM3019::i2c_address

private

Definition at line 44 of file driver_SFM3019.h.

i2c_device

t_i2cdevices SensorSFM3019::i2c_device

private

Definition at line 45 of file driver_SFM3019.h.

Integral

float SensorSFM3019::Integral

private

Definition at line 51 of file driver_SFM3019.h.

sfm3019

SfmConfig SensorSFM3019::sfm3019

private

Definition at line 361 of file driver_SFM3019.h.

---

The documentation for this class was generated from the following files:

• driver_SFM3019.h
• driver_SFM3019.cpp