Cppcheck - HTML report - ethercatcpp-clipx

/*      File: clipx.h
 *       This file is part of the program ethercatcpp-clipx
 *       Program description : EtherCAT driver libraries for HMB ClipX
 *       Copyright (C) 2018-2022 -  Robin Passama (CNRS/LIRMM) Arnaud Meline
 * (CNRS/LIRMM). All Right reserved.
 *
 *       This software is free software: you can redistribute it and/or modify
 *       it under the terms of the CeCILL-C license as published by
 *       the CEA CNRS INRIA, either version 1
 *       of the License, or (at your option) any later version.
 *       This software is distributed in the hope that it will be useful,
 *       but WITHOUT ANY WARRANTY without even the implied warranty of
 *       MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 *       CeCILL-C License for more details.
 *
 *       You should have received a copy of the CeCILL-C License
 *       along with this software. If not, it can be found on the official
 * website of the CeCILL licenses family (http://www.cecill.info/index.en.html).
 */
/**
 * @defgroup ethercatcpp-clipx ethercatcpp-clipx: HMB clipx driver
 *
 * This library provides a ethercatcpp driver for the HMB clipx device, a device
 * used for force sensor acquisition.
 *
 */
/**
 * @file clipx.h
 * @author Robin Passama (maintenace)
 * @author Arnaud Meline (original author)
 * @brief EtherCAT driver for HMB ClipX device.
 * @date October 2018 12.
 * @ingroup ethercatcpp-clipx
 * @example clipx_example.cpp
 */
#pragma once

#include <ethercatcpp/core.h>

/*! \namespace ethercatcpp
 *
 */
namespace ethercatcpp {
/**
 *   @brief EtherCAT driver for HMB ClipX device
 *   @details It allows to communicate with a "HMB ClipX" through an ehtercat
 * bus using the ethercatcpp framework.
 */
class ClipX : public SlaveDevice {
public:
  //! This enum define all fieldbus flags we can use
  enum fieldbus_flag_t : std::uint16_t {
    fieldbus_flag_1 = 0,   //!< Define fieldbus flag number 1
    fieldbus_flag_2 = 1,   //!< Define fieldbus flag number 2
    fieldbus_flag_3 = 2,   //!< Define fieldbus flag number 3
    fieldbus_flag_4 = 3,   //!< Define fieldbus flag number 4
    fieldbus_flag_5 = 4,   //!< Define fieldbus flag number 5
    fieldbus_flag_6 = 5,   //!< Define fieldbus flag number 6
    fieldbus_flag_7 = 6,   //!< Define fieldbus flag number 7
    fieldbus_flag_8 = 7,   //!< Define fieldbus flag number 8
    fieldbus_flag_9 = 8,   //!< Define fieldbus flag number 9
    fieldbus_flag_10 = 9,  //!< Define fieldbus flag number 10
    fieldbus_flag_11 = 10, //!< Define fieldbus flag number 11
    fieldbus_flag_12 = 11, //!< Define fieldbus flag number 12
    fieldbus_flag_13 = 12, //!< Define fieldbus flag number 13
    fieldbus_flag_14 = 13, //!< Define fieldbus flag number 14
    fieldbus_flag_15 = 14, //!< Define fieldbus flag number 15
    fieldbus_flag_16 = 15  //!< Define fieldbus flag number 16
  };

  //! This enum define all flags we can use to get I/O status
  enum io_status_t {
    digital_input_1 = 0,
    digital_input_2 = 1,
    digital_input_1_debounced = 2,
    digital_input_2_debounced = 3,
    digital_output_1 = 4,
    digital_output_2 = 5,
    digital_output_1_delayed = 6,
    digital_output_2_delayed = 7,
    result_limit_value_switch_1 = 8,
    result_limit_value_switch_2 = 9,
    result_limit_value_switch_3 = 10,
    result_limit_value_switch_4 = 11,
    calculated_channel_flag_1 = 12,
    calculated_channel_flag_2 = 13,
    calculated_channel_flag_3 = 14,
    calculated_channel_flag_4 = 15,
    calculated_channel_flag_5 = 16,
    calculated_channel_flag_6 = 17,
    calculated_channel_flag_7 = 18,
    calculated_channel_flag_8 = 19,
    fieldbus_flag_status_1 = 32,
    fieldbus_flag_status_2 = 33,
    fieldbus_flag_status_3 = 34,
    fieldbus_flag_status_4 = 35,
    fieldbus_flag_status_5 = 36,
    fieldbus_flag_status_6 = 37,
    fieldbus_flag_status_7 = 38,
    fieldbus_flag_status_8 = 39,
    fieldbus_flag_status_9 = 40,
    fieldbus_flag_status_10 = 41,
    fieldbus_flag_status_11 = 42,
    fieldbus_flag_status_12 = 43,
    fieldbus_flag_status_13 = 44,
    fieldbus_flag_status_14 = 45,
    fieldbus_flag_status_15 = 46,
    fieldbus_flag_status_16 = 47,
    ethernet_api_flag_1 = 48,
    ethernet_api_flag_2 = 49,
    ethernet_api_flag_3 = 50,
    ethernet_api_flag_4 = 51,
    ethernet_api_flag_5 = 52,
    ethernet_api_flag_6 = 53,
    ethernet_api_flag_7 = 54,
    ethernet_api_flag_8 = 55,
    ethernet_api_flag_9 = 56,
    ethernet_api_flag_10 = 57,
    ethernet_api_flag_11 = 58,
    ethernet_api_flag_12 = 59,
    ethernet_api_flag_13 = 60,
    ethernet_api_flag_14 = 61,
    ethernet_api_flag_15 = 62,
    ethernet_api_flag_16 = 63
  };

