Source code for sensirion_i2c_sen66.device

#!/usr/bin/env python
# -*- coding: utf-8 -*-
#
# (c) Copyright 2024 Sensirion AG, Switzerland
#
#     THIS FILE IS AUTOMATICALLY GENERATED!
#
# Generator:     sensirion-driver-generator 1.0.1
# Product:       sen66
# Model-Version: 1.3.1
#
"""
The class Sen66DeviceBase implements the low level interface of the sensor.
The class Sen66Device extends the Sen66DeviceBase. It provides additional functions to ease the use of the
sensor.
"""

from sensirion_driver_adapters.transfer import execute_transfer
from sensirion_driver_support_types.mixin_access import MixinAccess
from sensirion_i2c_sen66.commands import (ActivateShtHeater, DeviceReset, DeviceStatus, GetAmbientPressure,
                                          GetCo2SensorAutomaticSelfCalibration, GetDataReady,
                                          GetNoxAlgorithmTuningParameters, GetProductName, GetSensorAltitude,
                                          GetSerialNumber, GetVocAlgorithmState, GetVocAlgorithmTuningParameters,
                                          PerformForcedCo2Recalibration, ReadAndClearDeviceStatus, ReadDeviceStatus,
                                          ReadMeasuredRawValues, ReadMeasuredValuesAsIntegers,
                                          ReadNumberConcentrationValuesAsIntegers, SetAmbientPressure,
                                          SetCo2SensorAutomaticSelfCalibration, SetNoxAlgorithmTuningParameters,
                                          SetSensorAltitude, SetTemperatureAccelerationParameters,
                                          SetTemperatureOffsetParameters, SetVocAlgorithmState,
                                          SetVocAlgorithmTuningParameters, StartContinuousMeasurement,
                                          StartFanCleaning, StopMeasurement)

from sensirion_i2c_sen66.result_types import (SignalCo2, SignalHumidity, SignalMassConcentrationPm10p0,
                                              SignalMassConcentrationPm1p0, SignalMassConcentrationPm2p5,
                                              SignalMassConcentrationPm4p0, SignalNoxIndex,
                                              SignalNumberConcentrationPm0p5, SignalNumberConcentrationPm10p0,
                                              SignalNumberConcentrationPm1p0, SignalNumberConcentrationPm2p5,
                                              SignalNumberConcentrationPm4p0, SignalTemperature, SignalVocIndex)


