Configure sensor parameters
********************************************************
Every sensor supported by the Huxon language provides several configuration parameters tunable
according to the application needs.
Most sensors have at least the following configuration parameters:

- **Output Data Rate (ODR)**: defines the sampling frequency of the sensor and the rate at which the sensor outputs its data
- **Full Scale (FS)**: defines the sensibility of the sensor and the corresponding measurement range

It is possible to declare a configuration for a given sensor type 
using the :c:macro:`HUX_DECLARE_SENSOR_CONFIGURATION` construct:

.. code-block:: cpp
    
    /* Namespace alias to simplify access to STMicroelectronics sensor types */
    namespace STM = hux::sensors::STMicroelectronics;
    ...

    /*
     * desired_configuration   : the label of the configuration
     * STM::IIS2DLPC           : the namespace of the sensor type
     * .odr                    : the Output Data Rate (ODR) configuration parameter
     * .fs                     : the Full Scale (FS) configuration parameter
     */
    HUX_DECLARE_SENSOR_CONFIGURATION(desired_configuration, STM::IIS2DLPC,
        .odr = STM::IIS2DLPC::configs::odr_25,
        .fs = STM::IIS2DLPC::configs::fs_8
    );

Available configuration values for ODR and FS can be retrieved from the sensor model namespace under "configs":

.. code-block:: cpp

    hux::sensors::MANUFACTURER::SENSOR_MODEL::configs::VALUE

.. note::

   Multiple configuration parameters can be configured within the :c:macro:`HUX_DECLARE_SENSOR_CONFIGURATION` construct. 
   If a configuration parameter is not specified, its default value is used. For a list of the available
   configuration parameters and their default values refer to the :ref:`sensors` documentation.

A **sensor configuration** can then be assigned to a specific sensor during its declaration:

.. code-block:: cpp
    
    /*
     * my_sensor                 : the sensor label
     * STM::IIS2DLPC             : the sensor type namespace
     * {}                        : the (empty) simulation dataset
     * desired_configuration     : the configuration for this sensor
     */
    HUX_DECLARE_SENSOR(my_sensor, STM::IIS2DLPC, {}, desired_configuration);

.. note::

   A **configuration** is sensor-type specific and can be assigned to multiple sensors of the same type.

Average temperature example
=============================
The following example shows how to write a simple application that computes an average temperature
every 60 seconds using the :ref:`LPS22HB` temperature and humidity sensor.
To ensure proper timing, we set a specific Output Data Rate (ODR) for the sensor via the corresponding configuration parameter.

In this example, we introduce the "buffer" channel logic.
A buffer channel emits a single std::array of *N* samples for every *N* samples received as input. The buffer size *N* is configurable
and can be specified together with the channel logic as: *buffer<N>*.

.. note::
    
    A buffer channel of size *N* does not emit any output if less than *N* samples are given as input.
    

.. code-block:: cpp

    /* Import Huxon language headers */
    #include <huxon/lang.hpp>
    #include <huxon/sensors/STMicroelectronics.hpp>
    
    /* Import other libraries */
    #include <numeric>
    
    /* Set a namespace alias to ease constants and methods retrieval from vendor's namespace. */
    namespace STM = hux::sensors::STMicroelectronics;
    
    /* Declare a sensor configuration for STMicroelectronics HTS221 sensors.
     * The Output Data Rate (ODR) is set to 1 Hz to ensure that the sensor
     * emits one sample every second.
     * */
    HUX_DECLARE_SENSOR_CONFIGURATION(desired_configuration, STM::HTS221,
        .odr = STM::HTS221::configs::odr_1
    )
    
    /* Declare a new STMicroelectronics HTS221 sensor called "temp_sensor" 
     * by providing the custom configuration (the simulation data is left empty).
     * */
    HUX_DECLARE_SENSOR(temp_sensor, STM::HTS221, {}, desired_configuration);
    
    /* Declare a "buffer" channel with the sensor temperature source as input.
     * A buffer channel emits a single std::array of N samples for every N 
     * samples received as input.
     * Since we receive a temperature sample every second, we set the buffer size N=60, so that
     * the buffer channel produces an array of 60 temperature samples once every minute.
     * */
    HUX_DECLARE_CHANNEL(temp_array_ch, buffer<60>,
        temp_sensor.get_temperature()
    );
    
    /* Declare a processing node to compute the average temperature over the array generated
     * by the buffer channel. Here, "hux_input" will be of type: std::array<float, 60>.
     * The processing node also prepares the output of the algorithm 
     * using "HUX_DECLARE_OUTPUT_VALUE".
     * */
    HUX_DECLARE_PROCESSING(average_temperature, temp_array_ch, {

        float temp_sum = std::accumulate(hux_input.begin(), hux_input.end(), 0.0);
        float avg_temperature = temp_sum / hux_input.size();

        HUX_DECLARE_OUTPUT_VALUE(result, Float, "average_temperature", avg_temperature);
        return result;
    });
    
    /* Configure the output of the Huxon application. The output must be a processing node 
     * (or channel) that produces an output value created with HUX_DECLARE_OUTPUT_VALUE 
     * */
    HUX_REGISTER_OUTPUT(average_temperature);