  //! This enum define all flags we can use to get system status
  enum system_status_t {
    device_ready = 0,      //!< Defined flag to get "device ready" status
    sync_as_CF_master = 1, //!< Defined flag to get "sync as CF master" status
    sync_as_CF_slave = 2,  //!< Defined flag to get "sync as CF slave" status
    sync_as_CF_slave_no_signal =
        3, //!< Defined flag to get "sync as CF slave no signal" status
    parameter_set_switching =
        4, //!< Defined flag to get "parameter set swtiching" status
    error_parameter_set =
        5,                 //!< Defined flag to get "error parameter set" status
    error_file_system = 6, //!< Defined flag to get "error file system" status
    error_ADC_com = 7,     //!< Defined flag to get "error ADC com" status
    error_ADC_IRQ = 8,     //!< Defined flag to get "error ADC IRQ" status
    error_ADC_stuck = 9,   //!< Defined flag to get "error ADC stuck" status
    error_ADC_DMA = 10,    //!< Defined flag to get "error ADC DMA" status
    error_DAC_com = 11,    //!< Defined flag to get "error DAC com" status
    error_1_wire_com = 12, //!< Defined flag to get "error one wire com" status
    error_clipx_bus = 13,  //!< Defined flag to get "error clipx bus" status
    error_external_ram =
        14, //!< Defined flag to get "error external RAM" status
    error_sensor_excitation =
        15, //!< Defined flag to get "error sensor excitation" status
    cyclic_com_fieldbus =
        16, //!< Defined flag to get "cyclic communication fieldbus" status
    fieldbus_controller_defective =
        17, //!< Defined flag to get "fieldbus controller defective" status
    error_factory_calibration =
        18, //!< Defined flag to get "error factory calibration"status
    reading_TEDS = 29, //!< Defined flag to get "reading TEDS" status
    error_external_TEDS_RAM =
        30,        //!< Defined flag to get "error external TEDS RAM" status
    heartbeat = 31 //!< Defined flag to get "heartbeat" status
  };

  //! This enum define all flags we can use to check mesured value validity
  enum mesured_value_t {
    adc_value = 0, //!< Defined flag to get "ADC value" validity
    adc_filtered_value =
        1,           //!< Defined flag to get "ADC filtered value" validity
    field_value = 2, //!< Defined flag to get "Field value" validity
    gross_value = 3, //!< Defined flag to get "Gross value" validity
    net_value = 4,   //!< Defined flag to get "net value" validity
    min_value = 5,   //!< Defined flag to get "min value" validity
    max_value = 6,   //!< Defined flag to get "max value" validity
    peak_to_peak_value =
        7,                //!< Defined flag to get "peak to peak value" validity
    captured_value_1 = 8, //!< Defined flag to get "captured value 1" validity
    captured_value_2 = 9, //!< Defined flag to get "captured value 2" validity
    neighbor_value_1 = 10, //!< Defined flag to get "neighbor value 1" validity
    neighbor_value_2 = 11, //!< Defined flag to get "neighbor value 2" validity
    neighbor_value_3 = 12, //!< Defined flag to get "neighbor value 3" validity
    neighbor_value_4 = 13, //!< Defined flag to get "neighbor value 4" validity
    neighbor_value_5 = 14, //!< Defined flag to get "neighbor value 5" validity
    neighbor_value_6 = 15, //!< Defined flag to get "neighbor value 6" validity
    calculated_value_1 =
        21, //!< Defined flag to get "calculated value 1" validity
    calculated_value_2 =
        22, //!< Defined flag to get "calculated value 2" validity
    calculated_value_3 =
        23, //!< Defined flag to get "calculated value 3" validity
    calculated_value_4 =
        24, //!< Defined flag to get "calculated value 4" validity
    calculated_value_5 =
        25, //!< Defined flag to get "calculated value 5" validity
    calculated_value_6 =
        26, //!< Defined flag to get "calculated value 6" validity
    external_eth_value_1 =
        27, //!< Defined flag to get "external ethernet value 1" validity
    external_eth_value_2 =
        28, //!< Defined flag to get "external ethernet value 2" validity
    external_fieldbus_value_1 =
        29, //!< Defined flag to get "external fieldbus value 1" validity
    external_fieldbus_value_2 =
        30, //!< Defined flag to get "external fieldbus value 2" validity
    analog_output_value =
        31 //!< Defined flag to get "analog output value" validity
  };