[docs]class Sen66DeviceBase: """Low level API implementation of SEN66"""
[docs] def __init__(self, channel): self._channel = channel
@property def channel(self): return self._channel
[docs] def start_continuous_measurement(self): """ Starts a continuous measurement. After starting the measurement, it takes some time (~1.1s) until the first measurement results are available. You could poll with the command "Get Data Ready" to check when the results are ready to read. This command is only available in idle mode. If the device is already in any measure mode, this command has no effect. """ transfer = StartContinuousMeasurement() return execute_transfer(self._channel, transfer)
[docs] def stop_measurement(self): """ Stops the measurement and returns to idle mode. After sending this command, wait at least 1000 ms before starting a new measurement. If the device is already in idle mode, this command has no effect. """ transfer = StopMeasurement() return execute_transfer(self._channel, transfer)
[docs] def get_data_ready(self): """ This command can be used to check if new measurement results are ready to read. The data ready flag is automatically reset after reading the measurement values. :return padding: Padding byte, always 0x00. :return data_ready: True (0x01) if data is ready, False (0x00) if not. When no measurement is running, False will be returned. """ transfer = GetDataReady() return execute_transfer(self._channel, transfer)
[docs] def read_measured_values_as_integers(self): """ Returns the measured values. The command "Get Data Ready" can be used to check if new data is available since the last read operation. If no new data is available, the previous values will be returned again. If no data is available at all (e.g. measurement not running for at least one second), all values will be at their upper limit (0xFFFF for uint16, 0x7FFF for int16). :return mass_concentration_pm1p0: Value is scaled with factor 10: PM1.0 [µg/m³] = value / 10 *Note: If this value is unknown, 0xFFFF is returned.* :return mass_concentration_pm2p5: Value is scaled with factor 10: PM2.5 [µg/m³] = value / 10 *Note: If this value is unknown, 0xFFFF is returned.* :return mass_concentration_pm4p0: Value is scaled with factor 10: PM4.0 [µg/m³] = value / 10 *Note: If this value is unknown, 0xFFFF is returned.* :return mass_concentration_pm10p0: Value is scaled with factor 10: PM10.0 [µg/m³] = value / 10 *Note: If this value is unknown, 0xFFFF is returned.* :return ambient_humidity: Value is scaled with factor 100: RH [%] = value / 100 *Note: If this value is unknown, 0x7FFF is returned.* :return ambient_temperature: Value is scaled with factor 200: T [°C] = value / 200 *Note: If this value is unknown, 0x7FFF is returned.* :return voc_index: Value is scaled with factor 10: VOC Index = value / 10 *Note: If this value is unknown, 0x7FFF is returned.* :return nox_index: Value is scaled with factor 10: NOx Index = value / 10 *Note: If this value is unknown, 0x7FFF is returned. During the first 10..11 seconds after power-on or device reset, this value will be 0x7FFF as well.* :return co2: CO₂ concentration [ppm] *Note: If this value is unknown, 0xFFFF is returned. During the first 5..6 seconds after power-on or device reset, this value will be 0xFFFF as well.* """ transfer = ReadMeasuredValuesAsIntegers() return execute_transfer(self._channel, transfer)
[docs] def read_number_concentration_values_as_integers(self): """ Returns the measured number concentration values. The command "Get Data Ready" can be used to check if new data is available since the last read operation. If no new data is available, the previous values will be returned again. If no data is available at all (e.g. measurement not running for at least one second), all values will be at their upper limit (0xFFFF for uint16). :return number_concentration_pm0p5: Value is scaled with factor 10: PM0.5 [particles/cm³] = value / 10 *Note: If this value is unknown, 0xFFFF is returned.* :return number_concentration_pm1p0: Value is scaled with factor 10: PM1.0 [particles/cm³] = value / 10 *Note: If this value is unknown, 0xFFFF is returned.* :return number_concentration_pm2p5: Value is scaled with factor 10: PM2.5 [particles/cm³] = value / 10 *Note: If this value is unknown, 0xFFFF is returned.* :return number_concentration_pm4p0: Value is scaled with factor 10: PM4.0 [particles/cm³] = value / 10 *Note: If this value is unknown, 0xFFFF is returned.* :return number_concentration_pm10p0: Value is scaled with factor 10: PM10.0 [particles/cm³] = value / 10 *Note: If this value is unknown, 0xFFFF is returned.* """ transfer = ReadNumberConcentrationValuesAsIntegers() return execute_transfer(self._channel, transfer)
[docs] def read_measured_raw_values(self): """ Returns the measured raw values. The command "Get Data Ready" can be used to check if new data is available since the last read operation. If no new data is available, the previous values will be returned again. If no data is available at all (e.g. measurement not running for at least one second), all values will be at their upper limit (0xFFFF for uint16, 0x7FFF for int16). :return raw_humidity: Value is scaled with factor 100: RH [%] = value / 100 *Note: If this value is unknown, 0x7FFF is returned.* :return raw_temperature: Value is scaled with factor 200: T [°C] = value / 200 *Note: If this value is unknown, 0x7FFF is returned.* :return raw_voc: Raw measured VOC ticks without scale factor. *Note: If this value is unknown, 0xFFFF is returned.* :return raw_nox: Raw measured NOx ticks without scale factor. *Note: If this value is unknown, 0xFFFF is returned. During the first 10..11 seconds after power-on or device reset, this value will be 0xFFFF as well.* :return raw_co2: Not interpolated CO₂ concentration [ppm] updated every five seconds. *Note: If this value is unknown, 0xFFFF is returned. During the first 5..6 seconds after power-on or device reset, this value will be 0xFFFF as well.* """ transfer = ReadMeasuredRawValues() return execute_transfer(self._channel, transfer)
[docs] def start_fan_cleaning(self): """ This command triggers fan cleaning. The fan is set to the maximum speed for 10 seconds and then automatically stopped. Wait at least 10s after this command before starting a measurement. .. note:: This command is only available in idle mode. """ transfer = StartFanCleaning() return execute_transfer(self._channel, transfer)
[docs] def set_temperature_offset_parameters(self, offset, slope, time_constant, slot): """ This command allows to compensate temperature effects of the design-in at customer side by applying custom temperature offsets to the ambient temperature. The compensated ambient temperature is calculated as follows: T_Ambient_Compensated = T_Ambient + (slope * T_Ambient) + offset Where slope and offset are the values set with this command, smoothed with the specified time constant. All temperatures (T_Ambient_Compensated, T_Ambient and offset) are represented in °C. There are 5 temperature offset slots available that all contribute additively to T_Ambient_Compensated. The default values for the temperature offset parameters are all zero, meaning that T_Ambient_Compensated is equal to T_Ambient by default. The parameters can be changed in any state of the device, i.e. both in idle mode and in measure mode. :param offset: Constant temperature offset scaled with factor 200 (T [°C] = value / 200). :param slope: Normalized temperature offset slope scaled with factor 10000 (applied factor = value / 10000). :param time_constant: The time constant determines how fast the new slope and offset will be applied. After the specified value in seconds, 63% of the new slope and offset are applied. A time constant of zero means the new values will be applied immediately (within the next measure interval of 1 second). :param slot: The temperature offset slot to be modified. Valid values are 0 .. 4. If the value is outside this range, the parameters will not be applied. .. note:: This configuration is volatile, i.e. the parameters will be reverted to their default value of zero after a device reset. :Example: .. code-block:: python sensor.set_temperature_offset_parameters(1, 10, 1, 0) """ transfer = SetTemperatureOffsetParameters(offset, slope, time_constant, slot) return execute_transfer(self._channel, transfer)
[docs] def set_voc_algorithm_tuning_parameters(self, index_offset, learning_time_offset_hours, learning_time_gain_hours, gating_max_duration_minutes, std_initial, gain_factor): """ Sets the parameters to customize the VOC algorithm. This configuration is volatile, i.e. the parameters will be reverted to their default values after a device reset. :param index_offset: VOC index representing typical (average) conditions. Allowed values are in range 1..250. The default value is 100. :param learning_time_offset_hours: Time constant to estimate the VOC algorithm offset from the history in hours. Past events will be forgotten after about twice the learning time. Allowed values are in range 1..1000. The default value is 12 hours. :param learning_time_gain_hours: Time constant to estimate the VOC algorithm gain from the history in hours. Past events will be forgotten after about twice the learning time. Allowed values are in range 1..1000. The default value is 12 hours. :param gating_max_duration_minutes: Maximum duration of gating in minutes (freeze of estimator during high VOC index signal). Set to zero to disable the gating. Allowed values are in range 0..3000. The default value is 180 minutes :param std_initial: Initial estimate for standard deviation. Lower value boosts events during initial learning period, but may result in larger device-to-device variations. Allowed values are in range 10..5000. The default value is 50. :param gain_factor: Gain factor to amplify or to attenuate the VOC index output. Allowed values are in range 1..1000. The default value is 230. .. note:: This command is available only in idle mode. In measure mode, this command has no effect. In addition, it has no effect if at least one parameter is outside the specified range. :Example: .. code-block:: python sensor.set_voc_algorithm_tuning_parameters(100, 12, 12, 180, 50, 230) """ transfer = SetVocAlgorithmTuningParameters(index_offset, learning_time_offset_hours, learning_time_gain_hours, gating_max_duration_minutes, std_initial, gain_factor) return execute_transfer(self._channel, transfer)
[docs] def get_voc_algorithm_tuning_parameters(self): """ Gets the parameters to customize the VOC algorithm. :return index_offset: VOC index representing typical (average) conditions. :return learning_time_offset_hours: Time constant to estimate the VOC algorithm offset from the history in hours. Past events will be forgotten after about twice the learning time. :return learning_time_gain_hours: Time constant to estimate the VOC algorithm gain from the history in hours. Past events will be forgotten after about twice the learning time. :return gating_max_duration_minutes: Maximum duration of gating in minutes (freeze of estimator during high VOC index signal). Zero disables the gating. :return std_initial: Initial estimate for standard deviation. Lower value boosts events during initial learning period, but may result in larger device-to-device variations. :return gain_factor: Gain factor to amplify or to attenuate the VOC index output. .. note:: This command is only available in idle mode. """ transfer = GetVocAlgorithmTuningParameters() return execute_transfer(self._channel, transfer)
[docs] def set_nox_algorithm_tuning_parameters(self, index_offset, learning_time_offset_hours, learning_time_gain_hours, gating_max_duration_minutes, std_initial, gain_factor): """ Sets the parameters to customize the NOx algorithm. This configuration is volatile, i.e. the parameters will be reverted to their default values after a device reset. :param index_offset: NOx index representing typical (average) conditions. Allowed values are in range 1..250. The default value is 1. :param learning_time_offset_hours: Time constant to estimate the NOx algorithm offset from the history in hours. Past events will be forgotten after about twice the learning time. Allowed values are in range 1..1000. The default value is 12 hours. :param learning_time_gain_hours: The time constant to estimate the NOx algorithm gain from the history has no impact for NOx. This parameter is still in place for consistency reasons with the VOC tuning parameters command. This parameter must always be set to 12 hours. :param gating_max_duration_minutes: Maximum duration of gating in minutes (freeze of estimator during high NOx index signal). Set to zero to disable the gating. Allowed values are in range 0..3000. The default value is 720 minutes. :param std_initial: The initial estimate for standard deviation parameter has no impact for NOx. This parameter is still in place for consistency reasons with the VOC tuning parameters command. This parameter must always be set to 50. :param gain_factor: Gain factor to amplify or to attenuate the NOx index output. Allowed values are in range 1..1000. The default value is 230. .. note:: This command is available only in idle mode. In measure mode, this command has no effect. In addition, it has no effect if at least one parameter is outside the specified range. :Example: .. code-block:: python sensor.set_nox_algorithm_tuning_parameters(1, 12, 12, 720, 50, 230) """ transfer = SetNoxAlgorithmTuningParameters(index_offset, learning_time_offset_hours, learning_time_gain_hours, gating_max_duration_minutes, std_initial, gain_factor) return execute_transfer(self._channel, transfer)
[docs] def get_nox_algorithm_tuning_parameters(self): """ Gets the parameters to customize the NOx algorithm. :return index_offset: NOx index representing typical (average) conditions. :return learning_time_offset_hours: Time constant to estimate the NOx algorithm offset from the history in hours. Past events will be forgotten after about twice the learning time. :return learning_time_gain_hours: The time constant to estimate the NOx algorithm gain from the history has no impact for NOx. This parameter is still in place for consistency reasons with the VOC tuning parameters command. :return gating_max_duration_minutes: Maximum duration of gating in minutes (freeze of estimator during high NOx index signal). Zero disables the gating. :return std_initial: The initial estimate for standard deviation has no impact for NOx. This parameter is still in place for consistency reasons with the VOC tuning parameters command. :return gain_factor: Gain factor to amplify or to attenuate the NOx index output. .. note:: This command is available only in idle mode. """ transfer = GetNoxAlgorithmTuningParameters() return execute_transfer(self._channel, transfer)
[docs] def set_temperature_acceleration_parameters(self, k, p, t1, t2): """ This command allows to set custom temperature acceleration parameters of the RH/T engine. It overwrites the default temperature acceleration parameters of the RH/T engine with custom values. This configuration is volatile, i.e. the parameters will be reverted to their default values after a device reset. :param k: Filter constant K scaled with factor 10 (K = value / 10). :param p: Filter constant P scaled with factor 10 (P = value / 10). :param t1: Time constant T1 scaled with factor 10 (T1 [s] = value / 10). :param t2: Time constant T2 scaled with factor 10 (T2 [s] = value / 10). .. note:: The command is only available in idle mode. :Example: .. code-block:: python sensor.set_temperature_acceleration_parameters(1, 1, 1, 1) """ transfer = SetTemperatureAccelerationParameters(k, p, t1, t2) return execute_transfer(self._channel, transfer)
[docs] def set_voc_algorithm_state(self, state): """ Sets the VOC algorithm state previously received with "Get VOC Algorithm State" command. Allows restoration of the VOC algorithm state to resume operation after a power cycle or device reset, skipping initial learning phase. By default, the VOC Engine is reset, and the algorithm state is retained if a measurement is stopped and started again. If the VOC algorithm state shall be reset, a device reset, or a power cycle can be executed. :param state: VOC algorithm state to restore. .. note:: This command is only available in idle mode and the state will be applied only once when starting the next measurement. In measure mode, this command has no effect. """ transfer = SetVocAlgorithmState(state) return execute_transfer(self._channel, transfer)
[docs] def get_voc_algorithm_state(self): """ Gets the current VOC algorithm state. Allows to backup and restore the VOC algorithm state to resume operation after a power cycle or device reset, skipping initial learning phase. By default, the VOC Engine is reset and the algorithm state is retained if a measurement is stopped and started again. If the VOC algorithm state shall be reset, a device reset or a power cycle can be executed. :return state: Current VOC algorithm state. .. note:: This command can be used either in measure mode or in idle mode (which will then return the state at the time when the measurement was stopped). In measure mode, the state can be read each measure interval to always have the latest state available, even in case of a sudden power loss. """ transfer = GetVocAlgorithmState() return execute_transfer(self._channel, transfer)[0]
[docs] def perform_forced_co2_recalibration(self, target_co2_concentration): """ Execute the forced recalibration (FRC) of the CO₂. See the datasheet of the SCD4x sensor for details how the forced recalibration shall be used. :param target_co2_concentration: Target CO₂ concentration [ppm] of the test setup. :return correction: Correction value as received from the SCD [ppm CO₂]. FRC correction [ppm CO₂] is calculated as follows: FRC = return_value - 0x8000 If the recalibration has failed this returned value is 0xFFFF. .. note:: After power-on wait at least 1000 ms and after stopping a measurement 600 ms before sending this command. This command is not available in measure mode. The recalibration procedure will take about 500 ms to complete, during which time no other functions can be executed. """ transfer = PerformForcedCo2Recalibration(target_co2_concentration) return execute_transfer(self._channel, transfer)[0]
[docs] def set_co2_sensor_automatic_self_calibration(self, status): """ Sets the status of the CO₂ sensor automatic self-calibration (ASC). The CO₂ sensor supports automatic self calibration (ASC) for long-term stability of the CO₂ output. This feature can be enabled or disabled. By default it is enabled. This configuration is volatile, i.e. the parameter will be reverted to its default value after a device restart. :param status: Set to true (0x0001) to enable or false (0x0000) to disable the automatic CO₂ measurement self calibration feature. High byte of uint16 is padding and always 0x00. .. note:: This command is only available in idle mode. :Example: .. code-block:: python sensor.set_co2_sensor_automatic_self_calibration(0) """ transfer = SetCo2SensorAutomaticSelfCalibration(status) return execute_transfer(self._channel, transfer)
[docs] def get_co2_sensor_automatic_self_calibration(self): """ The CO₂ sensor supports automatic self calibration (ASC) for long-term stability of the CO₂ output. This feature can be enabled or disabled. By default it is enabled. This configuration is volatile, i.e. the parameter will be reverted to its default value after a device restart. :return padding: Padding byte, always 0x00. :return status: Is set true (0x01) if the automatic self calibration is enabled or false (0x00) if the automatic self calibration is disabled. .. note:: This command is only available in idle mode. """ transfer = GetCo2SensorAutomaticSelfCalibration() return execute_transfer(self._channel, transfer)
[docs] def set_ambient_pressure(self, ambient_pressure): """ The ambient pressure can be used for pressure compensation in the CO₂ sensor. Setting an ambient pressure overrides any pressure compensation based on a previously set sensor altitude. Use of this command is recommended for applications experiencing significant ambient pressure changes to ensure CO₂ sensor accuracy. Valid input values are between 700 to 1'200 hPa. The default value is 1013 hPa. This configuration is volatile, i.e. the parameter will be reverted to its default value after a device restart. :param ambient_pressure: Ambient pressure [hPa] to be used for pressure compensation. .. note:: This command can be used in any state of the device, i.e. both in idle mode and in measure mode. :Example: .. code-block:: python sensor.set_ambient_pressure(1013) """ transfer = SetAmbientPressure(ambient_pressure) return execute_transfer(self._channel, transfer)
[docs] def get_ambient_pressure(self): """ Gets the ambient pressure value. The ambient pressure can be used for pressure compensation in the CO₂ sensor. :return ambient_pressure: Currently used ambient pressure [hPa] for pressure compensation. .. note:: This command can be used in any state of the device, i.e. both in idle mode and in measure mode. """ transfer = GetAmbientPressure() return execute_transfer(self._channel, transfer)[0]
[docs] def set_sensor_altitude(self, altitude): """ The sensor altitude can be used for pressure compensation in the CO₂ sensor. The default sensor altitude value is set to 0 meters above sea level. Valid input values are between 0 and 3000m. This configuration is volatile, i.e. the parameter will be reverted to its default value after a device reset. :param altitude: Sensor altitude [m], valid input between 0 and 3000m. :Example: .. code-block:: python sensor.set_sensor_altitude(0) """ transfer = SetSensorAltitude(altitude) return execute_transfer(self._channel, transfer)
[docs] def get_sensor_altitude(self): """ Gets the current sensor altitude. The sensor altitude can be used for pressure compensation in the CO₂ sensor. :return altitude: Current sensor altitude [m]. .. note:: This command is only available in idle mode. """ transfer = GetSensorAltitude() return execute_transfer(self._channel, transfer)[0]
[docs] def activate_sht_heater(self): """ This command allows to use the inbuilt heater in SHT sensor to reverse creep at high humidity. This command activates the SHT sensor heater with 200mW for 1s. The heater is then automatically deactivated again. Wait at least 20s after this command before starting a measurement to get coherent temperature values (heating consequence to disappear). .. note:: This command is only available in idle mode. """ transfer = ActivateShtHeater() return execute_transfer(self._channel, transfer)
[docs] def get_product_name(self): """ Gets the product name from the device. :return product_name: Null-terminated ASCII string containing the product name. Up to 32 characters can be read from the device. """ transfer = GetProductName() return execute_transfer(self._channel, transfer)[0]
[docs] def get_serial_number(self): """ Gets the serial number from the device. :return serial_number: Null-terminated ASCII string containing the serial number. Up to 32 characters can be read from the device. """ transfer = GetSerialNumber() return execute_transfer(self._channel, transfer)[0]
[docs] def read_device_status(self): """ Reads the current device status. Use this command to get detailed information about the device status. The device status is encoded in flags. Each device status flag represents a single bit in a 32-bit integer value. If more than one error is present, the device status register value is the sum of the corresponding flag values. For details about the available flags, refer to the device status flags documentation in the data sheet. :return device_status: Device status (32 flags as an integer value). For details, please refer to the device status flags documentation in the datasheet. .. note:: The status flags of type "Error" are sticky, i.e. they are not cleared automatically even if the error condition no longer exists. So they can only be cleared manually with the command "Read And Clear Device Status" or with a device reset. All other flags are not sticky, i.e. they are cleared automatically if the trigger condition disappears. """ transfer = ReadDeviceStatus() res_0 = execute_transfer(self._channel, transfer)[0] return DeviceStatus(res_0)
[docs] def read_and_clear_device_status(self): """ Reads the current device status (like command 0xD206 "Read Device Status") and afterwards clears all flags. :return device_status: Device status (32 flags as an integer value) **before** clearing it. For details, please refer to the device status flags documentation. """ transfer = ReadAndClearDeviceStatus() res_0 = execute_transfer(self._channel, transfer)[0] return DeviceStatus(res_0)
[docs] def device_reset(self): """Executes a reset on the device. This has the same effect as a power cycle.""" transfer = DeviceReset() return execute_transfer(self._channel, transfer)
[docs]class Sen66Device(Sen66DeviceBase): """Driver class implementation of SEN66""" #: Access to base class sen66 = MixinAccess()
[docs] def __init__(self, channel): super().__init__(channel)
[docs] def read_measured_values(self): """ Read measured values and apply scaling as defined in datasheet. :return mass_concentration_pm1p0: Mass concentration in μg/m³ for particles smaller than 1.0 μm. :return mass_concentration_pm2p5: Mass concentration in μg/m³ for particles smaller than 2.5 μm. :return mass_concentration_pm4p0: Mass concentration in μg/m³ for particles smaller than 4.0 μm. :return mass_concentration_pm10p0: Mass concentration in μg/m³ for particles smaller than 10.0 μm. :return humidity: Measured humidity in %RH. :return temperature: Measured temperature in degrees celsius. :return voc_index: Measured VOC Index between 0 and 500. :return nox_index: Measured NOx Index between 0 and 500. :return co2: Measured CO2 concentration in ppm. """ (mass_concentration_pm1p0_raw, mass_concentration_pm2p5_raw, mass_concentration_pm4p0_raw, mass_concentration_pm10p0_raw, humidity_raw, temperature_raw, voc_index_raw, nox_index_raw, co2_raw ) = self.read_measured_values_as_integers() return (SignalMassConcentrationPm1p0(mass_concentration_pm1p0_raw), SignalMassConcentrationPm2p5(mass_concentration_pm2p5_raw), SignalMassConcentrationPm4p0(mass_concentration_pm4p0_raw), SignalMassConcentrationPm10p0(mass_concentration_pm10p0_raw), SignalHumidity(humidity_raw), SignalTemperature(temperature_raw), SignalVocIndex(voc_index_raw), SignalNoxIndex(nox_index_raw), SignalCo2(co2_raw))
[docs] def read_number_concentration_values(self): """ Read measured number concentration values and apply scaling as defined in datasheet. :return number_concentration_pm0p5: Number concentration in particles/cm³ for particles smaller than 0.5 μm. :return number_concentration_pm1p0: Number concentration in particles/cm³ for particles smaller than 1.0 μm. :return number_concentration_pm2p5: Number concentration in particles/cm³ for particles smaller than 2.5 μm. :return number_concentration_pm4p0: Number concentration in particles/cm³ for particles smaller than 4.0 μm. :return number_concentration_pm10p0: Number concentration in particles/cm³ for particles smaller than 10.0 μm. """ (number_concentration_pm0p5_raw, number_concentration_pm1p0_raw, number_concentration_pm2p5_raw, number_concentration_pm4p0_raw, number_concentration_pm10p0_raw ) = self.read_number_concentration_values_as_integers() return (SignalNumberConcentrationPm0p5(number_concentration_pm0p5_raw), SignalNumberConcentrationPm1p0(number_concentration_pm1p0_raw), SignalNumberConcentrationPm2p5(number_concentration_pm2p5_raw), SignalNumberConcentrationPm4p0(number_concentration_pm4p0_raw), SignalNumberConcentrationPm10p0(number_concentration_pm10p0_raw))