  //! This enum define all flags we can use to interract with the clipx
  enum control_word_t {
    zero_gross_value = 0, //!< Defined flag to set the zero gross value
    tare_net_value = 1,   //!< Defined flag to set the zero net value
    reset_zero_value = 2, //!< Defined flag to reset the zero value
    reset_tare_value = 3, //!< Defined flag to reset the tare value
    first_two_point_scaling =
        4, //!< Defined flag to set the first "two point scaling"
    second_two_point_scaling =
        5,              //!< Defined flag to set the second "two point scaling"
    hold_capture_1 = 6, //!< Defined flag to hold the current value in capture 1
    hold_capture_2 = 7, //!< Defined flag to hold the current value in capture 2
    delete_capture_1 = 8, //!< Defined flag to delete the capture 1 value
    delete_capture_2 = 9, //!< Defined flag to delete the capture 2 value
    reset_limit_value_switch_1 =
        10, //!< Defined flag to reset the limit switch value 1
    reset_limit_value_switch_2 =
        11, //!< Defined flag to reset the limit switch value 2
    reset_limit_value_switch_3 =
        12, //!< Defined flag to reset the limit switch value 3
    reset_limit_value_switch_4 =
        13, //!< Defined flag to reset the limit switch value 4
    reset_max_min_p2p_value =
        14, //!< Defined flag to reset the min, max and peak to peak value
    hold_max_min_p2p_value = 15, //!< Defined flag to hold as long as this bit
                                 //!< is set the min, max and peak to peak value
    filter_fast_track =
        16 //!< Defined flag to set the filter output jumps to the input value
  };

  /**
   * @brief Constructor of ClipX class
   */
  ClipX();
  ~ClipX() = default;

  /**
   * @brief Function used to calibrate all ClipX datas from mV/V to Newton.
   *
   * By default all datas are in mV/V. With this calibration all data are in
   * Newton (N)
   *
   * @param [in] coef is the coeficient to transform data from mV/V to Nexton
   * (N)
   */
  void calibrate_volt_To_newton(float coef);

  /**
   * @brief Function used to get ADC value.
   *
   * By default unit is Volt <B>(mV/V)</B>.
   * If user set the calibrated value, unit is <B>Newton (N)</B>
   * @return ADC value.
   */
  float adc();<--- Technically the member function 'ethercatcpp::ClipX::adc' can be const. [+]The member function 'ethercatcpp::ClipX::adc' can be made a const function. Making this function 'const' should not cause compiler errors. Even though the function can be made const function technically it may not make sense conceptually. Think about your design and the task of the function first - is it a function that must not change object internal state?

  /**
   * @brief Function used to get field value.
   *
   * By default unit is Volt <B>(mV/V)</B>.
   * If user set the calibrated value, unit is <B>Newton (N)</B>
   * @return field value.
   */
  float field();<--- Technically the member function 'ethercatcpp::ClipX::field' can be const. [+]The member function 'ethercatcpp::ClipX::field' can be made a const function. Making this function 'const' should not cause compiler errors. Even though the function can be made const function technically it may not make sense conceptually. Think about your design and the task of the function first - is it a function that must not change object internal state?

  /**
   * @brief Function used to get gross value.
   *
   * By default unit is Volt <B>(mV/V)</B>.
   * If user set the calibrated value, unit is <B>Newton (N)</B>
   * @return gross value.
   */
  float gross();<--- Technically the member function 'ethercatcpp::ClipX::gross' can be const. [+]The member function 'ethercatcpp::ClipX::gross' can be made a const function. Making this function 'const' should not cause compiler errors. Even though the function can be made const function technically it may not make sense conceptually. Think about your design and the task of the function first - is it a function that must not change object internal state?

  /**
   * @brief Function used to get net value.
   *
   * By default unit is Volt <B>(mV/V)</B>.
   * If user set the calibrated value, unit is <B>Newton (N)</B>
   * @return net value.
   */
  float net();<--- Technically the member function 'ethercatcpp::ClipX::net' can be const. [+]The member function 'ethercatcpp::ClipX::net' can be made a const function. Making this function 'const' should not cause compiler errors. Even though the function can be made const function technically it may not make sense conceptually. Think about your design and the task of the function first - is it a function that must not change object internal state?

  /**
   * @brief Function used to get minimum value.
   *
   * By default unit is Volt <B>(mV/V)</B>.
   * If user set the calibrated value, unit is <B>Newton (N)</B>
   * @return minimum value.
   */
  float min();<--- Technically the member function 'ethercatcpp::ClipX::min' can be const. [+]The member function 'ethercatcpp::ClipX::min' can be made a const function. Making this function 'const' should not cause compiler errors. Even though the function can be made const function technically it may not make sense conceptually. Think about your design and the task of the function first - is it a function that must not change object internal state?

  /**
   * @brief Function used to get maximum value.
   *
   * By default unit is Volt <B>(mV/V)</B>.
   * If user set the calibrated value, unit is <B>Newton (N)</B>
   * @return maximum value.
   */
  float max();<--- Technically the member function 'ethercatcpp::ClipX::max' can be const. [+]The member function 'ethercatcpp::ClipX::max' can be made a const function. Making this function 'const' should not cause compiler errors. Even though the function can be made const function technically it may not make sense conceptually. Think about your design and the task of the function first - is it a function that must not change object internal state?

  /**
   * @brief Function used to get peak to peak value.
   *
   * By default unit is Volt <B>(mV/V)</B>.
   * If user set the calibrated value, unit is <B>Newton (N)</B>
   * @return peak to peak value.
   */
  float peak_to_peak();<--- Technically the member function 'ethercatcpp::ClipX::peak_to_peak' can be const. [+]The member function 'ethercatcpp::ClipX::peak_to_peak' can be made a const function. Making this function 'const' should not cause compiler errors. Even though the function can be made const function technically it may not make sense conceptually. Think about your design and the task of the function first - is it a function that must not change object internal state?

  /**
   * @brief Function used to get captured value number 1.
   *
   * By default unit is Volt <B>(mV/V)</B>.
   * If user set the calibrated value, unit is <B>Newton (N)</B>.
   * @return caputred value number 1.
   */
  float captured_1();<--- Technically the member function 'ethercatcpp::ClipX::captured_1' can be const. [+]The member function 'ethercatcpp::ClipX::captured_1' can be made a const function. Making this function 'const' should not cause compiler errors. Even though the function can be made const function technically it may not make sense conceptually. Think about your design and the task of the function first - is it a function that must not change object internal state?

  /**
   * @brief Function used to get captured value number 2.
   *
   * By default unit is Volt <B>(mV/V)</B>.
   * If user set the calibrated value, unit is <B>Newton (N)</B>.
   * @return caputred value number 2.
   */
  float captured_2();<--- Technically the member function 'ethercatcpp::ClipX::captured_2' can be const. [+]The member function 'ethercatcpp::ClipX::captured_2' can be made a const function. Making this function 'const' should not cause compiler errors. Even though the function can be made const function technically it may not make sense conceptually. Think about your design and the task of the function first - is it a function that must not change object internal state?

  /**
   * @brief Function used to get calculated value number 1 .
   *
   * Unit don't know because don't know calcul made in ClipX by user.
   * Take care with units!
   * @return calculated value number 1.
   */
  float calculated_1();<--- Technically the member function 'ethercatcpp::ClipX::calculated_1' can be const. [+]The member function 'ethercatcpp::ClipX::calculated_1' can be made a const function. Making this function 'const' should not cause compiler errors. Even though the function can be made const function technically it may not make sense conceptually. Think about your design and the task of the function first - is it a function that must not change object internal state?

  /**
   * @brief Function used to get calculated value number 2 .
   *
   * Unit don't know because don't know calcul made in ClipX by user.
   * Take care with units!
   * @return calculated value number 2.
   */
  float calculated_2();<--- Technically the member function 'ethercatcpp::ClipX::calculated_2' can be const. [+]The member function 'ethercatcpp::ClipX::calculated_2' can be made a const function. Making this function 'const' should not cause compiler errors. Even though the function can be made const function technically it may not make sense conceptually. Think about your design and the task of the function first - is it a function that must not change object internal state?

  /**
   * @brief Function used to get calculated value number 3 .
   *
   * Unit don't know because don't know calcul made in ClipX by user.
   * Take care with units!
   * @return calculated value number 3.
   */
  float calculated_3();<--- Technically the member function 'ethercatcpp::ClipX::calculated_3' can be const. [+]The member function 'ethercatcpp::ClipX::calculated_3' can be made a const function. Making this function 'const' should not cause compiler errors. Even though the function can be made const function technically it may not make sense conceptually. Think about your design and the task of the function first - is it a function that must not change object internal state?

  /**
   * @brief Function used to get calculated value number 4 .
   *
   * Unit don't know because don't know calcul made in ClipX by user.
   * Take care with units!
   * @return calculated value number 4.
   */
  float calculated_4();<--- Technically the member function 'ethercatcpp::ClipX::calculated_4' can be const. [+]The member function 'ethercatcpp::ClipX::calculated_4' can be made a const function. Making this function 'const' should not cause compiler errors. Even though the function can be made const function technically it may not make sense conceptually. Think about your design and the task of the function first - is it a function that must not change object internal state?

  /**
   * @brief Function used to get calculated value number 5 .
   *
   * Unit don't know because don't know calcul made in ClipX by user.
   * Take care with units!
   * @return calculated value number 5.
   */
  float calculated_5();<--- Technically the member function 'ethercatcpp::ClipX::calculated_5' can be const. [+]The member function 'ethercatcpp::ClipX::calculated_5' can be made a const function. Making this function 'const' should not cause compiler errors. Even though the function can be made const function technically it may not make sense conceptually. Think about your design and the task of the function first - is it a function that must not change object internal state?

  /**
   * @brief Function used to get calculated value number 6 .
   *
   * Unit don't know because don't know calcul made in ClipX by user.
   * Take care with units!
   * @return calculated value number 6.
   */
  float calculated_6();<--- Technically the member function 'ethercatcpp::ClipX::calculated_6' can be const. [+]The member function 'ethercatcpp::ClipX::calculated_6' can be made a const function. Making this function 'const' should not cause compiler errors. Even though the function can be made const function technically it may not make sense conceptually. Think about your design and the task of the function first - is it a function that must not change object internal state?

  /**
   * @brief Function used to get clipx bus neighbor 1 value.
   *
   * By default unit is Volt <B>(mV/V)</B>.
   * If user set the calibrated value, unit is <B>Newton (N)</B>.
   * @return clipx bus neighbor 1 value.
   */
  float neighbor_1();<--- Technically the member function 'ethercatcpp::ClipX::neighbor_1' can be const. [+]The member function 'ethercatcpp::ClipX::neighbor_1' can be made a const function. Making this function 'const' should not cause compiler errors. Even though the function can be made const function technically it may not make sense conceptually. Think about your design and the task of the function first - is it a function that must not change object internal state?

  /**
   * @brief Function used to get clipx bus neighbor 2 value.
   *
   * By default unit is Volt <B>(mV/V)</B>.
   * If user set the calibrated value, unit is <B>Newton (N)</B>.
   * @return clipx bus neighbor 2 value.
   */
  float neighbor_2();<--- Technically the member function 'ethercatcpp::ClipX::neighbor_2' can be const. [+]The member function 'ethercatcpp::ClipX::neighbor_2' can be made a const function. Making this function 'const' should not cause compiler errors. Even though the function can be made const function technically it may not make sense conceptually. Think about your design and the task of the function first - is it a function that must not change object internal state?

  /**
   * @brief Function used to get clipx bus neighbor 3 value.
   *
   * By default unit is Volt <B>(mV/V)</B>.
   * If user set the calibrated value, unit is <B>Newton (N)</B>.
   * @return clipx bus neighbor 3 value.
   */
  float neighbor_3();<--- Technically the member function 'ethercatcpp::ClipX::neighbor_3' can be const. [+]The member function 'ethercatcpp::ClipX::neighbor_3' can be made a const function. Making this function 'const' should not cause compiler errors. Even though the function can be made const function technically it may not make sense conceptually. Think about your design and the task of the function first - is it a function that must not change object internal state?

  /**
   * @brief Function used to get clipx bus neighbor 4 value.
   *
   * By default unit is Volt <B>(mV/V)</B>.
   * If user set the calibrated value, unit is <B>Newton (N)</B>.
   * @return clipx bus neighbor 4 value.
   */
  float neighbor_4();<--- Technically the member function 'ethercatcpp::ClipX::neighbor_4' can be const. [+]The member function 'ethercatcpp::ClipX::neighbor_4' can be made a const function. Making this function 'const' should not cause compiler errors. Even though the function can be made const function technically it may not make sense conceptually. Think about your design and the task of the function first - is it a function that must not change object internal state?

  /**
   * @brief Function used to get clipx bus neighbor 5 value.
   *
   * By default unit is Volt <B>(mV/V)</B>.
   * If user set the calibrated value, unit is <B>Newton (N)</B>.
   * @return clipx bus neighbor 5 value.
   */
  float neighbor_5();<--- Technically the member function 'ethercatcpp::ClipX::neighbor_5' can be const. [+]The member function 'ethercatcpp::ClipX::neighbor_5' can be made a const function. Making this function 'const' should not cause compiler errors. Even though the function can be made const function technically it may not make sense conceptually. Think about your design and the task of the function first - is it a function that must not change object internal state?

  /**
   * @brief Function used to get clipx bus neighbor 6 value.
   *
   * By default unit is Volt <B>(mV/V)</B>.
   * If user set the calibrated value, unit is <B>Newton (N)</B>.
   * @return clipx bus neighbor 6 value.
   */
  float neighbor_6();<--- Technically the member function 'ethercatcpp::ClipX::neighbor_6' can be const. [+]The member function 'ethercatcpp::ClipX::neighbor_6' can be made a const function. Making this function 'const' should not cause compiler errors. Even though the function can be made const function technically it may not make sense conceptually. Think about your design and the task of the function first - is it a function that must not change object internal state?

  /**
   * @brief Function used to get external ethernet value number 1.
   *
   * No predefine unit. Take care with units!
   * @return external ethernet value number 1.
   */
  float external_eth_1();<--- Technically the member function 'ethercatcpp::ClipX::external_eth_1' can be const. [+]The member function 'ethercatcpp::ClipX::external_eth_1' can be made a const function. Making this function 'const' should not cause compiler errors. Even though the function can be made const function technically it may not make sense conceptually. Think about your design and the task of the function first - is it a function that must not change object internal state?

  /**
   * @brief Function used to get external ethernet value number 2.
   *
   * No predefine unit. Take care with units!
   * @return external ethernet value number 2.
   */
  float external_eth_2();<--- Technically the member function 'ethercatcpp::ClipX::external_eth_2' can be const. [+]The member function 'ethercatcpp::ClipX::external_eth_2' can be made a const function. Making this function 'const' should not cause compiler errors. Even though the function can be made const function technically it may not make sense conceptually. Think about your design and the task of the function first - is it a function that must not change object internal state?

  /**
   * @brief Function used to get analog output value.
   *
   * No predefine unit. Take care with units!
   * @return analog output value.
   */
  float analog_output();<--- Technically the member function 'ethercatcpp::ClipX::analog_output' can be const. [+]The member function 'ethercatcpp::ClipX::analog_output' can be made a const function. Making this function 'const' should not cause compiler errors. Even though the function can be made const function technically it may not make sense conceptually. Think about your design and the task of the function first - is it a function that must not change object internal state?

  /**
   * @brief Function used to set limit value number 1.
   *
   * By default unit is Volt <B>(mV/V)</B>.
   * If user set the calibrated value, unit is <B>Newton (N)</B>.
   * @param [in] value is limit value desired.
   */
  void set_limit_1(float value);

  /**
   * @brief Function used to get limit value number 1.
   *
   * By default unit is Volt <B>(mV/V)</B>.
   * If user set the calibrated value, unit is <B>Newton (N)</B>.
   * @return limit value number 1.
   */
  float limit_1();<--- Technically the member function 'ethercatcpp::ClipX::limit_1' can be const. [+]The member function 'ethercatcpp::ClipX::limit_1' can be made a const function. Making this function 'const' should not cause compiler errors. Even though the function can be made const function technically it may not make sense conceptually. Think about your design and the task of the function first - is it a function that must not change object internal state?

  /**
   * @brief Function used to set limit value number 2.
   *
   * By default unit is Volt <B>(mV/V)</B>.
   * If user set the calibrated value, unit is <B>Newton (N)</B>.
   * @param [in] value is limit value desired.
   */
  void set_limit_2(float value);

  /**
   * @brief Function used to get limit value number 2.
   *
   * By default unit is Volt <B>(mV/V)</B>.
   * If user set the calibrated value, unit is <B>Newton (N)</B>.
   * @return limit value number 2.
   */
  float limit_2();<--- Technically the member function 'ethercatcpp::ClipX::limit_2' can be const. [+]The member function 'ethercatcpp::ClipX::limit_2' can be made a const function. Making this function 'const' should not cause compiler errors. Even though the function can be made const function technically it may not make sense conceptually. Think about your design and the task of the function first - is it a function that must not change object internal state?

  /**
   * @brief Function used to set limit value number 3.
   *
   * By default unit is Volt <B>(mV/V)</B>.
   * If user set the calibrated value, unit is <B>Newton (N)</B>.
   * @param [in] value is limit value desired.
   */
  void set_limit_3(float value);

  /**
   * @brief Function used to get limit value number 3.
   *
   * By default unit is Volt <B>(mV/V)</B>.
   * If user set the calibrated value, unit is <B>Newton (N)</B>.
   * @return limit value number 3.
   */
  float limit_3();<--- Technically the member function 'ethercatcpp::ClipX::limit_3' can be const. [+]The member function 'ethercatcpp::ClipX::limit_3' can be made a const function. Making this function 'const' should not cause compiler errors. Even though the function can be made const function technically it may not make sense conceptually. Think about your design and the task of the function first - is it a function that must not change object internal state?

  /**
   * @brief Function used to set limit value number 4.
   *
   * By default unit is Volt <B>(mV/V)</B>.
   * If user set the calibrated value, unit is <B>Newton (N)</B>.
   * @param [in] value is limit value desired.
   */
  void set_limit_4(float value);

  /**
   * @brief Function used to get limit value number 4.
   *
   * By default unit is Volt <B>(mV/V)</B>.
   * If user set the calibrated value, unit is <B>Newton (N)</B>.
   * @return limit value number 4.
   */
  float limit_4();<--- Technically the member function 'ethercatcpp::ClipX::limit_4' can be const. [+]The member function 'ethercatcpp::ClipX::limit_4' can be made a const function. Making this function 'const' should not cause compiler errors. Even though the function can be made const function technically it may not make sense conceptually. Think about your design and the task of the function first - is it a function that must not change object internal state?

  /**
   * @brief Function used to change the "parameter set".
   * @param [in] value is the number of the parameter set needed, have to be
   * from 1 to 10.
   */
  void change_parameters(uint16_t value);

  /**
   * @brief Function used to read number of actual parameter set.
   * @return number of actual parameter set.
   */
  uint16_t parameters();<--- Technically the member function 'ethercatcpp::ClipX::parameters' can be const. [+]The member function 'ethercatcpp::ClipX::parameters' can be made a const function. Making this function 'const' should not cause compiler errors. Even though the function can be made const function technically it may not make sense conceptually. Think about your design and the task of the function first - is it a function that must not change object internal state?

  /**
   * @brief Function used to set fieldbus value number 1.
   *
   * No predefine unit. Take care with units!
   * @param [in] value is the coefficient value that user needed.
   */
  void fieldbus_1(float value);

  /**
   * @brief Function used to set fieldbus value number 2.
   *
   * No predefine unit. Take care with units!
   * @param [in] value is the coefficient value that user needed.
   */
  void fieldbus_2(float value);

  /**
   * @brief Function used to set fieldbus flags.
   *
   * @param [in] flag_id is the desired flag define in fieldbus_flag_t.
   * @param [in] state is the desired for the flag (TRUE or FALSE).
   */
  void fieldbus_flag(fieldbus_flag_t flag_id, bool state);

  /**
   * @brief Function used to check I/O status flags.
   *
   * @param [in] io_id is the desired I/O status flag define in io_status_t.
   * @return flag state (TRUE: active or FALSE: unactive).
   */
  bool check_io_status(io_status_t io_id);<--- Technically the member function 'ethercatcpp::ClipX::check_io_status' can be const. [+]The member function 'ethercatcpp::ClipX::check_io_status' can be made a const function. Making this function 'const' should not cause compiler errors. Even though the function can be made const function technically it may not make sense conceptually. Think about your design and the task of the function first - is it a function that must not change object internal state?

  /**
   * @brief Function used to get system status flags.
   *
   * @param [in] status_id is the desired system status flag define in
   * system_status_t.
   * @return flag state (TRUE: active or FALSE: unactive).
   */
  bool system_status(system_status_t status_id);<--- Technically the member function 'ethercatcpp::ClipX::system_status' can be const. [+]The member function 'ethercatcpp::ClipX::system_status' can be made a const function. Making this function 'const' should not cause compiler errors. Even though the function can be made const function technically it may not make sense conceptually. Think about your design and the task of the function first - is it a function that must not change object internal state?

  /**
   * @brief Function used to check validity of mesured value.
   *
   * @param [in] mesured_value_id is the desired value validity flag define in
   * mesured_value_t.
   * @return flag state (TRUE: invalid or FALSE: valid).
   */
  bool check_measure_validity(<--- Technically the member function 'ethercatcpp::ClipX::check_measure_validity' can be const. [+]The member function 'ethercatcpp::ClipX::check_measure_validity' can be made a const function. Making this function 'const' should not cause compiler errors. Even though the function can be made const function technically it may not make sense conceptually. Think about your design and the task of the function first - is it a function that must not change object internal state?
      mesured_value_t
          mesured_value_id); // 0 -> value valid || 1 -> invalid value

  /**
   * @brief Function used to set the control word.
   *
   * @param [in] control_word_id is the desired flag data who want to set. Flags
   * is defined in control_word_t.
   * @param [in] state is the desired state for the flag (TRUE: active flag or
   * FALSE: unactive flag).
   */
  void set_control_word(control_word_t control_word_id, bool state);

  /**
   * @brief Function used to print all datas that clipx have.
   */
  void print_data();<--- Technically the member function 'ethercatcpp::ClipX::print_data' can be const. [+]The member function 'ethercatcpp::ClipX::print_data' can be made a const function. Making this function 'const' should not cause compiler errors. Even though the function can be made const function technically it may not make sense conceptually. Think about your design and the task of the function first - is it a function that must not change object internal state?

private:
  void update_command_buffer();
  void unpack_status_buffer();
  void update_control_word_ack();

  // Command variable
  float fieldbus_value_1_;<--- class member 'ClipX::fieldbus_value_1_' is never used.
  float fieldbus_value_2_;<--- class member 'ClipX::fieldbus_value_2_' is never used.
  uint16_t fieldbus_flag_;<--- class member 'ClipX::fieldbus_flag_' is never used.
  float limit_value_1_;<--- class member 'ClipX::limit_value_1_' is never used.
  float limit_value_2_;<--- class member 'ClipX::limit_value_2_' is never used.
  float limit_value_3_;<--- class member 'ClipX::limit_value_3_' is never used.
  float limit_value_4_;<--- class member 'ClipX::limit_value_4_' is never used.
  uint32_t control_word_;<--- class member 'ClipX::control_word_' is never used.
  uint16_t parameter_set_number_;<--- class member 'ClipX::parameter_set_number_' is never used.

  // Status variable
  uint32_t system_status_;<--- class member 'ClipX::system_status_' is never used.
  float adc_value_;<--- class member 'ClipX::adc_value_' is never used.
  float field_value_;<--- class member 'ClipX::field_value_' is never used.
  float gross_value_;<--- class member 'ClipX::gross_value_' is never used.
  float net_value_;<--- class member 'ClipX::net_value_' is never used.
  float min_value_;<--- class member 'ClipX::min_value_' is never used.
  float max_value_;<--- class member 'ClipX::max_value_' is never used.
  float peak_to_peak_value_;<--- class member 'ClipX::peak_to_peak_value_' is never used.
  float captured_value_1_;<--- class member 'ClipX::captured_value_1_' is never used.
  float captured_value_2_;<--- class member 'ClipX::captured_value_2_' is never used.
  float calculated_value_1_;<--- class member 'ClipX::calculated_value_1_' is never used.
  float calculated_value_2_;<--- class member 'ClipX::calculated_value_2_' is never used.
  float calculated_value_3_;<--- class member 'ClipX::calculated_value_3_' is never used.
  float calculated_value_4_;<--- class member 'ClipX::calculated_value_4_' is never used.
  float calculated_value_5_;<--- class member 'ClipX::calculated_value_5_' is never used.
  float calculated_value_6_;<--- class member 'ClipX::calculated_value_6_' is never used.
  float neighbor_value_1_;<--- class member 'ClipX::neighbor_value_1_' is never used.
  float neighbor_value_2_;<--- class member 'ClipX::neighbor_value_2_' is never used.
  float neighbor_value_3_;<--- class member 'ClipX::neighbor_value_3_' is never used.
  float neighbor_value_4_;<--- class member 'ClipX::neighbor_value_4_' is never used.
  float neighbor_value_5_;<--- class member 'ClipX::neighbor_value_5_' is never used.
  float neighbor_value_6_;<--- class member 'ClipX::neighbor_value_6_' is never used.
  float external_eth_value_1_;<--- class member 'ClipX::external_eth_value_1_' is never used.
  float external_eth_value_2_;<--- class member 'ClipX::external_eth_value_2_' is never used.
  float analog_output_value_;<--- class member 'ClipX::analog_output_value_' is never used.
  uint32_t io_status_low_;<--- class member 'ClipX::io_status_low_' is never used.
  uint32_t io_stauts_high_;<--- class member 'ClipX::io_stauts_high_' is never used.
  uint32_t measured_value_status_;<--- class member 'ClipX::measured_value_status_' is never used.
  float limit_value_1_read_;<--- class member 'ClipX::limit_value_1_read_' is never used.
  float limit_value_2_read_;<--- class member 'ClipX::limit_value_2_read_' is never used.
  float limit_value_3_read_;<--- class member 'ClipX::limit_value_3_read_' is never used.
  float limit_value_4_read_;<--- class member 'ClipX::limit_value_4_read_' is never used.
  uint32_t control_word_validation_;<--- class member 'ClipX::control_word_validation_' is never used.
  uint16_t parameter_set_number_read_;<--- class member 'ClipX::parameter_set_number_read_' is never used.

  // Calibrate variable
  float calibrate_from_V_to_N_;<--- class member 'ClipX::calibrate_from_V_to_N_' is never used.
  bool clipx_calibrated_;<--- class member 'ClipX::clipx_calibrated_' is never used.
};
} // namespace ethercatcpp
Cppcheck report - ethercatcpp-clipx: /builds/ethercatcpp/ethercatcpp-clipx/include/ethercat_master/ethercatcpp/clipx.h
