diff --git a/Firmware/.gitignore b/Firmware/.gitignore
index 1757ea432..f6faee73a 100644
--- a/Firmware/.gitignore
+++ b/Firmware/.gitignore
@@ -1,4 +1,4 @@
-/*Debug/
+**/Debug/
 **/Release/
 **/.settings/
 *.launch
@@ -7,5 +7,4 @@
 .mxproject
 fixlang
 /build/
-/OpenFFBoard/
-/*Targets/F407VG/*.cfg
+/OpenFFBoard/
\ No newline at end of file
diff --git a/Firmware/FFBoard/Inc/AxesManager.h b/Firmware/FFBoard/Inc/AxesManager.h
index f1b9e3762..fb361e127 100644
--- a/Firmware/FFBoard/Inc/AxesManager.h
+++ b/Firmware/FFBoard/Inc/AxesManager.h
@@ -47,10 +47,10 @@ class AxesManager
 	void emergencyStop(bool reset);
 	void resetPosZero();
 
+	void updateSamplerate(float newSamplerate);
+
 private:
 	volatile Control_t* control;
-	volatile bool *p_usb_disabled;
-	volatile bool *p_emergency;
 	std::shared_ptr<EffectsCalculator> effects_calc;
 	uint16_t axis_count = 0;
 	std::vector<std::unique_ptr<Axis>> axes;
diff --git a/Firmware/FFBoard/Inc/Axis.h b/Firmware/FFBoard/Inc/Axis.h
index 05e87fdc9..6603eb5cb 100644
--- a/Firmware/FFBoard/Inc/Axis.h
+++ b/Firmware/FFBoard/Inc/Axis.h
@@ -2,7 +2,9 @@
  * Axis.h
  *
  *  Created on: 21.01.2021
- *      Author: Yannick / Lidders
+ *      Author: Yannick / Lidders / Vincent
+ * 
+ *  Release 27.10.25: Vincent, add reconstruction filter, equalizer, slew rate.
  */
 
 #ifndef SRC_AXIS_H_
@@ -10,7 +12,6 @@
 #include <FFBoardMain.h>
 #include <MotorPWM.h>
 #include "usb_hid_ffb_desc.h"
-#include "TMC4671.h"
 #include "PersistentStorage.h"
 #include "ButtonSource.h"
 #include "EncoderLocal.h"
@@ -24,6 +25,10 @@
 #include "ExtiHandler.h"
 #include "EffectsCalculator.h"
 
+#ifdef USE_DSP_FUNCTIONS
+#include "arm_math.h"
+#endif
+
 #define INTERNAL_AXIS_DAMPER_SCALER 0.7
 #define INTERNAL_AXIS_FRICTION_SCALER 0.7
 #define INTERNAL_AXIS_INERTIA_SCALER 0.7
@@ -34,22 +39,28 @@
 #define AXIS_SPEEDLIMITER_I 0.03
 #endif
 
-
+/**
+ * @brief Global control flags for all axes.
+ */
 struct Control_t {
-	bool emergency = false;
-	bool usb_disabled = true;
-	bool update_disabled = true;
-	bool request_update_disabled = false;
+	bool emergency = false;				//!< Emergency stop is active.
+	bool usb_disabled = true;			//!< FFB is disabled by USB.
+	bool update_disabled = true;		//!< FFB updates are disabled.
+	bool request_update_disabled = false; //!< A request to disable FFB updates is pending.
 //	bool usb_update_flag = false;
 //	bool update_flag = false;
-	bool resetEncoder = false;
+	bool resetEncoder = false;			//!< A request to reset the encoder is pending.
 };
 
-struct AxisFlashAddrs
+/**
+ * @brief Defines the flash memory addresses for axis-specific settings.
+ */
+struct AxisFlashAddresses
 {
 	uint16_t config = ADR_AXIS1_CONFIG;
 	uint16_t maxSpeed = ADR_AXIS1_MAX_SPEED;
 	uint16_t maxAccel = ADR_AXIS1_MAX_ACCEL;
+	uint16_t maxSlewRateDrv = ADR_AXIS1_MAX_SLEWRATE_DRV;
 
 	uint16_t endstop = ADR_AXIS1_ENDSTOP;
 	uint16_t power = ADR_AXIS1_POWER;
@@ -62,229 +73,462 @@ struct AxisFlashAddrs
 	uint16_t postprocess1 = ADR_AXIS1_POSTPROCESS1;
 };
 
+/**
+ * @brief Configuration for an axis, including driver and encoder types.
+ */
 struct AxisConfig
 {
-	uint8_t drvtype = 0;
-	uint8_t enctype = 0;
-	//bool invert = false;
+	uint8_t drvtype = 0; //!< Motor driver type ID.
+	uint8_t enctype = 0; //!< Encoder type ID.
 };
+/**
+ * @brief Holds the physical metrics of an axis at a point in time.
+ */
 struct metric_t {
-	float accel = 0;	// in deg/s²
-	float speed = 0; // in deg/s
-	int32_t pos = 0; // scaled position as 16b int -0x7fff to 0x7fff
-	float pos_f = 0; // scaled position as float. -1 to 1 range
-	float posDegrees = 0; // Position in degrees. Not scaled to selected range
-	int32_t torque = 0; // total of effect + endstop torque
+	float accel = 0;	  //!< Acceleration in deg/s².
+	float speed = 0;	  //!< Speed in deg/s.
+	int32_t pos_scaled_16b = 0;	  //!< Scaled position as a 16-bit integer (-0x7fff to 0x7fff).
+	float pos_f = 0;	  //!< Scaled position as a float (-1.0 to 1.0).
+	float posDegrees = 0; //!< Position in degrees, not scaled to the selected range.
+	int32_t torque = 0;	  //!< Total torque applied to the axis.
 };
 
 
+/**
+ * @brief Holds the current and previous metrics for an axis, used for calculating derivatives.
+ */
 struct axis_metric_t {
-	metric_t current;
-	metric_t previous;
+	metric_t current;  //!< Current metrics.
+	metric_t previous; //!< Metrics from the previous update cycle.
 };
 
+/**
+ * @brief Represents a gear ratio for scaling encoder values.
+ */
 struct GearRatio_t{
-	uint8_t denominator = 0;
-	uint8_t numerator = 0;
-	float gearRatio = 1.0;
+	uint8_t denominator = 0; //!< Denominator of the gear ratio.
+	uint8_t numerator = 0;   //!< Numerator of the gear ratio.
+	float gearRatio = 1.0;   //!< The calculated gear ratio (numerator/denominator).
 };
 
-
 enum class Axis_commands : uint32_t{
 	power=0x00,degrees=0x01,esgain,zeroenc,invert,idlespring,axisdamper,enctype,drvtype,
-	pos,maxspeed,maxtorquerate,fxratio,curtorque,curpos,curspd,curaccel,reductionScaler,
+	pos,curtorque,curpos,curspd,curaccel,
+	fxratio,reductionScaler,
 	filterSpeed, filterAccel, filterProfileId,cpr,axisfriction,axisinertia,
+	maxspeed,slewrate,
+	calibrate_maxSlewRateDrv,
+	maxSlewRateDrv,
 	expo,exposcale
 };
 
+/**
+ * @brief This class represents a single FFB axis.
+ * It handles the motor driver, encoder, and all related calculations for force feedback effects.
+ */
 class Axis : public PersistentStorage, public CommandHandler, public ErrorHandler
 {
 public:
+	/**
+	 * @brief Construct a new Axis object.
+	 * @param axis The character identifier for this axis (e.g., 'x', 'y').
+	 * @param control A pointer to the global control structure.
+	 */
 	Axis(char axis, volatile Control_t* control);
 	virtual ~Axis();
 
-	static ClassIdentifier info;
+	static ClassIdentifier info; //!< Static class identifier.
 	const ClassIdentifier getInfo();
 	const ClassType getClassType() override {return ClassType::Axis;};
 
 	virtual std::string getHelpstring() { return "FFB axis"	;}
-#ifdef TMC4671DRIVER
-	void setupTMC4671();
-#endif
 	// Dynamic classes
+	/**
+	 * @brief Sets the motor driver type.
+	 * @param drvtype The type of the motor driver.
+	 */
 	void setDrvType(uint8_t drvtype);
+
+	/**
+	 * @brief Sets the encoder type.
+	 * @param enctype The type of the encoder.
+	 */
 	void setEncType(uint8_t enctype);
+
+	/**
+	 * @brief Gets the motor driver type.
+	 * @return The type of the motor driver.
+	 */
 	uint8_t getDrvType();
+
+	/**
+	 * @brief Gets the encoder type.
+	 * @return The type of the encoder.
+	 */
 	uint8_t getEncType();
 
+	/**
+	 * @brief Gets the encoder instance.
+	 * @return A pointer to the encoder instance.
+	 */
 	Encoder* getEncoder();
+
+	/**
+	 * @brief Gets the motor driver instance.
+	 * @return A pointer to the motor driver instance.
+	 */
 	MotorDriver* getDriver();
 
-	void usbSuspend(); // Called on usb disconnect and suspend
-	void usbResume();  // Called on usb resume
+	/**
+	 * @brief Called on USB disconnect and suspend.
+	 */
+	void usbSuspend();
+
+	/**
+	 * @brief Called on USB resume. Enables the motor driver.
+	 */
+	void usbResume();
 
+	/**
+	 * @brief Saves axis settings to flash memory.
+	 * @override from PersistentStorage
+	 */
 	void saveFlash() override;
+
+	/**
+	 * @brief Restores axis settings from flash memory.
+	 * @override from PersistentStorage
+	 */
 	void restoreFlash() override;
 
-	void prepareForUpdate();  // called before the effects are calculated
-	void updateDriveTorque(); //int32_t effectTorque);
+	/**
+	 * @brief Prepares the axis for an update cycle. Called from the main loop before effects are calculated.
+	 * Reads the encoder, scales the value, and updates metrics (speed, acceleration).
+	 */
+	void prepareForUpdate();
+
+	/**
+	 * @brief Sends the final calculated torque to the motor driver.
+	 */
+	void updateDriveTorque();
+
+	/**
+	 * @brief Triggers an emergency stop. Disables the motor driver.
+	 * @param reset If true, resets the axis after stopping.
+	 */
 	void emergencyStop(bool reset);
 
+	/**
+	 * @brief Sets the position of the axis.
+	 * @param val The new position value.
+	 */
 	void setPos(uint16_t val);
+
+	/**
+	 * @brief Zeros the current encoder position.
+	 */
 	void zeroPos();
 
+	/**
+	 * @brief Checks if FFB is globally active.
+	 * @return true if FFB is active, false otherwise.
+	 */
 	bool getFfbActive();
 
+	/**
+	 * @brief Scales an encoder value.
+	 * @param angle The angle to scale.
+	 * @param degrees The total degrees of rotation.
+	 * @return A pair containing the scaled integer value and the float value.
+	 */
 	std::pair<int32_t,float> scaleEncValue(float angle, uint16_t degrees);
-	float 	getEncAngle(Encoder *enc);
 
+	/**
+	 * @brief Gets the angle from the encoder.
+	 * @param enc A pointer to the encoder.
+	 * @return The angle in degrees.
+	 */
+	float 	getEncAngle(Encoder *enc);
 
+	/**
+	 * @brief Sets the maximum power (torque) of the motor.
+	 * @param power The new power value.
+	 */
 	void setPower(uint16_t power);
 
-
+	/**
+	 * @brief Callback for handling errors.
+	 * @param error The error that occurred.
+	 * @param cleared Whether the error has been cleared.
+	 * @override from ErrorHandler
+	 */
 	void errorCallback(const Error &error, bool cleared) override;
 
-	//ParseStatus command(ParsedCommand_old* cmd,std::string* reply) override;
+	/**
+	 * @brief Registers the commands for this axis with the command handler.
+	 */
 	void registerCommands();
-	CommandStatus command(const ParsedCommand& cmd,std::vector<CommandReply>& replies);
-
-	ClassChooser<MotorDriver> drv_chooser;
-	ClassChooser<Encoder> enc_chooser;
-
+	/**
+	 * @brief Handles command line interface commands for this axis.
+	 * @param cmd The parsed command.
+	 * @param replies A vector of replies to be sent back.
+	 * @return The status of the command execution.
+	 * @override from CommandHandler
+	 */
+	CommandStatus command(const ParsedCommand& cmd,std::vector<CommandReply>& replies) override;
+
+	ClassChooser<MotorDriver> driverChooser; //!< Class chooser for motor drivers.
+	ClassChooser<Encoder> encoderChooser;     //!< Class chooser for encoders.
+
+	/**
+	 * @brief Gets the last scaled encoder value.
+	 * @return The last scaled encoder value.
+	 */
 	int32_t getLastScaledEnc();
+
+	/**
+	 * @brief Resets the metrics of the axis.
+	 * @param new_pos The new position to reset to.
+	 */
 	void resetMetrics(float new_pos);
+
+	/**
+	 * @brief Updates the metrics of the axis.
+	 * @param new_pos The new position.
+	 */
 	void updateMetrics(float new_pos);
+
+	/**
+	 * @brief Updates the idle spring force.
+	 * @return The calculated idle spring force.
+	 */
 	int32_t updateIdleSpringForce();
+
+	/**
+	 * @brief Sets the idle spring strength.
+	 * @param spring The new spring strength.
+	 */
 	void setIdleSpringStrength(uint8_t spring);
-	void setFxStrengthAndFilter(uint8_t val,uint8_t& valToSet, Biquad& filter);
-	void calculateAxisEffects(bool ffb_on);
-	int32_t getTorque(); // current torque scaled as a 32 bit signed value
-	int16_t updateEndstop();
 
-	int32_t calculateExpoTorque(int32_t torque);
+	/**
+	 * @brief Sets the strength and filter for an effect.
+	 * @param val The new strength value.
+	 * @param valToSet A reference to the value to be set.
+	 * @param filter A reference to the biquad filter.
+	 */
+	void setFxStrengthAndFilter(uint8_t val,uint8_t& valToSet, Biquad& filter);
 
+	/**
+	 * @brief Calculates the mechanical effects (damper, friction, inertia) that are always active.
+	 * These are separate from the HID FFB effects sent by the game.
+	 * @param ffb_on A flag indicating if FFB is on.
+	 */
+	void calculateMechanicalEffects(bool ffb_on);
+
+	/**
+	 * @brief Gets the current torque.
+	 * @return The current torque scaled as a 32-bit signed value.
+	 */
+	int32_t getTorque();
+
+	/**
+	 * @brief Calculates the endstop torque.
+	 * @return The calculated endstop torque.
+	 */
+	int32_t calculateEndstopTorque();
+
+	/**
+	 * @brief Calculates the FFB torque exponential torque, from the input torque and apply expo and scaler
+	 * @return The calculated exponential torque.
+	 */
+	int64_t calculateFFBTorque();
+
+	/**
+	 * @brief Starts a force fade-in.
+	 * @param start The starting force multiplier.
+	 * @param fadeTime The duration of the fade-in.
+	 */
 	void startForceFadeIn(float start = 0,float fadeTime = 0.5);
 
 	metric_t* getMetrics();
 
-	void setEffectTorque(int32_t torque);
+	/**
+	 * @brief Sets the FFB effect torque.
+	 * @param torque The new FFB effect torque from the EffectsCalculator.
+	 */
+	void setFfbEffectTorque(int64_t torque);
+
+	/**
+	 * @brief Updates the total torque.
+	 * @param totalTorque A pointer to the total torque value.
+	 * @return true if the torque was updated, false otherwise.
+	 */
 	bool updateTorque(int32_t* totalTorque);
 
 
+	void updateSamplerate(float newSamplerate);
+	void updateFilters(uint8_t profileId);
+
+	/**
+	 * @brief Sets the gear ratio.
+	 * @param numerator The numerator of the gear ratio.
+	 * @param denominator The denominator of the gear ratio.
+	 */
 	void setGearRatio(uint8_t numerator,uint8_t denominator);
 
-	static const std::vector<class_entry<MotorDriver>> axis1_drivers;
-	static const std::vector<class_entry<MotorDriver>> axis2_drivers;
+	static const std::vector<class_entry<MotorDriver>> axis1_drivers; //!< List of available motor drivers for the first axis.
+	static const std::vector<class_entry<MotorDriver>> axis2_drivers; //!< List of available motor drivers for the second axis.
 
 private:
-	// Axis damper is lower than default scale of HID Damper
+	// Internal constants
 	const float AXIS_DAMPER_RATIO = INTERNAL_SCALER_DAMPER * INTERNAL_AXIS_DAMPER_SCALER / 255.0;
 	const float AXIS_INERTIA_RATIO = INTERNAL_SCALER_INERTIA * INTERNAL_AXIS_INERTIA_SCALER / 255.0;
 
-	AxisFlashAddrs flashAddrs;
-	volatile Control_t* control;
+	// Private methods
+	/**
+	 * @brief Sets the degrees of rotation for the axis.
+	 * @param degrees The new range of rotation.
+	 */
+	void setDegrees(uint16_t degrees);
+	/**
+	 * @brief Returns the current power setting of the axis.
+	 * @return The power value.
+	 */
+	uint16_t getPower();
+	/**
+	 * @brief Returns the calculated torque scaler.
+	 * @return The torque scaler value.
+	 */
+	bool isInverted();
+	/**
+	 * @brief Sets the ratio between game effects and endstop force and updates the internal torque scaler based on power and fx_ratio
+	 * @param val The new ratio value (0-255).
+	 */
+	void setEffectRatio(uint8_t val);
+	/**
+	 * @brief Sets the exponential torque curve.
+	 * @param val The new expo value.
+	 */
+	void setExpo(int val);
 
-	//TIM_HandleTypeDef *timer_update;
-	AxisConfig conf;
+	int32_t calculateExpoTorque(int32_t torque);
+	/**
+	 * @brief Applies the speed limiter PI controller to the torque.
+	 * @param torque A reference to the torque value to be modified.
+	 * @return torque update to apply to reduced de speed.
+	 */
+	int64_t applySpeedLimiterTorque(int64_t& torque);
+	/**
+	 * @brief Applies the torque slew rate limiter to the torque.
+	 * @param torque A reference to the torque value to be modified.
+	 */
+	void applyTorqueSlewRateLimiter(int64_t& torque);
+	/**
+	 * @brief Decodes the axis configuration from a 16-bit integer stored in flash.
+	 * @param val The 16-bit encoded configuration value.
+	 */
+	static AxisConfig decodeConfFromInt(uint16_t val);
+	/**
+	 * @brief Encodes the axis configuration into a 16-bit integer for flash storage.
+	 * @param conf The AxisConfig struct to encode.
+	 * @return The encoded 16-bit value.
+	 */
+	static uint16_t encodeConfToInt(AxisConfig conf);
 
-	std::unique_ptr<MotorDriver> drv = std::make_unique<MotorDriver>(); // dummy
-	std::shared_ptr<Encoder> enc = nullptr;
 
-	bool outOfBounds = false;
 
-	static AxisConfig decodeConfFromInt(uint16_t val);
-	static uint16_t encodeConfToInt(AxisConfig conf);
+	// Member variables
+	AxisFlashAddresses flashAddresses;			//!< Flash memory addresses for this axis.
+	volatile Control_t* control;		//!< Pointer to the global control structure.
+	AxisConfig conf;					//!< Configuration for this axis (driver and encoder types).
+	char axis;							//!< Axis identifier ('X', 'Y', 'Z').
 
-	const Error outOfBoundsError = Error(ErrorCode::axisOutOfRange,ErrorType::warning,"Axis out of bounds");
+	std::unique_ptr<MotorDriver> drv = std::make_unique<MotorDriver>(); //!< Unique pointer to the active motor driver.
+	std::shared_ptr<Encoder> enc = nullptr;	//!< Shared pointer to the active encoder.
 
-	float forceFadeTime = 1.0;
-	float forceFadeCurMult = 1.0;
+	bool outOfBounds = false;			//!< Flag indicating if the axis is out of its valid range.
+	const Error outOfBoundsError = Error(ErrorCode::axisOutOfRange,ErrorType::warning,"Axis out of bounds"); //!< Error object for out-of-bounds condition.
 
-#ifdef TMC4671DRIVER
-	TMC4671Limits tmclimits = TMC4671Limits({.pid_torque_flux_ddt = 32767,
-											 .pid_uq_ud = 30000,
-											 .pid_torque_flux = 30000,
-											 .pid_acc_lim = 2147483647,
-											 .pid_vel_lim = 2147483647,
-											 .pid_pos_low = -2147483647,
-											 .pid_pos_high = 2147483647});
-#endif
-	float encoderOffset = 0; // Offset for absolute encoders
-	uint16_t degreesOfRotation = 900;					// How many degrees of range for the full gamepad range
-	uint16_t lastdegreesOfRotation = degreesOfRotation; // Used to store the previous value
-	uint16_t nextDegreesOfRotation = degreesOfRotation; // Buffer when changing range
+	// Force fade-in effect
+	float forceFadeDuration = 1.0;			//!< Duration of the force fade-in in seconds.
+	float forceFadeMultiplier = 1.0;		//!< Current multiplier for the force fade-in.
 
-	// Limiters
-	uint16_t maxSpeedDegS  = 0; // Set to non zero to enable. example 1000. 8b * 10?
-	//float	 maxAccelDegSS = 0;
-	uint32_t maxTorqueRateMS = 0; // 8b * 128?
-	float speedLimiterP = AXIS_SPEEDLIMITER_P;
-	float speedLimiterI = AXIS_SPEEDLIMITER_I;
+	float encoderOffset = 0; //!< Offset for absolute encoders.
+	uint16_t degreesOfRotation = 900;		//!< Current degrees of rotation.
+	uint16_t previousDegreesOfRotation = degreesOfRotation; //!< Previous degrees of rotation (for smooth transitions).
+	uint16_t nextDegreesOfRotation = degreesOfRotation; //!< Target degrees of rotation.
 
-	float spdlimitreducerI = 0;
-	//float acclimitreducerI = 0;
-	//const uint8_t accelFactor = 10.0; // Conversion factor between internal and external acc limit
+	// Limiters
+	uint16_t maxSlewRate_Driver = MAX_SLEW_RATE;		//!< Maximum slew rate as measured by the driver (in units/ms).
+	uint16_t maxSpeedDegS  = 0;		//!< Maximum speed in degrees per second. 0 to disable.
+	uint32_t maxTorqueRateMS = 0;		//!< Maximum torque rate of change per millisecond. 0 to disable.
+
+	float speedLimiterP = AXIS_SPEEDLIMITER_P; //!< Proportional term for the speed limiter.
+	float speedLimiterI = AXIS_SPEEDLIMITER_I; //!< Integral term for the speed limiter.
+#ifdef USE_DSP_FUNCTIONS
+	arm_pid_instance_f32 speedLimiterPID; //!< PID instance for the speed limiter.
+#else
+	// Speed limiter PID
+	float speedLimitReducerI = 0;
+#endif
 
-	void setDegrees(uint16_t degrees);
+	// Axis metrics
+	axis_metric_t metric;			//!< Current and previous physical metrics of the axis.
+	float previousFrameSpeed = 0;			//!< Instantaneous speed from the last cycle, used for acceleration calculation.
 
-	uint16_t getPower();
-	float getTorqueScaler();
-	bool isInverted();
-	char axis;
+	// Torque components
+	int64_t ffbEffectTorque = 0;		//!< Torque from HID FFB effects.
+	int32_t mechanicalEffectTorque = 0;	//!< Torque from mechanical effects (damper, friction, inertia).
 
+	// Power and scaling
+	uint16_t power = 5000;			//!< Maximum motor power/torque.
+	uint8_t effectRatio = 204;		//!< Ratio of HID effects vs. endstop effects (0-255).
+	float effectRatioScaler = 0;	//!< Scaler for HID effects based on effectRatio.
+	float torqueScaler = 0;			//!< Final torque scaler based on power.
 
-	// Merge normalized
-	axis_metric_t metric;
-	float _lastSpeed = 0;
-	int32_t effectTorque = 0;
-	int32_t axisEffectTorque = 0;
-	uint8_t fx_ratio_i = 204; // Reduce effects to a certain ratio of the total power to have a margin for the endstop. 80% = 204
-	uint16_t power = 5000;
-	float torqueScaler = 0; // power * fx_ratio as a ratio between 0 & 1
-	float effect_margin_scaler = 0;
-	bool invertAxis = true; // By default most motors and encoders count up CCW while gamepads are counting up CW.
-	uint8_t endstopStrength = 127; // Sets how much extra torque per count above endstop is added. High = stiff endstop. Low = softer
-	const float endstopGain = 25; // Overall max endstop intensity
+	// Axis configuration
+	bool invertAxis = true;			//!< Invert axis direction.
+	uint8_t endstopStrength = 127;	//!< Stiffness of the endstop effect.
+	const float endstopGain = 25;	//!< Overall maximum endstop intensity.
 
+	// Idle spring effect
+	uint8_t idleSpringStrength = 127; //!< Strength of the idle spring.
+	int16_t idleSpringClip = 0;       //!< Maximum force for the idle spring.
+	float idleSpringScale = 0;        //!< Scaler for the idle spring force.
+	bool motorWasNotReady = true;     //!< Flag to detect motor readiness transition.
 
-	uint8_t idlespringstrength = 127;
-	int16_t idlespringclip = 0;
-	float idlespringscale = 0;
-	bool motorWasNotReady = true;
+	// Slew rate calibration tracking: true when Axis requested a calibration and
+	// is waiting for the driver to finish measuring the max slew rate.
+	bool awaitingSlewCalibration = false;
 
+	// Filters
 	// TODO tune these and check if it is really stable and beneficial to the FFB. index 4 placeholder
-	const std::array<biquad_constant_t,4> filterSpeedCst = { {{ 40, 55 }, { 70, 55 }, { 120, 55 }, {180, 55}} };
-	const std::array<biquad_constant_t,4> filterAccelCst = { {{ 40, 30 }, { 55, 30 }, { 70, 30 }, {120, 55}} };
-	const biquad_constant_t filterDamperCst = {60, 55};
-	const biquad_constant_t filterFrictionCst = {50, 20};
-	const biquad_constant_t filterInertiaCst = {20, 20};
-	uint8_t filterProfileId = 1; // Default medium (1) as this is the most common encoder resolution and users can go lower or higher if required.
-	const float filter_f = 1000; // 1khz
-	const int32_t intFxClip = 20000;
-	uint8_t damperIntensity = 30;
-
-	uint8_t frictionIntensity = 0;
-	uint8_t inertiaIntensity = 0;
-
+	const std::array<biquad_constant_t,4> filterSpeedCst = { {{ 40, 55 }, { 70, 55 }, { 120, 55 }, {180, 55}} }; //!< Speed filter profiles.
+	const std::array<biquad_constant_t,4> filterAccelCst = { {{ 40, 30 }, { 55, 30 }, { 70, 30 }, {120, 55}} }; //!< Acceleration filter profiles.
+	const biquad_constant_t filterDamperCst = {60, 55};     //!< Damper filter constants.
+	const biquad_constant_t filterFrictionCst = {50, 20};   //!< Friction filter constants.
+	const biquad_constant_t filterInertiaCst = {20, 20};    //!< Inertia filter constants.
+	uint8_t filterProfileId = 1; //!< Currently selected filter profile ID.
+	float filter_f = 1000.0; // 1khz
+	const int32_t internalFxClip = 20000; //!< Clipping value for internal effects.
+
+	// Internal effects intensity
+	uint8_t damperIntensity = 30;	//!< Intensity of the internal damper effect.
+	uint8_t frictionIntensity = 0;	//!< Intensity of the internal friction effect.
+	uint8_t inertiaIntensity = 0;	//!< Intensity of the internal inertia effect.
+
+	// Biquad filter instances
 	Biquad speedFilter = Biquad(BiquadType::lowpass, filterSpeedCst[filterProfileId].freq/filter_f, filterSpeedCst[filterProfileId].q/100.0, 0.0);
 	Biquad accelFilter = Biquad(BiquadType::lowpass, filterAccelCst[filterProfileId].freq/filter_f, filterAccelCst[filterProfileId].q/100.0, 0.0);
-	Biquad damperFilter = Biquad(BiquadType::lowpass, filterDamperCst.freq/filter_f, filterDamperCst.q / 100.0, 0.0); // enable on class constructor
-	Biquad frictionFilter = Biquad(BiquadType::lowpass, filterFrictionCst.freq/filter_f, filterFrictionCst.q / 100.0, 0.0); // enable on class constructor
-	Biquad inertiaFilter = Biquad(BiquadType::lowpass, filterInertiaCst.freq/filter_f, filterInertiaCst.q / 100.0, 0.0); // enable on class constructor
-
-
-	void setFxRatio(uint8_t val);
-	void updateTorqueScaler();
-
-	void setExpo(int val);
-
-
-	GearRatio_t gearRatio;
-
-	int expoValInt = 0; // expo v = val*2 => v<0 ? 1/-v : v
-	float expo = 1;
-	float expoScaler = 50; // 0.28 to 3.54
-
+	Biquad damperFilter = Biquad(BiquadType::lowpass, filterDamperCst.freq/filter_f, filterDamperCst.q / 100.0, 0.0);
+	Biquad frictionFilter = Biquad(BiquadType::lowpass, filterFrictionCst.freq/filter_f, filterFrictionCst.q / 100.0, 0.0);
+	Biquad inertiaFilter = Biquad(BiquadType::lowpass, filterInertiaCst.freq/filter_f, filterInertiaCst.q / 100.0, 0.0);
+
+	// Post-processing
+	GearRatio_t gearRatio;	//!< Gear ratio between encoder and axis.
+	int expoValue = 0;		//!< Raw integer value for the expo curve. Formula: v = val*2 => v<0 ? 1/-v : v
+	float expo = 1;			//!< Calculated exponent for the torque curve.
+	float expoScaler = 50;	//!< Scaler for the expo calculation : 0.28 to 3.54
 };
 
 #endif /* SRC_AXIS_H_ */
diff --git a/Firmware/FFBoard/Inc/CAN.h b/Firmware/FFBoard/Inc/CAN.h
index d58a31841..06357e6ed 100644
--- a/Firmware/FFBoard/Inc/CAN.h
+++ b/Firmware/FFBoard/Inc/CAN.h
@@ -11,6 +11,7 @@
 #ifdef CANBUS
 //#include "CanHandler.h"
 #include "main.h"
+#include <algorithm>
 #include <vector>
 #include "semaphore.hpp"
 #include <GPIOPin.h>
diff --git a/Firmware/FFBoard/Inc/CmdParser.h b/Firmware/FFBoard/Inc/CmdParser.h
index 48094d3c5..be3221884 100644
--- a/Firmware/FFBoard/Inc/CmdParser.h
+++ b/Firmware/FFBoard/Inc/CmdParser.h
@@ -17,7 +17,9 @@
 #include "CommandHandler.h"
 #include "ringbufferwrapper.h"
 
+#ifndef CMDPARSER_MAX_VALID_CAPACITY
 #define CMDPARSER_MAX_VALID_CAPACITY 2048
+#endif
 
 class CommandHandler;
 class CommandInterface;
diff --git a/Firmware/FFBoard/Inc/CommandHandler.h b/Firmware/FFBoard/Inc/CommandHandler.h
index 0a5cb92a7..71c005a53 100644
--- a/Firmware/FFBoard/Inc/CommandHandler.h
+++ b/Firmware/FFBoard/Inc/CommandHandler.h
@@ -13,7 +13,7 @@
 #include "mutex.hpp"
 #include "ClassIDs.h"
 #include <vector>
-
+#include <span>
 
 #define CMDFLAG_GET	 	0x01
 #define CMDFLAG_SET	 	0x02
@@ -22,6 +22,7 @@
 #define CMDFLAG_SETADR	 	0x20
 #define CMDFLAG_HIDDEN	 0x40
 #define CMDFLAG_DEBUG	 0x80
+#define CMDFLAG_EXTOVERRIDE 0x80000000
 
 #define CMDFLAG_STR_ONLY 0x100
 #define CMDFLAG_HID_ONLY 0x200 // Command not available for string based parsers
@@ -50,8 +51,8 @@ class CmdHandlerCommanddef
 	  {};
 	const char* cmd = nullptr;
 	const char* helpstring = nullptr;
-	const uint32_t cmdId;
-	const uint32_t flags;
+	uint32_t cmdId;
+	uint32_t flags;
 };
 
 struct CmdHandlerInfo
@@ -260,17 +261,22 @@ class CommandHandler {
 	 */
 	template<typename ID>
 	void registerCommand(const char* cmd,const ID cmdid,const char* help=nullptr,uint32_t flags = 0){
-		for(CmdHandlerCommanddef& cmdDef : registeredCommands){
-			if(cmdDef.cmdId == static_cast<uint32_t>(cmdid))
-				return; //already present
-		}
+		registerCommand_INT(cmd, static_cast<uint32_t>(cmdid), help, flags);
+	}
 
-		this->registeredCommands.emplace_back(cmd, help,static_cast<uint32_t>(cmdid),flags);
-		this->registeredCommands.shrink_to_fit();
+
+	virtual void postCmdhandlerInit(){}; // Can implement in external file to override command flags
+	template<typename ID>
+	/**
+	 * Can override command flags to make it read only
+	 */
+	void overrideCommandFlags(const ID cmdid,uint32_t flagmask = 0){
+		overrideCommandFlags_INT(static_cast<uint32_t>(cmdid), flagmask);
 	}
 
 
 
+
 protected:
 	void setInstance(uint8_t instance);
 	bool commandsEnabled = true;
@@ -287,6 +293,9 @@ class CommandHandler {
 
 	CmdHandlerInfo cmdHandlerInfo;
 
+	void registerCommand_INT(const char* cmd,const uint32_t cmdid,const char* help=nullptr,uint32_t flags = 0);
+	void overrideCommandFlags_INT(const uint32_t cmdid,uint32_t flagmask = CMDFLAG_GET | CMDFLAG_GETADR);
+
 };
 
 #endif /* COMMANDHANDLER_H_ */
diff --git a/Firmware/FFBoard/Inc/CommandInterface.h b/Firmware/FFBoard/Inc/CommandInterface.h
index d99ec7b92..b70a57da6 100644
--- a/Firmware/FFBoard/Inc/CommandInterface.h
+++ b/Firmware/FFBoard/Inc/CommandInterface.h
@@ -60,7 +60,7 @@ class StringCommandInterface : public CommandInterface{
 	CmdParser parser; // String parser
 };
 
-
+#define CDC_CMD_BUFFER_SIZE (TUD_OPT_HIGH_SPEED ? 4096 : 1024)
 //receives bytes from mainclass. calls its own parser instance, calls global parser thread, passes replies  back to cdc port.
 class CDC_CommandInterface : public StringCommandInterface,public cpp_freertos::Thread{
 public:
@@ -83,7 +83,7 @@ class CDC_CommandInterface : public StringCommandInterface,public cpp_freertos::
 	bool nextFormat = false;
 	std::string sendBuffer;
 	uint32_t bufferLength = 0;
-	const uint32_t maxSendBuffer = 1024; // Max buffered command size before sending immediately
+	const uint32_t maxSendBuffer = CDC_CMD_BUFFER_SIZE; // Max buffered command size before sending immediately
 };
 
 
diff --git a/Firmware/FFBoard/Inc/EffectsCalculator.h b/Firmware/FFBoard/Inc/EffectsCalculator.h
index e065c0335..adec8d5ad 100644
--- a/Firmware/FFBoard/Inc/EffectsCalculator.h
+++ b/Firmware/FFBoard/Inc/EffectsCalculator.h
@@ -27,7 +27,16 @@
 class Axis;
 struct metric_t;
 
-// default effect gains
+enum class ReconFilterMode : uint8_t {
+	NO_RECONSTRUCTION = 0,
+    LINEAR_INTERPOLATION = 1, 	// More responsive, attempts to match the game's signal precisely. Can feel "grainy" if slew rate is high.
+	SPLINE_CUBIC_NATURAL = 2,	// Highest fidelity, smooth curve through last 4 points. More CPU intensive.
+    SPLINE_CUBIC_HERMITE = 3  	// Mixed solution, good fidelity and optimized timing
+};
+
+/**
+ * @brief Default gains for conditional effects.
+ */
 struct effect_gain_t {
 	uint8_t friction = 254;
 	uint8_t spring = 64;
@@ -35,6 +44,9 @@ struct effect_gain_t {
 	uint8_t inertia = 127;
 };
 
+/**
+ * @brief Scaler values for conditional effects to adjust their intensity.
+ */
 struct effect_scaler_t {
 	float friction = 1.0; //0.4 * 40;
 	float spring = 16.0;
@@ -42,6 +54,9 @@ struct effect_scaler_t {
 	float inertia = 2.0;//0.5 * 40;
 };
 
+/**
+ * @brief Biquad filter coefficients for various effects.
+ */
 struct effect_biquad_t {
 	biquad_constant_t constant	= { 500, 70 };
 	biquad_constant_t friction 	= { 50, 20 };
@@ -49,10 +64,13 @@ struct effect_biquad_t {
 	biquad_constant_t inertia	= { 15, 20 };
 };
 
+/**
+ * @brief Statistics for each effect type.
+ */
 struct effect_stat_t {
-	std::array<int16_t,MAX_AXIS> current={0};
-	std::array<int16_t,MAX_AXIS> max={0};
-	uint16_t nb=0;
+	std::array<int16_t,MAX_AXIS> current={0}; //!< Current force value.
+	std::array<int16_t,MAX_AXIS> max={0};     //!< Maximum force value since reset.
+	uint16_t nb=0;                           //!< Number of times this effect has been used.
 };
 
 enum class EffectsCalculator_commands : uint32_t {
@@ -60,8 +78,13 @@ enum class EffectsCalculator_commands : uint32_t {
 	damper_f, damper_q, friction_f, friction_q, inertia_f, inertia_q, filterProfileId,
 	frictionPctSpeedToRampup,
 	monitorEffect, effectsDetails, effectsForces,
+	reconFilterMode
 };
 
+/**
+ * @brief This class is responsible for calculating the forces of all active FFB effects.
+ * It runs in its own thread to perform the calculations.
+ */
 class EffectsCalculator: public PersistentStorage,
 						 public CommandHandler,
 						 cpp_freertos::Thread {
@@ -69,94 +92,288 @@ class EffectsCalculator: public PersistentStorage,
 	EffectsCalculator();
 	virtual ~EffectsCalculator();
 
-	static ClassIdentifier info;
+	static ClassIdentifier info; //!< Static class identifier.
+	/**
+	 * @brief Returns the class identifier.
+	 * @return The class identifier.
+	 */
 	const ClassIdentifier getInfo();
 	const ClassType getClassType() override {return ClassType::Internal;};
 
-	void saveFlash();
-	void restoreFlash();
+	/**
+	 * @brief Saves effect settings to flash memory.
+	 * @override from PersistentStorage
+	 */
+	void saveFlash() override;
 
+	/**
+	 * @brief Restores effect settings from flash memory.
+	 * @override from PersistentStorage
+	 */
+	void restoreFlash() override;
+
+	/**
+	 * @brief Checks if the effects calculator is active.
+	 * @return true if active, false otherwise.
+	 */
 	bool isActive();
+
+	/**
+	 * @brief Sets the active state of the effects calculator.
+	 * @param active The new active state.
+	 */
 	void setActive(bool active);
+
+	/**
+	 * @brief This is the main calculation method. It iterates through all active effects and sums up the forces for each axis.
+	 * @param axes A reference to the vector of axes.
+	 */
 	void calculateEffects(std::vector<std::unique_ptr<Axis>> &axes);
+
+	/**
+	 * @brief Sets the filters for a specific effect.
+	 * @param effect A pointer to the effect.
+	 */
 	virtual void setFilters(FFB_Effect* effect);
+
+	/**
+	 * @brief Sets the global gain for all effects.
+	 * @param gain The new gain value.
+	 */
 	void setGain(uint8_t gain);
+
+	/**
+	 * @brief Gets the global gain.
+	 * @return The current global gain value.
+	 */
 	uint8_t getGain();
+
+	/**
+	 * @brief Logs the usage of an effect type for statistics.
+	 * @param type The effect type.
+	 * @param remove True to decrement the usage count, false to increment.
+	 */
 	void logEffectType(uint8_t type,bool remove = false);
-	//void setDirectionEnableMask(uint8_t mask);
-	void calcStatsEffectType(uint8_t type, int16_t force,uint8_t axis);
+
+	/**
+	 * @brief Calculates and stores statistics for a given effect type.
+	 * @param type The effect type.
+	 * @param force The calculated force.
+	 * @param axis The axis index.
+	 */
+	void calcStatsEffectType(uint8_t type, int32_t force,uint8_t axis);
+
+	/**
+	 * @brief Logs the state of an effect (start/stop).
+	 * @param type The effect type.
+	 * @param state The new state.
+	 */
 	void logEffectState(uint8_t type,uint8_t state);
+
+	/**
+	 * @brief Resets the statistics of active effects.
+	 * @param reinit If true, re-initializes the stats based on currently active effects.
+	 */
 	void resetLoggedActiveEffects(bool reinit);
 
+	/**
+	 * @brief Finds a free slot for a new effect.
+	 * @param type The type of the effect.
+	 * @return The index of the free slot, or -1 if no slot is available.
+	 */
 	int32_t find_free_effect(uint8_t type);
+
+	/**
+	 * @brief Frees an effect slot.
+	 * @param idx The index of the effect to free.
+	 */
 	void free_effect(uint16_t idx);
 
-	CommandStatus command(const ParsedCommand& cmd,std::vector<CommandReply>& replies);
+	/**
+     * @brief Met à jour les tampons d'interpolation pour un effet non-conditionnel.
+     * Appelé par le handler HID (ex: 60Hz).
+     * @param effect Pointeur vers l'effet à modifier.
+     * @param new_magnitude Nouvelle magnitude/amplitude cible.
+     * @param new_offset Nouvel offset cible (utilisé uniquement si is_periodic est true).
+     * @param is_periodic Si true, met à jour les deux tampons (mag + offset).
+     */
+    void pushReconFilterValue(FFB_Effect* effect, float new_magnitude, float new_offset, bool is_periodic);
+
+	/**
+	 * @brief Handles command line interface commands for the effects calculator.
+	 * @param cmd The parsed command.
+	 * @param replies A vector of replies to be sent back.
+	 * @return The status of the command execution.
+	 * @override from CommandHandler
+	 */
+	CommandStatus command(const ParsedCommand& cmd,std::vector<CommandReply>& replies) override;
 	virtual std::string getHelpstring() { return "Controls internal FFB effects"; }
 
 	static const uint32_t max_effects = MAX_EFFECTS;
-	std::array<FFB_Effect,max_effects> effects; // Main effects storage
+	std::array<FFB_Effect,max_effects> effects; //!< Main effects storage array.
+
+	/**
+	 * @brief The main loop for the effects calculator thread.
+	 * @override from cpp_freertos::Thread
+	 */
+	void Run() override;
 
-	// Thread impl
-	void Run();
+	void updateSamplerate(float newSamplerate); // Must be called if update rate is changed to update filters and effects
 
 
 protected:
 
 private:
-	//uint8_t directionEnableMask = 0;
 	// Filters
-	effect_biquad_t filter[2];		// 0 is the default profile and the custom for CFFilter, CUSTOM_PROFILE_ID is the custom slot
-	uint8_t filterProfileId = 0;
-	const uint32_t calcfrequency = 1000; 		// HID frequency 1khz
-	const float qfloatScaler = 0.01;
+	effect_biquad_t filter[2];		//!< Filter coefficients for CFFilter, default (0) and custom (1) profiles.
+	uint8_t filterProfileId = 0;	//!< Currently active filter profile (0 or 1).
+	uint32_t calcfrequency = 1000; //!< Calculation frequency in Hz (matches HID rate 1khz).
+	const float qfloatScaler = 0.01;	 //!< Scaler for Q factor.
 
-	// Rescale factor for conditional effect to boost or decrease the intensity
-	uint8_t global_gain = 0xff;
-	effect_gain_t gain;
-	effect_scaler_t scaler;
-	uint8_t frictionPctSpeedToRampup = 25;	// define the max value of the range (0..5% of maxspeed) where torque is rampup on friction
+	// Gains and scalers
+	uint8_t global_gain = 0xff;		//!< Global gain for all effects.
+	effect_gain_t gain;				//!< Per-effect type gains.
+	effect_scaler_t scaler;			//!< Per-effect type intensity scalers.
+	uint8_t frictionPctSpeedToRampup = 25;	//!< Speed percentage for friction ramp-up. : define the max value of the range (0..5% of maxspeed) where torque is rampup on friction
 
 	// FFB status
-	bool effects_active = false; // If FFB is on
-	uint32_t effects_used = 0;
-	std::array<effect_stat_t,12> effects_stats; // [0..12 effect types]
-	std::array<effect_stat_t,12> effects_statslast; // [0..12 effect types]
-	bool isMonitorEffect = false;
+	bool effects_active = false;	//!< True if FFB is globally active.
+	uint32_t effects_used = 0;		//!< Bitmask of effect types used since reset.
+	std::array<effect_stat_t,12> effects_stats; //!< Statistics for each effect type, [0..12 effect types].
+	std::array<effect_stat_t,12> effects_statslast; //!< Statistics from the previous cycle, [0..12 effect types].
+	bool isMonitorEffect = false;	//!< Flag to enable effect monitoring.
+
+	// Reconstruction filter
+	ReconFilterMode reconFilterMode = ReconFilterMode::NO_RECONSTRUCTION;	//!< Current reconstruction filter mode.
+
+	/**
+	 * @brief Internal method to push a new value into the reconstruction filter.
+	 * @param state Pointer to the reconstruction filter state.
+	 * @param newValue The new value to push into the filter.
+	 */
+	void pushReconParam(ReconFilterState* state, float newValue);
+
+	/**
+	 * @brief Retrieves the value from the linear reconstruction filter.
+	 * @param state Pointer to the reconstruction filter state.
+	 * @param fallbackValue Value to return if the filter is not ready.
+	 * @return The interpolated value from the filter.
+	 */
+	float getReconstructedvalue(ReconFilterState* state, float fallbackValue);
+
+	/**
+	 * @brief Calculates the force for a single component of an effect on a specific axis.
+	 * Dispatches between conditional and non-conditional effects.
+	 */
+	int32_t calculateEffectForceOnAxis(FFB_Effect *effect, int32_t forceVector, std::vector<std::unique_ptr<Axis>> &axes, uint8_t axis);
 
-	int32_t calcComponentForce(FFB_Effect *effect, int32_t forceVector, std::vector<std::unique_ptr<Axis>> &axes, uint8_t axis);
+	/**
+	 * @brief Calculates the base force for non-conditional effects (Constant, Ramp, Periodic).
+	 */
 	int32_t calcNonConditionEffectForce(FFB_Effect* effect);
+
+	/**
+	 * @brief Calculates the speed threshold for friction ramp-up.
+	 */
 	float speedRampupPct();
+
+	/**
+	 * @brief Calculates the force for conditional effects (Spring, Damper, Inertia, Friction).
+	 */
 	int32_t calcConditionEffectForce(FFB_Effect *effect, float metric, uint8_t gain, uint8_t idx, float scale, float angle_ratio);
-	int32_t getEnvelopeMagnitude(FFB_Effect *effect);
+
+	/**
+	 * @brief Calculates the magnitude of an effect with an envelope.
+	 */
+	int32_t getEnvelopeMagnitude(FFB_Effect *effect, int32_t baseMagnitude);
+
+	/**
+	 * @brief Generates a string listing the effects used.
+	 */
 	std::string listEffectsUsed(bool details = false,uint8_t axis = 0);
-	//std::string listForceEffects();
+
+	/**
+	 * @brief Validates and sanitizes filter coefficients.
+	 */
 	void checkFilterCoeff(biquad_constant_t *filter, uint32_t freq,uint8_t q);
+
+	/**
+	 * @brief Updates the filters for all active effects of a specific type.
+	 */
 	void updateFilterSettingsForEffects(uint8_t type_effect);
 };
 
 /**
  * Helper interface class for common effects calculator related control functions
  */
+/**
+ * @brief Helper interface class for common effects calculator related control functions.
+ * This class provides a common interface for controlling FFB effects.
+ */
 class EffectsControlItf{
 public:
-	virtual void set_FFB(bool state) = 0; // Enables or disables FFB
+	/**
+	 * @brief Enables or disables FFB.
+	 * @param state The new state of the FFB.
+	 */
+	virtual void set_FFB(bool state) = 0;
+
+	/**
+	 * @brief Stops the FFB.
+	 */
 	virtual void stop_FFB(){set_FFB(false);};
+
+	/**
+	 * @brief Starts the FFB.
+	 */
 	virtual void start_FFB(){set_FFB(true);};
+
+	/**
+	 * @brief Resets all FFB effects.
+	 */
 	virtual void reset_ffb() = 0;
-	virtual uint32_t getConstantForceRate(); // Returns an estimate of the constant force effect update rate in hz
-	virtual uint32_t getRate(); // Returns an estimate of the overall effect update speed in hz
+
+	/**
+	 * @brief Returns an estimate of the constant force effect update rate in Hz.
+	 * @return The estimated update rate.
+	 */
+	virtual uint32_t getConstantForceRate();
+
+	/**
+	 * @brief Returns an estimate of the overall effect update speed in Hz.
+	 * @return The estimated update rate.
+	 */
+	virtual uint32_t getRate();
+
+	/**
+	 * @brief Checks if FFB is active.
+	 * @return true if FFB is active, false otherwise.
+	 */
 	virtual bool getFfbActive() = 0;
+
+	/**
+	 * @brief Sets the global gain for all effects.
+	 * @param gain The new gain value.
+	 */
 	virtual void set_gain(uint8_t gain) = 0;
+
+	/**
+	 * @brief To be called when a constant force update event occurs. Used for rate calculation.
+	 */
 	virtual void cfUpdateEvent();
+
+	/**
+	 * @brief To be called when any FFB update event occurs. Used for rate calculation.
+	 */
 	virtual void fxUpdateEvent();
+	virtual void updateSamplerate(float newSamplerate) = 0; // Should be called when update loop rate is changed
 
 private:
-	FastMovingAverage<float> fxPeriodAvg{20};
-	FastMovingAverage<float> cfUpdatePeriodAvg{20};
+	FastMovingAverage<float> fxPeriodAvg{5};
+	FastMovingAverage<float> cfUpdatePeriodAvg{5};
 
-	uint32_t lastFxUpdate = 0;
-	uint32_t lastCfUpdate = 0;
+	uint32_t lastFxUpdate = 0;	//!< Timestamp of the last FFB update.
+	uint32_t lastCfUpdate = 0;	//!< Timestamp of the last constant force update.
 };
 
 #endif /* EFFECTSCALCULATOR_H_ */
diff --git a/Firmware/FFBoard/Inc/Filters.h b/Firmware/FFBoard/Inc/Filters.h
index 83a31bf17..92c2a7959 100644
--- a/Firmware/FFBoard/Inc/Filters.h
+++ b/Firmware/FFBoard/Inc/Filters.h
@@ -2,13 +2,17 @@
  * Filters.h
  *
  *  Created on: Feb 13, 2020
- *      Author: Yannick
+ *      Author: Yannick, Vincent
  */
 
 #ifndef FILTERS_H_
 #define FILTERS_H_
 #include "cppmain.h"
 
+#ifdef USE_DSP_FUNCTIONS
+#include "arm_math.h"
+#endif
+
 #ifdef __cplusplus
 
 // Frequency in hz, q in float q*100. Example: Q 0.5 -> 50
@@ -40,14 +44,27 @@ class Biquad{
     float getFc() const;
     void setQ(float Q);
     float getQ() const;
+    void setPeakGain(float peakGainDB);
     void calcBiquad(void);
 
-protected:
+#ifdef USE_DSP_FUNCTIONS
+    const float* getCoeffs() const { return pCoeffs; }
+#endif
 
+protected:
     BiquadType type;
-    float a0, a1, a2, b1, b2;
     float Fc, Q, peakGain;
+
+#ifdef USE_DSP_FUNCTIONS
+    // CMSIS-DSP instance
+    arm_biquad_casd_df1_inst_f32 S;
+    float32_t pCoeffs[5];
+    float32_t pState[4]; // For a single biquad stage (DF1 float requires 4 states)
+#else
     float z1, z2;
+    float a0, a1, a2, b1, b2;
+#endif
+
 };
 
 
diff --git a/Firmware/FFBoard/Inc/HidFFB.h b/Firmware/FFBoard/Inc/HidFFB.h
index 28ddc6707..bb0d0cfcd 100644
--- a/Firmware/FFBoard/Inc/HidFFB.h
+++ b/Firmware/FFBoard/Inc/HidFFB.h
@@ -20,53 +20,184 @@
 #define Z_AXIS_ENABLE 4
 #define DIRECTION_ENABLE(AXES) (1 << AXES)
 
+/**
+ * @brief This class handles the Force Feedback (FFB) HID communication.
+ * It inherits from UsbHidHandler to process HID reports and from EffectsControlItf to control FFB effects.
+ * It is responsible for parsing HID FFB reports from the host and managing the lifecycle of FFB effects.
+ */
 class HidFFB: public UsbHidHandler, public EffectsControlItf {
 public:
+	/**
+	 * @brief Construct a new HidFFB object.
+	 * @param ec A shared pointer to the EffectsCalculator instance.
+	 * @param axisCount The number of axes to be controlled.
+	 */
 	HidFFB(std::shared_ptr<EffectsCalculator> ec,uint8_t axisCount);
 	virtual ~HidFFB();
 
+	/**
+	 * @brief Handles outgoing HID reports from the host (PC -> Device). This is the main entry point for FFB commands.
+	 * @param report_id The report ID.
+	 * @param report_type The type of the report.
+	 * @param buffer A pointer to the report data.
+	 * @param bufsize The size of the report data.
+	 * @override from UsbHidHandler
+	 */
 	void hidOut(uint8_t report_id, hid_report_type_t report_type,const uint8_t* buffer, uint16_t bufsize) override;
+
+	/**
+	 * @brief Handles incoming HID GET_FEATURE requests from the host (Device -> PC).
+	 * Used for status reports like block load and PID pool.
+	 * @param report_id The report ID.
+	 * @param report_type The type of the report.
+	 * @param buffer A pointer to the buffer where the report data should be stored.
+	 * @param reqlen The requested length of the report.
+	 * @return The actual length of the report.
+	 * @override from UsbHidHandler
+	 */
 	uint16_t hidGet(uint8_t report_id, hid_report_type_t report_type,uint8_t* buffer, uint16_t reqlen) override;
 
-	bool getFfbActive();
+	/**
+	 * @brief Checks if the FFB is active.
+	 * @return true if FFB is active, false otherwise.
+	 * @override from EffectsControlItf
+	 */
+	bool getFfbActive() override;
+
+	/**
+	 * @brief Sends a HID report to the host.
+	 * @param report A pointer to the report data.
+	 * @param len The length of the report data.
+	 * @return true if the report was sent successfully, false otherwise.
+	 */
 	static bool HID_SendReport(uint8_t *report,uint16_t len);
 
-	void reset_ffb();
-	void start_FFB();
-	void stop_FFB();
-	void set_FFB(bool state);
-	void set_gain(uint8_t gain);
+	/**
+	 * @brief Resets all FFB effects.
+	 * @override from EffectsControlItf
+	 */
+	void reset_ffb() override;
+
+	/**
+	 * @brief Starts the FFB.
+	 * @override from EffectsControlItf
+	 */
+	void start_FFB() override;
+
+	/**
+	 * @brief Stops the FFB.
+	 * @override from EffectsControlItf
+	 */
+	void stop_FFB() override;
+
+	/**
+	 * @brief Sets the FFB state (active/inactive).
+	 * @param state The new state of the FFB.
+	 * @override from EffectsControlItf
+	 */
+	void set_FFB(bool state) override;
+
+	/**
+	 * @brief Sets the global gain for all FFB effects.
+	 * @param gain The new gain value (0-255).
+	 * @override from EffectsControlItf
+	 */
+	void set_gain(uint8_t gain) override;
 	
+	/**
+	 * @brief Sends a status report for a specific effect to the host.
+	 * @param effect The ID of the effect.
+	 */
 	void sendStatusReport(uint8_t effect);
+
+	/**
+	 * @brief Sets the direction enable mask for the axes.
+	 * This mask determines how direction parameters in HID reports are interpreted.
+	 * @param mask The new direction enable mask.
+	 */
 	void setDirectionEnableMask(uint8_t mask);
+	void updateSamplerate(float newSamplerate);
 
 private:
-	// HID
-	std::shared_ptr<EffectsCalculator> effects_calc;
-	std::array<FFB_Effect,EffectsCalculator::max_effects>& effects; // Must be passed in constructor
+	// HID processing methods
+	std::shared_ptr<EffectsCalculator> effects_calc; //!< A shared pointer to the EffectsCalculator instance.
+	std::array<FFB_Effect,EffectsCalculator::max_effects>& effects; //!< A reference to the array of FFB effects, managed by EffectsCalculator, Must be passed in constructor.
+
+	/**
+	 * @brief Handles the "Create New Effect" HID report. Allocates a new effect.
+	 * @param effect Pointer to the HID report data.
+	 */
 	void new_effect(FFB_CreateNewEffect_Feature_Data_t* effect);
+
+	/**
+	 * @brief Frees an effect slot. This is called when a HID_ID_BLKFRREP is received.
+	 * @param id The block index of the effect to free.
+	 */
 	void free_effect(uint16_t id);
+
+	/**
+	 * @brief Handles FFB control commands (Enable, Disable, Stop, Reset, etc.).
+	 * @param cmd The control command byte.
+	 */
 	void ffb_control(uint8_t cmd);
+
+	/**
+	 * @brief Handles the "Set Effect" HID report. Configures a previously created effect.
+	 * @param effect Pointer to the HID report data.
+	 */
 	void set_effect(FFB_SetEffect_t* effect);
+
+	/**
+	 * @brief Handles the "Set Condition" HID report (Spring, Damper, Friction, Inertia).
+	 * @param cond Pointer to the HID report data.
+	 */
 	void set_condition(FFB_SetCondition_Data_t* cond);
+
+	/**
+	 * @brief Handles the "Set Envelope" HID report.
+	 * @param report Pointer to the HID report data.
+	 */
 	void set_envelope(FFB_SetEnvelope_Data_t* report);
+
+	/**
+	 * @brief Handles the "Set Ramp" HID report.
+	 * @param report Pointer to the HID report data.
+	 */
 	void set_ramp(FFB_SetRamp_Data_t* report);
+
+	/**
+	 * @brief Handles the "Set Constant Force" HID report.
+	 * @param effect Pointer to the HID report data.
+	 */
 	void set_constant_effect(FFB_SetConstantForce_Data_t* effect);
+
+	/**
+	 * @brief Handles the "Set Periodic" HID report (Sine, Square, etc.).
+	 * @param report Pointer to the HID report data.
+	 */
 	void set_periodic(FFB_SetPeriodic_Data_t* report);
-	void set_effect_operation(FFB_EffOp_Data_t* report);
 
+	/**
+	 * @brief Handles the "Effect Operation" HID report (Start, Stop, Start Solo).
+	 * @param report Pointer to the HID report data.
+	 */
+	void set_effect_operation(FFB_EffOp_Data_t* report);
 
+	/**
+	 * @brief Sets the default filters for a new effect based on its type.
+	 * @param effect Pointer to the effect to configure.
+	 */
 	void set_filters(FFB_Effect* effect);
 
-	uint8_t directionEnableMask; // Has to be adjusted if bit is not last bit after axis enable bits
-	uint16_t used_effects = 0;
-	bool ffb_active = false;
-	FFB_BlockLoad_Feature_Data_t blockLoad_report;
-	FFB_PIDPool_Feature_Data_t pool_report;
+	uint8_t directionEnableMask; //!< Mask to enable/disable directions for axes. Adjusted based on axis count.
+	uint16_t used_effects = 0; //!< The number of currently active effects.
+	bool ffb_active = false; //!< Flag indicating if FFB is globally active.
+	FFB_BlockLoad_Feature_Data_t blockLoad_report; //!< HID report structure for block load status.
+	FFB_PIDPool_Feature_Data_t pool_report; //!< HID report structure for PID pool status.
 
-	reportFFB_status_t reportFFBStatus;
+	reportFFB_status_t reportFFBStatus; //!< HID report structure for general FFB status.
 
-	uint8_t axisCount;
+	uint8_t axisCount; //!< The number of axes supported by this FFB instance.
 };
 
 #endif /* HIDFFB_H_ */
diff --git a/Firmware/FFBoard/Inc/MotorDriver.h b/Firmware/FFBoard/Inc/MotorDriver.h
index 0446ac3ba..b643a66ac 100644
--- a/Firmware/FFBoard/Inc/MotorDriver.h
+++ b/Firmware/FFBoard/Inc/MotorDriver.h
@@ -2,12 +2,14 @@
  * MotorDriver.h
  *
  *  Created on: Feb 1, 2020
- *      Author: Yannick
+ *      Author: Yannick, Vincent
  */
 
 #ifndef MOTORDRIVER_H_
 #define MOTORDRIVER_H_
 
+#define MAX_SLEW_RATE 65535
+
 #include "cppmain.h"
 #include "ChoosableClass.h"
 #include "PersistentStorage.h"
@@ -25,11 +27,32 @@ class MotorDriver : public ChoosableClass{
 	const ClassType getClassType() override {return ClassType::Motordriver;};
 	static const std::vector<class_entry<MotorDriver>> all_drivers;
 
+	virtual void setupDriver();
 	virtual void turn(int16_t power);
 	virtual void stopMotor();
 	virtual void startMotor();
 	virtual void emergencyStop(bool reset = false);
 
+	virtual void setPowerLimit(uint16_t power){}; // specific motor driver manager power, this is used to send powerLimit to the driver, like TMC4671.
+	
+	// 
+	/**
+	 * Slew rate calibration interface (no-op by default)
+	 * If driver can't calibration the max slew rate will by MAX_SLEW_RATE (65535)
+	 * @return false is the driver not implemented this process or true if calibration start
+	 */
+	virtual bool startSlewRateCalibration() { return false; };
+	/**
+	 * Check if calibration is in process
+	 * @return the state of calibration process
+	 */
+	virtual bool isSlewRateCalibrationInProgress() { return false; };
+	/**
+	 * Get the value of the Slew Rate after a calibration
+	 * @return 
+	 */
+	virtual uint16_t getDrvSlewRate() { return MAX_SLEW_RATE; };
+	
 	virtual bool motorReady(); // Returns true if the driver is active and ready to receive commands
 
 	virtual Encoder* getEncoder(); // Encoder is managed by the motor driver. Must always return an encoder
diff --git a/Firmware/FFBoard/Inc/SPI.h b/Firmware/FFBoard/Inc/SPI.h
index b1a063f79..0f6afedfe 100644
--- a/Firmware/FFBoard/Inc/SPI.h
+++ b/Firmware/FFBoard/Inc/SPI.h
@@ -14,6 +14,7 @@
 
 #include "SpiHandler.h"
 #include "semaphore.hpp"
+#include <math.h>
 
 struct SPIConfig {
 	SPIConfig(OutputPin cs,bool cspol = true)
@@ -77,7 +78,7 @@ class SPIPort: public SpiHandler {
 	bool hasFreePins();
 
 	uint32_t getBaseClk();
-	std::pair<uint32_t,float> getClosestPrescaler(float clock);
+	std::pair<uint32_t,float> getClosestPrescaler(float clock,float min = 0, float max = INFINITY);
 
 	SPI_HandleTypeDef* getPortHandle();
 
diff --git a/Firmware/FFBoard/Inc/SerialFFB.h b/Firmware/FFBoard/Inc/SerialFFB.h
index e16cfc1a7..9ec6e26be 100644
--- a/Firmware/FFBoard/Inc/SerialFFB.h
+++ b/Firmware/FFBoard/Inc/SerialFFB.h
@@ -37,6 +37,7 @@ class SerialFFB : public CommandHandler, public EffectsControlItf{
 	void setMagnitude(uint8_t idx,int16_t magnitude);
 
 	void setEffectState(uint8_t id, bool state);
+	void updateSamplerate(float newSamplerate);
 
 private:
 	static ClassIdentifier info;
diff --git a/Firmware/FFBoard/Inc/SystemCommands.h b/Firmware/FFBoard/Inc/SystemCommands.h
index 46ef39695..ec6118529 100644
--- a/Firmware/FFBoard/Inc/SystemCommands.h
+++ b/Firmware/FFBoard/Inc/SystemCommands.h
@@ -11,7 +11,7 @@
 #include "CommandHandler.h"
 
 enum class FFBoardMain_commands : uint32_t{
-	help=0,save=1,reboot=2,dfu=3,swver=4,hwtype=5,lsmain,main,lsactive,format,errors,errorsclr,flashdump,flashraw,vint,vext,mallinfo,heapfree,taskstats,debug,devid,uid,temp,otp,signature
+	help=0,save=1,reboot=2,dfu=3,swver=4,hwtype=5,lsmain,main,lsactive,format,errors,errorsclr,flashdump,flashraw,vint,vext,mallinfo,heapfree,taskstats,debug,devid,uid,temp,otp,signature,tasklist
 };
 
 class SystemCommands : public CommandHandler {
diff --git a/Firmware/FFBoard/Inc/constants.h b/Firmware/FFBoard/Inc/constants.h
index 8f6724a9e..a80453b77 100644
--- a/Firmware/FFBoard/Inc/constants.h
+++ b/Firmware/FFBoard/Inc/constants.h
@@ -31,11 +31,19 @@ static const uint8_t SW_VERSION_INT[3] = {1,16,5}; // Version as array. 8 bit ea
 
 #ifdef FFBWHEEL
 #ifdef FFBWHEEL_USE_1AXIS_DESC
+#ifdef HIDAXISRES_USE_32B_DESC
+#define AXIS1_FFB_HID_DESC_32B
+#else
 #define AXIS1_FFB_HID_DESC
+#endif
+#else
+#ifdef HIDAXISRES_USE_32B_DESC
+#define AXIS2_FFB_HID_DESC_32B
 #else
 #define AXIS2_FFB_HID_DESC
 #endif
 #endif
+#endif
 
 #ifdef FFBJOYSTICK
 #define AXIS2_FFB_HID_DESC
diff --git a/Firmware/FFBoard/Inc/cpp_target_config.h b/Firmware/FFBoard/Inc/cpp_target_config.h
index fcf4f7ed6..20b898825 100644
--- a/Firmware/FFBoard/Inc/cpp_target_config.h
+++ b/Firmware/FFBoard/Inc/cpp_target_config.h
@@ -47,4 +47,8 @@ extern const OutputPin debugpin;
 extern const OutputPin gpMotor;
 #endif
 
+#if defined(I2C_PORT_EEPROM)
+extern I2CPort i2cport_int;
+#endif
+
 #endif
diff --git a/Firmware/FFBoard/Inc/ffb_defs.h b/Firmware/FFBoard/Inc/ffb_defs.h
index e78b1e6fd..ccce5f402 100644
--- a/Firmware/FFBoard/Inc/ffb_defs.h
+++ b/Firmware/FFBoard/Inc/ffb_defs.h
@@ -96,55 +96,96 @@
 // Only include these for cpp
 #ifdef __cplusplus
 
-// HID gamepad report
-
 
+template<class dtypeaxis>
 struct  __attribute__((__packed__)) reportHID_t {
 		uint8_t id = 1;
 		uint64_t buttons = 0;
+#if MAX_AXIS >= 1
+		dtypeaxis X = 0;
+#else
 		int16_t X = 0;
+#endif
+#if MAX_AXIS >= 2
+		dtypeaxis Y = 0;
+#else
 		int16_t Y = 0;
+#endif
+#if MAX_AXIS >= 3
+		dtypeaxis Z = 0;
+#else
 		int16_t Z = 0;
+#endif
 		int16_t RX = 0;
 		int16_t RY = 0;
 		int16_t RZ = 0;
 		int16_t Dial = 0;
 		int16_t Slider = 0;
 };
-
-/*
- * Helper function to access analog axes in packed HID report struct
+/**
+ * Helper class for double buffered HID gamepad reports to allow use of different datatypes for main axes
+ * Double buffer allows testing if data has changed before sending
  */
-inline void setHidReportAxis(reportHID_t *report, uint8_t idx, int16_t val){
-	switch(idx){
-	case 0:
-		report->X = val;
-		break;
-	case 1:
-		report->Y = val;
-		break;
-	case 2:
-		report->Z = val;
-		break;
-	case 3:
-		report->RX = val;
-		break;
-	case 4:
-		report->RY = val;
-		break;
-	case 5:
-		report->RZ = val;
-		break;
-	case 6:
-		report->Dial = val;
-		break;
-	case 7:
-		report->Slider = val;
-		break;
-	default:
-		return;
+class HID_GamepadReport_base{
+public:
+	virtual void setHidReportAxis(uint8_t idx, uint32_t val) = 0;
+	virtual uint8_t* getBuffer() = 0;
+	virtual uint32_t getLength() = 0;
+	virtual uint64_t getButtons() = 0;
+	virtual void setButtons(uint64_t btn) = 0; //! Must use setter to prevent unaligned access
+	virtual bool changed() = 0;
+	virtual void swap() = 0;
+};
+
+template<class dtypeaxis>
+class HID_GamepadReport : public HID_GamepadReport_base{
+private:
+	reportHID_t<dtypeaxis> report1;
+	reportHID_t<dtypeaxis> report2;
+	reportHID_t<dtypeaxis>* report = &report1;
+
+public:
+	uint64_t getButtons() override {return report->buttons;}
+	void setButtons(uint64_t btn) override {report->buttons = btn;}
+
+	void setHidReportAxis(uint8_t idx, uint32_t val) override {
+		switch(idx){
+		case 0:
+			report->X = val;
+			break;
+		case 1:
+			report->Y = val;
+			break;
+		case 2:
+			report->Z = val;
+			break;
+		case 3:
+			report->RX = val;
+			break;
+		case 4:
+			report->RY = val;
+			break;
+		case 5:
+			report->RZ = val;
+			break;
+		case 6:
+			report->Dial = val;
+			break;
+		case 7:
+			report->Slider = val;
+			break;
+		default:
+			return;
+		}
 	}
-}
+	bool changed() override {return memcmp(&report1,&report2,sizeof(reportHID_t<dtypeaxis>)) != 0;}
+	void swap() override {report = (report == &report1 ? &report2 : &report1);} // Swaps report buffers
+
+	uint32_t getLength() override {return sizeof(reportHID_t<dtypeaxis>);}
+	uint8_t* getBuffer() override {return reinterpret_cast<uint8_t*>(this->report);}
+
+};
+
 
 typedef struct
 {
@@ -154,7 +195,25 @@ typedef struct
 
 } __attribute__((packed)) reportFFB_status_t;
 
-
+/**
+ * @brief Contient l'état et les tampons pour
+ * l'interpolation d'un seul paramètre (ex: magnitude ou offset).
+ */
+typedef struct
+{
+#ifdef USE_DSP_FUNCTIONS
+	float32_t spline_x[4] = {0}; 		// Buffer time(en us)
+	float32_t spline_y[4] = {0}; 		// Buffer value
+	float32_t spline_y2[4] = {0};    	// Buffer for Spline Natural
+	float32_t spline_scratch[8] = {0}; 	// Buffer for Spline Natural
+	arm_spline_instance_f32 spline_instance; // Instance pour CMSIS-DSP
+	bool spline_arm_initialized = false;	 // CMSIS-DSP initialized ?
+#else
+	float spline_x[4] = {0}; 		// Buffer time(en us)
+	float spline_y[4] = {0}; 		// Buffer value
+#endif
+	bool isSplineReady = false;	// Le tampon est-il plein ?
+} ReconFilterState;
 
 typedef struct
 	{
@@ -292,6 +351,9 @@ typedef struct
 	uint16_t samplePeriod = 0;
 	bool useEnvelope = false;
 	bool useSingleCondition = true;
+
+	ReconFilterState recon_magnitude; // State pour Magnitude (ou Amplitude)
+    ReconFilterState recon_offset;    // State pour Offset (périodiques)
 } FFB_Effect;
 
 
diff --git a/Firmware/FFBoard/Inc/flash_helpers.h b/Firmware/FFBoard/Inc/flash_helpers.h
index a409a48fe..09fab245d 100644
--- a/Firmware/FFBoard/Inc/flash_helpers.h
+++ b/Firmware/FFBoard/Inc/flash_helpers.h
@@ -2,7 +2,7 @@
  * flash_helpers.h
  *
  *  Created on: 31.01.2020
- *      Author: Yannick
+ *      Author: Yannick, Vincent
  */
 
 #ifndef FLASH_HELPERS_H_
@@ -23,6 +23,7 @@ extern "C" {
 
 #include <tuple>
 #include <vector>
+#include <span>
 
 bool Flash_Init();
 bool Flash_Write(uint16_t adr,uint16_t dat); // Writes or updates only if changed or missing
@@ -31,6 +32,11 @@ bool Flash_ReadWriteDefault(uint16_t adr,uint16_t *buf,uint16_t def); // returns
 void Flash_Dump(std::vector<std::tuple<uint16_t,uint16_t>> *result,bool includeAll = false);
 bool Flash_Format();
 
+#ifdef COGGING_TABLE_FLASH_START_ADDRESS
+bool Flash_WriteCoggingTable(uint8_t table_idx, int16_t* data);
+bool Flash_ReadCoggingTable(uint8_t table_idx, int16_t* data);
+#endif
+
 bool OTP_Write(uint16_t adroffset,uint64_t dat);
 bool OTP_Read(uint16_t adroffset,uint64_t* dat);
 
@@ -58,4 +64,7 @@ inline std::tuple<uint8_t, uint8_t> unpack(uint16_t v) {
 
 #endif
 
+extern const std::span<const std::pair<uint16_t,uint16_t>> flash_factory_defaults; // address,value pair
+void Flash_Write_Defaults();
+
 #endif /* FLASH_HELPERS_H_ */
diff --git a/Firmware/FFBoard/Inc/ringbufferwrapper.h b/Firmware/FFBoard/Inc/ringbufferwrapper.h
index 2ba46b8c8..99eef8caf 100644
--- a/Firmware/FFBoard/Inc/ringbufferwrapper.h
+++ b/Firmware/FFBoard/Inc/ringbufferwrapper.h
@@ -57,7 +57,7 @@ T RingBufferWrapper::peek_as(bool* ok) noexcept
    T data;
    // Only POD types can be trivially copied from
    // the ring buffer.
-   if (!std::is_pod<T>::value) {
+   if (!std::is_standard_layout<T>::value && !std::is_trivial<T>::value) {
       *ok = false;
       return data;
    }
diff --git a/Firmware/FFBoard/Src/AxesManager.cpp b/Firmware/FFBoard/Src/AxesManager.cpp
index dd1edd726..c2855fe11 100644
--- a/Firmware/FFBoard/Src/AxesManager.cpp
+++ b/Firmware/FFBoard/Src/AxesManager.cpp
@@ -102,19 +102,25 @@ bool AxesManager::setAxisCount(int8_t count) {
 }
 
 void AxesManager::usbSuspend() {
-		for (auto &axis : axes) {
-			axis->usbSuspend();
-		}
+	for (auto &axis : axes) {
+		axis->usbSuspend();
+	}
 }
 
 void AxesManager::usbResume() {
-		for (auto &axis : axes) {
-			axis->usbResume();
-		}
+	for (auto &axis : axes) {
+		axis->usbResume();
+	}
 }
 
 void AxesManager::resetPosZero() {
-		for (auto &axis : axes) {
-			axis->setPos(0);
-		}
+	for (auto &axis : axes) {
+		axis->setPos(0);
+	}
+}
+
+void AxesManager::updateSamplerate(float newSamplerate){
+	for (auto &axis : axes) {
+		axis->updateSamplerate(newSamplerate);
+	}
 }
diff --git a/Firmware/FFBoard/Src/Axis.cpp b/Firmware/FFBoard/Src/Axis.cpp
index f5394a296..90aacf662 100644
--- a/Firmware/FFBoard/Src/Axis.cpp
+++ b/Firmware/FFBoard/Src/Axis.cpp
@@ -2,17 +2,33 @@
  * Axis.cpp
  *
  *  Created on: 31.01.2020
- *      Author: Yannick
+ *      Author: Yannick, Vincent
+ * 		
  */
 
 #include "Axis.h"
 #include "voltagesense.h"
+#include "critical.hpp"
+
+// Load the driver is they are declared in targer_constants.h
+#ifdef TMC4671DRIVER
 #include "TMC4671.h"
+#endif
+#ifdef PWMDRIVER
 #include "MotorPWM.h"
-#include "VescCAN.h"
+#endif
+#ifdef ODRIVE
 #include "ODriveCAN.h"
+#endif
+#ifdef VESC
+#include "VescCAN.h"
+#endif
+#ifdef SIMPLEMOTION
 #include "MotorSimplemotion.h"
+#endif
+#ifdef RMDCAN
 #include "RmdMotorCAN.h"
+#endif
 
 //////////////////////////////////////////////
 /*
@@ -85,39 +101,50 @@ const std::vector<class_entry<MotorDriver>> Axis::axis2_drivers =
 /**
  * Axis class manages motor drivers and passes effect torque to the motor drivers
  */
-Axis::Axis(char axis,volatile Control_t* control) :CommandHandler("axis", CLSID_AXIS), drv_chooser(MotorDriver::all_drivers),enc_chooser{Encoder::all_encoders}
+Axis::Axis(char axis,volatile Control_t* control) :CommandHandler("axis", CLSID_AXIS), driverChooser(MotorDriver::all_drivers),encoderChooser{Encoder::all_encoders}
 {
+
+#ifdef USE_DSP_FUNCTIONS
+	speedLimiterPID.Kp = speedLimiterP;
+	speedLimiterPID.Ki = speedLimiterI;
+	speedLimiterPID.Kd = 0.0f;
+	arm_pid_init_f32(&speedLimiterPID, 1);
+#endif
+
 	this->axis = axis;
 	this->control = control;
 	if (axis == 'X')
 	{
-		drv_chooser = ClassChooser<MotorDriver>(axis1_drivers);
+		driverChooser = ClassChooser<MotorDriver>(axis1_drivers);
 		setInstance(0);
-		this->flashAddrs = AxisFlashAddrs({ADR_AXIS1_CONFIG, ADR_AXIS1_MAX_SPEED, ADR_AXIS1_MAX_ACCEL,
+		this->flashAddresses = AxisFlashAddresses({ADR_AXIS1_CONFIG, ADR_AXIS1_MAX_SPEED, ADR_AXIS1_MAX_ACCEL, ADR_AXIS1_MAX_SLEWRATE_DRV,
 										   ADR_AXIS1_ENDSTOP, ADR_AXIS1_POWER, ADR_AXIS1_DEGREES,ADR_AXIS1_EFFECTS1,ADR_AXIS1_EFFECTS2,ADR_AXIS1_ENC_RATIO,
 										   ADR_AXIS1_SPEEDACCEL_FILTER,ADR_AXIS1_POSTPROCESS1});
 	}
 	else if (axis == 'Y')
 	{
-		drv_chooser = ClassChooser<MotorDriver>(axis2_drivers);
+		driverChooser = ClassChooser<MotorDriver>(axis2_drivers);
 		setInstance(1);
-		this->flashAddrs = AxisFlashAddrs({ADR_AXIS2_CONFIG, ADR_AXIS2_MAX_SPEED, ADR_AXIS2_MAX_ACCEL,
+		this->flashAddresses = AxisFlashAddresses({ADR_AXIS2_CONFIG, ADR_AXIS2_MAX_SPEED, ADR_AXIS2_MAX_ACCEL, ADR_AXIS2_MAX_SLEWRATE_DRV,
 										   ADR_AXIS2_ENDSTOP, ADR_AXIS2_POWER, ADR_AXIS2_DEGREES,ADR_AXIS2_EFFECTS1,ADR_AXIS2_EFFECTS2, ADR_AXIS2_ENC_RATIO,
 										   ADR_AXIS2_SPEEDACCEL_FILTER,ADR_AXIS2_POSTPROCESS1});
 	}
 	else if (axis == 'Z')
 	{
 		setInstance(2);
-		this->flashAddrs = AxisFlashAddrs({ADR_AXIS3_CONFIG, ADR_AXIS3_MAX_SPEED, ADR_AXIS3_MAX_ACCEL,
+	this->flashAddresses = AxisFlashAddresses({ADR_AXIS3_CONFIG, ADR_AXIS3_MAX_SPEED, ADR_AXIS3_MAX_ACCEL, ADR_AXIS3_MAX_SLEWRATE_DRV,
 										   ADR_AXIS3_ENDSTOP, ADR_AXIS3_POWER, ADR_AXIS3_DEGREES,ADR_AXIS3_EFFECTS1,ADR_AXIS3_EFFECTS2,ADR_AXIS3_ENC_RATIO,
 										   ADR_AXIS3_SPEEDACCEL_FILTER,ADR_AXIS3_POSTPROCESS1});
 	}
 
+	// Initialize equalizer filters
+	/*for (uint8_t idx = 0; idx < num_eq_bands; idx++) {
+		eqFilters[idx].setBiquad(BiquadType::peak, eq_frequencies[idx] / filter_f, 1.0, 0.0);
+	}*/
 
-	restoreFlash(); // Load parameters
 	CommandHandler::registerCommands(); // Internal commands
 	registerCommands();
-	updateTorqueScaler(); // In case no flash setting has been loaded yet
+	restoreFlash(); // Load parameters
 }
 
 Axis::~Axis()
@@ -144,7 +171,7 @@ void Axis::registerCommands(){
 	registerCommand("drvtype", Axis_commands::drvtype, "Motor driver type get/set/list",CMDFLAG_GET | CMDFLAG_SET | CMDFLAG_INFOSTRING);
 	registerCommand("pos", Axis_commands::pos, "Encoder position",CMDFLAG_GET);
 	registerCommand("maxspeed", Axis_commands::maxspeed, "Speed limit in deg/s",CMDFLAG_GET | CMDFLAG_SET);
-	registerCommand("maxtorquerate", Axis_commands::maxtorquerate, "Torque rate limit in counts/ms",CMDFLAG_GET | CMDFLAG_SET);
+	registerCommand("slewrate", Axis_commands::slewrate, "Torque rate limit in counts/ms",CMDFLAG_GET | CMDFLAG_SET);
 	registerCommand("fxratio", Axis_commands::fxratio, "Effect ratio. Reduces game effects excluding endstop. 255=100%",CMDFLAG_GET | CMDFLAG_SET);
 	registerCommand("curtorque", Axis_commands::curtorque, "Axis torque",CMDFLAG_GET);
 	registerCommand("curpos", Axis_commands::curpos, "Axis position",CMDFLAG_GET);
@@ -165,10 +192,10 @@ void Axis::registerCommands(){
  * Read parameters from flash and restore settings
  */
 void Axis::restoreFlash(){
-	//NormalizedAxis::restoreFlash();
+	// TODO: This seems to be a remnant of a previous architecture (NormalizedAxis). Confirm and remove.
 	// read all constants
 	uint16_t value;
-	if (Flash_Read(flashAddrs.config, &value)){
+	if (Flash_Read(flashAddresses.config, &value)){
 		this->conf = Axis::decodeConfFromInt(value);
 	}else{
 		pulseErrLed();
@@ -177,57 +204,65 @@ void Axis::restoreFlash(){
 	setDrvType(this->conf.drvtype);
 	setEncType(this->conf.enctype);
 
-	if (Flash_Read(flashAddrs.maxSpeed, &value)){
+	if (Flash_Read(flashAddresses.maxSpeed, &value)){
 		this->maxSpeedDegS = value;
 	}else{
 		pulseErrLed();
 	}
-//
-//	if (Flash_Read(flashAddrs.maxAccel, &value)){
-//		this->maxTorqueRateMS = value;
-//	}else{
-//		pulseErrLed();
-//	}
-
-
-	uint16_t esval, power;
-	if(Flash_Read(flashAddrs.endstop, &esval)) {
-		fx_ratio_i = esval & 0xff;
-		endstopStrength = (esval >> 8) & 0xff;
+
+	// save the max torque for the slew rate
+	if (Flash_Read(flashAddresses.maxAccel, &value)){
+		this->maxTorqueRateMS = value;
+	}else{
+		pulseErrLed();
+	}
+
+	// save the max torque for the slew rate
+	if (Flash_Read(flashAddresses.maxSlewRateDrv, &value)){
+		this->maxSlewRate_Driver = value;
+	}else{
+		pulseErrLed();
+	}
+
+
+	uint16_t endstopRawValue, power;
+	if(Flash_Read(flashAddresses.endstop, &endstopRawValue)) {
+		setEffectRatio(endstopRawValue & 0xff);
+		endstopStrength = (endstopRawValue >> 8) & 0xff;
 	}
 
 
-	if(Flash_Read(flashAddrs.power, &power)){
+	if(Flash_Read(flashAddresses.power, &power)){
 		setPower(power);
 	}
-	uint16_t deg_t;
-	if(Flash_Read(flashAddrs.degrees, &deg_t)){
-		this->degreesOfRotation = deg_t & 0x7fff;
-		this->invertAxis = (deg_t >> 15) & 0x1;
+	uint16_t degreesRawValue;
+	if(Flash_Read(flashAddresses.degrees, &degreesRawValue)){
+		this->degreesOfRotation = degreesRawValue & 0x7fff;
+		this->invertAxis = (degreesRawValue >> 15) & 0x1;
 		setDegrees(degreesOfRotation);
 	}
 
 
 	uint16_t effects;
-	if(Flash_Read(flashAddrs.effects1, &effects)){
+	if(Flash_Read(flashAddresses.effects1, &effects)){
 		setIdleSpringStrength(effects & 0xff);
 		setFxStrengthAndFilter((effects >> 8) & 0xff,damperIntensity,damperFilter);
 	}else{
-		setIdleSpringStrength(idlespringstrength); // Use default
+		setIdleSpringStrength(idleSpringStrength); // Use default
 	}
 
-	if(Flash_Read(flashAddrs.effects2, &effects)){
+	if(Flash_Read(flashAddresses.effects2, &effects)){
 		setFxStrengthAndFilter(effects & 0xff,frictionIntensity,frictionFilter);
 		setFxStrengthAndFilter((effects >> 8) & 0xff,inertiaIntensity,inertiaFilter);
 	}
 
 	uint16_t ratio;
-	if(Flash_Read(flashAddrs.encoderRatio, &ratio)){
+	if(Flash_Read(flashAddresses.encoderRatio, &ratio)){
 		setGearRatio(ratio & 0xff, (ratio >> 8) & 0xff);
 	}
 
 	uint16_t filterStorage;
-	if (Flash_Read(flashAddrs.speedAccelFilter, &filterStorage))
+	if (Flash_Read(flashAddresses.speedAccelFilter, &filterStorage))
 	{
 		uint8_t profile = filterStorage & 0xFF;
 		this->filterProfileId = profile;
@@ -238,31 +273,32 @@ void Axis::restoreFlash(){
 	}
 
 	uint16_t pp1;
-	if(Flash_Read(flashAddrs.postprocess1, &pp1)){
+	if(Flash_Read(flashAddresses.postprocess1, &pp1)){
 		setExpo((int8_t)(pp1 & 0xff));
 	}
 
 }
 // Saves parameters to flash.
 void Axis::saveFlash(){
-	//NormalizedAxis::saveFlash();
-	Flash_Write(flashAddrs.config, Axis::encodeConfToInt(this->conf));
-	Flash_Write(flashAddrs.maxSpeed, this->maxSpeedDegS);
-//	Flash_Write(flashAddrs.maxAccel, (uint16_t)(this->maxTorqueRateMS));
-
-	Flash_Write(flashAddrs.endstop, fx_ratio_i | (endstopStrength << 8));
-	Flash_Write(flashAddrs.power, power);
-	Flash_Write(flashAddrs.degrees, (degreesOfRotation & 0x7fff) | (invertAxis << 15));
-	Flash_Write(flashAddrs.effects1, idlespringstrength | (damperIntensity << 8));
-	Flash_Write(flashAddrs.effects2, frictionIntensity | (inertiaIntensity << 8));
-	Flash_Write(flashAddrs.encoderRatio, gearRatio.numerator | (gearRatio.denominator << 8));
+	// TODO: This seems to be a remnant of a previous architecture (NormalizedAxis). Confirm and remove.
+	Flash_Write(flashAddresses.config, Axis::encodeConfToInt(this->conf));
+	Flash_Write(flashAddresses.maxSpeed, this->maxSpeedDegS);
+	Flash_Write(flashAddresses.maxAccel, (uint16_t)(this->maxTorqueRateMS));
+	Flash_Write(flashAddresses.maxSlewRateDrv, (uint16_t)(this->maxSlewRate_Driver));
+
+	Flash_Write(flashAddresses.endstop, effectRatio | (endstopStrength << 8));
+	Flash_Write(flashAddresses.power, power);
+	Flash_Write(flashAddresses.degrees, (degreesOfRotation & 0x7fff) | (invertAxis << 15));
+	Flash_Write(flashAddresses.effects1, idleSpringStrength | (damperIntensity << 8));
+	Flash_Write(flashAddresses.effects2, frictionIntensity | (inertiaIntensity << 8));
+	Flash_Write(flashAddresses.encoderRatio, gearRatio.numerator | (gearRatio.denominator << 8));
 
 	// save CF biquad
 	uint16_t filterStorage = (uint16_t)this->filterProfileId & 0xFF;
-	Flash_Write(flashAddrs.speedAccelFilter, filterStorage);
+	Flash_Write(flashAddresses.speedAccelFilter, filterStorage);
 
 	// Postprocessing
-	Flash_Write(flashAddrs.postprocess1, expoValInt & 0xff);
+	Flash_Write(flashAddresses.postprocess1, expoValue & 0xff);
 
 }
 
@@ -282,8 +318,9 @@ uint8_t Axis::getEncType(){
 void Axis::setPos(uint16_t val)
 {
 	startForceFadeIn(0.25,0.5);
-	if(this->drv != nullptr){
-		drv->getEncoder()->setPos(val);
+	Encoder* enc_p = getEncoder();
+	if(enc_p != nullptr){
+		enc_p->setPos(val);
 	}
 }
 
@@ -292,6 +329,7 @@ MotorDriver* Axis::getDriver(){
 }
 
 Encoder* Axis::getEncoder(){
+	if(!drv) return nullptr;
 	return drv->getEncoder();
 }
 
@@ -304,9 +342,10 @@ void Axis::prepareForUpdate(){
 		return;
 	}
 
+	// TODO: The motorReady() check was commented out. Review if this is still the desired behavior or if it should be restored.
 	//if (!drv->motorReady()) return;
 
-	float angle = getEncAngle(this->drv->getEncoder());
+	float angle = getEncAngle(getEncoder());
 
 	// Scale encoder value to set rotation range
 	// Update a change of range only when new range is within valid range
@@ -336,6 +375,7 @@ void Axis::prepareForUpdate(){
 
 	}else if(abs(scaledEnc) <= 0x7fff) {
 		outOfBounds = false;
+		// TODO: This error clearing seems to have been moved to the errorCallback. Confirm this is correct and remove this line.
 		//ErrorHandler::clearError(outOfBoundsError);
 	}
 
@@ -347,6 +387,7 @@ void Axis::prepareForUpdate(){
 
 
 	this->updateMetrics(angle);
+	//this->updateHandsOffState();
 
 }
 
@@ -371,17 +412,11 @@ void Axis::updateDriveTorque(){
 void Axis::setPower(uint16_t power)
 {
 	this->power = power;
-	updateTorqueScaler();
-#ifdef TMC4671DRIVER
-	// Update hardware limits for TMC for safety
-	TMC4671 *drv = dynamic_cast<TMC4671 *>(this->drv.get());
+	torqueScaler = ((float)power / (float)0x7fff);
 	if (drv != nullptr)
 	{
-		//tmclimits.pid_uq_ud = power;
-		//tmclimits.pid_torque_flux = power;
-		drv->setTorqueLimit(power);
+		drv->setPowerLimit(power);
 	}
-#endif
 }
 
 
@@ -390,29 +425,27 @@ void Axis::setPower(uint16_t power)
  */
 void Axis::setDrvType(uint8_t drvtype)
 {
-	if (!drv_chooser.isValidClassId(drvtype))
+	if (!driverChooser.isValidClassId(drvtype))
 	{
 		return;
 	}
-	this->drv.reset(nullptr);
-	MotorDriver* drv = drv_chooser.Create((uint16_t)drvtype);
+	cpp_freertos::CriticalSection::Enter();
+	this->drv.reset(driverChooser.Create((uint16_t)drvtype));
 	if (drv == nullptr)
 	{
+		cpp_freertos::CriticalSection::Exit();
 		return;
 	}
-	this->drv = std::unique_ptr<MotorDriver>(drv);
 	this->conf.drvtype = drvtype;
+	this->maxTorqueRateMS = drv->getDrvSlewRate();
 
 	// Pass encoder to driver again
 	if(!this->drv->hasIntegratedEncoder()){
 		this->drv->setEncoder(this->enc);
 	}
-#ifdef TMC4671DRIVER
-	if (dynamic_cast<TMC4671 *>(drv))
-	{
-		setupTMC4671();
-	}
-#endif
+
+	drv->setupDriver();
+	
 	if (!tud_connected())
 	{
 		control->usb_disabled = false;
@@ -422,27 +455,9 @@ void Axis::setDrvType(uint8_t drvtype)
 	{
 		drv->startMotor();
 	}
+	cpp_freertos::CriticalSection::Exit();
 }
 
-#ifdef TMC4671DRIVER
-// Special tmc setup methods
-void Axis::setupTMC4671()
-{
-	TMC4671 *drv = static_cast<TMC4671 *>(this->drv.get());
-//	drv->setAxis(axis);
-	drv->setExternalEncoderAllowed(true);
-	drv->restoreFlash();
-	tmclimits.pid_torque_flux = getPower();
-	drv->setLimits(tmclimits);
-	//drv->setBiquadTorque(TMC4671Biquad(tmcbq_500hz_07q_25k));
-	
-
-	// Enable driver
-
-	drv->setMotionMode(MotionMode::torque);
-	drv->Start(); // Start thread
-}
-#endif
 
 
 /**
@@ -450,18 +465,18 @@ void Axis::setupTMC4671()
  */
 void Axis::setEncType(uint8_t enctype)
 {
-	if (enc_chooser.isValidClassId(enctype) && !drv->hasIntegratedEncoder())
+	if (encoderChooser.isValidClassId(enctype) && !drv->hasIntegratedEncoder())
 	{
 
 		this->conf.enctype = (enctype);
-		this->enc = std::shared_ptr<Encoder>(enc_chooser.Create(enctype)); // Make new encoder
+		this->enc = std::shared_ptr<Encoder>(encoderChooser.Create(enctype)); // Make new encoder
 		if(drv && !drv->hasIntegratedEncoder())
 			this->drv->setEncoder(this->enc);
 	}else{
 		this->conf.enctype = 0; // None encoder
 	}
 
-	float angle = getEncAngle(this->drv->getEncoder());
+	float angle = getEncAngle(this->getEncoder());
 	//int32_t scaledEnc = scaleEncValue(angle, degreesOfRotation);
 	// reset metrics
 	this->resetMetrics(angle);
@@ -549,26 +564,26 @@ metric_t* Axis::getMetrics() {
 }
 
 /**
- * Returns position as 16b int scaled to gamepad range
+ * Returns position as int scaled to gamepad range
  */
 int32_t Axis::getLastScaledEnc() {
-	return  clip(metric.current.pos,-0x7fff,0x7fff);
+	return  clip(metric.current.pos_f * 0x7fffffff,-0x7fffffff,0x7fffffff); // Calc from float pos
 }
 
 /**
  * Changes intensity of idle spring when FFB is off
  */
 int32_t Axis::updateIdleSpringForce() {
-	return clip<int32_t,int32_t>((int32_t)(-metric.current.pos*idlespringscale),-idlespringclip,idlespringclip);
+	return clip<int32_t,int32_t>((int32_t)(-metric.current.pos_scaled_16b*idleSpringScale),-idleSpringClip,idleSpringClip);
 }
 
 /*
  * Set the strength of the spring effect if FFB is disabled
  */
 void Axis::setIdleSpringStrength(uint8_t spring){
-	idlespringstrength = spring;
-	idlespringclip = clip<int32_t,int32_t>((int32_t)spring*35,0,10000);
-	idlespringscale = 0.5f + ((float)spring * 0.01f);
+	idleSpringStrength = spring;
+	idleSpringClip = clip<int32_t,int32_t>((int32_t)spring*35,0,10000);
+	idleSpringScale = 0.5f + ((float)spring * 0.01f);
 }
 
 /**
@@ -582,26 +597,27 @@ void Axis::setFxStrengthAndFilter(uint8_t val,uint8_t& valToSet, Biquad& filter)
 }
 
 /**
- * Called before HID effects are calculated
- * Should calculate always on and idle effects specific to the axis like idlespring and friction
+ * Calculates the internal mechanical effects (damper, friction, inertia) that are always active.
+ * Called before HID effects are calculated.
+ * Also calculates idle spring when FFB is inactive.
  */
-void Axis::calculateAxisEffects(bool ffb_on){
-	axisEffectTorque = 0;
+void Axis::calculateMechanicalEffects(bool ffb_on){
+	mechanicalEffectTorque = 0;
 
 	if(!ffb_on){
-		axisEffectTorque += updateIdleSpringForce();
+		mechanicalEffectTorque += updateIdleSpringForce();
 	}
 
 	// Always active damper
 	if(damperIntensity != 0){
 		float speedFiltered = (metric.current.speed) * (float)damperIntensity * AXIS_DAMPER_RATIO;
-		axisEffectTorque -= damperFilter.process(clip<float, int32_t>(speedFiltered, -intFxClip, intFxClip));
+		mechanicalEffectTorque -= damperFilter.process(clip<float, int32_t>(speedFiltered, -internalFxClip, internalFxClip));
 	}
 
 	// Always active inertia
 	if(inertiaIntensity != 0){
 		float accelFiltered = metric.current.accel * (float)inertiaIntensity * AXIS_INERTIA_RATIO;
-		axisEffectTorque -= inertiaFilter.process(clip<float, int32_t>(accelFiltered, -intFxClip, intFxClip));
+		mechanicalEffectTorque -= inertiaFilter.process(clip<float, int32_t>(accelFiltered, -internalFxClip, internalFxClip));
 	}
 
 	// Always active friction. Based on effectsCalculator implementation
@@ -610,12 +626,17 @@ void Axis::calculateAxisEffects(bool ffb_on){
 		float speedRampupCeil = 4096;
 		float rampupFactor = 1.0;
 		if (fabs (speed) < speedRampupCeil) {								// if speed in the range to rampup we apply a sine curve
-			float phaseRad = M_PI * ((fabs (speed) / speedRampupCeil) - 0.5);// we start to compute the normalized angle (speed / normalizedSpeed@5%) and translate it of -1/2PI to translate sin on 1/2 periode
-			rampupFactor = ( 1 + sin(phaseRad ) ) / 2;						// sin value is -1..1 range, we translate it to 0..2 and we scale it by 2
+#ifdef USE_DSP_FUNCTIONS
+			float phaseRad = PI * ((fabsf (speed) / speedRampupCeil) - 0.5f);// we start to compute the normalized angle (speed / normalizedSpeed@5%) and translate it of -1/2PI to translate sin on 1/2 periode
+			rampupFactor = ( 1.0f + arm_sin_f32(phaseRad ) ) / 2.0f;			// sin value is -1..1 range, we translate it to 0..2 and we scale it by 2
+#else
+			float phaseRad = M_PI * ((fabsf (speed) / speedRampupCeil) - 0.5f);// we start to compute the normalized angle (speed / normalizedSpeed@5%) and translate it of -1/2PI to translate sin on 1/2 periode
+			rampupFactor = ( 1.0f + sinf(phaseRad ) ) / 2.0f;			// sin value is -1..1 range, we translate it to 0..2 and we scale it by 2
+#endif
 		}
 		int8_t sign = speed >= 0 ? 1 : -1;
 		float force = (float)frictionIntensity * rampupFactor * sign * INTERNAL_AXIS_FRICTION_SCALER * 32;
-		axisEffectTorque -= frictionFilter.process(clip<float, int32_t>(force, -intFxClip, intFxClip));
+		mechanicalEffectTorque -= frictionFilter.process(clip<float, int32_t>(force, -internalFxClip, internalFxClip));
 	}
 
 }
@@ -623,9 +644,9 @@ void Axis::calculateAxisEffects(bool ffb_on){
 /**
  * Changes the ratio of effects to endstop strength. 255 = same strength, 0 = no effects
  */
-void Axis::setFxRatio(uint8_t val) {
-	fx_ratio_i = val;
-	updateTorqueScaler();
+void Axis::setEffectRatio(uint8_t val) {
+	effectRatio = val;
+	effectRatioScaler = ((float)effectRatio/255.0);
 }
 
 /**
@@ -634,11 +655,15 @@ void Axis::setFxRatio(uint8_t val) {
 void Axis::resetMetrics(float new_pos= 0) { // pos is degrees
 	metric.current = metric_t();
 	metric.current.posDegrees = new_pos;
-	std::tie(metric.current.pos,metric.current.pos_f) = scaleEncValue(new_pos, degreesOfRotation);
+	std::tie(metric.current.pos_scaled_16b,metric.current.pos_f) = scaleEncValue(new_pos, degreesOfRotation);
 	metric.previous = metric_t();
 	// Reset filters
 	speedFilter.calcBiquad();
 	accelFilter.calcBiquad();
+
+#ifdef USE_DSP_FUNCTIONS
+	arm_pid_reset_f32(&speedLimiterPID);	// reset the PID limit
+#endif
 }
 
 /**
@@ -649,14 +674,14 @@ void Axis::updateMetrics(float new_pos) { // pos is degrees
 	metric.previous = metric.current;
 
 	metric.current.posDegrees = new_pos;
-	std::tie(metric.current.pos,metric.current.pos_f) = scaleEncValue(new_pos, degreesOfRotation);
+	std::tie(metric.current.pos_scaled_16b,metric.current.pos_f) = scaleEncValue(new_pos, degreesOfRotation);
 
 
 	// compute speed and accel from raw instant speed normalized
-	float currentSpeed = (new_pos - metric.previous.posDegrees) * 1000.0; // deg/s
+	float currentSpeed = (new_pos - metric.previous.posDegrees) * this->filter_f; // deg/s
 	metric.current.speed = speedFilter.process(currentSpeed);
-	metric.current.accel = accelFilter.process((currentSpeed - _lastSpeed))* 1000.0; // deg/s/s
-	_lastSpeed = currentSpeed;
+	metric.current.accel = accelFilter.process((currentSpeed - previousFrameSpeed))* this->filter_f; // deg/s/s
+	previousFrameSpeed = currentSpeed;
 
 }
 
@@ -667,7 +692,7 @@ uint16_t Axis::getPower(){
 }
 
 /**
- * Calculates an exponential torque correction curve
+ * Calculates an exponential torque correction curve and scale for FFBEffect
  */
 int32_t Axis::calculateExpoTorque(int32_t torque){
 	float torquef = (float)torque / (float)0x7fff; // This down and upscaling may introduce float artifacts. Do this before scaling down.
@@ -678,17 +703,17 @@ int32_t Axis::calculateExpoTorque(int32_t torque){
 	}
 }
 
-void  Axis::updateTorqueScaler() {
-	effect_margin_scaler = ((float)fx_ratio_i/255.0);
-	torqueScaler = ((float)power / (float)0x7fff);
-}
+int64_t Axis::calculateFFBTorque() {
 
-float Axis::getTorqueScaler(){
-	return torqueScaler;
-}
+	int64_t torque = this->ffbEffectTorque;
+
+	// Compute scaler
+	torque *= effectRatioScaler;
 
+	return torque * 0x7fff;
+}
 
-int32_t Axis::getTorque() { return metric.current.torque; }
+int32_t Axis::getTorque() { return metric.current.torque; } // Fix: move from previous to current
 
 bool Axis::isInverted() {
 	return invertAxis;
@@ -697,20 +722,21 @@ bool Axis::isInverted() {
 /**
  * Calculate soft endstop effect
  */
-int16_t Axis::updateEndstop(){
-	int8_t clipdir = cliptest<int32_t,int32_t>(metric.current.pos, -0x7fff, 0x7fff);
-	if(clipdir == 0){
+int32_t Axis::calculateEndstopTorque(){
+	// TODO Check the type int8_t and the range clipping is -0x7fff..0x7fff
+	int8_t clipDirection = cliptest<int32_t,int32_t>(metric.current.pos_scaled_16b, -0x7fff, 0x7fff);
+	if(clipDirection == 0){
 		return 0;
 	}
-	float addtorque = clipdir*metric.current.posDegrees - (float)this->degreesOfRotation/2.0; // degress of rotation counts total range so multiply by 2
-	addtorque *= (float)endstopStrength * endstopGain; // Apply endstop gain for stiffness.
-	addtorque *= -clipdir;
+	float endstopTorque = clipDirection*metric.current.posDegrees - (float)this->degreesOfRotation/2.0; // degress of rotation counts total range so multiply by 2
+	endstopTorque *= (float)endstopStrength * endstopGain; // Apply endstop gain for stiffness.
+	endstopTorque *= -clipDirection;
 
-	return clip<int32_t,int32_t>(addtorque,-0x7fff,0x7fff);
+	return clip<int32_t,int32_t>(endstopTorque,-0x7fff,0x7fff);
 }
 
-void Axis::setEffectTorque(int32_t torque) {
-	effectTorque = torque;
+void Axis::setFfbEffectTorque(int64_t torque) {
+	this->ffbEffectTorque = torque;
 }
 
 /** pass in ptr to receive the sum of the effects + endstop torque
@@ -719,81 +745,138 @@ void Axis::setEffectTorque(int32_t torque) {
 
 bool Axis::updateTorque(int32_t* totalTorque) {
 
-	if(abs(effectTorque) >= 0x7fff){
-		pulseClipLed();
+	// Step 1: Process FFB torque from the game (via helper function)
+	int64_t torque = calculateFFBTorque();
+
+	// Step 2: Add internal torque effects
+	torque += mechanicalEffectTorque;		// Add locally calculated effects (damper, friction, inertia).
+	torque += calculateEndstopTorque();		// Add endstop force if the axis reaches its rotation limits.
+
+	// Step 3: Apply safety and comfort limiters
+	torque -= applySpeedLimiterTorque(torque);	// apply speedLimiter
+	applyTorqueSlewRateLimiter(torque);		// Torque Slew Rate Limiter: 
+
+	// Cut torque if the encoder is out of bounds (safety) or hands are off.
+	//if(outOfBounds || handsOff){
+	if(outOfBounds){
+		torque = 0;
 	}
 
-	// Scale effect torque
-	int32_t torque = effectTorque; // Game effects
-	if(expo != 1){
-		torque = calculateExpoTorque(torque);
+	// Apply a fade-in effect for a smooth force ramp-up on startup.
+	if(forceFadeMultiplier < 1){
+		torque = torque * forceFadeMultiplier;
+		forceFadeMultiplier += forceFadeDuration / this->filter_f; // Fade time
 	}
-	torque *= effect_margin_scaler;
-	torque += axisEffectTorque; // Independent effects
-	torque += updateEndstop();
-	torque *= torqueScaler; // Scale to power
 
+	// Step 4: Prepare the final torque for the driver.
+	torque *= torqueScaler;								// Apply the main power setting ("force volume").
+	torque = (invertAxis) ? -torque : torque;			// Invert axis if required.
 
-	// TODO speed and accel limiters
-	if(maxSpeedDegS > 0){
+	// clip and alert clipping
+	int32_t torqueAfterClipping = clip<int32_t, int32_t>(torque, -power, power);
+	if (torqueAfterClipping != torque){
+		pulseClipLed();
+	}
 
-		float torqueSign = torque > 0 ? 1 : -1; // Used to prevent metrics against the force to go into the limiter
-		// Speed. Mostly tuned...
-		//spdlimiterAvg.addValue(metric.current.speed);
-		float speedreducer = (float)((metric.current.speed*torqueSign) - (float)maxSpeedDegS) *  ((float)0x7FFF / maxSpeedDegS);
-		spdlimitreducerI = clip<float,int32_t>( spdlimitreducerI + ((speedreducer * speedLimiterI) * torqueScaler),0,power);
+	// Store the actually applied torque for the next iteration (used by the slew rate limiter).
+	metric.current.torque = torqueAfterClipping; 
 
-		// Accel limit. Not really useful. Maybe replace with torque slew rate limit?
-//		float accreducer = (float)((metric.current.accel*torqueSign) - (float)maxAccelDegSS) * getAccelScalerNormalized();
-//		acclimitreducerI = clip<float,int32_t>( acclimitreducerI + ((accreducer * 0.02) * torqueScaler),0,power);
+	// return result
+	*totalTorque = torqueAfterClipping;
+	return (metric.current.torque != metric.previous.torque);
+}
 
 
-		// Only reduce torque. Don't invert it to prevent oscillation
-		float torqueReduction = speedreducer * speedLimiterP + spdlimitreducerI;// accreducer * 0.025 + acclimitreducerI
-		if(torque > 0){
-			torqueReduction = clip<float,int32_t>(torqueReduction,0,torque);
-		}else{
-			torqueReduction = clip<float,int32_t>(-torqueReduction,torque,0);
+void Axis::applyTorqueSlewRateLimiter(int64_t& torque)
+{
+	// Limits the rate of change of the torque (slew rate), to smooths out sudden changes in torque.
+	// Essential for a natural feel and to prevent "clanking" noises.
+	if(maxTorqueRateMS == 0) {
+		return; // Limiter is disabled
+	}
+
+	// This prevents sudden torque jumps, resulting in a smoother feel.
+	const int64_t previousTorque = metric.previous.torque;
+	const int64_t maxTorqueChange = maxTorqueRateMS;
+
+	// The torque is clipped to be within the range of [previous torque - limit, previous torque + limit].
+	torque = clip<int64_t>(torque, previousTorque - maxTorqueChange, previousTorque + maxTorqueChange);
 		}
 
-		torque -= torqueReduction;
-	}
-	// Torque slew rate limiter
-	if(maxTorqueRateMS > 0){
-		torque = clip<int32_t,int32_t>(torque, metric.previous.torque - maxTorqueRateMS,metric.previous.torque + maxTorqueRateMS);
-	}
-//	if(torque - metric.previous.torque)
-	if(outOfBounds){
-		torque = 0;
-	}
+int64_t Axis::applySpeedLimiterTorque(int64_t& torque){
+	// Speed Limiter: A PI controller to reduce torque when speed exceeds maxSpeedDegS.
+	// The limiter only acts when torque is applied in the direction of movement.
 
-	// Fade in
-	if(forceFadeCurMult < 1){
-		torque = torque * forceFadeCurMult;
-		forceFadeCurMult += forceFadeTime / this->filter_f; // Fade time
+	// if limiter is disabled, return
+	if(maxSpeedDegS <= 0) {
+		return 0;
 	}
 
-	// Torque calculated. Now sending to driver
-	torque = (invertAxis) ? -torque : torque;
-	metric.current.torque = torque;
-	torque = clip<int32_t, int32_t>(torque, -power, power);
-
-	bool torqueChanged = metric.current.torque != metric.previous.torque;
+	int64_t resultTorque = 0;
 
-	if (abs(torque) == power){
-		pulseClipLed();
+#ifdef USE_DSP_FUNCTIONS
+	float effectiveSpeed = metric.current.speed * (torque > 0 ? 1.0f : -1.0f);
+	if (effectiveSpeed > maxSpeedDegS)
+	{
+		// --- PI Controller Logic ---
+		// 1. Calculate the error term (how much we are over the speed limit).
+		float speedError = effectiveSpeed - maxSpeedDegS;
+
+		// 2. Calculate the total reduction amount using the PID controller.
+		float reductionAmount = arm_pid_f32(&speedLimiterPID, speedError);
+
+		// 3. Apply the reduction to the main torque.
+		// We must only reduce the magnitude of the torque, not invert it.
+		reductionAmount = clip(reductionAmount, 0.0f, fabsf((float)torque));
+		if(torque > 0) {
+			resultTorque = reductionAmount;
+		} else {
+			resultTorque = -reductionAmount;
+		}
+	} else {
+		arm_pid_reset_f32(&speedLimiterPID); // Reset PID if not active
 	}
+#else
+	float torqueSign = torque > 0 ? 1 : -1; // Used to prevent metrics against the force to go into the limiter
+	// Speed. Mostly tuned...
+	//spdlimiterAvg.addValue(metric.current.speed);
+	float speedreducer = (float)((metric.current.speed*torqueSign) - (float)maxSpeedDegS) *  ((float)0x7FFF / maxSpeedDegS);
+	speedLimitReducerI = clip<float,int32_t>( speedLimitReducerI + ((speedreducer * speedLimiterI) * torqueScaler),0,power);
+
+	// Only reduce torque. Don't invert it to prevent oscillation
+	float torqueReduction = speedreducer * speedLimiterP + speedLimitReducerI;// accreducer * 0.025 + acclimitreducerI
+	if(torque > 0){
+		resultTorque = clip<float,int64_t>(torqueReduction,0,torque);
+	}else{
+		resultTorque = clip<float,int64_t>(-torqueReduction,torque,0);
+	}
+#endif
 
-	*totalTorque = torque;
-	return (torqueChanged);
+	return resultTorque;
+}
+
+void Axis::updateSamplerate(float newSamplerate){
+	this->filter_f = newSamplerate;
+	this->updateFilters(this->filterProfileId); // Recalculate filters
+}
+
+void Axis::updateFilters(uint8_t profileId){
+	this->filterProfileId = profileId;
+	speedFilter.setFc(filterSpeedCst[this->filterProfileId].freq / filter_f);
+	speedFilter.setQ(filterSpeedCst[this->filterProfileId].q / 100.0);
+	accelFilter.setFc(filterAccelCst[this->filterProfileId].freq / filter_f);
+	accelFilter.setQ(filterAccelCst[this->filterProfileId].q / 100.0);
+	damperFilter.setFc(filterDamperCst.freq/filter_f);
+	inertiaFilter.setFc(filterInertiaCst.freq/filter_f);
+	frictionFilter.setFc(filterFrictionCst.freq/filter_f);
 }
 
 /**
  * Starts fading in force from start to 1 over fadeTime
  */
 void Axis::startForceFadeIn(float start,float fadeTime){
-	this->forceFadeTime = fadeTime;
-	this->forceFadeCurMult = clip<float>(start, 0, 1);
+	this->forceFadeDuration = fadeTime;
+	this->forceFadeMultiplier = clip<float>(start, 0, 1);
 }
 
 
@@ -804,9 +887,9 @@ void Axis::setDegrees(uint16_t degrees){
 
 	degrees &= 0x7fff;
 	if(degrees == 0){
-		nextDegreesOfRotation = lastdegreesOfRotation;
+		nextDegreesOfRotation = previousDegreesOfRotation;
 	}else{
-		lastdegreesOfRotation = degreesOfRotation;
+		previousDegreesOfRotation = degreesOfRotation;
 		nextDegreesOfRotation = degrees;
 	}
 }
@@ -814,7 +897,7 @@ void Axis::setDegrees(uint16_t degrees){
 
 void Axis::setExpo(int val){
 	val = clip(val, -127, 127);
-	expoValInt = val;
+	expoValue = val;
 	if(val == 0){
 		expo = 1; // Explicitly force expo off
 		return;
@@ -844,14 +927,6 @@ CommandStatus Axis::command(const ParsedCommand& cmd,std::vector<CommandReply>&
 
 	case Axis_commands::degrees:
 		handleGetSetFunc(cmd, replies, degreesOfRotation, &Axis::setDegrees,this);
-//		if (cmd.type == CMDtype::get)
-//		{
-//			replies.emplace_back(degreesOfRotation);
-//		}
-//		else if (cmd.type == CMDtype::set)
-//		{
-//			setDegrees(cmd.val);
-//		}
 		break;
 
 	case Axis_commands::esgain:
@@ -877,7 +952,7 @@ CommandStatus Axis::command(const ParsedCommand& cmd,std::vector<CommandReply>&
 	case Axis_commands::idlespring:
 		if (cmd.type == CMDtype::get)
 		{
-			replies.emplace_back(idlespringstrength);
+			replies.emplace_back(idleSpringStrength);
 		}
 		else if (cmd.type == CMDtype::set)
 		{
@@ -920,7 +995,7 @@ CommandStatus Axis::command(const ParsedCommand& cmd,std::vector<CommandReply>&
 
 	case Axis_commands::enctype:
 		if(cmd.type == CMDtype::info){
-			enc_chooser.replyAvailableClasses(replies,this->getEncType());
+			encoderChooser.replyAvailableClasses(replies,this->getEncType());
 		}else if(cmd.type == CMDtype::get){
 			replies.emplace_back(this->getEncType());
 		}else if(cmd.type == CMDtype::set){
@@ -930,7 +1005,7 @@ CommandStatus Axis::command(const ParsedCommand& cmd,std::vector<CommandReply>&
 
 	case Axis_commands::drvtype:
 		if(cmd.type == CMDtype::info){
-			drv_chooser.replyAvailableClasses(replies,this->getDrvType());
+			driverChooser.replyAvailableClasses(replies,this->getDrvType());
 		}else if(cmd.type == CMDtype::get){
 			replies.emplace_back(this->getDrvType());
 		}else if(cmd.type == CMDtype::set){
@@ -939,14 +1014,14 @@ CommandStatus Axis::command(const ParsedCommand& cmd,std::vector<CommandReply>&
 		break;
 
 	case Axis_commands::pos:
-		if (cmd.type == CMDtype::get && this->drv->getEncoder() != nullptr)
+		if (cmd.type == CMDtype::get && getEncoder() != nullptr)
 		{
-			int32_t pos = this->drv->getEncoder()->getPos();
+			int32_t pos = getEncoder()->getPos();
 			replies.emplace_back(isInverted() ? -pos : pos);
 		}
-		else if (cmd.type == CMDtype::set && this->drv->getEncoder() != nullptr)
+		else if (cmd.type == CMDtype::set && getEncoder() != nullptr)
 		{
-			this->drv->getEncoder()->setPos(isInverted() ? -cmd.val : cmd.val);
+			getEncoder()->setPos(isInverted() ? -cmd.val : cmd.val);
 		}
 		else
 		{
@@ -958,29 +1033,60 @@ CommandStatus Axis::command(const ParsedCommand& cmd,std::vector<CommandReply>&
 		handleGetSet(cmd, replies, this->maxSpeedDegS);
 		break;
 
-	case Axis_commands::maxtorquerate:
-		handleGetSet(cmd, replies, this->maxTorqueRateMS);
+	case Axis_commands::slewrate:
+		{
+			if(cmd.type == CMDtype::get){
+				// If driver has a more restrictive calibrated value, update the axis limit
+				if(maxSlewRate_Driver < this->maxTorqueRateMS) {
+					this->maxTorqueRateMS = maxSlewRate_Driver;
+				}
+				replies.emplace_back(this->maxTorqueRateMS);
+			}else if(cmd.type == CMDtype::set){
+				this->maxTorqueRateMS = clip<uint32_t,uint32_t>(cmd.val, 0, maxSlewRate_Driver);
+			}
+		}
+		break;
+
+	case Axis_commands::calibrate_maxSlewRateDrv:
+		{
+			if(cmd.type == CMDtype::get){
+				// Start calibration on driver and set awaiting flag if start is OK
+				if (drv->startSlewRateCalibration()) {
+					this->awaitingSlewCalibration = true;
+				} else {
+					// Inform user that calibration can't started
+					CommandHandler::broadcastCommandReply(CommandReply("Slew rate calibration unsupported",1), (uint32_t)Axis_commands::calibrate_maxSlewRateDrv, CMDtype::get);
+				}
+				replies.emplace_back(1); // ack
+			}
+			break;
+		}
+
+	case Axis_commands::maxSlewRateDrv:
+		if (cmd.type == CMDtype::get) {
+			replies.emplace_back(maxSlewRate_Driver);
+		}
 		break;
 
 	case Axis_commands::fxratio:
 		if(cmd.type == CMDtype::get){
-			replies.emplace_back(this->fx_ratio_i);
+			replies.emplace_back(this->effectRatio);
 		}else if(cmd.type == CMDtype::set){
-			setFxRatio(cmd.val);
+			setEffectRatio(cmd.val);
 		}
 		break;
 
 	case Axis_commands::curpos:
-		replies.emplace_back(this->metric.current.pos);
+		replies.emplace_back(this->metric.previous.pos_scaled_16b);
 		break;
 	case Axis_commands::curtorque:
-		replies.emplace_back(this->metric.current.torque);
+		replies.emplace_back(getTorque());
 		break;
 	case Axis_commands::curspd:
-		replies.emplace_back(this->metric.current.speed);
+		replies.emplace_back(this->metric.previous.speed);
 		break;
 	case Axis_commands::curaccel:
-		replies.emplace_back(this->metric.current.accel);
+		replies.emplace_back(this->metric.previous.accel);
 		break;
 
 	case Axis_commands::reductionScaler:
@@ -999,11 +1105,7 @@ CommandStatus Axis::command(const ParsedCommand& cmd,std::vector<CommandReply>&
 		else if (cmd.type == CMDtype::set)
 		{
 			uint32_t value = clip<uint32_t, uint32_t>(cmd.val, 0, filterSpeedCst.size()-1);
-			this->filterProfileId = value;
-			speedFilter.setFc(filterSpeedCst[this->filterProfileId].freq / filter_f);
-			speedFilter.setQ(filterSpeedCst[this->filterProfileId].q / 100.0);
-			accelFilter.setFc(filterAccelCst[this->filterProfileId].freq / filter_f);
-			accelFilter.setQ(filterAccelCst[this->filterProfileId].q / 100.0);
+			this->updateFilters(value);
 		}
 		break;
 	case Axis_commands::filterSpeed:
@@ -1024,9 +1126,10 @@ CommandStatus Axis::command(const ParsedCommand& cmd,std::vector<CommandReply>&
 		if (cmd.type == CMDtype::get)
 		{
 			uint32_t cpr = 0;
-			if(this->drv->getEncoder() != nullptr){
-				cpr = this->drv->getEncoder()->getCpr();
+			if(this->getEncoder() != nullptr){
+				cpr = this->getEncoder()->getCpr();
 			}
+			// TODO: For TMC4671 drivers, CPR reporting might be inconsistent. Investigate if a prescale is needed or if the UI should handle the readout correction.
 //#ifdef TMC4671DRIVER // CPR should be consistent with position. Maybe change TMC to prescale to encoder count or correct readout in UI
 //			TMC4671 *tmcdrv = dynamic_cast<TMC4671 *>(this->drv.get()); // Special case for TMC. Get the actual encoder resolution
 //			if (tmcdrv && tmcdrv->hasIntegratedEncoder())
@@ -1041,7 +1144,7 @@ CommandStatus Axis::command(const ParsedCommand& cmd,std::vector<CommandReply>&
 		break;
 
 	case Axis_commands::expo:
-		handleGetSetFunc(cmd, replies, expoValInt, &Axis::setExpo, this); // need to also provide the expoScaler constant
+		handleGetSetFunc(cmd, replies, expoValue, &Axis::setExpo, this); // need to also provide the expoScaler constant
 		break;
 
 	case Axis_commands::exposcale:
diff --git a/Firmware/FFBoard/Src/CmdParser.cpp b/Firmware/FFBoard/Src/CmdParser.cpp
index 73640b9fd..bd61b1206 100644
--- a/Firmware/FFBoard/Src/CmdParser.cpp
+++ b/Firmware/FFBoard/Src/CmdParser.cpp
@@ -155,8 +155,8 @@ bool CmdParser::parse(std::vector<ParsedCommand>& commands){
 						// Check if conversion is even possible
 						bool validPqm = (pqm != std::string::npos && (std::isdigit(word[pqm+1]) || (std::isdigit(word[pqm+2]) && (word[pqm+1] == '-' || word[pqm+1] == '+')) || ( std::isxdigit(word[pqm+2]) && word[pqm+1] == 'x')));
 						bool validPeq = (peq != std::string::npos && (std::isdigit(word[peq+1]) || (std::isdigit(word[peq+2]) && (word[peq+1] == '-' || word[peq+1] == '+')) || ( std::isxdigit(word[peq+2]) && word[peq+1] == 'x')));
-
-						if(validPqm && validPeq && peq < pqm && (abs(pqm - peq) > 1)){ // <cmd>=<int>?<int>
+						int32_t pqm_peq_dist = (pqm - peq);
+						if(validPqm && validPeq && peq < pqm && (abs(pqm_peq_dist) > 1)){ // <cmd>=<int>?<int>
 							// Dual
 							int64_t val;
 							int64_t val2;
@@ -167,9 +167,9 @@ bool CmdParser::parse(std::vector<ParsedCommand>& commands){
 							}
 
 							if(word[peq+1] == 'x'){
-								val = (int64_t)std::strtoll(word.substr(peq+2, pqm-peq).c_str(),0,16);
+								val = (int64_t)std::strtoll(word.substr(peq+2, pqm_peq_dist).c_str(),0,16);
 							}else{
-								val = (int64_t)std::strtoll(word.substr(peq+1, pqm-peq).c_str(),0,10);
+								val = (int64_t)std::strtoll(word.substr(peq+1, pqm_peq_dist).c_str(),0,10);
 							}
 
 							cmdstring = word.substr(cmd_start, peq-cmd_start);
diff --git a/Firmware/FFBoard/Src/CommandHandler.cpp b/Firmware/FFBoard/Src/CommandHandler.cpp
index ae7c3fcbc..95cf4d823 100644
--- a/Firmware/FFBoard/Src/CommandHandler.cpp
+++ b/Firmware/FFBoard/Src/CommandHandler.cpp
@@ -12,6 +12,7 @@
 #include "CDCcomm.h"
 //#include <set>
 #include "ChoosableClass.h"
+#include <algorithm>
 
 //std::vector<CommandHandler*> CommandHandler::cmdHandlers;
 //std::set<uint16_t> CommandHandler::cmdHandlerIDs;
@@ -522,3 +523,39 @@ void CommandHandler::removeCommandHandler(){
 	removeCallbackHandler(getCommandHandlers(), this);
 	//cmdHandlerListMutex.Unlock();
 }
+
+/**
+ * Registers a new command. Called by registerCommand template
+ */
+void CommandHandler::registerCommand_INT(const char* cmd,const uint32_t cmdid,const char* help,uint32_t flags){
+	for(auto it = registeredCommands.begin();it!=registeredCommands.end();++it){
+		CmdHandlerCommanddef& cmdDef = *it;
+		if(cmdDef.cmdId == cmdid){
+			if(cmdDef.flags & CMDFLAG_EXTOVERRIDE){
+				// Override dummy present. Only update other data if not present and honor flag mask
+				flags &= flags | CMDFLAG_EXTOVERRIDE;
+				registeredCommands.erase(it); // Remove old dummy
+				break;
+			}else{
+				return; //already present
+			}
+		}
+	}
+
+	this->registeredCommands.emplace_back(cmd, help,cmdid,flags);
+	this->registeredCommands.shrink_to_fit();
+}
+
+/**
+ * Adds an override dummy or changes flags of a command. Called by template. TODO untested
+ */
+void CommandHandler::overrideCommandFlags_INT(const uint32_t cmdid,uint32_t flagmask){
+	for(CmdHandlerCommanddef& cmdDef : registeredCommands){
+		if(cmdDef.cmdId == static_cast<uint32_t>(cmdid)){
+			cmdDef.flags &= flagmask;
+			cmdDef.flags |= CMDFLAG_EXTOVERRIDE;
+			return; //already present
+		}
+	}
+	this->registeredCommands.emplace_back(nullptr, nullptr,cmdid,flagmask); // Dummy
+}
diff --git a/Firmware/FFBoard/Src/CommandInterface.cpp b/Firmware/FFBoard/Src/CommandInterface.cpp
index 9aa004c91..0427cd0d0 100644
--- a/Firmware/FFBoard/Src/CommandInterface.cpp
+++ b/Firmware/FFBoard/Src/CommandInterface.cpp
@@ -240,7 +240,7 @@ void StringCommandInterface::generateReplyFromCmd(std::string& replyPart,const P
  */
 
 
-CDC_CommandInterface::CDC_CommandInterface() : StringCommandInterface(1024), Thread("CDCCMD", 512, 37) {
+CDC_CommandInterface::CDC_CommandInterface() : StringCommandInterface(CDC_CMD_BUFFER_SIZE), Thread("CDCCMD", 512, 37) {
 	parser.setClearBufferTimeout(parserTimeout);
 	this->Start();
 }
diff --git a/Firmware/FFBoard/Src/EffectsCalculator.cpp b/Firmware/FFBoard/Src/EffectsCalculator.cpp
index 688afb25f..18fb6ed4f 100644
--- a/Firmware/FFBoard/Src/EffectsCalculator.cpp
+++ b/Firmware/FFBoard/Src/EffectsCalculator.cpp
@@ -11,6 +11,9 @@
 #include "Axis.h"
 #include "ledEffects.h"
 
+#ifdef USE_DSP_FUNCTIONS
+#include "arm_math.h"
+#endif
 
 #define EFFECT_STATE_INACTIVE 0
 
@@ -49,6 +52,7 @@ EffectsCalculator::EffectsCalculator() : CommandHandler("fx", CLSID_EFFECTSCALC)
 	registerCommand("filterProfile_id", EffectsCalculator_commands::filterProfileId, "Conditional effects filter profile: 0 default; 1 custom", CMDFLAG_GET | CMDFLAG_SET);
 
 	registerCommand("frictionPctSpeedToRampup", EffectsCalculator_commands::frictionPctSpeedToRampup, "% of max speed for gradual increase", CMDFLAG_GET | CMDFLAG_SET);
+	registerCommand("reconFilterMode", EffectsCalculator_commands::reconFilterMode, "Recon. filter: 0=None, 1=Linear, 2=CubicNatural, 3=CubicHermite", CMDFLAG_GET | CMDFLAG_SET);
 
 	//this->Start(); // Enable if we want to periodically monitor
 }
@@ -74,6 +78,15 @@ void EffectsCalculator::setActive(bool active)
 	setClipLed(active);
 }
 
+void EffectsCalculator::updateSamplerate(float newSamplerate){
+	this->calcfrequency = newSamplerate;
+	for(FFB_Effect &effect : this->effects){
+		if(effect.filter[0]){ // Update filters if effect has filters
+			setFilters(&effect);
+		}
+	}
+}
+
 
 /*
 If the metric is less than CP Offset - Dead Band, then the resulting force is given by the following formula:
@@ -87,6 +100,136 @@ An inertia condition uses axis acceleration as the metric.
 
  */
 
+float EffectsCalculator::getReconstructedvalue(ReconFilterState* state, float fallbackValue)
+{
+    // 'reconFilterMode' est une variable membre de la classe
+
+    float resulting_value = fallbackValue; // Par défaut, valeur "NONE"
+    uint32_t now_us = micros();
+    float last_known_time = state->spline_x[3]; // Le point le plus récent
+
+    // Timeout de 50ms (si le jeu est en pause, etc.)
+    if (!state->isSplineReady || (now_us > last_known_time + 50000)) {
+        return state->spline_y[3]; // Maintenir la dernière valeur
+    }
+
+    switch(reconFilterMode) {
+        case ReconFilterMode::NO_RECONSTRUCTION:
+            resulting_value = state->spline_y[3]; // La plus récente (pas de filtre)
+            break;
+
+        case ReconFilterMode::LINEAR_INTERPOLATION:
+        {
+			// "Safe" Linear Interpolation (Delayed by 1 sample)
+			// To absolutely guarantee NO OVERSHOOT, we must not extrapolate.
+			// We accept a strictly defined transport delay of 1 sample.
+			//
+			// Logic: We are currently at time 'now_us', which is AFTER the latest update 't1'.
+			// We don't know the future, so we replay the ramp from V0 to V1, but we start it NOW.
+			// We use the previous interval duration (t1 - t0) as our best guess for when the
+			// NEXT packet (t2) will arrive, ensuring we reach V1 exactly when t2 is expected.
+
+			float t0 = state->spline_x[2]; // Time of penultimate sample (T-1)
+			float t1 = state->spline_x[3]; // Time of latest sample (T)
+			float v0 = state->spline_y[2]; // Value of penultimate sample (V0)
+			float v1 = state->spline_y[3]; // Value of latest sample (V1)
+
+			// Estimate the expected duration until the next packet arrives.
+			float expected_interval = t1 - t0;
+
+			// Sanity check: avoid division by zero if updates are too fast (e.g. double-send bugs)
+			if (expected_interval < 1.0f) {
+				resulting_value = v1;
+				break;
+			}
+
+			// Calculate progress based on time elapsed SINCE t1.
+			float time_since_t1 = (float)(now_us - t1);
+			float progress = time_since_t1 / expected_interval;
+
+			// Clamp progress to [0.0, 1.0] to eliminate ANY overshoot.
+			progress = clip<float>(progress, 0.0f, 1.0f);
+
+			// Interpolate between the two KNOWN, SAFE past values.
+			resulting_value = v0 + progress * (v1 - v0);
+			break;
+        }
+
+#ifdef USE_DSP_FUNCTIONS
+        // if DSP is enabled we have SPLINE available, else use Hermite
+        case ReconFilterMode::SPLINE_CUBIC_NATURAL:
+        {
+        	//	 If spline is not ready, return last known value
+			if (!state->spline_arm_initialized) {
+				 resulting_value = state->spline_y[3];
+				 break;
+			}
+
+			float32_t interpolated_torque_f = 0.0f;
+			float32_t now_f = (float)now_us;
+
+			// Clamp time to known range to avoid extrapolation
+            float32_t interp_time = clip<float32_t>(now_f, state->spline_x[0], state->spline_x[3]);
+
+			// Perform the spline interpolation using CMSIS-DSP
+            arm_spline_f32(&state->spline_instance, &interp_time, &interpolated_torque_f, 1);
+
+			// Return the interpolated value
+            resulting_value = interpolated_torque_f;
+            break;
+        }
+#endif
+
+        case ReconFilterMode::SPLINE_CUBIC_HERMITE:
+#ifndef USE_DSP_FUNCTIONS
+        // if the DSP is not available, we use Hermite for spline
+        case ReconFilterMode::SPLINE_CUBIC_NATURAL:
+#endif
+        {
+            // Interpolation hermit is made betwwen P1 (idx 1) and P2 (idx 2)
+            const float p1 = state->spline_y[1];
+            const float p2 = state->spline_y[2];
+            const float t1 = state->spline_x[1];
+            const float t2 = state->spline_x[2];
+
+			// sanity check to not divide by zero and clamp for not overshoot
+            float interval = t2 - t1;
+            if (interval <= 0) {
+                resulting_value = p1;
+                break;
+            }
+            float t = ((float)now_us - t1) / interval;
+            t = clip<float>(t, 0.0f, 1.0f);
+
+            // Tangentes (Catmull-Rom)
+            float m1, m2;
+            float dt_m1 = state->spline_x[2] - state->spline_x[0];
+            float dt_m2 = state->spline_x[3] - state->spline_x[1];
+
+			// Compute tangents safely
+            if (dt_m1 > 0) m1 = (state->spline_y[2] - state->spline_y[0]) / dt_m1; else m1 = 0;
+            if (dt_m2 > 0) m2 = (state->spline_y[3] - state->spline_y[1]) / dt_m2; else m2 = 0;
+
+			// Scale tangents by interval
+            m1 *= interval;
+            m2 *= interval;
+
+			// Hermite basis functions
+            float tSq = t * t;
+            float tCub = tSq * t;
+            float h_00 = 2*tCub - 3*tSq + 1;
+            float h_10 = tCub - 2*tSq + t;
+            float h_01 = -2*tCub + 3*tSq;
+            float h_11 = tCub - tSq;
+
+			// Final interpolation
+            resulting_value = h_00 * p1 + h_10 * m1 + h_01 * p2 + h_11 * m2;
+            break;
+        }
+    }
+    return resulting_value;
+}
+
 /**
  * Calculates the resulting torque for FFB effects
  * Takes current position input scaled from -0x7fff to 0x7fff
@@ -94,67 +237,59 @@ An inertia condition uses axis acceleration as the metric.
  */
 void EffectsCalculator::calculateEffects(std::vector<std::unique_ptr<Axis>> &axes)
 {
-	for (auto &axis : axes) {
-		axis->setEffectTorque(0);
-		axis->calculateAxisEffects(isActive());
-	}
-
-	if(!isActive()){
-		return;
-	}
-
-	int32_t force = 0;
 	int axisCount = axes.size();
-	int32_t forces[MAX_AXIS] = {0};
+	int64_t forces[MAX_AXIS] = {0};
 
-	for (uint8_t i = 0; i < effects_stats.size(); i++)
-	{
-		effects_stats[i].current = {0}; // Reset active effect forces
-	}
+	if(isActive()){
+		int32_t force = 0;
+		for (uint8_t i = 0; i < effects_stats.size(); i++)
+		{
+			effects_stats[i].current = {0}; // Reset active effect forces
+		}
 
-	for (uint8_t fxi = 0; fxi < MAX_EFFECTS; fxi++)
-	{
-		FFB_Effect *effect = &effects[fxi];
+		for (uint8_t fxi = 0; fxi < MAX_EFFECTS; fxi++)
+		{
+			FFB_Effect *effect = &effects[fxi];
 
-		// Effect activated and not infinite (0 or 0xffff)
-		if (effect->state != EFFECT_STATE_INACTIVE && effect->duration != FFB_EFFECT_DURATION_INFINITE && effect->duration != 0){
-			// Start delay not yet reached
-			if(HAL_GetTick() < effect->startTime){
-				continue;
+			// Effect activated and not infinite (0 or 0xffff)
+			if (effect->state != EFFECT_STATE_INACTIVE && effect->duration != FFB_EFFECT_DURATION_INFINITE && effect->duration != 0){
+				// Start delay not yet reached
+				if(HAL_GetTick() < effect->startTime){
+					continue;
+				}
+				// If effect has expired make inactive
+				if (HAL_GetTick() - effect->startTime > effect->duration)
+				{
+					effect->state = EFFECT_STATE_INACTIVE;
+					for(uint8_t axis=0 ; axis < axisCount ; axis++)
+						calcStatsEffectType(effect->type, 0,axis); // record a 0 on the ended force
+				}
 			}
-			// If effect has expired make inactive
-			if (HAL_GetTick() - effect->startTime > effect->duration)
+
+			// Filter out inactive effects
+			if (effect->state == EFFECT_STATE_INACTIVE)
 			{
-				effect->state = EFFECT_STATE_INACTIVE;
-				for(uint8_t axis=0 ; axis < axisCount ; axis++)
-					calcStatsEffectType(effect->type, 0,axis); // record a 0 on the ended force
+				continue;
 			}
-		}
 
-		// Filter out inactive effects
-		if (effect->state == EFFECT_STATE_INACTIVE)
-		{
-			continue;
-		}
+			force = calcNonConditionEffectForce(effect);	// Compute the effect force
 
-		force = calcNonConditionEffectForce(effect);
-
-		for(uint8_t axis=0 ; axis < axisCount ; axis++) // Calculate effects for all axes
-		{
-			int32_t axisforce = calcComponentForce(effect, force, axes, axis);
-			calcStatsEffectType(effect->type, axisforce,axis);
-			forces[axis] += axisforce; // Do not clip yet to allow effects to subtract force correctly. Will not overflow as maxeffects * 0x7fff is less than int32 range
+			for(uint8_t axis=0 ; axis < axisCount ; axis++) // Calculate effects for all axes
+			{
+				int32_t axisforce = calculateEffectForceOnAxis(effect, force, axes, axis);
+				calcStatsEffectType(effect->type, axisforce,axis);
+				forces[axis] += axisforce; // Do not clip yet to allow effects to subtract force correctly. Will not overflow as maxeffects * 0x7fff is less than int32 range
+			}
 		}
+		effects_statslast = effects_stats;
 	}
 
 	// Apply summed force to axes
 	for(uint8_t i=0 ; i < axisCount ; i++)
 	{
-		int32_t force = clip<int32_t, int32_t>(forces[i], -0x7fff, 0x7fff); // Clip
-		axes[i]->setEffectTorque(force);
+		axes[i]->calculateMechanicalEffects(isActive());
+		axes[i]->setFfbEffectTorque(forces[i]);
 	}
-
-	effects_statslast = effects_stats;
 }
 
 /**
@@ -162,13 +297,40 @@ void EffectsCalculator::calculateEffects(std::vector<std::unique_ptr<Axis>> &axe
  * Periodic and constant effects
  */
 int32_t EffectsCalculator::calcNonConditionEffectForce(FFB_Effect *effect) {
-	int32_t force_vector = 0;
-	int32_t magnitude = effect->magnitude;
 
-	// If using an envelope modulate the magnitude based on time
-	if(effect->useEnvelope){
-		magnitude = getEnvelopeMagnitude(effect);
+	// Sanity check effect type must be non-conditional
+	// Avoid calculating reconstructed forces for conditional effects here
+	if (effect->type == FFB_EFFECT_SPRING ||
+		effect->type == FFB_EFFECT_DAMPER ||
+		effect->type == FFB_EFFECT_FRICTION ||
+		effect->type == FFB_EFFECT_INERTIA) {
+		return 0;
 	}
+
+	int32_t force_vector = 0;
+	
+	// Get interpolated magnitude (or amplitude)
+	float interpolated_magnitude = getReconstructedvalue(
+        &effect->recon_magnitude,    // Use the new structure
+        (float)effect->magnitude     // Fallback value (for NONE mode)
+    );
+
+    // Get interpolated offset
+    float interpolated_offset_float = getReconstructedvalue(
+        &effect->recon_offset,       // Use the new structure
+        (float)effect->offset		 // Fallback value (for NONE mode)
+    );
+    int32_t offset_lrf = (int32_t)interpolated_offset_float;
+
+	// Magnitude with envelope if used
+    int32_t magnitude; 
+	if(effect->useEnvelope){
+        magnitude = getEnvelopeMagnitude(effect, (int32_t)interpolated_magnitude);
+	} else {
+        magnitude = (int32_t)interpolated_magnitude;
+    }
+
+
 	switch (effect->type){
 
 	case FFB_EFFECT_CONSTANT:
@@ -179,34 +341,34 @@ int32_t EffectsCalculator::calcNonConditionEffectForce(FFB_Effect *effect) {
 
 	case FFB_EFFECT_RAMP:
 	{
-		uint32_t elapsed_time = HAL_GetTick() - effect->startTime;
+		float elapsed_time = (micros()/1000.0) - (float)effect->startTime;
 		int32_t duration = effect->duration;
-		force_vector = (int32_t)effect->startLevel + ((int32_t)elapsed_time * (effect->endLevel - effect->startLevel)) / duration;
+		force_vector = (int32_t)effect->startLevel + (elapsed_time * (effect->endLevel - effect->startLevel)) / duration;
 		break;
 	}
 
 	case FFB_EFFECT_SQUARE:
 	{
-		uint32_t elapsed_time = HAL_GetTick() - effect->startTime;
+		uint32_t elapsed_time = HAL_GetTick() - effect->startTime; // Square is ms aligned
 		int32_t force = ((elapsed_time + effect->phase) % ((uint32_t)effect->period + 2)) < (uint32_t)(effect->period + 2) / 2 ? -magnitude : magnitude;
-		force_vector = force + effect->offset;
+		force_vector = force + offset_lrf;
 		break;
 	}
 
 	case FFB_EFFECT_TRIANGLE:
 	{
 		int32_t force = 0;
-		int32_t offset = effect->offset;
-		uint32_t elapsed_time = HAL_GetTick() - effect->startTime;
+		int32_t offset = offset_lrf;
+		float elapsed_time = micros() - ((float)effect->startTime*1000.0);
 		uint32_t phase = effect->phase;
 		uint32_t period = effect->period;
 		float periodF = period;
 
 		int32_t maxMagnitude = offset + magnitude;
 		int32_t minMagnitude = offset - magnitude;
-		uint32_t phasetime = (phase * period) / 35999;
-		uint32_t timeTemp = elapsed_time + phasetime;
-		float remainder = timeTemp % period;
+		float phasetime = (phase * period) / 35999.0;
+		uint32_t timeTemp = elapsed_time + (phasetime*1000); // timetemp in µs
+		float remainder = (timeTemp % (period*1000)) / 1000;
 		float slope = ((maxMagnitude - minMagnitude) * 2) / periodF;
 		if (remainder > (periodF / 2))
 			force = slope * (periodF - remainder);
@@ -219,17 +381,17 @@ int32_t EffectsCalculator::calcNonConditionEffectForce(FFB_Effect *effect) {
 
 	case FFB_EFFECT_SAWTOOTHUP:
 	{
-		float offset = effect->offset;
-		uint32_t elapsed_time = HAL_GetTick() - effect->startTime;
+		float offset = offset_lrf;
+		float elapsed_time = micros() - ((float)effect->startTime*1000.0);
 		uint32_t phase = effect->phase;
 		uint32_t period = effect->period;
 		float periodF = effect->period;
 
 		float maxMagnitude = offset + magnitude;
 		float minMagnitude = offset - magnitude;
-		int32_t phasetime = (phase * period) / 35999;
-		uint32_t timeTemp = elapsed_time + phasetime;
-		float remainder = timeTemp % period;
+		float phasetime = (phase * period) / 35999.0;
+		uint32_t timeTemp = elapsed_time + (phasetime*1000); // timetemp in µs
+		float remainder = (timeTemp % (period*1000)) / 1000;
 		float slope = (maxMagnitude - minMagnitude) / periodF;
 		force_vector = (int32_t)(minMagnitude + slope * (period - remainder));
 		break;
@@ -237,17 +399,17 @@ int32_t EffectsCalculator::calcNonConditionEffectForce(FFB_Effect *effect) {
 
 	case FFB_EFFECT_SAWTOOTHDOWN:
 	{
-		float offset = effect->offset;
-		uint32_t elapsed_time = HAL_GetTick() - effect->startTime;
+		float offset = offset_lrf;
+		float elapsed_time = micros() - ((float)effect->startTime*1000.0);
 		float phase = effect->phase;
 		uint32_t period = effect->period;
 		float periodF = effect->period;
 
 		float maxMagnitude = offset + magnitude;
 		float minMagnitude = offset - magnitude;
-		int32_t phasetime = (phase * period) / 35999;
-		uint32_t timeTemp = elapsed_time + phasetime;
-		float remainder = timeTemp % period;
+		float phasetime = (phase * period) / 35999.0;
+		uint32_t timeTemp = elapsed_time + (phasetime*1000); // timetemp in µs
+		float remainder = (timeTemp % (period*1000)) / 1000;
 		float slope = (maxMagnitude - minMagnitude) / periodF;
 		force_vector = (int32_t)(minMagnitude + slope * (remainder)); // reverse time
 		break;
@@ -255,11 +417,15 @@ int32_t EffectsCalculator::calcNonConditionEffectForce(FFB_Effect *effect) {
 
 	case FFB_EFFECT_SINE:
 	{
-		float t = HAL_GetTick() - effect->startTime;
+		float t = (micros()/1000.0) - (float)effect->startTime;
 		float freq = 1.0f / (float)(std::max<uint16_t>(effect->period, 2));
 		float phase = (float)effect->phase / (float)35999; //degrees
-		float sine = sinf(2.0 * M_PI * (t * freq + phase)) * magnitude;
-		force_vector = (int32_t)(effect->offset + sine);
+#ifdef USE_DSP_FUNCTIONS
+		float sine = arm_sin_f32(2.0f * PI * (t * freq + phase)) * magnitude;
+#else
+		float sine = sinf(2.0f * M_PI * (t * freq + phase)) * magnitude;
+#endif
+		force_vector = (int32_t)(offset_lrf + sine);
 		break;
 	}
 	default:
@@ -273,10 +439,15 @@ int32_t EffectsCalculator::calcNonConditionEffectForce(FFB_Effect *effect) {
 
 
 /**
- * Calculates the force of an effect
+ * @brief Calculates the final force of a single effect on a specific axis.
+ * It applies directional scaling and computes conditional effects (spring, damper, etc.) based on the axis's metrics.
+ * @param effect The effect to calculate.
+ * @param forceVector The base force from a non-conditional calculation (e.g., sine wave value).
+ * @param axes The list of all axes.
+ * @param axis The index of the axis to calculate the force for.
+ * @return The calculated torque for the axis.
  */
-
-int32_t EffectsCalculator::calcComponentForce(FFB_Effect *effect, int32_t forceVector, std::vector<std::unique_ptr<Axis>> &axes, uint8_t axis)
+int32_t EffectsCalculator::calculateEffectForceOnAxis(FFB_Effect *effect, int32_t forceVector, std::vector<std::unique_ptr<Axis>> &axes, uint8_t axis)
 {
 	int32_t result_torque = 0;
 //	uint16_t direction;
@@ -313,7 +484,7 @@ int32_t EffectsCalculator::calcComponentForce(FFB_Effect *effect, int32_t forceV
 
 	case FFB_EFFECT_SPRING:
 	{
-		float pos = metrics->pos;
+		float pos = metrics->pos_scaled_16b;
 		result_torque -= calcConditionEffectForce(effect, pos, gain.spring, con_idx, scaler.spring, angle_ratio);
 		break;
 	}
@@ -351,9 +522,13 @@ int32_t EffectsCalculator::calcComponentForce(FFB_Effect *effect, int32_t forceV
 			float rampupFactor = 1.0;
 			if (fabs (speed) < speedRampupCeil) {								// if speed in the range to rampup we apply a sinus curbe to ramup
 
-				float phaseRad = M_PI * ((fabs (speed) / speedRampupCeil) - 0.5);// we start to compute the normalized angle (speed / normalizedSpeed@5%) and translate it of -1/2PI to translate sin on 1/2 periode
-				rampupFactor = ( 1 + sin(phaseRad ) ) / 2;						// sin value is -1..1 range, we translate it to 0..2 and we scale it by 2
-
+#ifdef USE_DSP_FUNCTIONS
+				float phaseRad = PI * ((fabsf (speed) / speedRampupCeil) - 0.5f);// we start to compute the normalized angle (speed / normalizedSpeed@5%) and translate it of -1/2PI to translate sin on 1/2 periode
+				rampupFactor = ( 1.0f + arm_sin_f32(phaseRad ) ) / 2.0f;			// sin value is -1..1 range, we translate it to 0..2 and we scale it by 2
+#else
+				float phaseRad = M_PI * ((fabsf (speed) / speedRampupCeil) - 0.5f);// we start to compute the normalized angle (speed / normalizedSpeed@5%) and translate it of -1/2PI to translate sin on 1/2 periode
+				rampupFactor = ( 1.0f + sinf(phaseRad ) ) / 2.0f;			// sin value is -1..1 range, we translate it to 0..2 and we scale it by 2
+#endif
 			}
 
 			int8_t sign = speed >= 0 ? 1 : -1;
@@ -438,12 +613,12 @@ int32_t EffectsCalculator::calcConditionEffectForce(FFB_Effect *effect, float  m
  * until the fade time where the strength changes to the fade level until the stop time of the effect.
  * Infinite effects can't have an envelope and return the normal magnitude.
  */
-int32_t EffectsCalculator::getEnvelopeMagnitude(FFB_Effect *effect)
+int32_t EffectsCalculator::getEnvelopeMagnitude(FFB_Effect *effect, int32_t baseMagnitude)
 {
 	if(effect->duration == FFB_EFFECT_DURATION_INFINITE || effect->duration == 0){
 		return effect->magnitude; // Effect is infinite. envelope is invalid
 	}
-	int32_t scaler = abs(effect->magnitude);
+	int32_t scaler = abs(baseMagnitude);
 	uint32_t elapsed_time = HAL_GetTick() - effect->startTime;
 	if (elapsed_time < effect->attackTime && effect->attackTime != 0)
 	{
@@ -457,7 +632,7 @@ int32_t EffectsCalculator::getEnvelopeMagnitude(FFB_Effect *effect)
 		scaler /= (int32_t)effect->fadeTime;
 		scaler += effect->fadeLevel;
 	}
-	scaler = signbit(effect->magnitude) ? -scaler : scaler; // Follow original sign of magnitude because envelope has no sign (important for constant force)
+	scaler = signbit(baseMagnitude) ? -scaler : scaler; // Follow original sign of magnitude because envelope has no sign (important for constant force)
 	return scaler;
 }
 
@@ -507,6 +682,66 @@ void EffectsCalculator::setFilters(FFB_Effect *effect){
 	}
 }
 
+void EffectsCalculator::pushReconParam(ReconFilterState* state, float newValue)
+{
+    uint32_t now_us = micros();
+
+    // Shift the spline points
+    for (int i = 0; i < 3; ++i) {
+        state->spline_x[i] = state->spline_x[i + 1];
+        state->spline_y[i] = state->spline_y[i + 1];
+    }
+
+    // Add the new point
+    state->spline_x[3] = (float)now_us;
+    state->spline_y[3] = newValue;
+
+    // FIll in initial points if not ready yet at 60Hz, so 16.66ms intervals
+    if (!state->isSplineReady) {
+        float fake_time_step = 16666.0f; // 60Hz
+        state->spline_x[0] = state->spline_x[3] - 3.0f * fake_time_step;
+        state->spline_y[0] = state->spline_y[3];
+        state->spline_x[1] = state->spline_x[3] - 2.0f * fake_time_step;
+        state->spline_y[1] = state->spline_y[3];
+        state->spline_x[2] = state->spline_x[3] - 1.0f * fake_time_step;
+        state->spline_y[2] = state->spline_y[3];
+        state->isSplineReady = true; // Ready after first fill
+    }
+
+    // Initialize spline if needed
+    if (reconFilterMode == ReconFilterMode::SPLINE_CUBIC_NATURAL) {
+#ifdef USE_DSP_FUNCTIONS
+        arm_spline_init_f32(
+            &state->spline_instance,
+            ARM_SPLINE_NATURAL,
+            state->spline_x,
+            state->spline_y,
+            4,
+            state->spline_y2,
+            state->spline_scratch
+        );
+
+		state->spline_arm_initialized = true;
+		
+#endif
+    }
+}
+
+void EffectsCalculator::pushReconFilterValue(FFB_Effect* effect, float new_magnitude, float new_offset, bool is_periodic)
+{
+	// Update target variables (for NONE mode and fallback)
+    effect->magnitude = (int16_t)new_magnitude;
+
+    // Push new magnitude into recon structure
+    pushReconParam(&effect->recon_magnitude, new_magnitude);
+
+    // Push new offset into recon structure if periodic
+    if (is_periodic) {
+        effect->offset = (int16_t)new_offset;
+        pushReconParam(&effect->recon_offset, new_offset);
+    }
+}
+
 
 void EffectsCalculator::setGain(uint8_t gain)
 {
@@ -515,8 +750,6 @@ void EffectsCalculator::setGain(uint8_t gain)
 
 uint8_t EffectsCalculator::getGain() { return global_gain; }
 
-
-
 /*
  * Read parameters from flash and restore settings
  */
@@ -569,6 +802,11 @@ void EffectsCalculator::restoreFlash()
 		frictionPctSpeedToRampup = (effects & 0xff);
 	}
 
+	// Read reconstruction parameters
+	if(Flash_Read(ADR_FFB_RECONSTRUCTION_FILTER, &effects)){
+		reconFilterMode = (ReconFilterMode)(effects & 0x03);
+	}
+
 }
 
 // Saves parameters to flash
@@ -609,6 +847,9 @@ void EffectsCalculator::saveFlash()
 	effects = frictionPctSpeedToRampup | (filterProfileId << 8);
 	Flash_Write(ADR_FFB_EFFECTS3, effects);
 
+	// Save reconstruction parameters
+	effects = (uint16_t)(reconFilterMode);
+	Flash_Write(ADR_FFB_RECONSTRUCTION_FILTER, effects);
 }
 
 void EffectsCalculator::checkFilterCoeff(biquad_constant_t *filter, uint32_t freq,uint8_t q)
@@ -669,12 +910,12 @@ void EffectsCalculator::logEffectState(uint8_t type,uint8_t state){
 }
 
 
-void EffectsCalculator::calcStatsEffectType(uint8_t type, int16_t force,uint8_t axis){
+void EffectsCalculator::calcStatsEffectType(uint8_t type, int32_t force,uint8_t axis){
 	if(axis >= MAX_AXIS)
 		return;
 	if(type > 0 && type < 13) {
 		uint8_t arrayLocation = type - 1;
-		effects_stats[arrayLocation].current[axis] = clip<int32_t,int16_t>(effects_stats[arrayLocation].current[axis] + force, -0x7fff, 0x7fff);
+		effects_stats[arrayLocation].current[axis] = clip<int32_t,int32_t>(effects_stats[arrayLocation].current[axis] + force, -0x7fff, 0x7fff);
 		effects_stats[arrayLocation].max[axis] = std::max(effects_stats[arrayLocation].max[axis], (int16_t)abs(force));
 	}
 }
@@ -934,6 +1175,15 @@ CommandStatus EffectsCalculator::command(const ParsedCommand& cmd,std::vector<Co
 		}
 		break;
 
+	case EffectsCalculator_commands::reconFilterMode:
+        if (cmd.type == CMDtype::get) {
+            replies.emplace_back((uint32_t)reconFilterMode);
+        } else if (cmd.type == CMDtype::set) {
+            uint32_t mode = clip<uint32_t, uint32_t>(cmd.val, 0, 3);
+            reconFilterMode = (ReconFilterMode)mode;
+        }
+        break;
+
 	default:
 		return CommandStatus::NOT_FOUND;
 	}
@@ -1001,12 +1251,12 @@ int32_t EffectsCalculator::find_free_effect(uint8_t type){
  */
 uint32_t EffectsControlItf::getRate(){
 	float periodAvg = fxPeriodAvg.getAverage();
-	if((HAL_GetTick() - lastFxUpdate) > 1000 || periodAvg == 0){
+	if((micros() - lastFxUpdate) > 1000000 || periodAvg == 0){
 		// Reset average
 		fxPeriodAvg.clear();
 		return 0;
 	}else{
-		return (1000.0/periodAvg);
+		return (1000000.0/periodAvg);
 	}
 }
 
@@ -1015,22 +1265,22 @@ uint32_t EffectsControlItf::getRate(){
  */
 uint32_t EffectsControlItf::getConstantForceRate(){
 	float periodAvg = cfUpdatePeriodAvg.getAverage();
-	if((HAL_GetTick() - lastCfUpdate) > 1000 || periodAvg == 0){
+	if((micros() - lastCfUpdate) > 1000000 || periodAvg == 0){
 		// Reset average
 		cfUpdatePeriodAvg.clear();
 		return 0;
 	}else{
-		return (1000.0/periodAvg);
+		return (1000000.0/periodAvg);
 	}
 }
 
 
 void EffectsControlItf::cfUpdateEvent(){
-	cfUpdatePeriodAvg.addValue((uint32_t)(HAL_GetTick() - lastCfUpdate));
-	lastCfUpdate = HAL_GetTick();
+	cfUpdatePeriodAvg.addValue((uint32_t)(micros() - lastCfUpdate));
+	lastCfUpdate = micros();
 }
 
 void EffectsControlItf::fxUpdateEvent(){
-	fxPeriodAvg.addValue((uint32_t)(HAL_GetTick() - lastFxUpdate));
-	lastFxUpdate = HAL_GetTick();
+	fxPeriodAvg.addValue((uint32_t)(micros() - lastFxUpdate));
+	lastFxUpdate = micros();
 }
diff --git a/Firmware/FFBoard/Src/ErrorHandler.cpp b/Firmware/FFBoard/Src/ErrorHandler.cpp
index 94f6eaf22..dc7ff60e4 100644
--- a/Firmware/FFBoard/Src/ErrorHandler.cpp
+++ b/Firmware/FFBoard/Src/ErrorHandler.cpp
@@ -10,6 +10,7 @@
 #include "FFBoardMain.h"
 #include "cppmain.h"
 #include "critical.hpp"
+#include <algorithm>
 #include <span>
 
 std::vector<ErrorHandler*> ErrorHandler::errorHandlers;
diff --git a/Firmware/FFBoard/Src/Filters.cpp b/Firmware/FFBoard/Src/Filters.cpp
index a62074783..0d3adc9c3 100644
--- a/Firmware/FFBoard/Src/Filters.cpp
+++ b/Firmware/FFBoard/Src/Filters.cpp
@@ -2,18 +2,33 @@
  * Filters.cpp
  *
  *  Created on: Feb 13, 2020
- *      Author: Yannick
+ *      Author: Yannick, Vincent
+ *
+ *  Based on http://www.earlevel.com/main/2012/11/26/biquad-c-source-code/
  */
 
 #include "Filters.h"
-
 #include <math.h>
 
+#ifdef USE_DSP_FUNCTIONS
+#include "arm_math.h"
+#endif
 
 Biquad::Biquad(){
-	z1 = z2 = 0.0;
+#ifdef USE_DSP_FUNCTIONS
+    // Clear state
+    memset(pState, 0, sizeof(pState));
+	// Initialize the CMSIS-DSP biquad instance
+    arm_biquad_cascade_df1_init_f32(&S, 1, pCoeffs, pState);
+#else
+    z1 = 0.0f;
+    z2 = 0.0f; 
+#endif
 }
 Biquad::Biquad(BiquadType type, float Fc, float Q, float peakGainDB) {
+#ifdef USE_DSP_FUNCTIONS
+    arm_biquad_cascade_df1_init_f32(&S, 1, pCoeffs, pState);
+#endif
     setBiquad(type, Fc, Q, peakGainDB);
 }
 
@@ -47,13 +62,23 @@ float Biquad::getQ() const {
 	return this->Q;
 }
 
+void Biquad::setPeakGain(float peakGainDB) {
+    this->peakGain = peakGainDB;
+    calcBiquad();
+}
+
 /**
  * Calculates one step of the filter and returns the output
  */
 float Biquad::process(float in) {
-	float out = in * a0 + z1;
+    float out;
+#ifdef USE_DSP_FUNCTIONS
+    arm_biquad_cascade_df1_f32(&S, &in, &out, 1);
+#else
+	out = in * a0 + z1;
     z1 = in * a1 + z2 - b1 * out;
     z2 = in * a2 - b2 * out;
+#endif
     return out;
 }
 
@@ -70,11 +95,18 @@ void Biquad::setBiquad(BiquadType type, float Fc, float Q, float peakGainDB) {
  * Updates parameters and resets the biquad filter
  */
 void Biquad::calcBiquad(void) {
+    float norm;
+    float K, V;
+#ifdef USE_DSP_FUNCTIONS
+    float a0, a1, a2, b1, b2;
+    V = powf(10, fabsf(peakGain) / 20.0f);
+    K = arm_sin_f32(PI * Fc) / arm_cos_f32(PI * Fc);
+#else
 	z1 = 0.0;
 	z2 = 0.0;
-    float norm;
-    float V = pow(10, fabs(peakGain) / 20.0);
-    float K = tan(M_PI * Fc);
+    V = pow(10, fabs(peakGain) / 20.0);
+    K = tan(M_PI * Fc);
+#endif
     switch (this->type) {
         case BiquadType::lowpass:
             norm = 1 / (1 + K / Q + K * K);
@@ -132,41 +164,84 @@ void Biquad::calcBiquad(void) {
             break;
         case BiquadType::lowshelf:
             if (peakGain >= 0) {    // boost
-                norm = 1 / (1 + sqrt(2) * K + K * K);
-                a0 = (1 + sqrt(2*V) * K + V * K * K) * norm;
+				float sqrt2, sqrt2V;
+#ifdef USE_DSP_FUNCTIONS
+				arm_sqrt_f32(2, &sqrt2);
+				arm_sqrt_f32(2*V, &sqrt2V);
+#else
+                sqrt2 = sqrt(2);
+                sqrt2V = sqrt(2*V);
+#endif
+                norm = 1 / (1 + sqrt2 * K + K * K);
+                a0 = (1 + sqrt2V * K + V * K * K) * norm;
                 a1 = 2 * (V * K * K - 1) * norm;
-                a2 = (1 - sqrt(2*V) * K + V * K * K) * norm;
+                a2 = (1 - sqrt2V * K + V * K * K) * norm;
                 b1 = 2 * (K * K - 1) * norm;
-                b2 = (1 - sqrt(2) * K + K * K) * norm;
+                b2 = (1 - sqrt2 * K + K * K) * norm;
             }
             else {    // cut
-                norm = 1 / (1 + sqrt(2*V) * K + V * K * K);
-                a0 = (1 + sqrt(2) * K + K * K) * norm;
+				float sqrt2, sqrt2V;
+#ifdef USE_DSP_FUNCTIONS
+				arm_sqrt_f32(2, &sqrt2);
+				arm_sqrt_f32(2*V, &sqrt2V);
+#else
+                sqrt2 = sqrt(2);
+                sqrt2V = sqrt(2*V);
+#endif
+                norm = 1 / (1 + sqrt2V * K + V * K * K);
+                a0 = (1 + sqrt2 * K + K * K) * norm;
                 a1 = 2 * (K * K - 1) * norm;
-                a2 = (1 - sqrt(2) * K + K * K) * norm;
+                a2 = (1 - sqrt2 * K + K * K) * norm;
                 b1 = 2 * (V * K * K - 1) * norm;
-                b2 = (1 - sqrt(2*V) * K + V * K * K) * norm;
+                b2 = (1 - sqrt2V * K + V * K * K) * norm;
             }
             break;
         case BiquadType::highshelf:
             if (peakGain >= 0) {    // boost
-                norm = 1 / (1 + sqrt(2) * K + K * K);
-                a0 = (V + sqrt(2*V) * K + K * K) * norm;
+				float sqrt2, sqrt2V;
+#ifdef USE_DSP_FUNCTIONS
+				arm_sqrt_f32(2, &sqrt2);
+				arm_sqrt_f32(2*V, &sqrt2V);
+#else
+                sqrt2 = sqrt(2);
+                sqrt2V = sqrt(2*V);
+#endif
+                norm = 1 / (1 + sqrt2 * K + K * K);
+                a0 = (V + sqrt2V * K + K * K) * norm;
                 a1 = 2 * (K * K - V) * norm;
-                a2 = (V - sqrt(2*V) * K + K * K) * norm;
+                a2 = (V - sqrt2V * K + K * K) * norm;
                 b1 = 2 * (K * K - 1) * norm;
-                b2 = (1 - sqrt(2) * K + K * K) * norm;
+                b2 = (1 - sqrt2 * K + K * K) * norm;
             }
             else {    // cut
-                norm = 1 / (V + sqrt(2*V) * K + K * K);
-                a0 = (1 + sqrt(2) * K + K * K) * norm;
+				float sqrt2, sqrt2V;
+#ifdef USE_DSP_FUNCTIONS
+				arm_sqrt_f32(2, &sqrt2);
+				arm_sqrt_f32(2*V, &sqrt2V);
+#else
+                sqrt2 = sqrt(2);
+                sqrt2V = sqrt(2*V);
+#endif
+                norm = 1 / (V + sqrt2V * K + K * K);
+                a0 = (1 + sqrt2 * K + K * K) * norm;
                 a1 = 2 * (K * K - 1) * norm;
-                a2 = (1 - sqrt(2) * K + K * K) * norm;
+                a2 = (1 - sqrt2 * K + K * K) * norm;
                 b1 = 2 * (K * K - V) * norm;
-                b2 = (V - sqrt(2*V) * K + K * K) * norm;
+                b2 = (V - sqrt2V * K + K * K) * norm;
             }
             break;
     }
 
-    return;
+#ifdef USE_DSP_FUNCTIONS
+    // Store coefficients in the format required by CMSIS-DSP: {b0, b1, b2, -a1, -a2}
+    // Note the negated feedback coefficients a1 and a2.
+    pCoeffs[0] = a0;
+    pCoeffs[1] = a1;
+    pCoeffs[2] = a2;
+    pCoeffs[3] = -b1;
+    pCoeffs[4] = -b2;
+
+	// Reset state
+	memset(pState, 0, sizeof(pState));
+#endif
 }
diff --git a/Firmware/FFBoard/Src/HidCommandInterface.cpp b/Firmware/FFBoard/Src/HidCommandInterface.cpp
index 9a73a4268..418c3a032 100644
--- a/Firmware/FFBoard/Src/HidCommandInterface.cpp
+++ b/Firmware/FFBoard/Src/HidCommandInterface.cpp
@@ -99,7 +99,7 @@ void HID_CommandInterface::sendReplies(const std::vector<CommandResult>& results
 		}
 
 
-		for(const CommandReply reply : replies){
+		for(const CommandReply& reply : replies){
 			if(reply.type == CommandReplyType::STRING){
 				continue; // Ignore string only replies
 			}
diff --git a/Firmware/FFBoard/Src/HidFFB.cpp b/Firmware/FFBoard/Src/HidFFB.cpp
index 21835fef3..fc4f3d3b3 100644
--- a/Firmware/FFBoard/Src/HidFFB.cpp
+++ b/Firmware/FFBoard/Src/HidFFB.cpp
@@ -12,6 +12,10 @@
 #include "cppmain.h"
 #include <math.h>
 
+#ifdef USE_DSP_FUNCTIONS
+#include "arm_math.h"
+#endif
+
 HidFFB::HidFFB(std::shared_ptr<EffectsCalculator> ec,uint8_t axisCount) : effects_calc(ec), effects(ec->effects),axisCount(axisCount)
 {
 	directionEnableMask = 1 << axisCount; // Direction enable bit is last bit after axis enable bits
@@ -39,6 +43,10 @@ void HidFFB::setDirectionEnableMask(uint8_t mask){
 	this->directionEnableMask = mask;
 }
 
+void HidFFB::updateSamplerate(float newSamplerate){
+	effects_calc->updateSamplerate(newSamplerate);
+}
+
 
 bool HidFFB::getFfbActive(){
 	return this->ffb_active;
@@ -231,7 +239,8 @@ void HidFFB::set_constant_effect(FFB_SetConstantForce_Data_t* data){
 	cfUpdateEvent();
 	FFB_Effect& effect_p = effects[data->effectBlockIndex-1];
 
-	effect_p.magnitude = data->magnitude;
+	//effect_p.magnitude = data->magnitude;
+	effects_calc->pushReconFilterValue(&effect_p, (float)data->magnitude, 0.0f, false);
 //	if(effect_p.state == 0){
 //		effect_p.state = 1; // Force start effect
 //	}
@@ -311,10 +320,16 @@ void HidFFB::set_effect(FFB_SetEffect_t* effect){
 
 
 	if(!overridesCondition){
-		float phaseX = M_PI*2.0 * (effect->directionX/36000.0f);
+#ifdef USE_DSP_FUNCTIONS
+		float phaseX = PI*2.0f * (effect->directionX/36000.0f);
 
+		effect_p->axisMagnitudes[0] = directionEnable ? arm_sin_f32(phaseX) : (effect->enableAxis & X_AXIS_ENABLE ? (effect->directionX - 18000.0f) / 18000.0f : 0); // Angular vector if dirEnable used otherwise linear or 0 if axis enabled
+		effect_p->axisMagnitudes[1] = directionEnable ? -arm_cos_f32(phaseX) : (effect->enableAxis & Y_AXIS_ENABLE ? -(effect->directionY - 18000.0f) / 18000.0f : 0);
+#else
+		float phaseX = M_PI*2.0f * (effect->directionX/36000.0);
 		effect_p->axisMagnitudes[0] = directionEnable ? sin(phaseX) : (effect->enableAxis & X_AXIS_ENABLE ? (effect->directionX - 18000.0f) / 18000.0f : 0); // Angular vector if dirEnable used otherwise linear or 0 if axis enabled
 		effect_p->axisMagnitudes[1] = directionEnable ? -cos(phaseX) : (effect->enableAxis & Y_AXIS_ENABLE ? -(effect->directionY - 18000.0f) / 18000.0f : 0);
+#endif
 	}
 
 #if MAX_AXIS == 3
@@ -449,9 +464,11 @@ void HidFFB::set_periodic(FFB_SetPeriodic_Data_t* report){
 	FFB_Effect* effect = &effects[report->effectBlockIndex-1];
 
 	effect->period = clip<uint32_t,uint32_t>(report->period,1,0x7fff); // Period is never 0
-	effect->magnitude = report->magnitude;
-	effect->offset = report->offset;
 	effect->phase = report->phase;
+
+	effects_calc->pushReconFilterValue(effect, (float)report->magnitude, (float)report->offset, true);
+	//effect->magnitude = report->magnitude;
+	//effect->offset = report->offset;
 	//effect->counter = 0;
 }
 
diff --git a/Firmware/FFBoard/Src/I2C.cpp b/Firmware/FFBoard/Src/I2C.cpp
index decbe4192..33470ab8a 100644
--- a/Firmware/FFBoard/Src/I2C.cpp
+++ b/Firmware/FFBoard/Src/I2C.cpp
@@ -14,24 +14,6 @@ ClassIdentifier I2CPort::info = {
 
 
 
-//static bool operator==(const I2C_InitTypeDef& lhs, const I2C_InitTypeDef& rhs) {
-//	return lhs.AddressingMode == rhs.AddressingMode
-//			&& lhs.ClockSpeed == rhs.ClockSpeed
-//			&& lhs.DualAddressMode == rhs.DualAddressMode
-//			&& lhs.DutyCycle == rhs.DutyCycle
-//			&& lhs.GeneralCallMode == rhs.GeneralCallMode
-//			&& lhs.NoStretchMode == rhs.NoStretchMode
-//			&& lhs.OwnAddress1 == rhs.OwnAddress1
-//			&& lhs.OwnAddress2 == rhs.OwnAddress2;
-//}
-
-//static bool operator==(const I2C_InitTypeDef& lhs, const I2C_InitTypeDef& rhs) {
-//	return memcmp(&lhs,&rhs,sizeof(I2C_InitTypeDef)) == 0;
-//}
-//
-
-
-
 I2CPort::I2CPort(I2C_HandleTypeDef &hi2c,const I2CPortHardwareConfig& presets,uint8_t instance) : CommandHandler("i2c", CLSID_I2CPORT, instance), hi2c(hi2c),presets(presets) {
 	restoreFlashDelayed();
 #ifdef I2C_COMMANDS_DISABLED_IF_NOT_USED
diff --git a/Firmware/FFBoard/Src/MotorDriver.cpp b/Firmware/FFBoard/Src/MotorDriver.cpp
index b7325de9d..cd27754cc 100644
--- a/Firmware/FFBoard/Src/MotorDriver.cpp
+++ b/Firmware/FFBoard/Src/MotorDriver.cpp
@@ -81,6 +81,12 @@ const ClassIdentifier MotorDriver::getInfo(){
 	return info;
 }
 
+/**
+ * Setup driver when is selected
+ */
+void MotorDriver::setupDriver(){
+
+}
 
 /**
  * Turn the motor with positive/negative power.
diff --git a/Firmware/FFBoard/Src/SPI.cpp b/Firmware/FFBoard/Src/SPI.cpp
index 37185ea27..937cae4a8 100644
--- a/Firmware/FFBoard/Src/SPI.cpp
+++ b/Firmware/FFBoard/Src/SPI.cpp
@@ -288,7 +288,7 @@ void SPIPort::SpiError(SPI_HandleTypeDef *hspi) {
  * Calculates the closest possible clock achievable with the current base clock and prescalers
  * Returns a pair of {prescaler,actual_clock}
  */
-std::pair<uint32_t,float> SPIPort::getClosestPrescaler(float clock){
+std::pair<uint32_t,float> SPIPort::getClosestPrescaler(float clock,float min,float max){
 	std::vector<std::pair<uint32_t,float>> distances;
 #if defined(SPI_BAUDRATEPRESCALER_2)
 	distances.push_back({SPI_BAUDRATEPRESCALER_2,(baseclk/2.0)});
@@ -318,7 +318,7 @@ std::pair<uint32_t,float> SPIPort::getClosestPrescaler(float clock){
 	std::pair<uint32_t,float> bestVal = distances[0];
 	float bestDist = INFINITY;
 	for(auto& val : distances){
-		if(std::abs(clock-val.second) < bestDist){
+		if(std::abs(clock-val.second) < bestDist && (val.second > min && val.second < max)){
 			bestDist = abs(clock-val.second);
 			bestVal = val;
 		}
@@ -328,9 +328,11 @@ std::pair<uint32_t,float> SPIPort::getClosestPrescaler(float clock){
 
 SPIDevice::SPIDevice(SPIPort& port,SPIConfig& spiConfig) : spiPort{port},spiConfig{spiConfig}{
 	spiPort.reserveCsPin(spiConfig.cs);
+	this->spiConfig.peripheral = port.getPortHandle()->Init;
 }
 SPIDevice::SPIDevice(SPIPort& port,OutputPin csPin) : spiPort{port},spiConfig{csPin}{
 	this->spiConfig.cs = csPin;
+	this->spiConfig.peripheral = port.getPortHandle()->Init;
 	spiPort.reserveCsPin(spiConfig.cs);
 }
 SPIDevice::~SPIDevice() {
diff --git a/Firmware/FFBoard/Src/SerialFFB.cpp b/Firmware/FFBoard/Src/SerialFFB.cpp
index a439850d4..6e00d25d0 100644
--- a/Firmware/FFBoard/Src/SerialFFB.cpp
+++ b/Firmware/FFBoard/Src/SerialFFB.cpp
@@ -121,6 +121,10 @@ void SerialFFB::setEffectState(uint8_t id, bool state){
 	effects[id].state = state ? 1 : 0;
 }
 
+void SerialFFB::updateSamplerate(float newSamplerate){
+	effects_calc->updateSamplerate(newSamplerate);
+}
+
 CommandStatus SerialFFB::command(const ParsedCommand& cmd,std::vector<CommandReply>& replies){
 	CommandStatus status = CommandStatus::OK;
 	EffectsControlItf::fxUpdateEvent();
diff --git a/Firmware/FFBoard/Src/SystemCommands.cpp b/Firmware/FFBoard/Src/SystemCommands.cpp
index c42b0918a..853f46ec6 100644
--- a/Firmware/FFBoard/Src/SystemCommands.cpp
+++ b/Firmware/FFBoard/Src/SystemCommands.cpp
@@ -61,7 +61,7 @@ void SystemCommands::registerCommands(){
 	CommandHandler::registerCommand("errors", FFBoardMain_commands::errors, "Read error states",CMDFLAG_GET);
 	CommandHandler::registerCommand("errorsclr", FFBoardMain_commands::errorsclr, "Reset errors",CMDFLAG_GET);
 	CommandHandler::registerCommand("heapfree", FFBoardMain_commands::heapfree, "Memory info",CMDFLAG_GET);
-#if configUSE_STATS_FORMATTING_FUNCTIONS> 0
+#if ( ( configGENERATE_RUN_TIME_STATS == 1 ) && ( configUSE_STATS_FORMATTING_FUNCTIONS > 0 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) )
 	CommandHandler::registerCommand("taskstats", FFBoardMain_commands::taskstats, "Task stats",CMDFLAG_GET);
 #endif
 	CommandHandler::registerCommand("format", FFBoardMain_commands::format, "set format=1 to erase all stored values",CMDFLAG_SET);
@@ -77,6 +77,9 @@ void SystemCommands::registerCommands(){
 #if defined(SIGNATURE)
 	CommandHandler::registerCommand("signature", FFBoardMain_commands::signature, "Chip signature in OTP. setadr to write data. set=1 to lock",CMDFLAG_GETADR | CMDFLAG_SETADR | CMDFLAG_GET | CMDFLAG_INFOSTRING);
 #endif
+#if ( ( configUSE_TRACE_FACILITY == 1 ) && ( configUSE_STATS_FORMATTING_FUNCTIONS > 0 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) )
+	CommandHandler::registerCommand("tasklist", FFBoardMain_commands::tasklist, "Task list",CMDFLAG_GET);
+#endif
 }
 
 // Choose lower optimize level because the compiler likes to blow up this function
@@ -218,7 +221,7 @@ CommandStatus SystemCommands::internalCommand(const ParsedCommand& cmd,std::vect
 			}
 
 
-		case FFBoardMain_commands::mallinfo: // UNUSED since freertos
+		case FFBoardMain_commands::mallinfo:
 		{
 			CommandReply reply;
 			struct mallinfo info = mallinfo();
@@ -238,14 +241,23 @@ CommandStatus SystemCommands::internalCommand(const ParsedCommand& cmd,std::vect
 			replies.emplace_back(xPortGetFreeHeapSize(),xPortGetMinimumEverFreeHeapSize());
 			break;
 		}
-#if configUSE_STATS_FORMATTING_FUNCTIONS>0
+#if ( ( configGENERATE_RUN_TIME_STATS == 1 ) && ( configUSE_STATS_FORMATTING_FUNCTIONS > 0 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) )
 		case FFBoardMain_commands::taskstats:
 		{
-			char repl[800];
+			char repl[uxTaskGetNumberOfTasks()*64];
 			vTaskGetRunTimeStats(repl);
 			replies.emplace_back("\n"+std::string(repl));
 			break;
 		}
+#endif
+#if ( ( configUSE_TRACE_FACILITY == 1 ) && ( configUSE_STATS_FORMATTING_FUNCTIONS > 0 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) )
+		case FFBoardMain_commands::tasklist:
+		{
+			char repl[uxTaskGetNumberOfTasks()*64];
+			vTaskList(repl);
+			replies.emplace_back("\n"+std::string(repl));
+			break;
+		}
 #endif
 		case FFBoardMain_commands::lsactive:
 		{
@@ -267,6 +279,7 @@ CommandStatus SystemCommands::internalCommand(const ParsedCommand& cmd,std::vect
 			if(cmd.type == CMDtype::set && cmd.val==1){
 
 				if(Flash_Format()){
+					Flash_Write_Defaults(); // Restore default values if present
 					flag = CommandStatus::OK;
 				}else{
 					flag = CommandStatus::ERR;
diff --git a/Firmware/FFBoard/Src/cppmain.cpp b/Firmware/FFBoard/Src/cppmain.cpp
index aa0f9a76d..412b75efb 100644
--- a/Firmware/FFBoard/Src/cppmain.cpp
+++ b/Firmware/FFBoard/Src/cppmain.cpp
@@ -15,6 +15,7 @@ extern IWDG_HandleTypeDef hiwdg; // Watchdog
 
 bool running = true;
 bool mainclassChosen = false;
+volatile bool forceErase = false;
 
 uint16_t main_id = 0;
 
@@ -46,6 +47,11 @@ void cppmain() {
 		Error_Handler();
 	}
 
+	if(forceErase){
+		Flash_Format();
+		Flash_Write_Defaults();
+	}
+
 //	// Check if flash is initialized
 //	uint16_t lastVersion = 0;
 //	if(!Flash_Read(ADR_SW_VERSION, &lastVersion)){ // Version never written
@@ -59,11 +65,13 @@ void cppmain() {
 	// Check if flash is initialized
 	uint16_t lastFlashVersion = 0;
 	if(!Flash_Read(ADR_FLASH_VERSION, &lastFlashVersion)){ // Version never written
+		Flash_Write_Defaults();
 		Flash_Write(ADR_FLASH_VERSION, FLASH_VERSION);
 	}
 	Flash_Read(ADR_FLASH_VERSION,&lastFlashVersion);
 	if(lastFlashVersion != FLASH_VERSION){
 		Flash_Format(); // Major version changed or could not write initial value. force a format
+		Flash_Write_Defaults();
 		Flash_Write(ADR_FLASH_VERSION, FLASH_VERSION);
 	}
 
diff --git a/Firmware/FFBoard/Src/flash_helpers.cpp b/Firmware/FFBoard/Src/flash_helpers.cpp
index cc8256ec0..75e0f61e0 100644
--- a/Firmware/FFBoard/Src/flash_helpers.cpp
+++ b/Firmware/FFBoard/Src/flash_helpers.cpp
@@ -8,6 +8,7 @@
 #include "eeprom_addresses.h"
 #include <vector>
 #include "mutex.hpp"
+#include <span>
 
 cpp_freertos::MutexStandard flashMutex;
 // Flash helpers
@@ -107,7 +108,10 @@ bool Flash_ReadWriteDefault(uint16_t adr,uint16_t *buf,uint16_t def){
 uint8_t i2cBufferEeprom[sizeof(uint16_t)] = {0};
 #include "string.h" // Memcpy
 #include "cassert"
-
+#include <array>
+#include "I2C.h"
+I2CDevice i2cdeveeprom;
+extern I2CPort i2cport_int;
 
 bool Flash_Write(uint16_t adr,uint16_t dat){
 	uint16_t dataLength = sizeof(dat);
@@ -120,12 +124,14 @@ bool Flash_Write(uint16_t adr,uint16_t dat){
 	// Do segmented writes
 	bool res = false;
 	while(curAdr < adr+dataLength){
-		while(!HAL_I2C_IsDeviceReady(&I2C_PORT_EEPROM, I2C_EEPROM_ADR, 100, I2C_EEPROM_TIMEOUT) == HAL_OK){
-			HAL_Delay(1);
+//		i2cport_int.isDeviceReady(i2cdeveeprom, I2C_EEPROM_ADR, 100, I2C_EEPROM_TIMEOUT,false)
+		while(!i2cport_int.isDeviceReady(&i2cdeveeprom, I2C_EEPROM_ADR, 100, I2C_EEPROM_TIMEOUT,false)){
+			vTaskDelay(1);
 		}
 
 		uint16_t wLen = std::min<uint16_t>(dataLength,I2C_EEPROM_PAGEWRITE_SIZE - (adr % I2C_EEPROM_PAGEWRITE_SIZE));
-		res = HAL_I2C_Mem_Write(&I2C_PORT_EEPROM, I2C_EEPROM_ADR, curAdr, I2C_EEPROM_ADR_SIZE, i2cBufferEeprom, wLen,I2C_EEPROM_TIMEOUT) == HAL_OK;
+		res = i2cport_int.writeMem(&i2cdeveeprom, I2C_EEPROM_ADR, curAdr, I2C_EEPROM_ADR_SIZE, i2cBufferEeprom, wLen, I2C_EEPROM_TIMEOUT, false);
+		//res = HAL_I2C_Mem_Write(&I2C_PORT_EEPROM, I2C_EEPROM_ADR, curAdr, I2C_EEPROM_ADR_SIZE, i2cBufferEeprom, wLen,I2C_EEPROM_TIMEOUT) == HAL_OK;
 		curAdr+=wLen;
 		if(!res){
 			break;
@@ -146,10 +152,12 @@ bool Flash_ReadWriteDefault(uint16_t adr,uint16_t *buf,uint16_t def){
 bool Flash_Read(uint16_t adr,uint16_t *buf, bool checkempty){
 	adr *= sizeof(*buf)/I2C_EEPROM_DATA_SIZE;
 	assert(adr < I2C_EEPROM_SIZE);
-	while(!HAL_I2C_IsDeviceReady(&I2C_PORT_EEPROM, I2C_EEPROM_ADR, 100, I2C_EEPROM_TIMEOUT) == HAL_OK){
-		HAL_Delay(1);
+	while(!i2cport_int.isDeviceReady(&i2cdeveeprom, I2C_EEPROM_ADR, 100, I2C_EEPROM_TIMEOUT,false)){
+		vTaskDelay(1);
 	}
-	bool res = HAL_I2C_Mem_Read(&I2C_PORT_EEPROM, I2C_EEPROM_ADR, I2C_EEPROM_OFS+adr, I2C_EEPROM_ADR_SIZE, i2cBufferEeprom, 2, I2C_EEPROM_TIMEOUT) == HAL_OK;
+
+	//bool res = HAL_I2C_Mem_Read(&I2C_PORT_EEPROM, I2C_EEPROM_ADR, I2C_EEPROM_OFS+adr, I2C_EEPROM_ADR_SIZE, i2cBufferEeprom, 2, I2C_EEPROM_TIMEOUT) == HAL_OK;
+	bool res = i2cport_int.readMem(&i2cdeveeprom, I2C_EEPROM_ADR, I2C_EEPROM_OFS+adr, I2C_EEPROM_ADR_SIZE, i2cBufferEeprom, 2, I2C_EEPROM_TIMEOUT, false);
 
 	if(checkempty){
 		bool empty = true;
@@ -175,19 +183,20 @@ bool Flash_Format(){
 	eraseBuf.fill(I2C_EEPROM_ERASED);
 	for(uint32_t i=I2C_EEPROM_OFS;i<I2C_EEPROM_SIZE;i+=I2C_EEPROM_PAGEWRITE_SIZE){
 
-		bool res = HAL_I2C_Mem_Write(&I2C_PORT_EEPROM, I2C_EEPROM_ADR, I2C_EEPROM_OFS+i, I2C_EEPROM_ADR_SIZE, eraseBuf.data(), std::min<int>(I2C_EEPROM_PAGEWRITE_SIZE,I2C_EEPROM_SIZE-i),I2C_EEPROM_TIMEOUT) == HAL_OK;
+		//bool res = HAL_I2C_Mem_Write(&I2C_PORT_EEPROM, I2C_EEPROM_ADR, I2C_EEPROM_OFS+i, I2C_EEPROM_ADR_SIZE, eraseBuf.data(), std::min<int>(I2C_EEPROM_PAGEWRITE_SIZE,I2C_EEPROM_SIZE-i),I2C_EEPROM_TIMEOUT) == HAL_OK;
+		bool res = i2cport_int.writeMem(&i2cdeveeprom, I2C_EEPROM_ADR, I2C_EEPROM_OFS+i, I2C_EEPROM_ADR_SIZE,  eraseBuf.data(), std::min<int>(I2C_EEPROM_PAGEWRITE_SIZE,I2C_EEPROM_SIZE-i), I2C_EEPROM_TIMEOUT, false);
 		if(!res){
 			flag = false;
 		}else{
-			while(!HAL_I2C_IsDeviceReady(&I2C_PORT_EEPROM, I2C_EEPROM_ADR, 100, I2C_EEPROM_TIMEOUT) == HAL_OK){
-				HAL_Delay(1);
+			while(!i2cport_int.isDeviceReady(&i2cdeveeprom, I2C_EEPROM_ADR, 100, I2C_EEPROM_TIMEOUT,false)){
+				vTaskDelay(1);
 			}
 		}
 	}
 	return flag;
 }
 bool Flash_Init(){
-	return HAL_I2C_IsDeviceReady(&I2C_PORT_EEPROM, I2C_EEPROM_ADR, 10, I2C_EEPROM_TIMEOUT) == HAL_OK;
+	return i2cport_int.isDeviceReady(&i2cdeveeprom, I2C_EEPROM_ADR, 50, I2C_EEPROM_TIMEOUT,false);
 }
 
 #else
@@ -283,3 +292,22 @@ __weak bool OTP_Read(uint16_t adroffset,uint64_t* dat){
 }
 
 #endif
+
+#ifndef FLASH_FACTORY_DEFAULTS_OVERRIDE
+ /**
+  * To define factory defaults create a span/array in a core folder defined for example as
+  * const auto flash_defaults = std::to_array<const std::pair<uint16_t,uint16_t>>({ {ADR_CURRENT_CONFIG,1} }); // ADR,VALUE pairs
+  * const std::span<const std::pair<uint16_t,uint16_t>> flash_factory_defaults = flash_defaults;
+  */
+const std::array<const std::pair<uint16_t,uint16_t>,0> empty_flash_defaults; // Empty
+const std::span<const std::pair<uint16_t,uint16_t>> flash_factory_defaults = empty_flash_defaults;
+#endif
+
+/**
+ * Writes factory default values to flash. Does nothing if no defaults are defined
+ */
+void Flash_Write_Defaults(){
+	for(const std::pair<uint16_t,uint16_t> &kv : flash_factory_defaults){
+		Flash_Write(kv.first, kv.second); // Try to write values
+	}
+}
\ No newline at end of file
diff --git a/Firmware/FFBoard/UserExtensions/Inc/FFBHIDMain.h b/Firmware/FFBoard/UserExtensions/Inc/FFBHIDMain.h
index 72855f793..736b6c81b 100644
--- a/Firmware/FFBoard/UserExtensions/Inc/FFBHIDMain.h
+++ b/Firmware/FFBoard/UserExtensions/Inc/FFBHIDMain.h
@@ -33,13 +33,17 @@
 #include "SelectableInputs.h"
 #include "thread.hpp"
 
-class FFBHIDMain: public FFBoardMain, public cpp_freertos::Thread, PersistentStorage,ExtiHandler,public UsbHidHandler, ErrorHandler, SelectableInputs{
+class FFBHIDMain: public FFBoardMain, public cpp_freertos::Thread, PersistentStorage,ExtiHandler,public UsbHidHandler, ErrorHandler, SelectableInputs
+#ifdef TIM_FFB
+, TimerHandler // Adds timer handler
+#endif
+{
 	enum class FFBWheel_commands : uint32_t{
 		ffbactive,axes,btntypes,lsbtn,addbtn,aintypes,lsain,addain,hidrate,hidsendspd,estop,cfrate
 	};
 
 public:
-	FFBHIDMain(uint8_t axisCount);
+	FFBHIDMain(uint8_t axisCount,bool hidAxis32b = false);
 	virtual ~FFBHIDMain();
 	void setFFBEffectsCalc(std::shared_ptr<EffectsControlItf> ffb,std::shared_ptr<EffectsCalculator> effects_calc);
 
@@ -74,6 +78,11 @@ class FFBHIDMain: public FFBoardMain, public cpp_freertos::Thread, PersistentSto
 	void errorCallback(const Error &error, bool cleared);
 
 	void systick();
+#ifdef TIM_FFB
+	void timerElapsed(TIM_HandleTypeDef* htim);
+#endif
+
+	float getCurFFBFreq();
 
 protected:
 	std::shared_ptr<EffectsControlItf> ffb;
@@ -91,9 +100,33 @@ class FFBHIDMain: public FFBoardMain, public cpp_freertos::Thread, PersistentSto
 	 * Warning: Report rate initialized by bInterval is overridden by saved speed preset at startup!
 	 */
 	void setReportRate(uint8_t rateidx);
-	uint8_t usb_report_rate = HID_BINTERVAL; //1 = 1000hz, 2 = 500hz, 3 = 333hz 4 = 250hz, 5 = 200hz 6 = 166hz, 8 = 125hz etc...
-	uint8_t usb_report_rate_idx = 0;
-	const uint8_t usb_report_rates[4] = {1,2,4,8}; // Maps stored hid speed to report rates
+	uint8_t usb_report_rate = HID_BINTERVAL; //for FS USB 1 = 1000hz, 2 = 500hz, 3 = 333hz 4 = 250hz, 5 = 200hz 6 = 166hz, 8 = 125hz etc...
+	uint8_t usb_report_rate_idx = ffbrates.defaultmode;
+#ifndef TIM_FFB
+	uint8_t ffb_rate_divider = 0;
+	uint8_t ffb_rate_counter = 0;
+#endif
+
+
+	struct FFB_update_rates{
+		struct FFB_update_rate_divider{
+			uint8_t basediv;
+			uint8_t hiddiv;
+		};
+
+#if TUD_OPT_HIGH_SPEED // divider pair <FFB div, USB div from base>
+		const uint8_t defaultmode = 3;
+		uint32_t basefreq = 8000;
+		std::array<FFB_update_rate_divider,7> dividers = {{{1,1},{2,1},{4,1},{8,1},{16,1},{32,1},{64,1}}}; // 8khz to 125hz
+#else
+		const uint8_t defaultmode = 0;
+		uint32_t basefreq = 1000;
+		std::array<FFB_update_rate_divider,4> dividers = {{{1,1},{2,1},{4,1},{8,1}}}; // 8 entries max. 1khz to 125hz
+#endif
+	};
+	const static FFB_update_rates ffbrates;
+
+	const bool hidAxis32b;
 
 	std::string usb_report_rates_names();
 
@@ -105,8 +138,8 @@ class FFBHIDMain: public FFBoardMain, public cpp_freertos::Thread, PersistentSto
 	std::vector<std::unique_ptr<ButtonSource>> btns;
 	std::vector<std::unique_ptr<AnalogSource>> analog_inputs;
 
-	reportHID_t reportHID;
-	reportHID_t lastReportHID;
+	std::unique_ptr<HID_GamepadReport_base> reportHID;
+
 	uint8_t reportSendCounter = 0;
 
 	const uint8_t analogAxisCount = 8;
diff --git a/Firmware/FFBoard/UserExtensions/Inc/FFBWheel.h b/Firmware/FFBoard/UserExtensions/Inc/FFBWheel.h
index 0f7be1be1..274e93cc0 100644
--- a/Firmware/FFBoard/UserExtensions/Inc/FFBWheel.h
+++ b/Firmware/FFBoard/UserExtensions/Inc/FFBWheel.h
@@ -12,6 +12,12 @@
 
 #include "FFBHIDMain.h"
 
+#ifdef HIDAXISRES_USE_32B_DESC
+#define FFBWHEEL_32B_MODE true
+#else
+#define FFBWHEEL_32B_MODE false
+#endif
+
 class FFBWheel : public FFBHIDMain {
 public:
 	FFBWheel();
diff --git a/Firmware/FFBoard/UserExtensions/Inc/TMC4671.h b/Firmware/FFBoard/UserExtensions/Inc/TMC4671.h
index dd19e51fb..2dffac900 100644
--- a/Firmware/FFBoard/UserExtensions/Inc/TMC4671.h
+++ b/Firmware/FFBoard/UserExtensions/Inc/TMC4671.h
@@ -2,7 +2,7 @@
  * TMC4671.h
  *
  *  Created on: Feb 1, 2020
- *      Author: Yannick
+ *      Author: Yannick, Vincent
  */
 
 #ifndef TMC4671_H_
@@ -21,7 +21,7 @@
 #include "ExtiHandler.h"
 #include "SPI.h"
 #include "TimerHandler.h"
-
+#include <span>
 #include "semaphore.hpp"
 #include <GPIOPin.h>
 #include "cpp_target_config.h"
@@ -38,6 +38,26 @@ extern SPI_HandleTypeDef HSPIDRV;
 extern TIM_HandleTypeDef TIM_TMC;
 #endif
 
+#ifndef TMC4671_DEFAULT_CURRENT_SCALER
+#define TMC4671_DEFAULT_CURRENT_SCALER 0
+#endif
+#ifndef TMC4671_DEFAULT_CLOCKFREQ
+#define TMC4671_DEFAULT_CLOCKFREQ 25e6
+#endif
+#ifndef TMC4671_DEFAULT_BBM
+#define TMC4671_DEFAULT_BBM 20
+#endif
+#ifndef TMC4671_DEFAULT_ANALOGENC_SKIPCAL
+#define TMC4671_DEFAULT_ANALOGENC_SKIPCAL 0
+#endif
+#ifndef TMC4671_ITUNE_CUTOFF
+#define TMC4671_ITUNE_CUTOFF 0.04
+#endif
+#ifndef TIM_TMC_ARR
+#define TIM_TMC_ARR 200
+#endif
+
+
 enum class TMC_ControlState : uint32_t {uninitialized,waitPower,Shutdown,Running,EncoderInit,EncoderFinished,HardError,OverTemp,IndexSearch,FullCalibration,ExternalEncoderInit,Pidautotune};
 
 enum class TMC_PwmMode : uint8_t {off = 0,HSlow_LShigh = 1, HShigh_LSlow = 2, res2 = 3, res3 = 4, PWM_LS = 5, PWM_HS = 6, PWM_FOC = 7};
@@ -46,7 +66,7 @@ enum class TMC_StartupType{NONE,coldStart,warmStart};
 
 enum class TMC_GpioMode{DebugSpi,DSAdcClkOut,DSAdcClkIn,Aout_Bin,Ain_Bout,Aout_Bout,Ain_Bin};
 
-enum class MotorType : uint8_t {NONE=0,DC=1,STEPPER=2,BLDC=3,ERR};
+enum class MotorType : uint8_t {NONE=0,DC=1,STEPPER=2,BLDC=3};
 enum class PhiE : uint8_t {ext=1,openloop=2,abn=3,hall=5,aenc=6,aencE=7,NONE,extEncoder};
 enum class MotionMode : uint8_t {stop=0,torque=1,velocity=2,position=3,prbsflux=4,prbstorque=5,prbsvelocity=6,uqudext=8,encminimove=9,NONE};
 enum class FFMode : uint8_t {none=0,velocity=1,torque=2};
@@ -54,18 +74,8 @@ enum class PosSelection : uint8_t {PhiE=0, PhiE_ext=1, PhiE_openloop=2, PhiE_abn
 enum class VelSelection : uint8_t {PhiE=0, PhiE_ext=1, PhiE_openloop=2, PhiE_abn=3, res1=4, PhiE_hal=5, PhiE_aenc=6, PhiA_aenc=7, res2=8, PhiM_abn=9, PhiM_abn2=10, PhiM_aenc=11, PhiM_hal=12};
 enum class EncoderType_TMC : uint8_t {NONE=0,abn=1,sincos=2,uvw=3,hall=4,ext=5}; // max 7
 
-// Hardware versions for identifying different types. 31 versions valid
+//// Hardware versions for identifying different types. 31 versions valid
 enum class TMC_HW_Ver : uint8_t {NONE=0,v1_0,v1_2,v1_2_2,v1_2_2_LEM20,v1_2_2_100mv,v1_3_66mv};
-// Selectable version names to be listed in commands
-const std::vector<std::pair<TMC_HW_Ver,std::string>> tmcHwVersionNames{
-			std::make_pair(TMC_HW_Ver::NONE,"Undefined"), // Do not select. Default but disables some safety features
-			std::make_pair(TMC_HW_Ver::v1_0,"v1.0 AD8417"),
-			std::make_pair(TMC_HW_Ver::v1_2,"v1.2 AD8417"),
-			std::make_pair(TMC_HW_Ver::v1_2_2,"v1.2.2 LEM GO 10 (80mV/A)"),
-			std::make_pair(TMC_HW_Ver::v1_2_2_LEM20,"v1.2.2 LEM GO 20 (40mV/A)"),
-			std::make_pair(TMC_HW_Ver::v1_2_2_100mv,"v1.2/3 100mV/A"),
-			std::make_pair(TMC_HW_Ver::v1_3_66mv,"v1.3 ACS724 30A (66mV/A)")
-};
 
 struct TMC4671MotConf{
 	MotorType motor_type = MotorType::NONE; //saved
@@ -81,23 +91,70 @@ struct TMC4671MotConf{
  * Settings that depend on the hardware version
  */
 struct TMC4671HardwareTypeConf{
-	TMC_HW_Ver hwVersion = TMC_HW_Ver::NONE;
+	const char* name="CUSTOM";
+	uint8_t hwVersion = 0;
 	int adcOffset = 0;
-	float thermistor_R2 = 1500;
-	float thermistor_R = 22000;
-	float thermistor_Beta = 4300;
-	bool temperatureEnabled = false; // Enables temperature readings
-	float temp_limit = 90;
-	float currentScaler = 2.5 / (0x7fff * 60.0 * 0.0015); // Converts from adc counts to current in Amps
-	uint16_t brakeLimLow = 50700;
-	uint16_t brakeLimHigh = 50900;
+
+	struct ThermistorSettings{
+		float thermistor_R2 = 1500;
+		float thermistor_R = 22000;
+		float thermistor_Beta = 4300;
+		float temp_limit = 90;
+		bool temperatureEnabled = false; // Enables temperature readings
+	};
+	ThermistorSettings thermistorSettings;
+
+
+	float currentScaler = TMC4671_DEFAULT_CURRENT_SCALER; // Converts from adc counts to current in Amps
+	uint16_t brakeLimLow = 0xffff;
+	uint16_t brakeLimHigh = 0xffff;
 	float vmScaler = (2.5 / 0x7fff) * ((1.5+71.5)/1.5);
 	float vSenseMult = VOLTAGE_MULT_DEFAULT;
-	float clockfreq = 25e6;
-	uint8_t bbm = 20;
+	float clockfreq = TMC4671_DEFAULT_CLOCKFREQ;
+	uint8_t bbm = TMC4671_DEFAULT_BBM;
 	float fluxDissipationScaler = 0.5;
-	bool allowFluxDissipationDeactivation = true;
-	// Todo restrict allowed motor and encoder types
+
+	/**
+	 * Flags which features are enabled in this hardware type
+	 */
+	struct SupportedModes_s {
+		uint32_t mot_none: 1 = 1,
+		mot_dc : 1 = 1,
+		mot_bldc: 1 = 1,
+		mot_stepper:1 = 1,
+
+		enc_none:1 = 1,
+		enc_abn:1 = 1,
+		enc_sincos:1 = 1,
+		enc_uvw:1 = 1,
+		enc_hall:1 = 1,
+		enc_ext:1 = 1,
+
+		analog_enc_skip_cal:1 = TMC4671_DEFAULT_ANALOGENC_SKIPCAL,
+
+		allowFluxDissipationDeactivation:1 = 1;
+	};
+	SupportedModes_s flags;
+	bool isEncSupported(EncoderType_TMC type){
+		switch(type){
+		case EncoderType_TMC::NONE: return flags.enc_none;
+		case EncoderType_TMC::abn: return flags.enc_abn;
+		case EncoderType_TMC::ext: return flags.enc_ext;
+		case EncoderType_TMC::sincos: return flags.enc_sincos;
+		case EncoderType_TMC::hall: return flags.enc_hall;
+		case EncoderType_TMC::uvw: return flags.enc_uvw;
+		default: return false;
+		}
+	}
+	bool isMotSupported(MotorType type){
+		switch(type){
+		case MotorType::NONE: return flags.mot_none;
+		case MotorType::DC: return flags.mot_dc;
+		case MotorType::STEPPER: return flags.mot_stepper;
+		case MotorType::BLDC: return flags.mot_bldc;
+		default: return false;
+		}
+	}
 };
 
 
@@ -157,7 +214,6 @@ struct TMC4671MainConfig{
 	uint16_t adc_I1_offset 	= 33415;
 	uint16_t adc_I0_scale	= 256;
 	uint16_t adc_I1_scale	= 256;
-	bool canChangeHwType 	= true; // Allows changing the hardware version by commands
 	bool encoderReversed	= false;
 	bool combineEncoder		= false;
 	bool invertForce		= false;
@@ -179,7 +235,7 @@ struct TMC4671PIDConf{
 struct TMC4671Limits{
 	uint16_t pid_torque_flux_ddt	= 32767;
 	uint16_t pid_uq_ud				= 30000;
-	uint16_t pid_torque_flux		= 32767;
+	uint16_t pid_torque_flux		= 30000;
 	uint32_t pid_acc_lim			= 2147483647;
 	uint32_t pid_vel_lim			= 2147483647;
 	int32_t pid_pos_low				= -2147483647;
@@ -237,7 +293,7 @@ struct TMC4671AENCConf{
 	int16_t AENC0_scale = 256;
 	uint16_t AENC1_offset = 0x7fff;
 	int16_t AENC1_scale = 256;
-	uint16_t AENC2_offset = 20000;
+	uint16_t AENC2_offset = 0x7fff;
 	int16_t AENC2_scale = 256;
 
 	int16_t nMask = 0; // 0x3c & 0xffff0000
@@ -289,6 +345,17 @@ class TMC4671Biquad{
 	}
 	TMC4671Biquad(const TMC4671Biquad_t bq) : params(bq){}
 	TMC4671Biquad(const Biquad& bq,bool enable = true){
+#ifdef USE_DSP_FUNCTIONS
+		const float* coeffs = bq.getCoeffs();
+		// coeffs is in order {b0, b1, b2, -a1, -a2}
+		// TMC expects {b0, b1, b2, a1, a2} with a1 and a2 negated
+		this->params.b0 = (int32_t)(coeffs[0] * (float)(1 << 29));
+		this->params.b1 = (int32_t)(coeffs[1] * (float)(1 << 29));
+		this->params.b2 = (int32_t)(coeffs[2] * (float)(1 << 29));
+		this->params.a1 = (int32_t)(coeffs[3] * (float)(1 << 29));
+		this->params.a2 = (int32_t)(coeffs[4] * (float)(1 << 29));
+		this->params.enable = bq.getFc() > 0 ? enable : false;
+#else
 		// Note: trinamic swapped the naming of b and a from the regular convention in the datasheet and a and b are possibly inverse to b in our filter class
 		this->params.a1 = -(int32_t)(bq.b1 * (float)(1 << 29));
 		this->params.a2 = -(int32_t)(bq.b2 * (float)(1 << 29));
@@ -296,6 +363,7 @@ class TMC4671Biquad{
 		this->params.b1 = (int32_t)(bq.a1 * (float)(1 << 29));
 		this->params.b2 = (int32_t)(bq.a2 * (float)(1 << 29));
 		this->params.enable = bq.getFc() > 0 ? enable : false;
+#endif
 	}
 	void enable(bool enable){
 		params.enable = enable;
@@ -346,7 +414,7 @@ friend class TMCDebugBridge;
 
 	TMC4671(SPIPort& spiport,OutputPin cspin,uint8_t address=1);
 
-	void setHwType(TMC_HW_Ver type);
+	void setHwType(uint8_t type);
 
 	void setAddress(uint8_t address);
 
@@ -356,6 +424,7 @@ friend class TMCDebugBridge;
 
 	TMC4671MainConfig conf;
 
+	void setupDriver();
 	bool initialize();
 	void initializeWithPower();
 
@@ -429,15 +498,20 @@ friend class TMCDebugBridge;
 	void stopMotor();
 	void startMotor();
 
+	void setPowerLimit(uint16_t power) override;
+
 	void emergencyStop(bool reset);
 	bool emergency = false;
 	bool estopTriggered = false;
 	void turn(int16_t power);
+
+	int16_t getVelocityControllerTorque();
 	int16_t nextFlux = 0;
 	int16_t idleFlux = 0;
 	uint16_t maxOffsetFlux = 0;
 
 	int16_t bangInitPower = 5000; // Default current in setup routines
+	uint16_t maxPowerAxis = 0;
 
 	int16_t controlFluxDissipate();
 	const float fluxDissipationLimit = 1000;
@@ -570,7 +644,10 @@ friend class TMCDebugBridge;
 		TMC4671* tmc;
 	};
 
+	static std::span<const TMC4671HardwareTypeConf> tmc4671_hw_configs; // Can override in external target file
+
 private:
+	uint8_t drv_address = 0;
 	OutputPin enablePin = OutputPin(*DRV_ENABLE_GPIO_Port,DRV_ENABLE_Pin);
 	const Error indexNotHitError = Error(ErrorCode::encoderIndexMissed,ErrorType::critical,"Encoder index missed");
 	const Error lowVoltageError = Error(ErrorCode::undervoltage,ErrorType::warning,"Low motor voltage");
@@ -600,6 +677,7 @@ friend class TMCDebugBridge;
 	bool fullCalibrationInProgress = false;
 	bool phiErestored = false;
 	bool encHallRestored = false;
+	bool canChangeHwType 	= true; // Allows changing the hardware version by commands
 	//int32_t phiEOffsetRestored = 0; //-0x8000 to 0x7fff
 	uint8_t calibrationFailCount = 2;
 
@@ -635,6 +713,8 @@ friend class TMCDebugBridge;
 	void errorCallback(const Error &error, bool cleared);
 	bool pidAutoTune();
 
+	void replyHardwareVersions(const std::span<const TMC4671HardwareTypeConf>& versions,std::vector<CommandReply>& replies);
+
 	uint32_t initTime = 0;
 	bool manualEncAlign = false;
 	bool spiActive = false; // Flag for tx interrupt that the transfer was started by this instance
@@ -676,5 +756,3 @@ class TMC_2 : public TMC4671 {
 };
 #endif
 #endif /* TMC4671_H_ */
-
-
diff --git a/Firmware/FFBoard/UserExtensions/Inc/eeprom_addresses.h b/Firmware/FFBoard/UserExtensions/Inc/eeprom_addresses.h
index d05638476..bed80e3af 100644
--- a/Firmware/FFBoard/UserExtensions/Inc/eeprom_addresses.h
+++ b/Firmware/FFBoard/UserExtensions/Inc/eeprom_addresses.h
@@ -13,11 +13,11 @@
 
 #include "main.h"
 // Change this to the amount of currently registered variables
-#define NB_OF_VAR 164
+#define NB_OF_VAR 168
 extern const uint16_t VirtAddVarTab[NB_OF_VAR];
 
 // Amount of variables in exportable list
-#define NB_EXPORTABLE_ADR 149
+#define NB_EXPORTABLE_ADR 153
 extern const uint16_t exportableFlashAddresses[NB_EXPORTABLE_ADR];
 
 
@@ -88,6 +88,7 @@ uint16_t EE_ReadVariable(uint16_t VirtAddress, uint16_t* Data) will return 1 if
 #define ADR_FFB_EFFECTS1 0x284 // 0-7 inertia, 8-15 friction
 #define ADR_FFB_EFFECTS2 0x285 // 0-7 spring, 8-15 damper
 #define ADR_FFB_EFFECTS3 0x286 // 0-7 friction ramp up zone, 8-9 filterProfile
+#define ADR_FFB_RECONSTRUCTION_FILTER 0x287 // 0-1 recon filter mode
 // Button Sources:
 #define ADR_ADS111X_CONF1 0x290
 // How many axis configured 1-3
@@ -98,6 +99,7 @@ uint16_t EE_ReadVariable(uint16_t VirtAddress, uint16_t* Data) will return 1 if
 #define ADR_AXIS1_DEGREES 0x303
 #define ADR_AXIS1_MAX_SPEED 0x304 // Store the max speed
 #define ADR_AXIS1_MAX_ACCEL 0x305 // Store the max accel
+#define ADR_AXIS1_MAX_SLEWRATE_DRV 0x306 // Max slew rate for drv
 #define ADR_AXIS1_ENDSTOP 0x307 // 0-7 endstop margin, 8-15 endstop stiffness
 #define ADR_AXIS1_EFFECTS1 0x308 // 0-7 idlespring, 8-15 damper
 #define ADR_AXIS1_SPEEDACCEL_FILTER 0x309 // Speed/Accel filter Lowpass profile
@@ -124,6 +126,7 @@ uint16_t EE_ReadVariable(uint16_t VirtAddress, uint16_t* Data) will return 1 if
 #define ADR_AXIS2_DEGREES 0x343
 #define ADR_AXIS2_MAX_SPEED 0x344 // Store the max speed
 #define ADR_AXIS2_MAX_ACCEL 0x345 // Store the max accel
+#define ADR_AXIS2_MAX_SLEWRATE_DRV 0x346 // Max slew rate for drv
 #define ADR_AXIS2_ENDSTOP 0x347 // 0-7 endstop margin, 8-15 endstop stiffness
 #define ADR_AXIS2_EFFECTS1 0x348 // 0-7 idlespring, 8-15 damper
 #define ADR_AXIS2_SPEEDACCEL_FILTER 0x349 // Speed/Accel filter Lowpass profile
@@ -150,6 +153,7 @@ uint16_t EE_ReadVariable(uint16_t VirtAddress, uint16_t* Data) will return 1 if
 #define ADR_AXIS3_DEGREES 0x383
 #define ADR_AXIS3_MAX_SPEED 0x384 // Store the max speed
 #define ADR_AXIS3_MAX_ACCEL 0x385 // Store the max accel
+#define ADR_AXIS3_MAX_SLEWRATE_DRV 0x386 // Max slew rate for drv
 #define ADR_AXIS3_ENDSTOP 0x387 // 0-7 endstop margin, 8-15 endstop stiffness
 #define ADR_AXIS3_EFFECTS1 0x388 // 0-7 idlespring, 8-15 damper
 #define ADR_AXIS3_SPEEDACCEL_FILTER 0x389 // Speed/Accel filter Lowpass profile
diff --git a/Firmware/FFBoard/UserExtensions/Inc/usb_descriptors.h b/Firmware/FFBoard/UserExtensions/Inc/usb_descriptors.h
index b4d6d8ee8..ef8507300 100644
--- a/Firmware/FFBoard/UserExtensions/Inc/usb_descriptors.h
+++ b/Firmware/FFBoard/UserExtensions/Inc/usb_descriptors.h
@@ -24,6 +24,16 @@ typedef struct usb_string_desc
 	const std::vector<std::string> interfaces;
 } usb_string_desc_t;
 
+/*
+ * Base combined usb config descriptor for HID and CDC composite device
+ */
+#define USB_CONF_DESC_HID_CDC(HIDREPSIZE,EPSIZE) \
+		  /* Config number, interface count, string index, total length, attribute, power in mA*/\
+		  TUD_CONFIG_DESCRIPTOR(1, 3, 0, (TUD_CONFIG_DESC_LEN + TUD_CDC_DESC_LEN + TUD_HID_INOUT_DESC_LEN), TUSB_DESC_CONFIG_ATT_REMOTE_WAKEUP | TUSB_DESC_CONFIG_ATT_SELF_POWERED, 100),\
+		  /* 1st CDC: Interface number, string index, EP notification address and size, EP data address (out, in) and size.*/\
+		  TUD_CDC_DESCRIPTOR(0, 4, 0x82, 8, 0x01, 0x81, EPSIZE),\
+		  /* HID Descriptor. EP 83 and 2*/\
+		  TUD_HID_INOUT_DESCRIPTOR(2, 5, HID_ITF_PROTOCOL_NONE, HIDREPSIZE, 0x83, 0x02,EPSIZE, HID_BINTERVAL)
 
 /*
  * Device descriptors
@@ -42,7 +52,9 @@ extern const uint8_t usb_cdc_hid_conf_1axis[];
 #ifdef AXIS2_FFB_HID_DESC
 extern const uint8_t usb_cdc_hid_conf_2axis[];
 #endif
-
+#ifdef AXIS2_FFB_HID_DESC_32B
+extern const uint8_t usb_cdc_hid_conf_2axis_32b[];
+#endif
 #ifdef FFB_HID_DESC_GAMEPAD
 extern const uint8_t usb_cdc_hid_conf_gamepad[];
 #endif
diff --git a/Firmware/FFBoard/UserExtensions/Inc/usb_hid_ffb_desc.h b/Firmware/FFBoard/UserExtensions/Inc/usb_hid_ffb_desc.h
index d6067effe..242536eba 100644
--- a/Firmware/FFBoard/UserExtensions/Inc/usb_hid_ffb_desc.h
+++ b/Firmware/FFBoard/UserExtensions/Inc/usb_hid_ffb_desc.h
@@ -8,21 +8,769 @@
 #ifndef USB_INC_USB_HID_FFB_DESC_H_
 #define USB_INC_USB_HID_FFB_DESC_H_
 #include "constants.h"
+#include "hid.h"
 
+/** \defgroup HID Descriptors
+ *  \details Contains definitions of different HID descriptor parts *
+ *  @{
+ */
 
-#define USB_HID_1FFB_REPORT_DESC_SIZE 1196
-#ifdef AXIS1_FFB_HID_DESC
-extern const uint8_t hid_1ffb_desc[USB_HID_1FFB_REPORT_DESC_SIZE];
+#if defined(HIDAXISRES_32B_BITS) && HIDAXISRES_32B_BITS > 2 && HIDAXISRES_32B_BITS < 32
+// 7FFFFFFF for 32
+#define HIDAXISRES_32B_MAXS (1 << (HIDAXISRES_32B_BITS-1))-1
+#else
+#define HIDAXISRES_32B_MAXS 0x7FFFFFFF
+#define HIDAXISRES_32B_BITS 32
+#endif
+
+// HID descriptor building blocks
+#define HIDDESC_32B_ENTRY(count)  /*     LOGICAL_MINIMUM (-7FFFFFFF)*/\
+  HID_LOGICAL_MIN_N(-HIDAXISRES_32B_MAXS,3), /*0x17, 0x01, 0x00, 0x00, 0x80,*/\
+  /*     LOGICAL_MAXIMUM (7FFFFFFF)*/\
+  HID_LOGICAL_MAX_N(HIDAXISRES_32B_MAXS,3), /*   0x27, 0xff, 0xff, 0xff, 0x7f, */ \
+ /*     REPORT_SIZE (32)*/\
+  0x75, 0x20,\
+  /* REPORT_COUNT */\
+  0x95, count,\
+/*     INPUT (Data,Var,Abs)*/\
+  0x81, 0x02,
+#define HIDDESC_32B_ENTRY_SIZE 16 // 16 bytes more for range definition
+
+
+#define HIDDESC_GAMEPAD_16B \
+		    0xa1, 0x00,                    /*   COLLECTION (Physical)*/\
+		    0x85, 0x01,                    /*     REPORT_ID (1)*/\
+		    0x05, 0x09,                    /*     USAGE_PAGE (Button)*/\
+		    0x19, 0x01,                    /*     USAGE_MINIMUM (Button 1)*/\
+		    0x29, 0x40,                    /*     USAGE_MAXIMUM (Button 64)*/\
+		    0x15, 0x00,                    /*     LOGICAL_MINIMUM (0)*/\
+		    0x25, 0x01,                    /*     LOGICAL_MAXIMUM (1)*/\
+		    0x95, 0x40,                    /*     REPORT_COUNT (64)*/\
+		    0x75, 0x01,                    /*     REPORT_SIZE (1)*/\
+		    0x81, 0x02,                    /*     INPUT (Data,Var,Abs)*/\
+		    0x05, 0x01,                    /*     USAGE_PAGE (Generic Desktop)*/\
+		    0x09, HID_USAGE_DESKTOP_X,             /*     USAGE (X)*/\
+		    0x09, HID_USAGE_DESKTOP_Y,             /*     USAGE (Y)*/\
+		    0x09, HID_USAGE_DESKTOP_Z,             /*     USAGE (Z)*/\
+		    0x09, HID_USAGE_DESKTOP_RX,            /*     USAGE (Rx)*/\
+		    0x09, HID_USAGE_DESKTOP_RY,            /*     USAGE (Ry)*/\
+			0x09, HID_USAGE_DESKTOP_RZ,            /*     USAGE (Rz)*/\
+			0x09, HID_USAGE_DESKTOP_DIAL,           /*     USAGE (Dial)*/\
+			0x09, HID_USAGE_DESKTOP_SLIDER,           /*     USAGE (Slider)*/\
+		    0x16, 0x01, 0x80,              /*     LOGICAL_MINIMUM (-32767)*/\
+		    0x26, 0xff, 0x7f,              /*     LOGICAL_MAXIMUM (32767)*/\
+		    0x75, 0x10,                    /*     REPORT_SIZE (16)*/\
+		    0x95, 0x08,                    /*     REPORT_COUNT (8)*/\
+		    0x81, 0x02,                    /*     INPUT (Data,Var,Abs)*/\
+		    0xc0
+#define HIDDESC_GAMEPAD_16B_SIZE 51
+
+// Define workaround because we can't have conditionals in macros
+#if MAX_AXIS == 1
+#define HIDDESC_GPENTRY_32B_1 0x09, HID_USAGE_DESKTOP_X,             /*     USAGE (X)*/\
+	HIDDESC_32B_ENTRY(0x01)
+#else
+#define HIDDESC_GPENTRY_32B_1 0x09, HID_USAGE_DESKTOP_X,             /*     USAGE (X)*/
+#endif
+#if MAX_AXIS == 2
+#define HIDDESC_GPENTRY_32B_2 0x09, HID_USAGE_DESKTOP_Y,             /*     USAGE (Y)*/\
+	HIDDESC_32B_ENTRY(0x02)
+#else
+#define HIDDESC_GPENTRY_32B_2 0x09, HID_USAGE_DESKTOP_Y,             /*     USAGE (Y)*/
+#endif
+#if MAX_AXIS == 3
+#define HIDDESC_GPENTRY_32B_3 0x09, HID_USAGE_DESKTOP_Z,             /*     USAGE (Z)*/\
+	HIDDESC_32B_ENTRY(0x03)
+#else
+#define HIDDESC_GPENTRY_32B_3 0x09, HID_USAGE_DESKTOP_Z,             /*     USAGE (Z)*/
 #endif
+#define HIDDESC_GAMEPAD_32B \
+		    0xa1, 0x00,                    /*   COLLECTION (Physical)*/\
+		    0x85, 0x01,                    /*     REPORT_ID (1)*/\
+		    0x05, 0x09,                    /*     USAGE_PAGE (Button)*/\
+		    0x19, 0x01,                    /*     USAGE_MINIMUM (Button 1)*/\
+		    0x29, 0x40,                    /*     USAGE_MAXIMUM (Button 64)*/\
+		    0x15, 0x00,                    /*     LOGICAL_MINIMUM (0)*/\
+		    0x25, 0x01,                    /*     LOGICAL_MAXIMUM (1)*/\
+		    0x95, 0x40,                    /*     REPORT_COUNT (64)*/\
+		    0x75, 0x01,                    /*     REPORT_SIZE (1)*/\
+		    0x81, 0x02,                    /*     INPUT (Data,Var,Abs)*/\
+		    0x05, 0x01,                    /*     USAGE_PAGE (Generic Desktop)*/\
+			HIDDESC_GPENTRY_32B_1 \
+			HIDDESC_GPENTRY_32B_2 \
+			HIDDESC_GPENTRY_32B_3 \
+		    0x09, HID_USAGE_DESKTOP_RX,            /*     USAGE (Rx)*/\
+		    0x09, HID_USAGE_DESKTOP_RY,            /*     USAGE (Ry)*/\
+			0x09, HID_USAGE_DESKTOP_RZ,            /*     USAGE (Rz)*/\
+			0x09, HID_USAGE_DESKTOP_DIAL,           /*     USAGE (Dial)*/\
+			0x09, HID_USAGE_DESKTOP_SLIDER,           /*     USAGE (Slider)*/\
+		    0x16, 0x01, 0x80,              /*     LOGICAL_MINIMUM (-32767)*/\
+		    0x26, 0xff, 0x7f,              /*     LOGICAL_MAXIMUM (32767)*/\
+		    0x75, 0x10,                    /*     REPORT_SIZE (16)*/\
+			0x95, 0x08-MAX_AXIS,           /*     REPORT_COUNT (8-32baxes)*/\
+		    0x81, 0x02,                    /*     INPUT (Data,Var,Abs)*/\
+		    0xc0
+#define HIDDESC_GAMEPAD_32B_SIZE HIDDESC_GAMEPAD_16B_SIZE + HIDDESC_32B_ENTRY_SIZE
+// Control reports for HID command interface
+#define HIDDESC_CTRL_REP(DIR) /* INPUT or OUTPUT*/\
+	0x85,HID_ID_HIDCMD, /*    Report ID*/\
+	0x09, 0x01,                    /*   USAGE (Vendor)*/\
+	0x15, 0x00,                    /*   LOGICAL_MINIMUM (0)*/\
+	0x26, 0x04,	0x00,			   /*   Logical Maximum 4*/\
+	0x75, 0x08,                    /*   REPORT_SIZE (8)*/\
+	0x95, 0x01,                    /*   REPORT_COUNT (1)*/\
+	HID_##DIR(1),                    /*   INPUT (Data,Var,Abs)*/\
+	\
+	0x09, 0x02,                    /*   USAGE (Vendor) class address*/\
+	0x75, 0x10,                    /*   REPORT_SIZE (16)*/\
+	0x95, 0x01,                    /*   REPORT_COUNT (1)*/\
+	HID_##DIR(1),                    /*   INPUT (Data,Var,Abs)*/\
+	\
+	0x09, 0x03,                    /*   USAGE (Vendor) class instance*/\
+	0x75, 0x08,                    /*   REPORT_SIZE (8)*/\
+	0x95, 0x01,                    /*   REPORT_COUNT (1)*/\
+	HID_##DIR(1),                    /*   INPUT (Data,Var,Abs)*/\
+	\
+	0x09, 0x04,                    /*   USAGE (Vendor) cmd*/\
+	0x75, 0x20,                    /*   REPORT_SIZE (32)*/\
+	0x95, 0x01,                    /*   REPORT_COUNT (1)*/\
+	HID_##DIR(1),                    /*   INPUT (Data,Var,Abs)*/\
+	\
+	0x09, 0x05,                    /*   USAGE (Vendor)*/\
+	0x75, 0x40,                    /*   REPORT_SIZE (64) value*/\
+	0x95, 0x01,                    /*   REPORT_COUNT (1)*/\
+	HID_##DIR(1),                    /*   INPUT (Data,Var,Abs)*/\
+	\
+	0x09, 0x06,                    /*   USAGE (Vendor) address*/\
+	0x75, 0x40,                    /*   REPORT_SIZE (64)*/\
+	0x95, 0x01,                    /*   REPORT_COUNT (1)*/\
+	HID_##DIR(1)                   /*   INPUT (Data,Var,Abs)*/
+#define HIDDESC_CTRL_REPORTS \
+		0x06, 0x00, 0xFF,              /* USAGE_PAGE (Vendor)*/\
+		0x09, 0x00,                    /*   USAGE (Vendor)*/\
+		0xA1, 0x01, 				   /* Collection (Application)*/\
+		HIDDESC_CTRL_REP(OUTPUT),\
+		HIDDESC_CTRL_REP(INPUT),\
+	  0xc0                          /*   END_COLLECTION*/
+#define HIDDESC_CTRL_REPORTS_SIZE 118
+
+#define HIDDESC_FFB_STATEREP \
+		0x05,0x0F, /*  Usage Page Physical Interface*/ \
+		0x09,0x92,        /*    Usage PID State report*/\
+		0xA1,0x02,        /*    Collection Datalink (logical)*/\
+		   0x85,HID_ID_STATE+FFB_ID_OFFSET,    /*    Report ID 2*/\
+/*			   0x09,0x22,        Usage Effect Block Index*/\
+/*			   0x15,0x01,        Logical Minimum 1*/\
+/*			   0x25,MAX_EFFECTS,        Logical Maximum 28h (40d)*/\
+/*			   0x35,0x01,        Physical Minimum 1*/\
+/*			   0x45,MAX_EFFECTS,        Physical Maximum 28h (40d)*/\
+/*			   0x75,0x08,        Report Size 8*/\
+/*			   0x95,0x01,        Report Count 1*/\
+/*			   0x81,0x02,        Input (Variable)*/\
+		   0x09,0x9F,    /*    Usage Device is Pause*/\
+		   0x09,0xA0,    /*    Usage Actuators Enabled*/\
+		   0x09,0xA4,    /*    Usage Safety Switch*/\
+		   0x09,0xA6,    /*    Usage Actuator Power*/\
+		   0x09,0x94,    /*    Usage Effect Playing*/\
+	/*		   0x15,0x00,        Logical Minimum 0*/\
+	/*		   0x25,0x01,        Logical Maximum 1*/\
+	/*		   0x35,0x00,        Physical Minimum 0*/\
+	/*		   0x45,0x01,        Physical Maximum 1*/\
+	/*		   0x75,0x01,        Report Size 1*/\
+	/*		   0x95,0x01,        Report Count 1*/\
+	/*		   0x81,0x02,        Input (Variable)*/\
+		   0x15,0x00,    /*    Logical Minimum 0*/\
+		   0x25,0x01,    /*    Logical Maximum 1*/\
+		   0x35,0x00,    /*    Physical Minimum 0*/\
+		   0x45,0x01,    /*    Physical Maximum 1*/\
+		   0x75,0x01,    /*    Report Size 1*/\
+		   0x95,0x05,    /*    Report Count 4*/\
+		   0x81,0x02,    /*    Input (Variable)*/\
+		   0x95,0x03,    /*    Report Count 3*/\
+		   0x81,0x03,    /*    Input (Constant, Variable)*/\
+		0xC0        // End Collection
+#define HIDDESC_FFB_STATEREP_SIZE 37
+
+/*
+Output
+Collection  Datalink:
+Usage Set Effect Report
+
+ID:1
+Effect Block Index:	8bit
+
+subcollection Effect Type
+12 effect types, 8bit each
+
+*/
+#define HIDDESC_FFB_SETEFREP \
+		0x09,0x21,    /*    Usage Set Effect Report*/\
+		0xA1,0x02,    /*    Collection Datalink (Logical)*/\
+		   0x85,HID_ID_EFFREP+FFB_ID_OFFSET,    /*    Report ID 1*/\
+		   0x09,0x22,    /*    Usage Effect Block Index*/\
+		   0x15,0x01,    /*    Logical Minimum 1*/\
+		   0x25,MAX_EFFECTS,    /*    Logical Maximum 28h (40d)*/\
+		   0x35,0x01,    /*    Physical Minimum 1*/\
+		   0x45,MAX_EFFECTS,    /*    Physical Maximum 28h (40d)*/\
+		   0x75,0x08,    /*    Report Size 8*/\
+		   0x95,0x01,    /*    Report Count 1*/\
+		   0x91,0x02,    /*    Output (Variable)*/\
+		   0x09,0x25,    /*    Usage Effect Type*/\
+		   0xA1,0x02,    /*    Collection Datalink*/\
+		 0x09, HID_USAGE_CONST,    /*    Usage ET Constant Force*/\
+		 0x09, HID_USAGE_RAMP,    /*    Usage ET Ramp*/\
+		 0x09, HID_USAGE_SQUR,    /*    Usage ET Square*/\
+		 0x09, HID_USAGE_SINE,    /*    Usage ET Sine*/\
+		 0x09, HID_USAGE_TRNG,    /*    Usage ET Triangle*/\
+		 0x09, HID_USAGE_STUP,    /*    Usage ET Sawtooth Up*/\
+		 0x09, HID_USAGE_STDN,    /*    Usage ET Sawtooth Down*/\
+		 0x09, HID_USAGE_SPRNG,    /*    Usage ET Spring*/\
+		 0x09, HID_USAGE_DMPR,    /*    Usage ET Damper*/\
+		 0x09, HID_USAGE_INRT,    /*    Usage ET Inertia*/\
+		 0x09, HID_USAGE_FRIC,    /*    Usage ET Friction*/\
+		/* 0x09, 0x28,    //    Usage ET Custom Force Data*/\
+		      0x25,0x0B,    /*    Logical Maximum Bh (11d)*/\
+		      0x15,0x01,    /*    Logical Minimum 1*/\
+		      0x35,0x01,    /*    Physical Minimum 1*/\
+		      0x45,0x0B,    /*    Physical Maximum Bh (11d)*/\
+		      0x75,0x08,    /*    Report Size 8*/\
+		      0x95,0x01,    /*    Report Count 1*/\
+		      0x91,0x00,    /*    Output*/\
+		   0xC0    ,          /*    End Collection*/\
+		   0x09,0x50,         /*    Usage Duration*/\
+		   0x09,0x54,         /*    Usage Trigger Repeat Interval*/\
+		   0x09,0x51,         /*    Usage Sample Period*/\
+		   0x09,0xA7,         /*    Usage Start Delay*/\
+		   0x15,0x00,         /*    Logical Minimum 0*/\
+		   0x26,0xFF,0x7F,    /*    Logical Maximum 7FFFh (32767d)*/\
+		   0x35,0x00,         /*    Physical Minimum 0*/\
+		   0x46,0xFF,0x7F,    /*    Physical Maximum 7FFFh (32767d)*/\
+		   0x66,0x03,0x10,    /*    Unit 1003h (4099d)*/\
+		   0x55,0xFD,         /*    Unit Exponent FDh (253d)*/\
+		   0x75,0x10,         /*    Report Size 10h (16d)*/\
+		   0x95,0x04,         /*    Report Count 4*/\
+		   0x91,0x02,         /*    Output (Variable)*/\
+		   0x55,0x00,         /*    Unit Exponent 0*/\
+		   0x66,0x00,0x00,    /*    Unit 0*/\
+		   0x09,0x52,         /*    Usage Gain*/\
+		   0x15,0x00,         /*    Logical Minimum 0*/\
+		   0x26,0xFF,0x00,    /*    Logical Maximum FFh (255d) // TODO scaling?*/\
+		   0x35,0x00,         /*    Physical Minimum 0*/\
+		   0x46,0x10,0x27,    /*    Physical Maximum 2710h (10000d)*/\
+		   0x75,0x08,         /*    Report Size 8*/\
+		   0x95,0x01,         /*    Report Count 1*/\
+		   0x91,0x02,         /*    Output (Variable)*/\
+		   0x09,0x53,         /*    Usage Trigger Button*/\
+		   0x15,0x01,         /*    Logical Minimum 1*/\
+		   0x25,0x08,         /*    Logical Maximum 8*/\
+		   0x35,0x01,         /*    Physical Minimum 1*/\
+		   0x45,0x08,         /*    Physical Maximum 8*/\
+		   0x75,0x08,         /*    Report Size 8*/\
+		   0x95,0x01,         /*    Report Count 1*/\
+		   0x91,0x02         //    Output (Variable)
+#define HIDDESC_FFB_SETEFREP_SIZE 131
+
+#define HIDDESC_FFB_SETENVREP \
+		/* Envelope Report Definition*/\
+		0x09,0x5A,    /*    Usage Set Envelope Report*/\
+		0xA1,0x02,    /*    Collection Datalink*/\
+		   0x85,HID_ID_ENVREP+FFB_ID_OFFSET,         /*    Report ID 2*/\
+		   0x09,0x22,         /*    Usage Effect Block Index*/\
+		   0x15,0x01,         /*    Logical Minimum 1*/\
+		   0x25,MAX_EFFECTS,         /*    Logical Maximum 28h (40d)*/\
+		   0x35,0x01,         /*    Physical Minimum 1*/\
+		   0x45,MAX_EFFECTS,         /*    Physical Maximum 28h (40d)*/\
+		   0x75,0x08,         /*    Report Size 8*/\
+		   0x95,0x01,         /*    Report Count 1*/\
+		   0x91,0x02,         /*    Output (Variable)*/\
+		   0x09,0x5B,         /*    Usage Attack Level*/\
+		   0x09,0x5D,         /*    Usage Fade Level*/\
+		 0x16,0x00,0x00,    /*    Logical Minimum 0*/\
+		 0x26,0xFF,0x7F,    /*    Logical Maximum 7FFFh (32767d)*/\
+		 0x36,0x00,0x00,    /*    Physical Minimum 0*/\
+		 0x46,0xFF,0x7F,    /*    Physical Maximum 7FFFh (32767d)*/\
+		 0x75,0x10,         /*    Report Size 16*/\
+		 0x95,0x02,         /*    Report Count 2*/\
+		   0x91,0x02,         /*    Output (Variable)*/\
+		 0x09, 0x5C,         /*    Usage Attack Time*/\
+		 0x09, 0x5E,         /*    Usage Fade Time*/\
+		 0x66, 0x03, 0x10,    /*    Unit 1003h (English Linear, Seconds)*/\
+		 0x55, 0xFD,         /*    Unit Exponent FDh (X10^-3 ==> Milisecond)*/\
+		 0x27, 0xFF, 0x7F, 0x00, 0x00,    /*    Logical Maximum FFFFFFFFh (4294967295)*/\
+		 0x47, 0xFF, 0x7F, 0x00, 0x00,    /*    Physical Maximum FFFFFFFFh (4294967295)*/\
+		 0x75, 0x20,         /*    Report Size 20h (32d)*/\
+		 0x91, 0x02,         /*    Output (Variable)*/\
+		 0x45, 0x00,         /*    Physical Maximum 0*/\
+		   0x66,0x00,0x00,    /*    Unit 0*/\
+		   0x55,0x00,         /*    Unit Exponent 0*/\
+		0xC0                 /*    End Collection*/
+#define HIDDESC_FFB_SETENVREP_SIZE 75
+
+// Contains axis dependant parts. not used
+#define HIDDESC_FFB_SETCONDREP \
+		0x09,0x5F,    /*    Usage Set Condition Report*/\
+		0xA1,0x02,    /*    Collection Datalink*/\
+		   0x85,HID_ID_CONDREP+FFB_ID_OFFSET,    /*    Report ID 3*/\
+		   0x09,0x22,    /*    Usage Effect Block Index*/\
+		   0x15,0x01,    /*    Logical Minimum 1*/\
+		   0x25,MAX_EFFECTS,    /*    Logical Maximum 28h (40d)*/\
+		   0x35,0x01,    /*    Physical Minimum 1*/\
+		   0x45,MAX_EFFECTS,    /*    Physical Maximum 28h (40d)*/\
+		   0x75,0x08,    /*    Report Size 8*/\
+		   0x95,0x01,    /*    Report Count 1*/\
+		   0x91,0x02,    /*    Output (Variable)*/\
+		   0x09,0x23,    /*    Usage Parameter Block Offset*/\
+		   0x15,0x00,    /*    Logical Minimum 0*/\
+		   0x25,0x03,    /*    Logical Maximum 3*/\
+		   0x35,0x00,    /*    Physical Minimum 0*/\
+		   0x45,0x03,    /*    Physical Maximum 3*/\
+		   0x75,0x04,    /*    Report Size 4*/\
+		   0x95,0x01,    /*    Report Count 1*/\
+		   0x91,0x02,    /*    Output (Variable)*/\
+		   0x09,0x58,    /*    Usage Type Specific Block Off...*/\
+		   0xA1,0x02,    /*    Collection Datalink*/\
+		      0x0B,0x01,0x00,0x0A,0x00,    /*    Usage Ordinals: Instance 1*/\
+		      0x0B,0x02,0x00,0x0A,0x00,    /*    Usage Ordinals: Instance 2*/\
+		      0x75,0x02,                   /*    Report Size 2*/\
+		      0x95,0x02,                   /*    Report Count 2*/\
+		      0x91,0x02,                   /*    Output (Variable)*/\
+		   0xC0     ,         /*    End Collection*/\
+		   0x16,0x00, 0x80,    /*    Logical Minimum 7FFFh (-32767d)*/\
+		   0x26,0xff, 0x7f,    /*    Logical Maximum 7FFFh (32767d)*/\
+		   0x36,0x00, 0x80,    /*    Physical Minimum 7FFFh (-32767d)*/\
+		   0x46,0xff, 0x7f,    /*    Physical Maximum 7FFFh (32767d)*/\
+\
+		   0x09,0x60,         /*    Usage CP Offset*/\
+		   0x75,0x10,         /*    Report Size 16*/\
+		   0x95,0x01,         /*    Report Count 1*/\
+		   0x91,0x02,         /*    Output (Variable)*/\
+		   0x36,0x00, 0x80,    /*    Physical Minimum  (-32768)*/\
+		   0x46,0xff, 0x7f,    /*    Physical Maximum  (32767)*/\
+		   0x09,0x61,         /*    Usage Positive Coefficient*/\
+		   0x09,0x62,         /*    Usage Negative Coefficient*/\
+		   0x95,0x02,         /*    Report Count 2*/\
+		   0x91,0x02,         /*    Output (Variable)*/\
+		 0x16,0x00,0x00,    /*    Logical Minimum 0*/\
+		 0x26,0xff, 0x7f,	  /*    Logical Maximum  (32767)*/\
+		 0x36,0x00,0x00,    /*    Physical Minimum 0*/\
+		   0x46,0xff, 0x7f,    /*    Physical Maximum  (32767)*/\
+		   0x09,0x63,         /*    Usage Positive Saturation*/\
+		   0x09,0x64,         /*    Usage Negative Saturation*/\
+		   0x75,0x10,         /*    Report Size 16*/\
+		   0x95,0x02,         /*    Report Count 2*/\
+		   0x91,0x02,         /*    Output (Variable)*/\
+		   0x09,0x65,         /*    Usage Dead Band*/\
+		   0x46,0xff, 0x7f,    /*    Physical Maximum (32767)*/\
+		   0x95,0x01,         /*    Report Count 1*/\
+		   0x91,0x02,         /*    Output (Variable)*/\
+		0xC0         /*    End Collection*/
+#define HIDDESC_FFB_SETCONDREP_SIZE 125
+
+#define HIDDESC_FFB_SETPERIODICREP \
+		0x09,0x6E,    /*    Usage Set Periodic Report*/\
+		0xA1,0x02,    /*    Collection Datalink*/\
+		   0x85,HID_ID_PRIDREP+FFB_ID_OFFSET,                   /*    Report ID 4*/\
+		   0x09,0x22,                   /*    Usage Effect Block Index*/\
+		   0x15,0x01,                   /*    Logical Minimum 1*/\
+		   0x25,MAX_EFFECTS,                   /*    Logical Maximum 28h (40d)*/\
+		   0x35,0x01,                   /*    Physical Minimum 1*/\
+		   0x45,MAX_EFFECTS,                   /*    Physical Maximum 28h (40d)*/\
+		   0x75,0x08,                   /*    Report Size 8*/\
+		   0x95,0x01,                   /*    Report Count 1*/\
+		   0x91,0x02,                   /*    Output (Variable)*/\
+		   0x09,0x70,                   /*    Usage Magnitude*/\
+		 0x16,0x00,0x00,              /*    Logical Minimum 0*/\
+		 0x26,0xff, 0x7f,    /*    Logical Maximum 7FFFh (32767d)*/\
+		 0x36,0x00,0x00,              /*    Physical Minimum 0*/\
+		 0x26,0xff, 0x7f,    /*    Logical Maximum 7FFFh (32767d)*/\
+		   0x75,0x10,                   /*    Report Size 16*/\
+		   0x95,0x01,                   /*    Report Count 1*/\
+		   0x91,0x02,                   /*    Output (Variable)*/\
+		 0x09, 0x6F,                   /*    Usage Offset*/\
+		 0x16,0x00, 0x80,    /*    Logical Minimum 7FFFh (-32767d)*/\
+	     0x26,0xff, 0x7f,    /*    Logical Maximum 7FFFh (32767d)*/\
+	     0x36,0x00, 0x80,    /*    Physical Minimum 7FFFh (-32767d)*/\
+	     0x46,0xff, 0x7f,    /*    Physical Maximum 7FFFh (32767d)*/\
+		 0x95, 0x01,                   /*    Report Count 1*/\
+		 0x75, 0x10,                   /*    Report Size 16*/\
+		 0x91, 0x02,                   /*    Output (Variable)*/\
+		 0x09, 0x71,                   /*    Usage Phase*/\
+		 0x66, 0x14, 0x00,             /*    Unit 14h (Eng Rotation, Degrees)*/\
+		 0x55, 0xFE,                   /*    Unit Exponent FEh (X10^-2)*/\
+		 0x15, 0x00,                   /*    Logical Minimum 0*/\
+		 0x27, 0x9F, 0x8C, 0x00, 0x00, /*    Logical Maximum 8C9Fh (35999d)*/\
+		 0x35, 0x00,                   /*    Physical Minimum 0*/\
+		 0x47, 0x9F, 0x8C, 0x00, 0x00, /*    Physical Maximum 8C9Fh (35999d)*/\
+		 0x75, 0x10,                   /*    Report Size 16*/\
+		 0x95, 0x01,                   /*    Report Count 1*/\
+		 0x91, 0x02,                   /*    Output (Variable)*/\
+		 0x09, 0x72,                   /*    Usage Period*/\
+		 0x15, 0x01,                   /*    Logical Minimum 1*/\
+		 0x27, 0xFF, 0x7F, 0x00, 0x00, /*    Logical Maximum 7FFFh (32K)*/\
+		 0x35, 0x01,                   /*    Physical Minimum 1*/\
+		 0x47, 0xFF, 0x7F, 0x00, 0x00, /*    Physical Maximum 7FFFh (32K)*/\
+		 0x66, 0x03, 0x10,             /*    Unit 1003h (English Linear, Seconds)*/\
+		 0x55, 0xFD,                   /*    Unit Exponent FDh (X10^-3 ==> Millisecond)*/\
+		 0x75, 0x20,                   /*    Report Size 20h (32)*/\
+		 0x95, 0x01,                   /*    Report Count 1*/\
+		 0x91, 0x02,                   /*    Output (Variable)*/\
+		 0x66, 0x00, 0x00,              /*    Unit 0*/\
+		   0x55,0x00,                   /*    Unit Exponent 0*/\
+		0xC0         /* End Collection*/
+#define HIDDESC_FFB_SETPERIODICREP_SIZE 122
+
+#define HIDDESC_FFB_SETCFREP \
+		0x09,0x73,    /*    Usage Set Constant Force Report*/\
+		0xA1,0x02,    /*    Collection Datalink*/\
+		   0x85,HID_ID_CONSTREP+FFB_ID_OFFSET,         /*    Report ID 5*/\
+		   0x09,0x22,         /*    Usage Effect Block Index*/\
+		   0x15,0x01,         /*    Logical Minimum 1*/\
+		   0x25,MAX_EFFECTS,         /*    Logical Maximum 28h (40d)*/\
+		   0x35,0x01,         /*    Physical Minimum 1*/\
+		   0x45,MAX_EFFECTS,         /*    Physical Maximum 28h (40d)*/\
+		   0x75,0x08,         /*    Report Size 8*/\
+		   0x95,0x01,         /*    Report Count 1*/\
+		   0x91,0x02,         /*    Output (Variable)*/\
+		   0x09,0x70,         /*    Usage Magnitude*/\
+		   0x16,0x01, 0x80,   /*    Logical Minimum -7FFFh (-32767d)*/\
+		   0x26,0xff, 0x7f,    /*    Logical Maximum 7FFFh (32767d)*/\
+		   0x36,0x01, 0x80,    /*    Physical Minimum -7FFFh (-32767d)*/\
+		   0x46,0xff, 0x7f,    /*    Physical Maximum 7FFFh (32767d)*/\
+		   0x75, 0x10,         /*    Report Size 10h (16d)*/\
+		   0x95,0x01,         /*    Report Count 1*/\
+		   0x91,0x02,         /*    Output (Variable)*/\
+		0xC0         /*    End Collection*/
+#define HIDDESC_FFB_SETCFREP_SIZE 43
+
+#define HIDDESC_FFB_SETRAMPREP \
+		0x09,0x74,    /*    Usage Set Ramp Force Report*/\
+		0xA1,0x02,    /*    Collection Datalink*/\
+		   0x85,HID_ID_RAMPREP+FFB_ID_OFFSET,         /*    Report ID 6*/\
+		   0x09,0x22,         /*    Usage Effect Block Index*/\
+		   0x15,0x01,         /*    Logical Minimum 1*/\
+		   0x25,MAX_EFFECTS,         /*    Logical Maximum 28h (40d)*/\
+		   0x35,0x01,         /*    Physical Minimum 1*/\
+		   0x45,MAX_EFFECTS,         /*    Physical Maximum 28h (40d)*/\
+		   0x75,0x08,         /*    Report Size 8*/\
+		   0x95,0x01,         /*    Report Count 1*/\
+		   0x91,0x02,         /*    Output (Variable)*/\
+		   0x09,0x75,         /*    Usage Ramp Start*/\
+		   0x09,0x76,         /*    Usage Ramp End*/\
+		   0x16,0x00, 0x80,    /*    Logical Minimum 7FFFh (-32767d)*/\
+		   0x26,0xff, 0x7f,    /*    Logical Maximum 7FFFh (32767d)*/\
+		   0x36,0x00, 0x80,    /*    Physical Minimum 7FFFh (-32767d)*/\
+		   0x46,0xff, 0x7f,    /*    Physical Maximum 7FFFh (32767d)*/\
+		   0x75,0x10,         /*    Report Size 16*/\
+		   0x95,0x02,         /*    Report Count 2*/\
+		   0x91,0x02,         /*    Output (Variable)*/\
+		0xC0         /*    End Collection*/
+#define HIDDESC_FFB_SETRAMPREP_SIZE 45
+// not to be used yet
+#define HIDDESC_FFB_CUSTOMFORCEREP \
+/*			0x09,0x68,    //    Usage Custom Force Data Report*/\
+/*			0xA1,0x02,    //    Collection Datalink*/\
+/*			   0x85,HID_ID_CSTMREP+FFB_ID_OFFSET,         //    Report ID 7*/\
+/*			   0x09,0x22,         //    Usage Effect Block Index*/\
+/*			   0x15,0x01,         //    Logical Minimum 1*/\
+/*			   0x25,MAX_EFFECTS,         //    Logical Maximum 28h (40d)*/\
+/*			   0x35,0x01,         //    Physical Minimum 1*/\
+/*			   0x45,MAX_EFFECTS,         //    Physical Maximum 28h (40d)*/\
+/*			   0x75,0x08,         //    Report Size 8*/\
+/*			   0x95,0x01,         //    Report Count 1*/\
+/*			   0x91,0x02,         //    Output (Variable)*/\
+/*			   0x09,0x6C,         //    Usage Custom Force Data Offset*/\
+/*			   0x15,0x00,         //    Logical Minimum 0*/\
+/*			   0x26,0x10,0x27,    //    Logical Maximum 2710h (10000d)*/\
+/*			   0x35,0x00,         //    Physical Minimum 0*/\
+/*			   0x46,0x10,0x27,    //    Physical Maximum 2710h (10000d)*/\
+/*			   0x75,0x10,         //    Report Size 10h (16d)*/\
+/*			   0x95,0x01,         //    Report Count 1*/\
+/*			   0x91,0x02,         //    Output (Variable)*/\
+/*			   0x09,0x69,         //    Usage Custom Force Data*/\
+/*			   0x15,0x81,         //    Logical Minimum 81h (-127d)*/\
+/*			   0x25,0x7F,         //    Logical Maximum 7Fh (127d)*/\
+/*			   0x35,0x00,         //    Physical Minimum 0*/\
+/*			   0x46,0xFF,0x00,    //    Physical Maximum FFh (255d)*/\
+/*			   0x75,0x08,         //    Report Size 8*/\
+/*			   0x95,0x0C,         //    Report Count Ch (12d)*/\
+/*			   0x92,0x02,0x01,    //       Output (Variable, Buffered)*/\
+/*			0xC0     ,    //    End Collection*/\
+/*			0x09,0x66,    //    Usage Download Force Sample*/\
+/*			0xA1,0x02,    //    Collection Datalink*/\
+/*			   0x85,HID_ID_SMPLREP+FFB_ID_OFFSET,         //    Report ID 8*/\
+/*			   0x05,0x01,         //    Usage Page Generic Desktop*/\
+/*			   0x09,0x30,         //    Usage X*/\
+/*			   0x09,0x31,         //    Usage Y*/\
+/*			   0x15,0x81,         //    Logical Minimum 81h (-127d)*/\
+/*			   0x25,0x7F,         //    Logical Maximum 7Fh (127d)*/\
+/*			   0x35,0x00,         //    Physical Minimum 0*/\
+/*			   0x46,0xFF,0x00,    //    Physical Maximum FFh (255d)*/\
+/*			   0x75,0x08,         //    Report Size 8*/\
+/*			   0x95,0x02,         //    Report Count 2*/\
+/*			   0x91,0x02,         //    Output (Variable)*/\
+/*			0xC0     ,   //    End Collection*/
+#define HIDDESC_FFB_EFOPREP \
+		0x05,0x0F,   /*    Usage Page Physical Interface*/\
+		0x09,0x77,   /*    Usage Effect Operation Report*/\
+		0xA1,0x02,   /*    Collection Datalink*/\
+		   0x85,HID_ID_EFOPREP+FFB_ID_OFFSET,    /*    Report ID Ah (10d)*/\
+		   0x09,0x22,    /*    Usage Effect Block Index*/\
+		   0x15,0x01,    /*    Logical Minimum 1*/\
+		   0x25,MAX_EFFECTS,    /*    Logical Maximum 28h (40d)*/\
+		   0x35,0x01,    /*    Physical Minimum 1*/\
+		   0x45,MAX_EFFECTS,    /*    Physical Maximum 28h (40d)*/\
+		   0x75,0x08,    /*    Report Size 8*/\
+		   0x95,0x01,    /*    Report Count 1*/\
+		   0x91,0x02,    /*    Output (Variable)*/\
+		   0x09,0x78,    /*    Usage Effect Operation*/\
+		   0xA1,0x02,    /*    Collection Datalink*/\
+		      0x09,0x79,    /*    Usage Op Effect Start*/\
+		      0x09,0x7A,    /*    Usage Op Effect Start Solo*/\
+		      0x09,0x7B,    /*    Usage Op Effect Stop*/\
+		      0x15,0x01,    /*    Logical Minimum 1*/\
+		      0x25,0x03,    /*    Logical Maximum 3*/\
+		      0x75,0x08,    /*    Report Size 8*/\
+		      0x95,0x01,    /*    Report Count 1*/\
+		      0x91,0x00,    /*    Output*/\
+		   0xC0     ,         /*    End Collection*/\
+		   0x09,0x7C,         /*    Usage Loop Count*/\
+		   0x15,0x00,         /*    Logical Minimum 0*/\
+		   0x26,0xFF,0x00,    /*    Logical Maximum FFh (255d)*/\
+		   0x35,0x00,         /*    Physical Minimum 0*/\
+		   0x46,0xFF,0x00,    /*    Physical Maximum FFh (255d)*/\
+		   0x91,0x02,         /*    Output (Variable)*/\
+		0xC0         /*    End Collection*/
+#define HIDDESC_FFB_EFOPREP_SIZE 60
+#define HIDDESC_FFB_BLOCKFREEREP \
+		0x09,0x90,    /*    Usage PID Block Free Report*/\
+		0xA1,0x02,    /*    Collection Datalink*/\
+		   0x85,HID_ID_BLKFRREP+FFB_ID_OFFSET,    /*    Report ID Bh (11d)*/\
+		   0x09,0x22,    /*    Usage Effect Block Index*/\
+		   0x15,0x01,    /*    Logical Minimum 1*/\
+		   0x25,MAX_EFFECTS,    /*    Logical Maximum 28h (40d)*/\
+		   0x35,0x01,    /*    Physical Minimum 1*/\
+		   0x45,MAX_EFFECTS,    /*    Physical Maximum 28h (40d)*/\
+		   0x75,0x08,    /*    Report Size 8*/\
+		   0x95,0x01,    /*    Report Count 1*/\
+		   0x91,0x02,    /*    Output (Variable)*/\
+		0xC0         /*    End Collection*/
+#define HIDDESC_FFB_BLOCKFREEREP_SIZE 23
+#define HIDDESC_FFB_DEVCTRLREP \
+		0x09,0x95,    /*    Usage PID Device Control (0x96?)*/\
+		0xA1,0x02,    /*    Collection Datalink*/\
+		0x85,HID_ID_CTRLREP+FFB_ID_OFFSET,    /*    Report ID Ch (12d)*/\
+		0x09,0x96,    /*    Usage PID Device Control (0x96?)*/\
+		0xA1,0x02,    /*    Collection Datalink*/\
+\
+		   0x09,0x97,    /*    Usage DC Enable Actuators*/\
+		   0x09,0x98,    /*    Usage DC Disable Actuators*/\
+		   0x09,0x99,    /*    Usage DC Stop All Effects*/\
+		   0x09,0x9A,    /*    Usage DC Device Reset*/\
+		   0x09,0x9B,    /*    Usage DC Device Pause*/\
+		   0x09,0x9C,    /*    Usage DC Device Continue*/\
+\
+\
+\
+		   0x15,0x01,    /*    Logical Minimum 1*/\
+		   0x25,0x06,    /*    Logical Maximum 6*/\
+		   0x75,0x01,    /*    Report Size 1*/\
+		   0x95,0x08,    /*    Report Count 8*/\
+		   0x91,0x02,    /*    Output*/\
+\
+		0xC0     ,    /*    End Collection*/\
+		0xC0     ,    /*    End Collection*/\
+		0x09,0x7D,    /*    Usage Device Gain Report*/\
+		0xA1,0x02,    /*    Collection Datalink*/\
+		   0x85,HID_ID_GAINREP+FFB_ID_OFFSET,         /*    Report ID Dh (13d)*/\
+		   0x09,0x7E,         /*    Usage Device Gain*/\
+		   0x15,0x00,         /*    Logical Minimum 0*/\
+		   0x26,0xFF,0x00,    /*    Logical Maximum FFh (255d)*/\
+		   0x35,0x00,         /*    Physical Minimum 0*/\
+		   0x46,0x10,0x27,    /*    Physical Maximum 2710h (10000d)*/\
+		   0x75,0x08,         /*    Report Size 8*/\
+		   0x95,0x01,         /*    Report Count 1*/\
+		   0x91,0x02,         /*    Output (Variable)*/\
+		0xC0                 /*    End Collection*/
+#define HIDDESC_FFB_DEVCTRLREP_SIZE 59
+// Do not use yet
+#define HIDDESC_FFB_SETCUSTFORCEREP \
+/*			0x09,0x6B,    //    Usage Set Custom Force Report*/\
+/*			0xA1,0x02,    //    Collection Datalink*/\
+/*			   0x85,HID_ID_SETCREP+FFB_ID_OFFSET,         //    Report ID Eh (14d)*/\
+/*			   0x09,0x22,         //    Usage Effect Block Index*/\
+/*			   0x15,0x01,         //    Logical Minimum 1*/\
+/*			   0x25,MAX_EFFECTS,         //    Logical Maximum 28h (40d)*/\
+/*			   0x35,0x01,         //    Physical Minimum 1*/\
+/*			   0x45,MAX_EFFECTS,         //    Physical Maximum 28h (40d)*/\
+/*			   0x75,0x08,         //    Report Size 8*/\
+/*			   0x95,0x01,         //    Report Count 1*/\
+/*			   0x91,0x02,         //    Output (Variable)*/\
+/*			   0x09,0x6D,         //    Usage Sample Count*/\
+/*			   0x15,0x00,         //    Logical Minimum 0*/\
+/*			   0x26,0xFF,0x00,    //    Logical Maximum FFh (255d)*/\
+/*			   0x35,0x00,         //    Physical Minimum 0*/\
+/*			   0x46,0xFF,0x00,    //    Physical Maximum FFh (255d)*/\
+/*			   0x75,0x08,         //    Report Size 8*/\
+/*			   0x95,0x01,         //    Report Count 1*/\
+/*			   0x91,0x02,         //    Output (Variable)*/\
+/*			   0x09,0x51,         //    Usage Sample Period*/\
+/*			   0x66,0x03,0x10,    //    Unit 1003h (4099d)*/\
+/*			   0x55,0xFD,         //    Unit Exponent FDh (253d)*/\
+/*			   0x15,0x00,         //    Logical Minimum 0*/\
+/*			   0x26,0xFF,0x7F,    //    Logical Maximum 7FFFh (32767d)*/\
+/*			   0x35,0x00,         //    Physical Minimum 0*/\
+/*			   0x46,0xFF,0x7F,    //    Physical Maximum 7FFFh (32767d)*/\
+/*			   0x75,0x10,         //    Report Size 10h (16d)*/\
+/*			   0x95,0x01,         //    Report Count 1*/\
+/*			   0x91,0x02,         //    Output (Variable)*/\
+/*			   0x55,0x00,         //    Unit Exponent 0*/\
+/*			   0x66,0x00,0x00,    //    Unit 0*/\
+/*			0xC0         //    End Collection*/
+#define HIDDESC_FFB_NEWEFREP \
+		0x09,0xAB,    /*    Usage Create New Effect Report*/\
+		0xA1,0x02,    /*    Collection Datalink*/\
+		   0x85,HID_ID_NEWEFREP+FFB_ID_OFFSET,    /*    Report ID 1*/\
+		   0x09,0x25,    /*    Usage Effect Type*/\
+		   0xA1,0x02,    /*    Collection Datalink*/\
+		 0x09, HID_USAGE_CONST,    /*    Usage ET Constant Force*/\
+		 0x09, HID_USAGE_RAMP,    /*    Usage ET Ramp*/\
+		 0x09, HID_USAGE_SQUR,    /*    Usage ET Square*/\
+		 0x09, HID_USAGE_SINE,    /*    Usage ET Sine*/\
+		 0x09, HID_USAGE_TRNG,    /*    Usage ET Triangle*/\
+		 0x09, HID_USAGE_STUP,    /*    Usage ET Sawtooth Up*/\
+		 0x09, HID_USAGE_STDN,    /*    Usage ET Sawtooth Down*/\
+		 0x09, HID_USAGE_SPRNG,    /*    Usage ET Spring*/\
+		 0x09, HID_USAGE_DMPR,    /*    Usage ET Damper*/\
+		 0x09, HID_USAGE_INRT,    /*    Usage ET Inertia*/\
+		 0x09, HID_USAGE_FRIC,    /*    Usage ET Friction*/\
+/*			 0x09, 0x28,    //    Usage ET Custom Force Data*/\
+		   0x25,0x0B,    /*    Logical Maximum Ch (11d)*/\
+		   0x15,0x01,    /*    Logical Minimum 1*/\
+		   0x35,0x01,    /*    Physical Minimum 1*/\
+		   0x45,0x0B,    /*    Physical Maximum Ch (11d)*/\
+		   0x75,0x08,    /*    Report Size 8*/\
+		   0x95,0x01,    /*    Report Count 1*/\
+		   0xB1,0x00,    /*    Feature*/\
+		0xC0     ,    /* End Collection*/\
+		0x05,0x01,         /*    Usage Page Generic Desktop*/\
+		0x09,0x3B,         /*    Usage Reserved (Byte count)*/\
+		0x15,0x00,         /*    Logical Minimum 0*/\
+		0x26,0xFF,0x01,    /*    Logical Maximum 1FFh (511d)*/\
+		0x35,0x00,         /*    Physical Minimum 0*/\
+		0x46,0xFF,0x01,    /*    Physical Maximum 1FFh (511d)*/\
+		0x75,0x0A,         /*    Report Size Ah (10d)*/\
+		0x95,0x01,         /*    Report Count 1*/\
+		0xB1,0x02,         /*    Feature (Variable)*/\
+		0x75,0x06,         /*    Report Size 6*/\
+		0xB1,0x01,         /*    Feature (Constant)*/\
+		0xC0         /*    End Collection*/
+#define HIDDESC_FFB_NEWEFREP_SIZE 72
+
+#define HIDDESC_FFB_BLOCKLOADREP \
+		0x05,0x0F,    /*    Usage Page Physical Interface*/\
+		0x09,0x89,    /*    Usage Block Load Report*/\
+		0xA1,0x02,    /*    Collection Datalink*/\
+		0x85,HID_ID_BLKLDREP+FFB_ID_OFFSET,    /*    Report ID 0x12*/\
+		0x09,0x22,    /*    Usage Effect Block Index*/\
+		0x25,MAX_EFFECTS,    /*    Logical Maximum 28h (40d)*/\
+		0x15,0x01,    /*    Logical Minimum 1*/\
+		0x35,0x01,    /*    Physical Minimum 1*/\
+		0x45,MAX_EFFECTS,    /*    Physical Maximum 28h (40d)*/\
+		0x75,0x08,    /*    Report Size 8*/\
+		0x95,0x01,    /*    Report Count 1*/\
+		0xB1,0x02,    /*    Feature (Variable)*/\
+		0x09,0x8B,    /*    Usage Block Load Status*/\
+		0xA1,0x02,    /*    Collection Datalink*/\
+		   0x09,0x8C,    /*    Usage Block Load Success*/\
+		   0x09,0x8D,    /*    Usage Block Load Full*/\
+		   0x09,0x8E,    /*    Usage Block Load Error*/\
+		   0x15,0x01,    /*    Logical Minimum 1*/\
+		   0x25,0x03,    /*    Logical Maximum 3*/\
+		   0x35,0x01,    /*    Physical Minimum 1*/\
+		   0x45,0x03,    /*    Physical Maximum 3*/\
+		   0x75,0x08,    /*    Report Size 8*/\
+		   0x95,0x01,    /*    Report Count 1*/\
+		   0xB1,0x00,    /*    Feature*/\
+		0xC0     ,                   /* End Collection*/\
+		0x09,0xAC,                   /*    Usage Pool available*/\
+		0x15,0x00,                   /*    Logical Minimum 0*/\
+		0x27,0xFF,0xFF,0x00,0x00,    /*    Logical Maximum FFFFh (65535d)*/\
+		0x35,0x00,                   /*    Physical Minimum 0*/\
+		0x47,0xFF,0xFF,0x00,0x00,    /*    Physical Maximum FFFFh (65535d)*/\
+		0x75,0x10,                   /*    Report Size 10h (16d)*/\
+		0x95,0x01,                   /*    Report Count 1*/\
+		0xB1,0x00,                   /*    Feature*/\
+		0xC0         //    End Collection
+#define HIDDESC_FFB_BLOCKLOADREP_SIZE 72
+
+#define HIDDESC_FFB_POOLREP \
+		0x09,0x7F,    /*    Usage PID Pool Report*/\
+		0xA1,0x02,    /*    Collection Datalink*/\
+			0x85,HID_ID_POOLREP+FFB_ID_OFFSET,                   /*    Report ID 0x13*/\
+			0x09,0x80,                   /*    Usage RAM Pool size*/\
+			0x75,0x10,                   /*    Report Size 10h (16d)*/\
+			0x95,0x01,                   /*    Report Count 1*/\
+			0x15,0x00,                   /*    Logical Minimum 0*/\
+			0x35,0x00,                   /*    Physical Minimum 0*/\
+			0x27,0xFF,0xFF,0x00,0x00,    /*    Logical Maximum FFFFh (65535d)*/\
+			0x47,0xFF,0xFF,0x00,0x00,    /*    Physical Maximum FFFFh (65535d)*/\
+			0xB1,0x02,                   /*    Feature (Variable)*/\
+			0x09,0x83,                   /*    Usage Simultaneous Effects Max*/\
+			0x26,0xFF,0x00,              /*    Logical Maximum FFh (255d)*/\
+			0x46,0xFF,0x00,              /*    Physical Maximum FFh (255d)*/\
+			0x75,0x08,                   /*    Report Size 8*/\
+			0x95,0x01,                   /*    Report Count 1*/\
+			0xB1,0x02,                   /*    Feature (Variable)*/\
+			0x09,0xA9,                   /*    Usage Device Managed Pool*/\
+			0x09,0xAA,                   /*    Usage Shared Parameter Blocks*/\
+			0x75,0x01,                   /*    Report Size 1*/\
+			0x95,0x02,                   /*    Report Count 2*/\
+			0x15,0x00,                   /*    Logical Minimum 0*/\
+			0x25,0x01,                   /*    Logical Maximum 1*/\
+			0x35,0x00,                   /*    Physical Minimum 0*/\
+			0x45,0x01,                   /*    Physical Maximum 1*/\
+			0xB1,0x02,                   /*    Feature (Variable)*/\
+			0x75,0x06,                   /*    Report Size 6*/\
+			0x95,0x01,                   /*    Report Count 1*/\
+			0xB1,0x03,                   /*    Feature (Constant, Variable)*/\
+		0xC0 //    End Collection
+#define HIDDESC_FFB_POOLREP_SIZE 67
+
+#define HIDDESC_FFB_DESCSIZE HIDDESC_FFB_STATEREP_SIZE + HIDDESC_FFB_POOLREP_SIZE + HIDDESC_FFB_BLOCKLOADREP_SIZE + HIDDESC_FFB_NEWEFREP_SIZE + HIDDESC_FFB_DEVCTRLREP_SIZE + HIDDESC_FFB_BLOCKFREEREP_SIZE + HIDDESC_FFB_EFOPREP_SIZE + HIDDESC_FFB_SETEFREP_SIZE + HIDDESC_FFB_SETRAMPREP_SIZE + HIDDESC_FFB_SETCFREP_SIZE + HIDDESC_FFB_SETPERIODICREP_SIZE + HIDDESC_FFB_SETENVREP_SIZE
+
+
 
-#define USB_HID_2FFB_REPORT_DESC_SIZE 1215//1213
 #ifdef AXIS2_FFB_HID_DESC
+#define USB_HID_2FFB_REPORT_DESC_SIZE HIDDESC_GAMEPAD_16B_SIZE + HIDDESC_CTRL_REPORTS_SIZE + HIDDESC_FFB_DESCSIZE + 7 + 108 + 125
 extern const uint8_t hid_2ffb_desc[USB_HID_2FFB_REPORT_DESC_SIZE];
 #endif
+#ifdef AXIS2_FFB_HID_DESC_32B
+#define USB_HID_2FFB_REPORT_DESC_32B_SIZE HIDDESC_GAMEPAD_32B_SIZE + HIDDESC_CTRL_REPORTS_SIZE + HIDDESC_FFB_DESCSIZE + 7 + 108 + 125
+extern const uint8_t hid_2ffb_desc_32b[USB_HID_2FFB_REPORT_DESC_32B_SIZE];
+#endif
+
+#ifdef AXIS1_FFB_HID_DESC
+#define USB_HID_1FFB_REPORT_DESC_SIZE HIDDESC_GAMEPAD_16B_SIZE + HIDDESC_CTRL_REPORTS_SIZE + HIDDESC_FFB_DESCSIZE + 7 + 94 + 120
+extern const uint8_t hid_1ffb_desc[USB_HID_1FFB_REPORT_DESC_SIZE];
+#endif
+#ifdef AXIS1_FFB_HID_DESC_32B
+#define USB_HID_1FFB_REPORT_DESC_SIZE HIDDESC_GAMEPAD_32B_SIZE + HIDDESC_CTRL_REPORTS_SIZE + HIDDESC_FFB_DESCSIZE + 7 + 94 + 120
+extern const uint8_t hid_1ffb_desc_32b[USB_HID_1FFB_REPORT_DESC_32B_SIZE];
+#endif
+
 
-#define USB_HID_GAMEPAD_REPORT_DESC_SIZE 176
 #ifdef FFB_HID_DESC_GAMEPAD
+#define USB_HID_GAMEPAD_REPORT_DESC_SIZE HIDDESC_GAMEPAD_16B_SIZE + HIDDESC_CTRL_REPORTS_SIZE + 7
 extern const uint8_t hid_gamepad_desc[USB_HID_GAMEPAD_REPORT_DESC_SIZE];
+#endif
+#ifdef FFB_HID_DESC_GAMEPAD_32B
+#define USB_HID_GAMEPAD_REPORT_DESC_32B_SIZE HIDDESC_GAMEPAD_32B_SIZE + HIDDESC_CTRL_REPORTS_SIZE + 7
+extern const uint8_t hid_gamepad_desc_32b[USB_HID_GAMEPAD_REPORT_DESC_32B_SIZE];
+#endif
+
+#ifdef HIDAXISRES_USE_32B_DESC
+
 #endif
 
+/** @}*/
 #endif /* USB_INC_USB_HID_FFB_DESC_H_ */
diff --git a/Firmware/FFBoard/UserExtensions/Src/CanBridge.cpp b/Firmware/FFBoard/UserExtensions/Src/CanBridge.cpp
index 9708e8908..5b013463c 100644
--- a/Firmware/FFBoard/UserExtensions/Src/CanBridge.cpp
+++ b/Firmware/FFBoard/UserExtensions/Src/CanBridge.cpp
@@ -12,8 +12,6 @@
 #include "ledEffects.h"
 #include "cdc_device.h"
 
-extern TIM_TypeDef TIM_MICROS;
-
 ClassIdentifier CanBridge::info = {
 		 .name = "CAN Bridge (GVRET)" ,
 		 .id=CLSID_MAIN_CAN,
@@ -63,9 +61,9 @@ void CanBridge::sendMessage(uint32_t id, uint64_t msg,uint8_t len = 8,bool rtr =
 	txHeader.id = id;
 	txHeader.length = len;
 	txHeader.rtr = rtr;
-	if(id & 1 << 31){
+	if(id & 0x80000000){
 		txHeader.extId = true;
-		id &= 0x7FFFFFFF;
+		txHeader.id &= 0x7FFFFFFF;
 	}else{
 		txHeader.extId = false;
 	}
@@ -102,10 +100,9 @@ void CanBridge::update(){
 			CAN_msg_header_rx rxHeader = msg.header;
 			uint32_t time = rxHeader.timestamp;
 			uint32_t id = rxHeader.id;
-//			if(rxHeader.ExtId != 0){
-//				id = rxHeader.ExtId;
-//				id |= 0x80000000;
-//			}
+			if(rxHeader.extId){
+				id |= 0x80000000;
+			}
 			std::vector<char> reply = {
 					0xF1,0,(char)(time & 0xff), (char)((time >> 8) & 0xff), (char)((time >> 16) & 0xff), (char)((time >> 24) & 0xff),
 					(char)(id & 0xff), (char)((id >> 8) & 0xff), (char)((id >> 16) & 0xff), (char)((id >> 24) & 0xff),
diff --git a/Firmware/FFBoard/UserExtensions/Src/EncoderBissC.cpp b/Firmware/FFBoard/UserExtensions/Src/EncoderBissC.cpp
index 218e3e03a..5f36b13b1 100644
--- a/Firmware/FFBoard/UserExtensions/Src/EncoderBissC.cpp
+++ b/Firmware/FFBoard/UserExtensions/Src/EncoderBissC.cpp
@@ -101,16 +101,16 @@ void EncoderBissC::configSPI() {
 	uint32_t prescale;
 	switch (spiSpeed) {
 		case 1 :
-			prescale = SPI_BAUDRATEPRESCALER_64;
+			prescale = spiPort.getClosestPrescaler(600000).first;
 			break;
 		case 2 :
-			prescale = SPI_BAUDRATEPRESCALER_32;
+			prescale = spiPort.getClosestPrescaler(1300000).first;
 			break;
 		case 3 :
-			prescale = SPI_BAUDRATEPRESCALER_16;
+			prescale = spiPort.getClosestPrescaler(2600000).first;
 			break;
 		default :
-			prescale = SPI_BAUDRATEPRESCALER_16;
+			prescale = spiPort.getClosestPrescaler(2600000).first;
 			break;
 	}
 
diff --git a/Firmware/FFBoard/UserExtensions/Src/FFBHIDMain.cpp b/Firmware/FFBoard/UserExtensions/Src/FFBHIDMain.cpp
index 3fd91228c..4bfa04554 100644
--- a/Firmware/FFBoard/UserExtensions/Src/FFBHIDMain.cpp
+++ b/Firmware/FFBoard/UserExtensions/Src/FFBHIDMain.cpp
@@ -2,7 +2,7 @@
  * FFBWheel.cpp
  *
  *  Created on: 31.01.2020
- *      Author: Yannick / Lidders
+ *      Author: Yannick / Lidders / Vincent
  */
 
 #include <FFBHIDMain.h>
@@ -14,18 +14,32 @@
 #include "cmsis_os.h"
 extern osThreadId_t defaultTaskHandle;
 
+#ifdef TIM_FFB
+extern TIM_HandleTypeDef TIM_FFB;
+#endif
+
+#ifndef OVERRIDE_FFBRATES
+const FFBHIDMain::FFB_update_rates FFBHIDMain::ffbrates; // Default rates
+#endif
+
 //////////////////////////////////////////////
 
 
 /**
  * setFFBEffectsCalc must be called in constructor of derived class to finish the setup
  */
-FFBHIDMain::FFBHIDMain(uint8_t axisCount) :
-		Thread("FFBMAIN", 256, 30),
+FFBHIDMain::FFBHIDMain(uint8_t axisCount,bool hidAxis32b) :
+		Thread("FFBMAIN", 312, 30),
 		SelectableInputs(ButtonSource::all_buttonsources,AnalogSource::all_analogsources),
-		axisCount(axisCount)
+		axisCount(axisCount),hidAxis32b(hidAxis32b)
 {
-
+	if(hidAxis32b){
+		reportHID = std::make_unique<HID_GamepadReport<int32_t>>();
+	}else{
+		reportHID = std::make_unique<HID_GamepadReport<int16_t>>();
+	}
+//	reportHID((hidAxis32b ? HID_GamepadReport<int32_t>() : HID_GamepadReport<int16_t>())),
+//	lastReportHID((hidAxis32b ? HID_GamepadReport<int32_t>() : HID_GamepadReport<int16_t>())),
 	restoreFlashDelayed(); // Load parameters
 	registerCommands();
 
@@ -76,7 +90,7 @@ void FFBHIDMain::saveFlash(){
 	Flash_Write(ADR_FFBWHEEL_ANALOGCONF,this->ainsources);
 
 	uint8_t conf1 = 0;
-	conf1 |= usb_report_rate_idx & 0x3;
+	conf1 |= usb_report_rate_idx & 0x7;
 	Flash_Write(ADR_FFBWHEEL_CONF1,conf1);
 }
 
@@ -90,9 +104,19 @@ void FFBHIDMain::Run(){
 //		control.emergency = true; // Immediately enter emergency state but without notifying other classes yet
 		lastEstop = HAL_GetTick();
 	}
+#endif
+#ifdef TIM_FFB
+	HAL_TIM_Base_Start_IT(&TIM_FFB); // Start generating updates
 #endif
 	while(true){
-		Delay(1);
+#ifndef TIM_FFB
+		while(ffb_rate_counter++ <= ffb_rate_divider){
+			Delay(1);
+		}
+		ffb_rate_counter = 0;
+#else
+		WaitForNotification();
+#endif
 		updateControl();
 	}
 }
@@ -154,12 +178,11 @@ void FFBHIDMain::send_report(){
 //	if(!sourcesSem.Take(10)){
 //		return;
 //	}
-	// Read buttons
-	reportHID.buttons = 0; // Reset buttons
 
+	// Read buttons
 	uint64_t b = 0;
 	SelectableInputs::getButtonValues(b);
-	reportHID.buttons = b;
+	reportHID->setButtons(b);
 
 	// Encoder
 	//axes_manager->addAxesToReport(analogAxesReport, &count);
@@ -167,7 +190,13 @@ void FFBHIDMain::send_report(){
 	std::vector<int32_t>* axes = axes_manager->getAxisValues();
 	uint8_t count = 0;
 	for(auto val : *axes){
-		setHidReportAxis(&reportHID,count++,val);
+		if(!hidAxis32b){
+			val = val >> 16; // Scale to 16b
+		}else{
+			val = val >> (32-HIDAXISRES_32B_BITS); // Scale if less than 32b
+		}
+		//setHidReportAxis(&reportHID,count++,val);
+		reportHID->setHidReportAxis(count++, val);
 	}
 
 	// Fill remaining values with analog inputs
@@ -175,61 +204,99 @@ void FFBHIDMain::send_report(){
 	for(int32_t val : *axes){
 		if(count >= analogAxisCount)
 			break;
-		setHidReportAxis(&reportHID,count++,val);
+		if((count < MAX_AXIS) && hidAxis32b)
+			val = val << (HIDAXISRES_32B_BITS-16); // Shift up 16 bit to fill 32b value. Primary axis is 32b
+		reportHID->setHidReportAxis(count++, val);
 	}
+
 //	sourcesSem.Give();
 	// Fill rest
 	for(;count<analogAxisCount; count++){
-		setHidReportAxis(&reportHID,count,0);
+		//setHidReportAxis(&reportHID,count,0);
+		reportHID->setHidReportAxis(count, 0);
 	}
 
 
 	/*
 	 * Only send a new report if actually changed since last time or timeout and hid is ready
 	 */
-	if( (reportSendCounter > 100/usb_report_rate || (memcmp(&lastReportHID,&reportHID,sizeof(reportHID_t)) != 0) ))
+	if( (reportSendCounter > 100/usb_report_rate || reportHID->changed()) )
 	{
-
-
-	tud_hid_report(0, reinterpret_cast<uint8_t*>(&reportHID), sizeof(reportHID_t));
-	lastReportHID = reportHID;
-	reportSendCounter = 0;
-
+		tud_hid_report(0, reportHID->getBuffer(), reportHID->getLength());
+		reportHID->swap(); // Report has changed and was sent. Swap buffers.
+		reportSendCounter = 0;
 	}
 
 }
 
+/**
+ * Returns current FFB update loop frequency in Hz
+ */
+float FFBHIDMain::getCurFFBFreq(){
+	return ffbrates.basefreq/((uint32_t)ffbrates.dividers[usb_report_rate_idx].basediv);
+}
+
 /**
  * Changes the hid report rate based on the index for usb_report_rates
  */
 void FFBHIDMain::setReportRate(uint8_t rateidx){
-	rateidx = clip<uint8_t,uint8_t>(rateidx, 0,sizeof(usb_report_rates));
+	uint32_t usbrate_base = TUD_OPT_HIGH_SPEED ? 8000 : 1000;
+	if(tud_connected()){ // Get either actual rate or max supported rate if not connected
+		usbrate_base = tud_speed_get() == TUSB_SPEED_HIGH ? 8000 : 1000; // Only FS and HS supported
+	}
+
+	rateidx = clip<uint8_t,uint8_t>(rateidx, 0,ffbrates.dividers.size());
 	usb_report_rate_idx = rateidx;
-	usb_report_rate = usb_report_rates[rateidx]*HID_BINTERVAL;
+
+
+	// Either limit using rate counter or HW timer if present.
+#ifdef TIM_FFB
+	TIM_FFB.Instance->ARR = ((1000000*(uint32_t)ffbrates.dividers[rateidx].basediv)/ffbrates.basefreq); // Assumes 1µs timer steps
+#else
+	ffb_rate_divider = ffbrates.dividers[rateidx].basediv;
+#endif
+	usb_report_rate = ffbrates.dividers[rateidx].hiddiv*HID_BINTERVAL;
+	// Divide report rate down if above actual usb rate
+	while(((ffbrates.basefreq / (uint32_t)ffbrates.dividers[rateidx].basediv) / usb_report_rate)  > usbrate_base){
+		usb_report_rate++;
+	}
+
+	// Pass updated rate to other classes to update filters
+	float newRate = getCurFFBFreq();
+	if(ffb)
+		ffb->updateSamplerate(newRate);
+	if(axes_manager)
+		axes_manager->updateSamplerate(newRate);
 }
 
 /**
  * Generates the speed strings to display to the user
  */
 std::string FFBHIDMain::usb_report_rates_names() {
-		std::string s = "";
-		for(uint8_t i = 0 ; i < sizeof(usb_report_rates);i++){
-			s += std::to_string(1000/(HID_BINTERVAL*usb_report_rates[i])) + "Hz:"+std::to_string(i);
-			if(i < sizeof(usb_report_rates)-1)
-				s += ",";
+	std::string s = "";
+	uint32_t usbrate_base = TUD_OPT_HIGH_SPEED ? 8000 : 1000;
+	if(tud_connected()){ // Get either actual rate or max supported rate if not connected
+		usbrate_base = tud_speed_get() == TUSB_SPEED_HIGH ? 8000 : 1000; // Only FS and HS supported
+	}
+	for(uint8_t i = 0 ; i < ffbrates.dividers.size();i++){
+		uint32_t updatefreq = ffbrates.basefreq/((uint32_t)ffbrates.dividers[i].basediv);
+		uint32_t hidrate = (HID_BINTERVAL*ffbrates.dividers[i].hiddiv);
+		while((updatefreq/hidrate)  > usbrate_base){ // Fall back if usb rate is still higher than supported
+			hidrate++;
 		}
-		return s;
+		uint32_t hidfreq = updatefreq/hidrate;
+		s += "FFB "+std::to_string(updatefreq) + "Hz\nUSB " + std::to_string(hidfreq) + "Hz:"+std::to_string(i);
+		if(i < ffbrates.dividers.size()-1)
+			s += ",";
 	}
+	return s;
+}
 
 void FFBHIDMain::emergencyStop(bool reset){
 	control.emergency = !reset;
 	axes_manager->emergencyStop(reset);
 }
 
-//void FFBHIDMain::timerElapsed(TIM_HandleTypeDef* htim){
-//
-//}
-
 
 /**
  * USB unplugged
@@ -253,6 +320,7 @@ void FFBHIDMain::usbResume(){
 		control.emergency = false;
 	}
 #endif
+	setReportRate(this->usb_report_rate_idx);
 	control.usb_disabled = false;
 	axes_manager->usbResume();
 }
@@ -301,3 +369,11 @@ void FFBHIDMain::errorCallback(const Error &error, bool cleared){
 	}
 }
 
+#ifdef TIM_FFB
+void FFBHIDMain::timerElapsed(TIM_HandleTypeDef* htim){
+	if(htim == &TIM_FFB){
+		NotifyFromISR();
+	}
+}
+#endif
+
diff --git a/Firmware/FFBoard/UserExtensions/Src/FFBWheel.cpp b/Firmware/FFBoard/UserExtensions/Src/FFBWheel.cpp
index b77f5c37d..1e94dd4cc 100644
--- a/Firmware/FFBoard/UserExtensions/Src/FFBWheel.cpp
+++ b/Firmware/FFBoard/UserExtensions/Src/FFBWheel.cpp
@@ -24,7 +24,7 @@ const ClassIdentifier FFBWheel::getInfo(){
 
 
 FFBWheel::FFBWheel() :
-		FFBHIDMain(1)
+		FFBHIDMain(1,FFBWHEEL_32B_MODE)
 {
 	FFBHIDMain::setFFBEffectsCalc(ffb, effects_calc);
 }
@@ -34,17 +34,29 @@ FFBWheel::~FFBWheel() {
 }
 
 
-
 void FFBWheel::usbInit(){
+#ifdef HIDAXISRES_USE_32B_DESC
 #ifdef FFBWHEEL_USE_1AXIS_DESC
-	this->usbdev = std::make_unique<USBdevice>(&usb_devdesc_ffboard_composite,usb_cdc_hid_conf_1axis,&usb_ffboard_strings_default);
-	FFBHIDMain::UsbHidHandler::setHidDesc(hid_1ffb_desc);
-	static_cast<HidFFB*>(ffb.get())->setDirectionEnableMask(0x02);
+const uint8_t* usbconf = usb_cdc_hid_conf_1axis_32b;
+const uint8_t* ffbdesc = hid_1ffb_desc_32b;
 #else
-	this->usbdev = std::make_unique<USBdevice>(&usb_devdesc_ffboard_composite,usb_cdc_hid_conf_2axis,&usb_ffboard_strings_default);
-	FFBHIDMain::UsbHidHandler::setHidDesc(hid_2ffb_desc);
-	static_cast<HidFFB*>(ffb.get())->setDirectionEnableMask(0x04);
+const uint8_t* ffbdesc = hid_2ffb_desc_32b;
+const uint8_t* usbconf = usb_cdc_hid_conf_2axis_32b;
+#endif
+#else // ELSE 32B
+#ifdef FFBWHEEL_USE_1AXIS_DESC
+const uint8_t* usbconf = usb_cdc_hid_conf_1axis;
+const uint8_t* ffbdesc = hid_1ffb_desc;
+#else
+const uint8_t* ffbdesc = hid_2ffb_desc;
+const uint8_t* usbconf = usb_cdc_hid_conf_2axis;
 #endif
+#endif
+
+	this->usbdev = std::make_unique<USBdevice>(&usb_devdesc_ffboard_composite,usbconf,&usb_ffboard_strings_default);
+
+	FFBHIDMain::UsbHidHandler::setHidDesc(ffbdesc);
+	static_cast<HidFFB*>(ffb.get())->setDirectionEnableMask(0x04);
 
 	usbdev->registerUsb();
 }
diff --git a/Firmware/FFBoard/UserExtensions/Src/FFBoardMain.cpp b/Firmware/FFBoard/UserExtensions/Src/FFBoardMain.cpp
index da0b8da10..a3c9b559f 100644
--- a/Firmware/FFBoard/UserExtensions/Src/FFBoardMain.cpp
+++ b/Firmware/FFBoard/UserExtensions/Src/FFBoardMain.cpp
@@ -2,7 +2,7 @@
  * FFBoardMain.cpp
  *
  *  Created on: 23.01.2020
- *      Author: Yannick
+ *      Author: Yannick, Vincent
  */
 
 #include "FFBoardMain.h"
@@ -14,7 +14,7 @@
 
 ClassIdentifier FFBoardMain::info ={.name = "Basic (Failsafe)" ,.id=0};
 
-char FFBoardMain::cdcbuf[64];
+char FFBoardMain::cdcbuf[(TUD_OPT_HIGH_SPEED ? 512 : 64)];
 
 
 
diff --git a/Firmware/FFBoard/UserExtensions/Src/TMC4671.cpp b/Firmware/FFBoard/UserExtensions/Src/TMC4671.cpp
index 3b331632a..22ccd465c 100644
--- a/Firmware/FFBoard/UserExtensions/Src/TMC4671.cpp
+++ b/Firmware/FFBoard/UserExtensions/Src/TMC4671.cpp
@@ -2,14 +2,13 @@
  * TMC4671.cpp
  *
  *  Created on: Feb 1, 2020
- *      Author: Yannick
+ *      Author: Yannick, Vincent
  */
 
 #include "TMC4671.h"
 #ifdef TMC4671DRIVER
 #include "ledEffects.h"
 #include "voltagesense.h"
-//#include "stm32f4xx_hal_spi.h"
 #include <math.h>
 #include <assert.h>
 #include "ErrorHandler.h"
@@ -46,9 +45,11 @@ ClassIdentifier TMC4671::info = {
 };
 
 
+
 TMC4671::TMC4671(SPIPort& spiport,OutputPin cspin,uint8_t address) :
 		CommandHandler("tmc", CLSID_MOT_TMC0,address-1), SPIDevice{motor_spi,cspin},Thread("TMC", TMC_THREAD_MEM, TMC_THREAD_PRIO)
 {
+	this->drv_address = address;
 	CommandHandler::setCommandsEnabled(false);
 	setAddress(address);
 	registerCommands();
@@ -59,7 +60,7 @@ TMC4671::TMC4671(SPIPort& spiport,OutputPin cspin,uint8_t address) :
 	spiConfig.peripheral.CLKPolarity = SPI_POLARITY_HIGH;
 	spiConfig.peripheral.CLKPhase = SPI_PHASE_2EDGE;
 	spiConfig.peripheral.NSS = SPI_NSS_SOFT;
-	spiConfig.peripheral.BaudRatePrescaler = spiPort.getClosestPrescaler(10e6).first; // 10MHz
+	spiConfig.peripheral.BaudRatePrescaler = spiPort.getClosestPrescaler(8e6,0,10e6).first; // 8 target, 10MHz max
 	spiConfig.peripheral.FirstBit = SPI_FIRSTBIT_MSB;
 	spiConfig.peripheral.TIMode = SPI_TIMODE_DISABLE;
 	spiConfig.peripheral.CRCCalculation = SPI_CRCCALCULATION_DISABLE;
@@ -180,6 +181,9 @@ void TMC4671::restoreFlash(){
 	if(Flash_Read(flashAddrs.encA, &miscval)){
 		restoreEncHallMisc(miscval);
 		encHallRestored = true;
+	}else{
+		// set first hwconf if we can't restore
+		this->setHwType(TMC4671::tmc4671_hw_configs[0].hwVersion);
 	}
 	uint16_t filterval;
 	if(Flash_Read(flashAddrs.torqueFilter, &filterval)){
@@ -236,6 +240,18 @@ int32_t TMC4671::getTmcVM(){
 	return ((float)agpiA_VM * conf.hwconf.vmScaler) * 1000;
 }
 
+void TMC4671::setupDriver() {
+	// Configuration specific to TMC4671 upon starting the motor
+	// The power limit is set by the Axis class via setPowerLimit during initialization.
+
+	this->setExternalEncoderAllowed(true);
+	this->restoreFlash();
+	this->setLimits(curLimits);
+
+	// Start driver
+	this->setMotionMode(MotionMode::torque);
+	this->Start(); // Start thread
+}
 
 /**
  * Sets all parameters of the driver at startup. Only has to be called once when the driver is detected
@@ -261,7 +277,7 @@ bool TMC4671::initialize(){
 		 */
 		pulseClipLed();
 
-		this->spiConfig.peripheral.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_64;
+		this->spiConfig.peripheral.BaudRatePrescaler = spiPort.getClosestPrescaler(1e6).first; // 1MHz target
 		spiPort.configurePort(&this->spiConfig.peripheral);
 		ES_TMCdetected = true;
 	}
@@ -347,7 +363,7 @@ bool TMC4671::initialize(){
  * Not calibrated perfectly!
  */
 float TMC4671::getTemp(){
-	if(!this->conf.hwconf.temperatureEnabled){
+	if(!this->conf.hwconf.thermistorSettings.temperatureEnabled){
 		return 0;
 	}
 	TMC4671HardwareTypeConf* hwconf = &conf.hwconf;
@@ -358,10 +374,10 @@ float TMC4671::getTemp(){
 	if(adcval <= 0){
 		return 0.0;
 	}
-	float r = hwconf->thermistor_R2 * (((float)43252 / (float)adcval)); //43252 equivalent ADC count if it was 3.3V and not 2.5V
+	float r = hwconf->thermistorSettings.thermistor_R2 * (((float)43252 / (float)adcval)); //43252 equivalent ADC count if it was 3.3V and not 2.5V
 
 	// Beta
-	r = (1.0 / 298.15) + log(r / hwconf->thermistor_R) / hwconf->thermistor_Beta;
+	r = (1.0 / 298.15) + log(r / hwconf->thermistorSettings.thermistor_R) / hwconf->thermistorSettings.thermistor_Beta;
 	r = 1.0 / r;
 	r -= 273.15;
 	return r;
@@ -549,9 +565,9 @@ void TMC4671::Run(){
 				}
 
 				// Temperature sense
-				if(conf.hwconf.temperatureEnabled){
+				if(conf.hwconf.thermistorSettings.temperatureEnabled){
 					float temp = getTemp();
-					if(temp > conf.hwconf.temp_limit){
+					if(temp > conf.hwconf.thermistorSettings.temp_limit){
 						changeState(TMC_ControlState::OverTemp);
 						pulseErrLed();
 					}
@@ -577,12 +593,12 @@ void TMC4671::Run(){
 			break;
 
 		case TMC_ControlState::EncoderInit:
-			if(powerInitialized && hasPower())
+			if(powerInitialized && hasPower() && conf.motconf.motor_type != MotorType::NONE)
 				encoderInit();
 		break;
 
 		case TMC_ControlState::ExternalEncoderInit:
-			if(powerInitialized && hasPower() && drvEncoder != nullptr)
+			if(powerInitialized && hasPower() && drvEncoder != nullptr && conf.motconf.motor_type != MotorType::NONE)
 				encoderInit();
 			break;
 
@@ -651,7 +667,9 @@ void TMC4671::calibrateEncoder(){
 		// Report changes
 		CommandHandler::broadcastCommandReply(CommandReply(abnconf.npol ? 1 : 0), (uint32_t)TMC4671_commands::encpol, CMDtype::get);
 	}else if(conf.motconf.enctype == EncoderType_TMC::sincos || conf.motconf.enctype == EncoderType_TMC::uvw){
-		calibrateAenc();
+		if(!conf.hwconf.flags.analog_enc_skip_cal){
+			calibrateAenc();
+		}
 	}else if(conf.motconf.enctype == EncoderType_TMC::ext){
 		estimateExtEnc();
 	}
@@ -724,7 +742,7 @@ bool TMC4671::pidAutoTune(){
 			flux = getActualFlux();
 		}
 
-		if(peakflux > (targetflux + ( targetflux * 0.03))) // Overshoot target by 3%
+		if(peakflux > (targetflux + ( targetflux * TMC4671_ITUNE_CUTOFF))) // Overshoot target by 4% default
 		{
 			fluxI -= step_i; // Revert last step
 			break;
@@ -1165,8 +1183,8 @@ int16_t TMC4671::getPhiE_Enc(){
  * Steps the motor a few times to check if the encoder follows correctly
  */
 bool TMC4671::checkEncoder(){
-	if(this->conf.motconf.motor_type != MotorType::STEPPER && this->conf.motconf.motor_type != MotorType::BLDC &&
-			conf.motconf.enctype != EncoderType_TMC::uvw && conf.motconf.enctype != EncoderType_TMC::sincos && conf.motconf.enctype != EncoderType_TMC::abn && conf.motconf.enctype != EncoderType_TMC::ext)
+	if((this->conf.motconf.motor_type != MotorType::STEPPER && this->conf.motconf.motor_type != MotorType::BLDC) || (
+			conf.motconf.enctype != EncoderType_TMC::uvw && conf.motconf.enctype != EncoderType_TMC::sincos && conf.motconf.enctype != EncoderType_TMC::abn && conf.motconf.enctype != EncoderType_TMC::ext))
 	{ // If not stepper or bldc return
 		return true;
 	}
@@ -1362,8 +1380,8 @@ bool TMC4671::calibrateAdcOffset(uint16_t time){
 	uint32_t measurements_idle = 0;
 	uint64_t totalA=0;
 	uint64_t totalB=0;
-	bool allowTemp = conf.hwconf.temperatureEnabled;
-	conf.hwconf.temperatureEnabled = false; // Temp check interrupts adc
+	bool allowTemp = conf.hwconf.thermistorSettings.temperatureEnabled;
+	conf.hwconf.thermistorSettings.temperatureEnabled = false; // Temp check interrupts adc
 	writeReg(0x03, 0); // Read raw adc
 	PhiE lastphie = getPhiEtype();
 	MotionMode lastmode = getMotionMode();
@@ -1402,7 +1420,7 @@ bool TMC4671::calibrateAdcOffset(uint16_t time){
 //		setPwm(TMC_PwmMode::off); //Disable pwm
 //		this->changeState(TMC_ControlState::HardError);
 		adcCalibrated = false;
-		conf.hwconf.temperatureEnabled = allowTemp;
+		conf.hwconf.thermistorSettings.temperatureEnabled = allowTemp;
 		return false; // An adc or shunt amp is likely broken. do not proceed.
 	}
 	conf.adc_I0_offset = offsetAidle;
@@ -1413,7 +1431,7 @@ bool TMC4671::calibrateAdcOffset(uint16_t time){
 	setPhiEtype(lastphie);
 	setMotionMode(lastmode,true);
 	adcCalibrated = true;
-	conf.hwconf.temperatureEnabled = allowTemp;
+	conf.hwconf.thermistorSettings.temperatureEnabled = allowTemp;
 	return true;
 }
 
@@ -1447,7 +1465,9 @@ void TMC4671::encoderInit(){
 		setPosSel(PosSelection::PhiM_aenc); // Mechanical Angle
 		setVelSel(VelSelection::PhiM_aenc); // Mechanical Angle (RPM)
 		//setup_AENC(aencconf);
-		calibrateAenc();
+		if(!conf.hwconf.flags.analog_enc_skip_cal){
+			calibrateAenc();
+		}
 	}
 
 	// find index
@@ -1512,9 +1532,10 @@ void TMC4671::encoderInit(){
  */
 void TMC4671::setEncoderType(EncoderType_TMC type){
 	// If no external timer is set external encoder is not valid
-	if((!externalEncoderTimer || !externalEncoderAllowed()) && type == EncoderType_TMC::ext){
+	if( !conf.hwconf.isEncSupported(type) || ((!externalEncoderTimer || !externalEncoderAllowed()) && type == EncoderType_TMC::ext)){
 		type = EncoderType_TMC::NONE;
 	}
+
 	this->conf.motconf.enctype = type;
 	this->statusMask.flags.AENC_N = 0;
 	this->statusMask.flags.ENC_N = 0;
@@ -1848,7 +1869,9 @@ Encoder* TMC4671::getEncoder(){
 void TMC4671::setEncoder(std::shared_ptr<Encoder>& encoder){
 	MotorDriver::drvEncoder = encoder;
 	if(conf.motconf.enctype == EncoderType_TMC::ext && externalEncoderTimer){
-		// TODO Calibrate and align external encoder
+		if(!extEncUpdater){ // If updater has not been set up because the encoder mode was changed before the external encoder passed force it now
+			setUpExtEncTimer();
+		}
 		changeState(TMC_ControlState::ExternalEncoderInit);
 	}
 }
@@ -2007,14 +2030,19 @@ bool TMC4671::externalEncoderAllowed(){
 #ifndef TIM_TMC
 	return false;
 #else
-	return allowExternalEncoder;
+	return allowExternalEncoder && conf.hwconf.flags.enc_ext;
 #endif
 }
 
 void TMC4671::setMotorType(MotorType motor,uint16_t poles){
+
+	if(!conf.hwconf.isMotSupported(motor)){
+		motor = MotorType::NONE;
+	}
 	if(motor == MotorType::DC){
 		poles = 1;
 	}
+
 	conf.motconf.motor_type = motor;
 	conf.motconf.pole_pairs = poles;
 	uint32_t mtype = poles | ( ((uint8_t)motor&0xff) << 16);
@@ -2031,8 +2059,11 @@ void TMC4671::setTorque(int16_t torque){
 	if(curMotionMode != MotionMode::torque){
 		setMotionMode(MotionMode::torque,true);
 	}
-	updateReg(0x64,torque,0xffff,16);
+
+	// Update main torque setpoint
+	updateReg(0x64, torque, 0xffff, 16);
 }
+
 int16_t TMC4671::getTorque(){
 	return readReg(0x64) >> 16;
 }
@@ -2050,7 +2081,17 @@ void TMC4671::setFluxTorque(int16_t flux, int16_t torque){
 	if(curMotionMode != MotionMode::torque && !emergency){
 		setMotionMode(MotionMode::torque,true);
 	}
+#ifdef TMC4671_TORQUE_USE_ASYNC
+	writeRegAsync(0x64, (flux & 0xffff) | (torque << 16));
+#else
+	// Update main flux and torque setpoints
 	writeReg(0x64, (flux & 0xffff) | (torque << 16));
+#endif
+}
+
+int16_t TMC4671::getVelocityControllerTorque(){
+    writeReg(0x6F, 4); // INTERIM_ADDR = 4 for PIDOUT_TARGET_TORQUE
+    return (int16_t)readReg(0x6E); // Read from INTERIM_DATA
 }
 
 void TMC4671::setFluxTorqueFF(int16_t flux, int16_t torque){
@@ -2104,6 +2145,11 @@ void TMC4671::setUqUdLimit(uint16_t limit){
 	writeReg(0x5D, limit);
 }
 
+void TMC4671::setPowerLimit(uint16_t power) {
+	maxPowerAxis = power;
+	setTorqueLimit(power);
+}
+
 void TMC4671::setTorqueLimit(uint16_t limit){
 	this->curLimits.pid_torque_flux = limit;
 	bangInitPower = (float)limit*0.75;
@@ -2262,7 +2308,7 @@ void TMC4671::setTorqueFilter(TMC4671Biquad_conf& conf){
 /**
  *  Sets the raw brake resistor limits.
  *  Centered at 0x7fff
- *  Set both 0 to deactivate
+ *  Set both 0xffff to deactivate
  */
 void TMC4671::setBrakeLimits(uint16_t low,uint16_t high){
 	uint32_t val = low | (high << 16);
@@ -2682,161 +2728,47 @@ void TMC4671::restoreEncHallMisc(uint16_t val){
 	this->hallconf.interpolation = (val>>9) & 0x01;
 	this->curPids.sequentialPI = (val>>10) & 0x01;
 
-	setHwType((TMC_HW_Ver)((val >> 11) & 0x1F));
+	setHwType((uint8_t)((val >> 11) & 0x1F));
 
 }
 
+
+
 /**
  * Sets some constants and features depending on the hardware version of the driver
  */
-void TMC4671::setHwType(TMC_HW_Ver type){
-	//TMC4671HardwareTypeConf newHwConf;
-	switch(type){
-	case TMC_HW_Ver::v1_3_66mv:
-		{
-		TMC4671HardwareTypeConf newHwConf = {
-			.hwVersion = TMC_HW_Ver::v1_3_66mv,
-			.adcOffset = 0,
-			.thermistor_R2 = 1500,
-			.thermistor_R = 10000,
-			.thermistor_Beta = 4300,
-			.temperatureEnabled = true,
-			.temp_limit = 90,
-			.currentScaler = 2.5 / (0x7fff * 0.066), // sensor 66mV/A
-			.brakeLimLow = 50700,
-			.brakeLimHigh = 50900,
-			.vmScaler = (2.5 / 0x7fff) * ((1.5+71.5)/1.5),
-			.vSenseMult = VOLTAGE_MULT_DEFAULT,
-			.bbm = 50 // DMTH8003SPS need longer deadtime
-		};
-		this->conf.hwconf = newHwConf;
-	break;
-	}
-	case TMC_HW_Ver::v1_2_2_100mv:
-	{
-		TMC4671HardwareTypeConf newHwConf = {
-			.hwVersion = TMC_HW_Ver::v1_2_2_100mv,
-			.adcOffset = 0,
-			.thermistor_R2 = 1500,
-			.thermistor_R = 10000,
-			.thermistor_Beta = 4300,
-			.temperatureEnabled = true,
-			.temp_limit = 90,
-			.currentScaler = 2.5 / (0x7fff * 0.1), // w. TMCS1100A2 sensor 100mV/A
-			.brakeLimLow = 50700,
-			.brakeLimHigh = 50900,
-			.vmScaler = (2.5 / 0x7fff) * ((1.5+71.5)/1.5),
-			.vSenseMult = VOLTAGE_MULT_DEFAULT,
-			.bbm = 40
-		};
-		this->conf.hwconf = newHwConf;
-	break;
-	}
-	case TMC_HW_Ver::v1_2_2_LEM20:
-	{
-		// TODO possibly lower PWM limit because of lower valid sensor range
-		TMC4671HardwareTypeConf newHwConf = {
-			.hwVersion = TMC_HW_Ver::v1_2_2,
-			.adcOffset = 0,
-			.thermistor_R2 = 1500,
-			.thermistor_R = 10000,
-			.thermistor_Beta = 4300,
-			.temperatureEnabled = true,
-			.temp_limit = 90,
-			.currentScaler = 2.5 / (0x7fff * 0.04), // w. LEM 20 sensor 40mV/A
-			.brakeLimLow = 50700,
-			.brakeLimHigh = 50900,
-			.vmScaler = (2.5 / 0x7fff) * ((1.5+71.5)/1.5),
-			.vSenseMult = VOLTAGE_MULT_DEFAULT,
-			.bbm = 20
-		};
-		this->conf.hwconf = newHwConf;
-	break;
-	}
-	case TMC_HW_Ver::v1_2_2:
-	{
-		// TODO possibly lower PWM limit because of lower valid sensor range
-		TMC4671HardwareTypeConf newHwConf = {
-			.hwVersion = TMC_HW_Ver::v1_2_2,
-			.adcOffset = 0,
-			.thermistor_R2 = 1500,
-			.thermistor_R = 10000,
-			.thermistor_Beta = 4300,
-			.temperatureEnabled = true,
-			.temp_limit = 90,
-			.currentScaler = 2.5 / (0x7fff * 0.08), // w. LEM 10 sensor 80mV/A
-			.brakeLimLow = 50700,
-			.brakeLimHigh = 50900,
-			.vmScaler = (2.5 / 0x7fff) * ((1.5+71.5)/1.5),
-			.vSenseMult = VOLTAGE_MULT_DEFAULT,
-			.bbm = 20
-		};
-		this->conf.hwconf = newHwConf;
-	break;
-	}
-
-	case TMC_HW_Ver::v1_2:
-	{
-		TMC4671HardwareTypeConf newHwConf = {
-			.hwVersion = TMC_HW_Ver::v1_2,
-			.adcOffset = 1000,
-			.thermistor_R2 = 1500,
-			.thermistor_R = 22000,
-			.thermistor_Beta = 4300,
-			.temperatureEnabled = true,
-			.temp_limit = 90,
-			.currentScaler = 2.5 / (0x7fff * 60.0 * 0.0015), // w. 60x 1.5mOhm sensor
-			.brakeLimLow = 50700,
-			.brakeLimHigh = 50900,
-			.vmScaler = (2.5 / 0x7fff) * ((1.5+71.5)/1.5),
-			.vSenseMult = VOLTAGE_MULT_DEFAULT,
-			.bbm = 20
-		};
-		this->conf.hwconf = newHwConf;
-		// Activates around 60V as last resort failsave. Check offsets from tmc leakage. ~ 1.426V
-	break;
-	}
-
-
-	case TMC_HW_Ver::v1_0:
-	{
-		TMC4671HardwareTypeConf newHwConf = {
-			.hwVersion = TMC_HW_Ver::v1_0,
-			.adcOffset = 1000,
-			.thermistor_R2 = 0,
-			.thermistor_R = 0,
-			.thermistor_Beta = 0,
-			.temperatureEnabled = false,
-			.temp_limit = 90,
-			.currentScaler = 2.5 / (0x7fff * 60.0 * 0.0015), // w. 60x 1.5mOhm sensor
-			.brakeLimLow = 52400,
-			.brakeLimHigh = 52800,
-			.vmScaler = (2.5 / 0x7fff) * ((1.5+71.5)/1.5),
-			.vSenseMult = VOLTAGE_MULT_DEFAULT,
-			.bbm = 20
-		};
-		this->conf.hwconf = newHwConf;
-
-	break;
+void TMC4671::setHwType(uint8_t type){
+	// If only one config is valid use this regardless of requested type
+	if(TMC4671::tmc4671_hw_configs.size() == 1){
+		this->conf.hwconf = TMC4671::tmc4671_hw_configs[0];
+	}else{ // Search for config matching requested type
+		for(const TMC4671HardwareTypeConf& newConf : TMC4671::tmc4671_hw_configs){
+			if(type == newConf.hwVersion){
+				this->conf.hwconf = newConf;
+				break;
+			}
+		}
 	}
 
-	case TMC_HW_Ver::NONE:
-	{
-	default:
-		TMC4671HardwareTypeConf newHwConf;
-		newHwConf.temperatureEnabled = false;
-		newHwConf.hwVersion = TMC_HW_Ver::NONE;
-		newHwConf.currentScaler = 0;
-		this->conf.hwconf = newHwConf;
-		setBrakeLimits(0,0); // Disables internal brake resistor activation. DANGER!
-		break;
-	}
-	}
 	setVSenseMult(this->conf.hwconf.vSenseMult); // Update vsense multiplier
 	//setupBrakePin(vdiffAct, vdiffDeact, vMax); // TODO if required
 	setBrakeLimits(this->conf.hwconf.brakeLimLow,this->conf.hwconf.brakeLimHigh);
 	setBBM(this->conf.hwconf.bbm,this->conf.hwconf.bbm);
+	// Force changing motor and encoder types to prevent invalid types being selected if new hw type does not support them
+	setMotorType(this->conf.motconf.motor_type, this->conf.motconf.pole_pairs);
+	setEncoderType(this->conf.motconf.enctype);
+}
 
+/**
+ * Appends a formatted reply with currently available hardware version configs
+ */
+void TMC4671::replyHardwareVersions(const std::span<const TMC4671HardwareTypeConf>& versions,std::vector<CommandReply>& replies){
+//	uint8_t idx = 0;
+	for(const TMC4671HardwareTypeConf& c : versions){
+		if(this->canChangeHwType || c.hwVersion == this->conf.hwconf.hwVersion){
+			replies.emplace_back( std::to_string((uint8_t)c.hwVersion) + ":" + c.name,(uint8_t)c.hwVersion);
+		}
+	}
 }
 
 void TMC4671::registerCommands(){
@@ -2923,10 +2855,16 @@ CommandStatus TMC4671::command(const ParsedCommand& cmd,std::vector<CommandReply
 	case TMC4671_commands::mtype:
 		if(cmd.type == CMDtype::get){
 			replies.emplace_back((uint8_t)this->conf.motconf.motor_type);
-		}else if(cmd.type == CMDtype::set && (uint8_t)cmd.type < (uint8_t)MotorType::ERR){
+		}else if(cmd.type == CMDtype::set && (uint8_t)cmd.type <= (uint8_t)MotorType::BLDC){
 			this->setMotorType((MotorType)cmd.val, this->conf.motconf.pole_pairs);
 		}else{
-			replies.emplace_back("NONE=0,DC=1,2Ph Stepper=2,3Ph BLDC=3");
+			std::string rplstr = "";
+			TMC4671HardwareTypeConf::SupportedModes_s* confflags = &conf.hwconf.flags;
+			if(confflags->mot_none) rplstr += "NONE=0,";
+			if(confflags->mot_dc) rplstr += "DC=1,";
+			if(confflags->mot_stepper) rplstr += "Stepper 2Ph=2,";
+			if(confflags->mot_bldc) rplstr += "BLDC 3Ph=3";
+			replies.emplace_back(rplstr);
 		}
 		break;
 
@@ -2936,11 +2874,15 @@ CommandStatus TMC4671::command(const ParsedCommand& cmd,std::vector<CommandReply
 		}else if(cmd.type == CMDtype::set){
 			this->setEncoderType((EncoderType_TMC)cmd.val);
 		}else{
-			if(externalEncoderAllowed())
-				replies.emplace_back("NONE=0,ABN=1,SinCos=2,Analog UVW=3,Hall=4,External=5");
-			else
-				replies.emplace_back("NONE=0,ABN=1,SinCos=2,Analog UVW=3,Hall=4");
-
+			std::string rplstr = "";
+			TMC4671HardwareTypeConf::SupportedModes_s* confflags = &conf.hwconf.flags;
+			if(confflags->enc_none) rplstr += "NONE=0,";
+			if(confflags->enc_abn) rplstr += "ABN=1,";
+			if(confflags->enc_sincos) rplstr += "SinCos=2,";
+			if(confflags->enc_uvw) rplstr += "UVW=3,";
+			if(confflags->enc_hall) rplstr += "HALL=4,";
+			if(confflags->enc_ext && externalEncoderAllowed()) rplstr += "External=5";
+			replies.emplace_back(rplstr);
 		}
 		break;
 
@@ -2948,16 +2890,11 @@ CommandStatus TMC4671::command(const ParsedCommand& cmd,std::vector<CommandReply
 		if(cmd.type == CMDtype::get){
 			replies.push_back((uint8_t)conf.hwconf.hwVersion);
 		}else if(cmd.type == CMDtype::set){
-			if(conf.canChangeHwType)
-				setHwType((TMC_HW_Ver)(cmd.val & 0x1F));
+			if(canChangeHwType)
+				setHwType((uint8_t)(cmd.val & 0x1F));
 		}else{
 			// List known hardware versions
-			for(auto v : tmcHwVersionNames){
-				if(conf.canChangeHwType || v.first == conf.hwconf.hwVersion){
-					replies.emplace_back( std::to_string((uint8_t)v.first) + ":" + v.second,(uint8_t)v.first);
-				}
-
-			}
+			replyHardwareVersions(tmc4671_hw_configs, replies);
 		}
 		break;
 
@@ -3195,7 +3132,6 @@ CommandStatus TMC4671::command(const ParsedCommand& cmd,std::vector<CommandReply
 	default:
 		return CommandStatus::NOT_FOUND;
 	}
-
 	return status;
 
 
@@ -3221,8 +3157,8 @@ void TMC4671::setUpExtEncTimer(){
 		extEncUpdater = std::make_unique<TMC_ExternalEncoderUpdateThread>(this);
 	// Setup timer
 	this->externalEncoderTimer = &TIM_TMC;
-	this->externalEncoderTimer->Instance->ARR = 200; // 200 = 5khz = 5 tmc cycles, 250 = 4khz, 240 = 6 tmc cycles
-	this->externalEncoderTimer->Instance->PSC = (SystemCoreClock / 2000000)+1; // timer running at half clock speed. 1µs ticks
+	this->externalEncoderTimer->Instance->ARR = TIM_TMC_ARR; // 200 = 5khz = 5 tmc cycles, 250 = 4khz, 240 = 6 tmc cycles
+	this->externalEncoderTimer->Instance->PSC = ((TIM_TMC_BCLK)/1000000) +1; // 1µs ticks
 	this->externalEncoderTimer->Instance->CR1 = 1;
 	HAL_TIM_Base_Start_IT(this->externalEncoderTimer);
 #endif
diff --git a/Firmware/FFBoard/UserExtensions/Src/TMC4671_configs.cpp b/Firmware/FFBoard/UserExtensions/Src/TMC4671_configs.cpp
new file mode 100644
index 000000000..1d5cb0d0d
--- /dev/null
+++ b/Firmware/FFBoard/UserExtensions/Src/TMC4671_configs.cpp
@@ -0,0 +1,117 @@
+/*
+ * TMC4671_configs.cpp
+ *
+ *  Created on: Feb 20, 2024
+ *      Author: Yannick
+ */
+
+#include "TMC4671.h"
+#include "constants.h"
+#include "span"
+
+#if !defined(TMC4671_OVERRIDE_HWCONFS) && defined(TMC4671DRIVER)
+// Default configs for officially supported hardware
+
+
+const TMC4671HardwareTypeConf conf1_0 = {
+		.name = "v1.0 AD8417 (1.5mOhm)",
+		.hwVersion = (uint8_t)TMC_HW_Ver::v1_0,
+		.adcOffset = 1000,
+		.thermistorSettings = {
+			.thermistor_R2 = 0,
+			.thermistor_R = 0,
+			.thermistor_Beta = 0,
+			.temp_limit = 90,
+			.temperatureEnabled = false,
+		},
+		.currentScaler = 2.5 / (0x7fff * 60.0 * 0.0015), // w. 60x 1.5mOhm sensor
+		.brakeLimLow = 52400,
+		.brakeLimHigh = 52800,
+		.vmScaler = (2.5 / 0x7fff) * ((1.5+71.5)/1.5),
+		.vSenseMult = VOLTAGE_MULT_DEFAULT,
+		.clockfreq = 25e6,
+		.bbm = 20,
+};
+const TMC4671HardwareTypeConf conf1_2 = {
+		.name = "v1.2 AD8417 (1.5mOhm)",
+		.hwVersion = (uint8_t)TMC_HW_Ver::v1_2,
+		.adcOffset = 1000,
+		.thermistorSettings = {
+			.thermistor_R2 = 1500,
+			.thermistor_R = 22000,
+			.thermistor_Beta = 4300,
+			.temp_limit = 90,
+			.temperatureEnabled = true,
+		},
+		.currentScaler = 2.5 / (0x7fff * 60.0 * 0.0015), // w. 60x 1.5mOhm sensor
+		.brakeLimLow = 50700,
+		.brakeLimHigh = 50900,
+		.vmScaler = (2.5 / 0x7fff) * ((1.5+71.5)/1.5),
+		.vSenseMult = VOLTAGE_MULT_DEFAULT,
+		.clockfreq = 25e6,
+		.bbm = 20,
+};
+const TMC4671HardwareTypeConf conf1_2_2 = {
+		.name = "v1.2.2 LEM 10 (80mV/A)",
+		.hwVersion = (uint8_t)TMC_HW_Ver::v1_2_2,
+		.adcOffset = 0,
+		.thermistorSettings = {
+			.thermistor_R2 = 1500,
+			.thermistor_R = 10000,
+			.thermistor_Beta = 4300,
+			.temp_limit = 90,
+			.temperatureEnabled = true,
+		},
+		.currentScaler = 2.5 / (0x7fff * 0.08), // w. LEM 10 sensor 80mV/A
+		.brakeLimLow = 50700,
+		.brakeLimHigh = 50900,
+		.vmScaler = (2.5 / 0x7fff) * ((1.5+71.5)/1.5),
+		.vSenseMult = VOLTAGE_MULT_DEFAULT,
+		.clockfreq = 25e6,
+		.bbm = 20,
+};
+const TMC4671HardwareTypeConf conf1_3 = {
+		.name = "v1.3 ACS724 (66mV/A)",
+		.hwVersion = (uint8_t)TMC_HW_Ver::v1_3_66mv,
+		.adcOffset = 0,
+		.thermistorSettings = {
+			.thermistor_R2 = 1500,
+			.thermistor_R = 10000,
+			.thermistor_Beta = 4300,
+			.temp_limit = 90,
+			.temperatureEnabled = true,
+		},
+		.currentScaler = 2.5 / (0x7fff * 0.066), // sensor 66mV/A
+		.brakeLimLow = 50700,
+		.brakeLimHigh = 50900,
+		.vmScaler = (2.5 / 0x7fff) * ((1.5+71.5)/1.5),
+		.vSenseMult = VOLTAGE_MULT_DEFAULT,
+		.clockfreq = 25e6,
+		.bbm = 40, // May need longer deadtime
+		.flags{
+			.mot_none = 1,
+			.mot_dc = 1,
+			.mot_bldc = 1,
+			.mot_stepper = 1,
+
+			.enc_none = 1,
+			.enc_abn = 1,
+			.enc_sincos = 1,
+			.enc_uvw = 1,
+			.enc_hall = 1,
+			.enc_ext = 1,
+
+			.allowFluxDissipationDeactivation = 1
+		}
+};
+const auto tmc4671_hw_configs_array = std::to_array<const TMC4671HardwareTypeConf>({conf1_3,conf1_2_2,conf1_2,conf1_0});
+std::span<const TMC4671HardwareTypeConf> TMC4671::tmc4671_hw_configs = tmc4671_hw_configs_array;
+#endif
+
+// Only a single config with default settings. Some defaults can be overridden by defines
+#ifdef TMC4671_CUSTOM_DEFAULT_HWCONF
+const TMC4671HardwareTypeConf defaultconf;
+const auto tmc4671_hw_configs_array = std::to_array<const TMC4671HardwareTypeConf>({defaultconf});
+std::span<const TMC4671HardwareTypeConf> TMC4671::tmc4671_hw_configs = tmc4671_hw_configs_array;
+
+#endif
diff --git a/Firmware/FFBoard/UserExtensions/Src/eeprom_addresses.c b/Firmware/FFBoard/UserExtensions/Src/eeprom_addresses.c
index d111d712a..2a0e83a21 100644
--- a/Firmware/FFBoard/UserExtensions/Src/eeprom_addresses.c
+++ b/Firmware/FFBoard/UserExtensions/Src/eeprom_addresses.c
@@ -70,6 +70,7 @@ const uint16_t VirtAddVarTab[NB_OF_VAR] =
 	ADR_FFB_EFFECTS1, // 0-7 inertia, 8-15 friction
 	ADR_FFB_EFFECTS2, // 0-7 spring, 8-15 damper
 	ADR_FFB_EFFECTS3, // 0-7 friction ramp up zone, 8-9 filterProfile
+	ADR_FFB_RECONSTRUCTION_FILTER, // 0-1 recon filter mode
 // Button Sources:
 	ADR_ADS111X_CONF1,
 // How many axis configured 1-3
@@ -80,6 +81,7 @@ const uint16_t VirtAddVarTab[NB_OF_VAR] =
 	ADR_AXIS1_DEGREES,
 	ADR_AXIS1_MAX_SPEED, // Store the max speed
 	ADR_AXIS1_MAX_ACCEL, // Store the max accel
+	ADR_AXIS1_MAX_SLEWRATE_DRV, // Max slew rate for drv
 	ADR_AXIS1_ENDSTOP, // 0-7 endstop margin, 8-15 endstop stiffness
 	ADR_AXIS1_EFFECTS1, // 0-7 idlespring, 8-15 damper
 	ADR_AXIS1_SPEEDACCEL_FILTER, // Speed/Accel filter Lowpass profile
@@ -106,6 +108,7 @@ const uint16_t VirtAddVarTab[NB_OF_VAR] =
 	ADR_AXIS2_DEGREES,
 	ADR_AXIS2_MAX_SPEED, // Store the max speed
 	ADR_AXIS2_MAX_ACCEL, // Store the max accel
+	ADR_AXIS2_MAX_SLEWRATE_DRV, // Max slew rate for drv
 	ADR_AXIS2_ENDSTOP, // 0-7 endstop margin, 8-15 endstop stiffness
 	ADR_AXIS2_EFFECTS1, // 0-7 idlespring, 8-15 damper
 	ADR_AXIS2_SPEEDACCEL_FILTER, // Speed/Accel filter Lowpass profile
@@ -132,6 +135,7 @@ const uint16_t VirtAddVarTab[NB_OF_VAR] =
 	ADR_AXIS3_DEGREES,
 	ADR_AXIS3_MAX_SPEED, // Store the max speed
 	ADR_AXIS3_MAX_ACCEL, // Store the max accel
+	ADR_AXIS3_MAX_SLEWRATE_DRV, // Max slew rate for drv
 	ADR_AXIS3_ENDSTOP, // 0-7 endstop margin, 8-15 endstop stiffness
 	ADR_AXIS3_EFFECTS1, // 0-7 idlespring, 8-15 damper
 	ADR_AXIS3_SPEEDACCEL_FILTER, // Speed/Accel filter Lowpass profile
@@ -270,6 +274,7 @@ const uint16_t exportableFlashAddresses[NB_EXPORTABLE_ADR] =
 	ADR_FFB_EFFECTS1, // 0-7 inertia, 8-15 friction
 	ADR_FFB_EFFECTS2, // 0-7 spring, 8-15 damper
 	ADR_FFB_EFFECTS3, // 0-7 friction ramp up zone, 8-9 filterProfile
+	ADR_FFB_RECONSTRUCTION_FILTER, // 0-1 recon filter mode
 // Button Sources:
 	ADR_ADS111X_CONF1,
 // How many axis configured 1-3
@@ -280,6 +285,7 @@ const uint16_t exportableFlashAddresses[NB_EXPORTABLE_ADR] =
 	ADR_AXIS1_DEGREES,
 	ADR_AXIS1_MAX_SPEED, // Store the max speed
 	ADR_AXIS1_MAX_ACCEL, // Store the max accel
+	ADR_AXIS1_MAX_SLEWRATE_DRV, // Max slew rate for drv
 	ADR_AXIS1_ENDSTOP, // 0-7 endstop margin, 8-15 endstop stiffness
 	ADR_AXIS1_EFFECTS1, // 0-7 idlespring, 8-15 damper
 	ADR_AXIS1_SPEEDACCEL_FILTER, // Speed/Accel filter Lowpass profile
@@ -306,6 +312,7 @@ const uint16_t exportableFlashAddresses[NB_EXPORTABLE_ADR] =
 	ADR_AXIS2_DEGREES,
 	ADR_AXIS2_MAX_SPEED, // Store the max speed
 	ADR_AXIS2_MAX_ACCEL, // Store the max accel
+	ADR_AXIS2_MAX_SLEWRATE_DRV, // Max slew rate for drv
 	ADR_AXIS2_ENDSTOP, // 0-7 endstop margin, 8-15 endstop stiffness
 	ADR_AXIS2_EFFECTS1, // 0-7 idlespring, 8-15 damper
 	ADR_AXIS2_SPEEDACCEL_FILTER, // Speed/Accel filter Lowpass profile
@@ -332,6 +339,7 @@ const uint16_t exportableFlashAddresses[NB_EXPORTABLE_ADR] =
 	ADR_AXIS3_DEGREES,
 	ADR_AXIS3_MAX_SPEED, // Store the max speed
 	ADR_AXIS3_MAX_ACCEL, // Store the max accel
+	ADR_AXIS3_MAX_SLEWRATE_DRV, // Max slew rate for drv
 	ADR_AXIS3_ENDSTOP, // 0-7 endstop margin, 8-15 endstop stiffness
 	ADR_AXIS3_EFFECTS1, // 0-7 idlespring, 8-15 damper
 	ADR_AXIS3_SPEEDACCEL_FILTER, // Speed/Accel filter Lowpass profile
diff --git a/Firmware/FFBoard/UserExtensions/Src/usb_descriptors.cpp b/Firmware/FFBoard/UserExtensions/Src/usb_descriptors.cpp
index 442758d04..d199462e9 100644
--- a/Firmware/FFBoard/UserExtensions/Src/usb_descriptors.cpp
+++ b/Firmware/FFBoard/UserExtensions/Src/usb_descriptors.cpp
@@ -7,7 +7,6 @@
 #include "tusb.h"
 #include "usb_descriptors.h"
 #include "usbd.h"
-#include "stm32f4xx_hal.h"
 #include "main.h"
 #include "usb_hid_ffb_desc.h"
 
@@ -48,62 +47,44 @@ const tusb_desc_device_t usb_devdesc_ffboard_composite =
 const uint8_t usb_cdc_conf[] =
 {
   // Config number, interface count, string index, total length, attribute, power in mA
-  TUD_CONFIG_DESCRIPTOR(1, 2, 0, (TUD_CONFIG_DESC_LEN + TUD_CDC_DESC_LEN), TUSB_DESC_CONFIG_ATT_REMOTE_WAKEUP, 100),
+  TUD_CONFIG_DESCRIPTOR(1, 2, 0, (TUD_CONFIG_DESC_LEN + TUD_CDC_DESC_LEN), TUSB_DESC_CONFIG_ATT_REMOTE_WAKEUP | TUSB_DESC_CONFIG_ATT_SELF_POWERED, 100),
 
   // 1st CDC: Interface number, string index, EP notification address and size, EP data address (out, in) and size.
   TUD_CDC_DESCRIPTOR(0, 4, 0x82, 8, 0x01, 0x81, 64),
 };
 
+
 // Composite CDC and HID
 #ifdef AXIS1_FFB_HID_DESC
-const uint8_t usb_cdc_hid_conf_1axis[] =
-{
-  // Config number, interface count, string index, total length, attribute, power in mA
-  TUD_CONFIG_DESCRIPTOR(1, 3, 0, (TUD_CONFIG_DESC_LEN + TUD_CDC_DESC_LEN + TUD_HID_INOUT_DESC_LEN), TUSB_DESC_CONFIG_ATT_REMOTE_WAKEUP, 100),
-
-  // 1st CDC: Interface number, string index, EP notification address and size, EP data address (out, in) and size.
-  TUD_CDC_DESCRIPTOR(0, 4, 0x82, 8, 0x01, 0x81, 64),
+	const uint8_t usb_cdc_hid_conf_1axis[] ={USB_CONF_DESC_HID_CDC(USB_HID_1FFB_REPORT_DESC_SIZE,64)};
+#endif
 
-  // HID Descriptor. EP 83 and 2
-  TUD_HID_INOUT_DESCRIPTOR(2, 5, HID_ITF_PROTOCOL_NONE, USB_HID_1FFB_REPORT_DESC_SIZE, 0x83, 0x02, 64, HID_BINTERVAL),
-};
+#ifdef AXIS1_FFB_HID_DESC_32B
+	const uint8_t usb_cdc_hid_conf_1axis_32b[] ={USB_CONF_DESC_HID_CDC(USB_HID_1FFB_REPORT_DESC_32B_SIZE,64)};
+#if TUD_OPT_HIGH_SPEED
+	const uint8_t usb_cdc_hid_conf_1axis_32b_hs[] ={USB_CONF_DESC_HID_CDC(USB_HID_1FFB_REPORT_DESC_32B_SIZE,512)};
+#endif
 #endif
 
 // Composite CDC and HID
 #ifdef AXIS2_FFB_HID_DESC
-const uint8_t usb_cdc_hid_conf_2axis[] =
-{
-  // Config number, interface count, string index, total length, attribute, power in mA
-  TUD_CONFIG_DESCRIPTOR(1, 3, 0, (TUD_CONFIG_DESC_LEN + TUD_CDC_DESC_LEN + TUD_HID_INOUT_DESC_LEN), TUSB_DESC_CONFIG_ATT_REMOTE_WAKEUP, 100),
-
-  // 1st CDC: Interface number, string index, EP notification address and size, EP data address (out, in) and size.
-  TUD_CDC_DESCRIPTOR(0, 4, 0x82, 8, 0x01, 0x81, 64),
+	const uint8_t usb_cdc_hid_conf_2axis[] ={USB_CONF_DESC_HID_CDC(USB_HID_2FFB_REPORT_DESC_SIZE,64)};
+#endif
 
-  // HID Descriptor. EP 83 and 2
-  TUD_HID_INOUT_DESCRIPTOR(2, 5, HID_ITF_PROTOCOL_NONE, USB_HID_2FFB_REPORT_DESC_SIZE, 0x83, 0x02, 64, HID_BINTERVAL),
-};
+#ifdef AXIS2_FFB_HID_DESC_32B
+	const uint8_t usb_cdc_hid_conf_2axis_32b[] ={USB_CONF_DESC_HID_CDC(USB_HID_2FFB_REPORT_DESC_32B_SIZE,64)};
 #endif
 
 // Composite CDC and HID
 #ifdef FFB_HID_DESC_GAMEPAD
-const uint8_t usb_cdc_hid_conf_gamepad[] =
-{
-  // Config number, interface count, string index, total length, attribute, power in mA
-  TUD_CONFIG_DESCRIPTOR(1, 3, 0, (TUD_CONFIG_DESC_LEN + TUD_CDC_DESC_LEN + TUD_HID_INOUT_DESC_LEN), TUSB_DESC_CONFIG_ATT_REMOTE_WAKEUP, 100),
-
-  // 1st CDC: Interface number, string index, EP notification address and size, EP data address (out, in) and size.
-  TUD_CDC_DESCRIPTOR(0, 4, 0x82, 8, 0x01, 0x81, 64),
-
-  // HID Descriptor. EP 83 and 2
-  TUD_HID_INOUT_DESCRIPTOR(2, 5, HID_ITF_PROTOCOL_NONE, USB_HID_GAMEPAD_REPORT_DESC_SIZE, 0x83, 0x02, 64, HID_BINTERVAL),
-};
+	const uint8_t usb_cdc_hid_conf_gamepad[] ={USB_CONF_DESC_HID_CDC(USB_HID_GAMEPAD_REPORT_DESC_SIZE,64)};
 #endif
 
 // Composite CDC and MIDI
 uint8_t const usb_cdc_midi_conf[] =
 {
   // Config number, interface count, string index, total length, attribute, power in mA
-  TUD_CONFIG_DESCRIPTOR(1, 4, 0, TUD_CONFIG_DESC_LEN + TUD_CDC_DESC_LEN + TUD_MIDI_DESC_LEN, TUSB_DESC_CONFIG_ATT_REMOTE_WAKEUP, 100),
+  TUD_CONFIG_DESCRIPTOR(1, 4, 0, TUD_CONFIG_DESC_LEN + TUD_CDC_DESC_LEN + TUD_MIDI_DESC_LEN, TUSB_DESC_CONFIG_ATT_REMOTE_WAKEUP | TUSB_DESC_CONFIG_ATT_SELF_POWERED, 100),
   // 1st CDC: Interface number, string index, EP notification address and size, EP data address (out, in) and size.
   TUD_CDC_DESCRIPTOR(0, 4, 0x82, 8, 0x01, 0x81, 64),
   // Interface number, string index, EP Out & EP In address, EP size
diff --git a/Firmware/FFBoard/UserExtensions/Src/usb_hid_1ffb_desc.c b/Firmware/FFBoard/UserExtensions/Src/usb_hid_1ffb_desc.c
index 3d1e30b26..afbc27caa 100644
--- a/Firmware/FFBoard/UserExtensions/Src/usb_hid_1ffb_desc.c
+++ b/Firmware/FFBoard/UserExtensions/Src/usb_hid_1ffb_desc.c
@@ -13,231 +13,17 @@
 
 __ALIGN_BEGIN const uint8_t hid_1ffb_desc[USB_HID_1FFB_REPORT_DESC_SIZE] __ALIGN_END =
 {
-		   0x05, 0x01,                    // USAGE_PAGE (Generic Desktop)
-		    0x09, 0x04,                    // USAGE (Joystick)
-		    0xa1, 0x01,                    // COLLECTION (Application)
-		    0xa1, 0x00,                    //   COLLECTION (Physical)
-		    0x85, 0x01,                    //     REPORT_ID (1)
-		    0x05, 0x09,                    //     USAGE_PAGE (Button)
-		    0x19, 0x01,                    //     USAGE_MINIMUM (Button 1)
-		    0x29, 0x40,                    //     USAGE_MAXIMUM (Button 64)
-		    0x15, 0x00,                    //     LOGICAL_MINIMUM (0)
-		    0x25, 0x01,                    //     LOGICAL_MAXIMUM (1)
-		    0x95, 0x40,                    //     REPORT_COUNT (64)
-		    0x75, 0x01,                    //     REPORT_SIZE (1)
-		    0x81, 0x02,                    //     INPUT (Data,Var,Abs)
-		    0x05, 0x01,                    //     USAGE_PAGE (Generic Desktop)
-		    0x09, HID_USAGE_X,             //     USAGE (X)
-		    0x09, HID_USAGE_Y,             //     USAGE (Y)
-		    0x09, HID_USAGE_Z,             //     USAGE (Z)
-		    0x09, HID_USAGE_RX,            //     USAGE (Rx)
-		    0x09, HID_USAGE_RY,            //     USAGE (Ry)
-			0x09, HID_USAGE_RZ,            //     USAGE (Rz)
-			0x09, HID_USAGE_SL1,           //     USAGE (Dial)
-			0x09, HID_USAGE_SL0,           //     USAGE (Slider)
-		    0x16, 0x01, 0x80,              //     LOGICAL_MINIMUM (-32767)
-		    0x26, 0xff, 0x7f,              //     LOGICAL_MAXIMUM (32767)
-		    0x75, 0x10,                    //     REPORT_SIZE (16)
-		    0x95, 0x08,                    //     REPORT_COUNT (8)
-		    0x81, 0x02,                    //     INPUT (Data,Var,Abs)
-		    0xc0,                          //   END_COLLECTION
-
-
-			// Control reports
-			0x06, 0x00, 0xFF,                    // USAGE_PAGE (Vendor)
-			0x09, 0x00,                    //   USAGE (Vendor)
-			0xA1, 0x01, // Collection (Application)
-
-				0x85,HID_ID_HIDCMD, //    Report ID
-				0x09, 0x01,                    //   USAGE (Vendor)
-				0x15, 0x00,                    //   LOGICAL_MINIMUM (0)
-				0x26, 0x04,	0x00,			   //   Logical Maximum 4
-				0x75, 0x08,                    //   REPORT_SIZE (8)
-				0x95, 0x01,                    //   REPORT_COUNT (1)
-				0x91, 0x02,                    //   OUTPUT (Data,Var,Abs)
-
-				0x09, 0x02,                    //   USAGE (Vendor) class address
-				0x75, 0x10,                    //   REPORT_SIZE (16)
-				0x95, 0x01,                    //   REPORT_COUNT (1)
-				0x91, 0x02,                    //   OUTPUT (Data,Var,Abs)
-
-				0x09, 0x03,                    //   USAGE (Vendor) class instance
-				0x75, 0x08,                    //   REPORT_SIZE (8)
-				0x95, 0x01,                    //   REPORT_COUNT (1)
-				0x91, 0x02,                    //   OUTPUT (Data,Var,Abs)
-
-				0x09, 0x04,                    //   USAGE (Vendor) cmd
-				0x75, 0x20,                    //   REPORT_SIZE (32)
-				0x95, 0x01,                    //   REPORT_COUNT (1)
-				0x91, 0x02,                    //   OUTPUT (Data,Var,Abs)
-
-				0x09, 0x05,                    //   USAGE (Vendor)
-				0x75, 0x40,                    //   REPORT_SIZE (64) value
-				0x95, 0x01,                    //   REPORT_COUNT (1)
-				0x91, 0x02,                    //   OUTPUT (Data,Var,Abs)
-
-				0x09, 0x06,                    //   USAGE (Vendor) address
-				0x75, 0x40,                    //   REPORT_SIZE (64)
-				0x95, 0x01,                    //   REPORT_COUNT (1)
-				0x91, 0x02,                    //   OUTPUT (Data,Var,Abs)
-
-				0x85,HID_ID_HIDCMD, //    Report ID
-				0x09, 0x01,                    //   USAGE (Vendor)
-				0x15, 0x00,                    //   LOGICAL_MINIMUM (0)
-				0x26, 0x04,	0x00,			   //   Logical Maximum 4
-				0x75, 0x08,                    //   REPORT_SIZE (8)
-				0x95, 0x01,                    //   REPORT_COUNT (1)
-				0x81, 0x02,                    //   INPUT (Data,Var,Abs)
-
-				0x09, 0x02,                    //   USAGE (Vendor) class address
-				0x75, 0x10,                    //   REPORT_SIZE (16)
-				0x95, 0x01,                    //   REPORT_COUNT (1)
-				0x81, 0x02,                    //   INPUT (Data,Var,Abs)
-
-				0x09, 0x03,                    //   USAGE (Vendor) class instance
-				0x75, 0x08,                    //   REPORT_SIZE (8)
-				0x95, 0x01,                    //   REPORT_COUNT (1)
-				0x81, 0x02,                    //   INPUT (Data,Var,Abs)
-
-				0x09, 0x04,                    //   USAGE (Vendor) cmd
-				0x75, 0x20,                    //   REPORT_SIZE (32)
-				0x95, 0x01,                    //   REPORT_COUNT (1)
-				0x81, 0x02,                    //   INPUT (Data,Var,Abs)
-
-				0x09, 0x05,                    //   USAGE (Vendor)
-				0x75, 0x40,                    //   REPORT_SIZE (64) value
-				0x95, 0x01,                    //   REPORT_COUNT (1)
-				0x81, 0x02,                    //   INPUT (Data,Var,Abs)
-
-				0x09, 0x06,                    //   USAGE (Vendor) address
-				0x75, 0x40,                    //   REPORT_SIZE (64)
-				0x95, 0x01,                    //   REPORT_COUNT (1)
-				0x81, 0x02,                    //   INPUT (Data,Var,Abs)
-
-
-
-		  0xc0,                          //   END_COLLECTION
-
-
-		// BEGIN PID effects
-			0x05,0x0F,        //    Usage Page Physical Interface
-			0x09,0x92,        //    Usage PID State report
-			0xA1,0x02,        //    Collection Datalink (logical)
-			   0x85,HID_ID_STATE+FFB_ID_OFFSET,    //    Report ID 2
-
-//			   0x09,0x22,    //    Usage Effect Block Index
-//			   0x15,0x01,    //    Logical Minimum 1
-//			   0x25,MAX_EFFECTS,    //    Logical Maximum 28h (40d)
-//			   0x35,0x01,    //    Physical Minimum 1
-//			   0x45,MAX_EFFECTS,    //    Physical Maximum 28h (40d)
-//			   0x75,0x08,    //    Report Size 8
-//			   0x95,0x01,    //    Report Count 1
-//			   0x81,0x02,    //    Input (Variable)
-
-
-
-			   0x09,0x9F,    //    Usage Device is Pause
-			   0x09,0xA0,    //    Usage Actuators Enabled
-			   0x09,0xA4,    //    Usage Safety Switch
-			   0x09,0xA6,    //    Usage Actuator Power
-
-			   0x09,0x94,    //    Usage Effect Playing
-			   			   /*
-			   			   			   0x15,0x00,    //    Logical Minimum 0
-			   			   			   0x25,0x01,    //    Logical Maximum 1
-			   			   			   0x35,0x00,    //    Physical Minimum 0
-			   			   			   0x45,0x01,    //    Physical Maximum 1
-			   			   			   0x75,0x01,    //    Report Size 1
-			   			   			   0x95,0x01,    //    Report Count 1
-			   			   			   0x81,0x02,    //    Input (Variable)*/ //14
+		0x05, 0x01,                    /* USAGE_PAGE (Generic Desktop)*/
+			0x09, 0x04,                    /* USAGE (Joystick)*/
+			0xa1, 0x01,                    /* COLLECTION (Application)*/
+		HIDDESC_GAMEPAD_16B,
 
-			   0x15,0x00,    //    Logical Minimum 0
-			   0x25,0x01,    //    Logical Maximum 1
-			   0x35,0x00,    //    Physical Minimum 0
-			   0x45,0x01,    //    Physical Maximum 1
-			   0x75,0x01,    //    Report Size 1
-			   0x95,0x05,    //    Report Count 4
-			   0x81,0x02,    //    Input (Variable)
-			   0x95,0x03,    //    Report Count 3
-			   0x81,0x03,    //    Input (Constant, Variable)
-			0xC0    ,    // End Collection
+		HIDDESC_CTRL_REPORTS, // HID command report support
 
-			/*
-			Output
-			Collection  Datalink:
-			Usage Set Effect Report
 
-			ID:1
-			Effect Block Index:	8bit
+		HIDDESC_FFB_STATEREP,
 
-			subcollection Effect Type
-			12 effect types, 8bit each
-
-			*/
-			0x09,0x21,    //    Usage Set Effect Report
-			0xA1,0x02,    //    Collection Datalink (Logical)
-			   0x85,HID_ID_EFFREP+FFB_ID_OFFSET,    //    Report ID 1
-			   0x09,0x22,    //    Usage Effect Block Index
-			   0x15,0x01,    //    Logical Minimum 1
-			   0x25,MAX_EFFECTS,    //    Logical Maximum 28h (40d)
-			   0x35,0x01,    //    Physical Minimum 1
-			   0x45,MAX_EFFECTS,    //    Physical Maximum 28h (40d)
-			   0x75,0x08,    //    Report Size 8
-			   0x95,0x01,    //    Report Count 1
-			   0x91,0x02,    //    Output (Variable)
-			   0x09,0x25,    //    Usage Effect Type
-			   0xA1,0x02,    //    Collection Datalink
-			 0x09, HID_USAGE_CONST,    //    Usage ET Constant Force
-			 0x09, HID_USAGE_RAMP,    //    Usage ET Ramp
-			 0x09, HID_USAGE_SQUR,    //    Usage ET Square
-			 0x09, HID_USAGE_SINE,    //    Usage ET Sine
-			 0x09, HID_USAGE_TRNG,    //    Usage ET Triangle
-			 0x09, HID_USAGE_STUP,    //    Usage ET Sawtooth Up
-			 0x09, HID_USAGE_STDN,    //    Usage ET Sawtooth Down
-			 0x09, HID_USAGE_SPRNG,    //    Usage ET Spring
-			 0x09, HID_USAGE_DMPR,    //    Usage ET Damper
-			 0x09, HID_USAGE_INRT,    //    Usage ET Inertia
-			 0x09, HID_USAGE_FRIC,    //    Usage ET Friction
-			// 0x09, 0x28,    //    Usage ET Custom Force Data
-			      0x25,0x0B,    //    Logical Maximum Bh (11d)
-			      0x15,0x01,    //    Logical Minimum 1
-			      0x35,0x01,    //    Physical Minimum 1
-			      0x45,0x0B,    //    Physical Maximum Bh (11d)
-			      0x75,0x08,    //    Report Size 8
-			      0x95,0x01,    //    Report Count 1
-			      0x91,0x00,    //    Output
-			   0xC0    ,          //    End Collection
-			   0x09,0x50,         //    Usage Duration
-			   0x09,0x54,         //    Usage Trigger Repeat Interval
-			   0x09,0x51,         //    Usage Sample Period
-			   0x09,0xA7,         //    Usage Start Delay
-			   0x15,0x00,         //    Logical Minimum 0
-			   0x26,0xFF,0x7F,    //    Logical Maximum 7FFFh (32767d)
-			   0x35,0x00,         //    Physical Minimum 0
-			   0x46,0xFF,0x7F,    //    Physical Maximum 7FFFh (32767d)
-			   0x66,0x03,0x10,    //    Unit 1003h (4099d)
-			   0x55,0xFD,         //    Unit Exponent FDh (253d)
-			   0x75,0x10,         //    Report Size 10h (16d)
-			   0x95,0x04,         //    Report Count 4
-			   0x91,0x02,         //    Output (Variable)
-			   0x55,0x00,         //    Unit Exponent 0
-			   0x66,0x00,0x00,    //    Unit 0
-			   0x09,0x52,         //    Usage Gain
-			   0x15,0x00,         //    Logical Minimum 0
-			   0x26,0xFF,0x00,    //    Logical Maximum FFh (255d) // TODO scaling?
-			   0x35,0x00,         //    Physical Minimum 0
-			   0x46,0x10,0x27,    //    Physical Maximum 2710h (10000d)
-			   0x75,0x08,         //    Report Size 8
-			   0x95,0x01,         //    Report Count 1
-			   0x91,0x02,         //    Output (Variable)
-			   0x09,0x53,         //    Usage Trigger Button
-			   0x15,0x01,         //    Logical Minimum 1
-			   0x25,0x08,         //    Logical Maximum 8
-			   0x35,0x01,         //    Physical Minimum 1
-			   0x45,0x08,         //    Physical Maximum 8
-			   0x75,0x08,         //    Report Size 8
-			   0x95,0x01,         //    Report Count 1
-			   0x91,0x02,         //    Output (Variable)
+		HIDDESC_FFB_SETEFREP,
 
 			   0x09,0x55,       //    Usage Axes Enable TODO multi axis
 			   0xA1,0x02,       //    Collection Datalink
@@ -289,39 +75,8 @@ __ALIGN_BEGIN const uint8_t hid_1ffb_desc[USB_HID_1FFB_REPORT_DESC_SIZE] __ALIGN
 			   0xC0,              //     END_COLLECTION
 			0xC0,                 //     END_COLLECTION
 
-			// Envelope Report Definition
-			0x09,0x5A,    //    Usage Set Envelope Report
-			0xA1,0x02,    //    Collection Datalink
-			   0x85,HID_ID_ENVREP+FFB_ID_OFFSET,         //    Report ID 2
-			   0x09,0x22,         //    Usage Effect Block Index
-			   0x15,0x01,         //    Logical Minimum 1
-			   0x25,MAX_EFFECTS,         //    Logical Maximum 28h (40d)
-			   0x35,0x01,         //    Physical Minimum 1
-			   0x45,MAX_EFFECTS,         //    Physical Maximum 28h (40d)
-			   0x75,0x08,         //    Report Size 8
-			   0x95,0x01,         //    Report Count 1
-			   0x91,0x02,         //    Output (Variable)
-			   0x09,0x5B,         //    Usage Attack Level
-			   0x09,0x5D,         //    Usage Fade Level
-			 0x16,0x00,0x00,    //    Logical Minimum 0
-			 0x26,0xFF,0x7F,    //    Logical Maximum 7FFFh (32767d)
-			 0x36,0x00,0x00,    //    Physical Minimum 0
-			 0x46,0xFF,0x7F,    //    Physical Maximum 7FFFh (32767d)
-			 0x75,0x10,         //    Report Size 16
-			 0x95,0x02,         //    Report Count 2
-			   0x91,0x02,         //    Output (Variable)
-			 0x09, 0x5C,         //    Usage Attack Time
-			 0x09, 0x5E,         //    Usage Fade Time
-			 0x66, 0x03, 0x10,    //    Unit 1003h (English Linear, Seconds)
-			 0x55, 0xFD,         //    Unit Exponent FDh (X10^-3 ==> Milisecond)
-			 0x27, 0xFF, 0x7F, 0x00, 0x00,    //    Logical Maximum FFFFFFFFh (4294967295)
-			 0x47, 0xFF, 0x7F, 0x00, 0x00,    //    Physical Maximum FFFFFFFFh (4294967295)
-			 0x75, 0x20,         //    Report Size 20h (32d)
-			 0x91, 0x02,         //    Output (Variable)
-			 0x45, 0x00,         //    Physical Maximum 0
-			   0x66,0x00,0x00,    //    Unit 0
-			   0x55,0x00,         //    Unit Exponent 0
-			0xC0     ,            //    End Collection
+			HIDDESC_FFB_SETENVREP,
+
 			0x09,0x5F,    //    Usage Set Condition Report
 			0xA1,0x02,    //    Collection Datalink
 			   0x85,HID_ID_CONDREP+FFB_ID_OFFSET,    //    Report ID 3
@@ -378,97 +133,12 @@ __ALIGN_BEGIN const uint8_t hid_1ffb_desc[USB_HID_1FFB_REPORT_DESC_SIZE] __ALIGN
 			   0x95,0x01,         //    Report Count 1
 			   0x91,0x02,         //    Output (Variable)
 			0xC0     ,    //    End Collection
-			0x09,0x6E,    //    Usage Set Periodic Report
-			0xA1,0x02,    //    Collection Datalink
-			   0x85,HID_ID_PRIDREP+FFB_ID_OFFSET,                   //    Report ID 4
-			   0x09,0x22,                   //    Usage Effect Block Index
-			   0x15,0x01,                   //    Logical Minimum 1
-			   0x25,MAX_EFFECTS,                   //    Logical Maximum 28h (40d)
-			   0x35,0x01,                   //    Physical Minimum 1
-			   0x45,MAX_EFFECTS,                   //    Physical Maximum 28h (40d)
-			   0x75,0x08,                   //    Report Size 8
-			   0x95,0x01,                   //    Report Count 1
-			   0x91,0x02,                   //    Output (Variable)
-			   0x09,0x70,                   //    Usage Magnitude
-			 0x16,0x00,0x00,              //    Logical Minimum 0
-			 0x26,0xff, 0x7f,    //    Logical Maximum 7FFFh (32767d)
-			 0x36,0x00,0x00,              //    Physical Minimum 0
-			 0x26,0xff, 0x7f,    //    Logical Maximum 7FFFh (32767d)
-			   0x75,0x10,                   //    Report Size 16
-			   0x95,0x01,                   //    Report Count 1
-			   0x91,0x02,                   //    Output (Variable)
-			 0x09, 0x6F,                   //    Usage Offset
-			 0x16,0x00, 0x80,    //    Logical Minimum 7FFFh (-32767d)
-		     0x26,0xff, 0x7f,    //    Logical Maximum 7FFFh (32767d)
-		     0x36,0x00, 0x80,    //    Physical Minimum 7FFFh (-32767d)
-		     0x46,0xff, 0x7f,    //    Physical Maximum 7FFFh (32767d)
-			 0x95, 0x01,                   //    Report Count 1
-			 0x75, 0x10,                   //    Report Size 16
-			 0x91, 0x02,                   //    Output (Variable)
-			 0x09, 0x71,                   //    Usage Phase
-			 0x66, 0x14, 0x00,             //    Unit 14h (Eng Rotation, Degrees)
-			 0x55, 0xFE,                   //    Unit Exponent FEh (X10^-2)
-			 0x15, 0x00,                   //    Logical Minimum 0
-			 0x27, 0x9F, 0x8C, 0x00, 0x00, //    Logical Maximum 8C9Fh (35999d)
-			 0x35, 0x00,                   //    Physical Minimum 0
-			 0x47, 0x9F, 0x8C, 0x00, 0x00, //    Physical Maximum 8C9Fh (35999d)
-			 0x75, 0x10,                   //    Report Size 16
-			 0x95, 0x01,                   //    Report Count 1
-			 0x91, 0x02,                   //    Output (Variable)
-			 0x09, 0x72,                   //    Usage Period
-			 0x15, 0x01,                   //    Logical Minimum 1
-			 0x27, 0xFF, 0x7F, 0x00, 0x00, //    Logical Maximum 7FFFh (32K)
-			 0x35, 0x01,                   //    Physical Minimum 1
-			 0x47, 0xFF, 0x7F, 0x00, 0x00, //    Physical Maximum 7FFFh (32K)
-			 0x66, 0x03, 0x10,             //    Unit 1003h (English Linear, Seconds)
-			 0x55, 0xFD,                   //    Unit Exponent FDh (X10^-3 ==> Milisecond)
-			 0x75, 0x20,                   //    Report Size 20h (32)
-			 0x95, 0x01,                   //    Report Count 1
-			 0x91, 0x02,                   //    Output (Variable)
-			 0x66, 0x00, 0x00,              //    Unit 0
-			   0x55,0x00,                   //    Unit Exponent 0
-			0xC0     ,    // End Collection
-			0x09,0x73,    //    Usage Set Constant Force Report
-			0xA1,0x02,    //    Collection Datalink
-			   0x85,HID_ID_CONSTREP+FFB_ID_OFFSET,         //    Report ID 5
-			   0x09,0x22,         //    Usage Effect Block Index
-			   0x15,0x01,         //    Logical Minimum 1
-			   0x25,MAX_EFFECTS,         //    Logical Maximum 28h (40d)
-			   0x35,0x01,         //    Physical Minimum 1
-			   0x45,MAX_EFFECTS,         //    Physical Maximum 28h (40d)
-			   0x75,0x08,         //    Report Size 8
-			   0x95,0x01,         //    Report Count 1
-			   0x91,0x02,         //    Output (Variable)
-			   0x09,0x70,         //    Usage Magnitude
-			   0x16,0x00, 0x80,    //    Logical Minimum 7FFFh (-32767d)
-			   0x26,0xff, 0x7f,    //    Logical Maximum 7FFFh (32767d)
-			   0x36,0x00, 0x80,    //    Physical Minimum 7FFFh (-32767d)
-			   0x46,0xff, 0x7f,    //    Physical Maximum 7FFFh (32767d)
-			 0x75, 0x10,         //    Report Size 10h (16d)
-			   0x95,0x01,         //    Report Count 1
-			   0x91,0x02,         //    Output (Variable)
-			0xC0     ,    //    End Collection
-			0x09,0x74,    //    Usage Set Ramp Force Report
-			0xA1,0x02,    //    Collection Datalink
-			   0x85,HID_ID_RAMPREP+FFB_ID_OFFSET,         //    Report ID 6
-			   0x09,0x22,         //    Usage Effect Block Index
-			   0x15,0x01,         //    Logical Minimum 1
-			   0x25,MAX_EFFECTS,         //    Logical Maximum 28h (40d)
-			   0x35,0x01,         //    Physical Minimum 1
-			   0x45,MAX_EFFECTS,         //    Physical Maximum 28h (40d)
-			   0x75,0x08,         //    Report Size 8
-			   0x95,0x01,         //    Report Count 1
-			   0x91,0x02,         //    Output (Variable)
-			   0x09,0x75,         //    Usage Ramp Start
-			   0x09,0x76,         //    Usage Ramp End
-			   0x16,0x00, 0x80,    //    Logical Minimum 7FFFh (-32767d)
-			   0x26,0xff, 0x7f,    //    Logical Maximum 7FFFh (32767d)
-			   0x36,0x00, 0x80,    //    Physical Minimum 7FFFh (-32767d)
-			   0x46,0xff, 0x7f,    //    Physical Maximum 7FFFh (32767d)
-			   0x75,0x10,         //    Report Size 16
-			   0x95,0x02,         //    Report Count 2
-			   0x91,0x02,         //    Output (Variable)
-			0xC0     ,    //    End Collection
+
+			HIDDESC_FFB_SETPERIODICREP,
+
+			HIDDESC_FFB_SETCFREP,
+
+			HIDDESC_FFB_SETRAMPREP,
 
 
 //			0x09,0x68,    //    Usage Custom Force Data Report
@@ -514,84 +184,10 @@ __ALIGN_BEGIN const uint8_t hid_1ffb_desc[USB_HID_1FFB_REPORT_DESC_SIZE] __ALIGN
 //			   0x91,0x02,         //    Output (Variable)
 //			0xC0     ,   //    End Collection
 
-			0x05,0x0F,   //    Usage Page Physical Interface
-			0x09,0x77,   //    Usage Effect Operation Report
-			0xA1,0x02,   //    Collection Datalink
-			   0x85,HID_ID_EFOPREP+FFB_ID_OFFSET,    //    Report ID Ah (10d)
-			   0x09,0x22,    //    Usage Effect Block Index
-			   0x15,0x01,    //    Logical Minimum 1
-			   0x25,MAX_EFFECTS,    //    Logical Maximum 28h (40d)
-			   0x35,0x01,    //    Physical Minimum 1
-			   0x45,MAX_EFFECTS,    //    Physical Maximum 28h (40d)
-			   0x75,0x08,    //    Report Size 8
-			   0x95,0x01,    //    Report Count 1
-			   0x91,0x02,    //    Output (Variable)
-			   0x09,0x78,    //    Usage Effect Operation
-			   0xA1,0x02,    //    Collection Datalink
-			      0x09,0x79,    //    Usage Op Effect Start
-			      0x09,0x7A,    //    Usage Op Effect Start Solo
-			      0x09,0x7B,    //    Usage Op Effect Stop
-			      0x15,0x01,    //    Logical Minimum 1
-			      0x25,0x03,    //    Logical Maximum 3
-			      0x75,0x08,    //    Report Size 8
-			      0x95,0x01,    //    Report Count 1
-			      0x91,0x00,    //    Output
-			   0xC0     ,         //    End Collection
-			   0x09,0x7C,         //    Usage Loop Count
-			   0x15,0x00,         //    Logical Minimum 0
-			   0x26,0xFF,0x00,    //    Logical Maximum FFh (255d)
-			   0x35,0x00,         //    Physical Minimum 0
-			   0x46,0xFF,0x00,    //    Physical Maximum FFh (255d)
-			   0x91,0x02,         //    Output (Variable)
-			0xC0     ,    //    End Collection
-			0x09,0x90,    //    Usage PID Block Free Report
-			0xA1,0x02,    //    Collection Datalink
-			   0x85,HID_ID_BLKFRREP+FFB_ID_OFFSET,    //    Report ID Bh (11d)
-			   0x09,0x22,    //    Usage Effect Block Index
-			   0x15,0x01,    //    Logical Minimum 1
-			   0x25,MAX_EFFECTS,    //    Logical Maximum 28h (40d)
-			   0x35,0x01,    //    Physical Minimum 1
-			   0x45,MAX_EFFECTS,    //    Physical Maximum 28h (40d)
-			   0x75,0x08,    //    Report Size 8
-			   0x95,0x01,    //    Report Count 1
-			   0x91,0x02,    //    Output (Variable)
-			0xC0     ,    //    End Collection
-
-			0x09,0x95,    //    Usage PID Device Control (0x96?)
-			0xA1,0x02,    //    Collection Datalink
-			0x85,HID_ID_CTRLREP+FFB_ID_OFFSET,    //    Report ID Ch (12d)
-			0x09,0x96,    //    Usage PID Device Control (0x96?)
-			0xA1,0x02,    //    Collection Datalink
-
-			   0x09,0x97,    //    Usage DC Enable Actuators
-			   0x09,0x98,    //    Usage DC Disable Actuators
-			   0x09,0x99,    //    Usage DC Stop All Effects
-			   0x09,0x9A,    //    Usage DC Device Reset
-			   0x09,0x9B,    //    Usage DC Device Pause
-			   0x09,0x9C,    //    Usage DC Device Continue
-
-
+			HIDDESC_FFB_EFOPREP,
+			HIDDESC_FFB_BLOCKFREEREP,
 
-			   0x15,0x01,    //    Logical Minimum 1
-			   0x25,0x06,    //    Logical Maximum 6
-			   0x75,0x01,    //    Report Size 1
-			   0x95,0x08,    //    Report Count 8
-			   0x91,0x02,    //    Output
-
-			0xC0     ,    //    End Collection
-			0xC0     ,    //    End Collection
-			0x09,0x7D,    //    Usage Device Gain Report
-			0xA1,0x02,    //    Collection Datalink
-			   0x85,HID_ID_GAINREP+FFB_ID_OFFSET,         //    Report ID Dh (13d)
-			   0x09,0x7E,         //    Usage Device Gain
-			   0x15,0x00,         //    Logical Minimum 0
-			   0x26,0xFF,0x00,    //    Logical Maximum FFh (255d)
-			   0x35,0x00,         //    Physical Minimum 0
-			   0x46,0x10,0x27,    //    Physical Maximum 2710h (10000d)
-			   0x75,0x08,         //    Report Size 8
-			   0x95,0x01,         //    Report Count 1
-			   0x91,0x02,         //    Output (Variable)
-			0xC0     ,            //    End Collection
+			HIDDESC_FFB_DEVCTRLREP,
 //			0x09,0x6B,    //    Usage Set Custom Force Report
 //			0xA1,0x02,    //    Collection Datalink
 //			   0x85,HID_ID_SETCREP+FFB_ID_OFFSET,         //    Report ID Eh (14d)
@@ -624,110 +220,168 @@ __ALIGN_BEGIN const uint8_t hid_1ffb_desc[USB_HID_1FFB_REPORT_DESC_SIZE] __ALIGN
 //			   0x55,0x00,         //    Unit Exponent 0
 //			   0x66,0x00,0x00,    //    Unit 0
 //			0xC0     ,    //    End Collection
-			0x09,0xAB,    //    Usage Create New Effect Report
-			0xA1,0x02,    //    Collection Datalink
-			   0x85,HID_ID_NEWEFREP+FFB_ID_OFFSET,    //    Report ID 1
-			   0x09,0x25,    //    Usage Effect Type
+			HIDDESC_FFB_NEWEFREP,
+			HIDDESC_FFB_BLOCKLOADREP,
+
+			HIDDESC_FFB_POOLREP,
+
+  0xC0    /*     END_COLLECTION	             */
+};
+#endif
+
+#ifdef AXIS1_FFB_HID_DESC_32B
+__ALIGN_BEGIN const uint8_t hid_1ffb_desc_32b[USB_HID_1FFB_REPORT_DESC_32B_SIZE] __ALIGN_END =
+{
+		0x05, 0x01,                    /* USAGE_PAGE (Generic Desktop)*/
+			0x09, 0x04,                    /* USAGE (Joystick)*/
+			0xa1, 0x01,                    /* COLLECTION (Application)*/
+		HIDDESC_GAMEPAD_32B,
+
+			HIDDESC_CTRL_REPORTS, // HID command report support
+
+			HIDDESC_FFB_STATEREP,
+			/*
+			Output
+			Collection  Datalink:
+			Usage Set Effect Report
+
+			ID:1
+			Effect Block Index:	8bit
+
+			subcollection Effect Type
+			12 effect types, 8bit each
+
+			*/
+			HIDDESC_FFB_SETEFREP,
+
+			   0x09,0x55,       //    Usage Axes Enable TODO multi axis
+			   0xA1,0x02,       //    Collection Datalink
+			      0x05,0x01,    //    Usage Page Generic Desktop
+			      0x09,0x30,    //    Usage X
+			      //0x09,0x31,    //    Usage Y
+			      0x15,0x00,    //    Logical Minimum 0
+			      0x25,0x00,    //    Logical Maximum 0
+			      0x75,0x01,    //    Report Size 1
+			      0x95,0x01,    //    Report Count 1
+			      0x91,0x02,    //    Output (Variable)
+			   0xC0     ,    // End Collection
+			   0x05,0x0F,    //    Usage Page Physical Interface
+			   0x09,0x56,    //    Usage Direction Enable
+			   0x95,0x01,    //    Report Count 1
+			   0x91,0x02,    //    Output (Variable)
+			   0x95,0x06,    //    Report Count 6
+			   0x91,0x03,    //    Output (Constant, Variable)
+
+			   0x09,0x57,    //    Usage Direction
 			   0xA1,0x02,    //    Collection Datalink
-			 0x09, HID_USAGE_CONST,    //    Usage ET Constant Force
-			 0x09, HID_USAGE_RAMP,    //    Usage ET Ramp
-			 0x09, HID_USAGE_SQUR,    //    Usage ET Square
-			 0x09, HID_USAGE_SINE,    //    Usage ET Sine
-			 0x09, HID_USAGE_TRNG,    //    Usage ET Triangle
-			 0x09, HID_USAGE_STUP,    //    Usage ET Sawtooth Up
-			 0x09, HID_USAGE_STDN,    //    Usage ET Sawtooth Down
-			 0x09, HID_USAGE_SPRNG,    //    Usage ET Spring
-			 0x09, HID_USAGE_DMPR,    //    Usage ET Damper
-			 0x09, HID_USAGE_INRT,    //    Usage ET Inertia
-			 0x09, HID_USAGE_FRIC,    //    Usage ET Friction
-//			 0x09, 0x28,    //    Usage ET Custom Force Data
-			   0x25,0x0B,    //    Logical Maximum Ch (11d)
+			      0x0B,0x01,0x00,0x0A,0x00,    //    Usage Ordinals: Instance 1
+//			      0x0B,0x02,0x00,0x0A,0x00,    //    Usage Ordinals: Instance 2
+			      0x66,0x14,0x00,              //    Unit 14h (20d)
+//			      0x55,0xFE,                   //    Unit Exponent FEh (254d)
+//			      0x15,0x00,                   //    Logical Minimum 0
+//			      0x26,0xFF,0x00,              //    Logical Maximum FFh (255d)
+				  0x15,0x00,                   //    Logical Minimum 0
+				  0x27,0xA0,0x8C,0x00,0x00,    //    Logical Maximum 8CA0h (36000d)
+			      0x35,0x00,                   //    Physical Minimum 0
+			      0x47,0xA0,0x8C,0x00,0x00,    //    Physical Maximum 8CA0h (36000d)
+			      0x66,0x00,0x00,              //    Unit 0
+			      0x75,0x10,                   //    Report Size 16
+			      0x95,0x01,                   //    Report Count 1
+			      0x91,0x02,                   //    Output (Variable)
+			      0x55,0x00,                   //    Unit Exponent 0
+			      0x66,0x00,0x00,              //    Unit 0
+			   0xC0,                           //    End Collection
+
+			   0x05, 0x0F,        //     USAGE_PAGE (Physical Interface)
+			   0x09, 0x58,        //     USAGE (Type Specific Block Offset)
+			   0xA1, 0x02,        //     COLLECTION (Logical)
+			      0x0B, 0x01, 0x00, 0x0A, 0x00, //USAGE (Ordinals:Instance 1
+			      //0x0B, 0x02, 0x00, 0x0A, 0x00, //USAGE (Ordinals:Instance 2)
+			      0x26, 0xFD, 0x7F, //   LOGICAL_MAXIMUM (32765) ; 32K RAM or ROM max.
+			      0x75, 0x10,     //     REPORT_SIZE (16)
+			      0x95, 0x01,     //     REPORT_COUNT (1)
+			      0x91, 0x02,     //     OUTPUT (Data,Var,Abs)
+			   0xC0,              //     END_COLLECTION
+			0xC0,                 //     END_COLLECTION
+
+			HIDDESC_FFB_SETENVREP,
+
+			0x09,0x5F,    //    Usage Set Condition Report
+			0xA1,0x02,    //    Collection Datalink
+			   0x85,HID_ID_CONDREP+FFB_ID_OFFSET,    //    Report ID 3
+			   0x09,0x22,    //    Usage Effect Block Index
 			   0x15,0x01,    //    Logical Minimum 1
+			   0x25,MAX_EFFECTS,    //    Logical Maximum 28h (40d)
 			   0x35,0x01,    //    Physical Minimum 1
-			   0x45,0x0B,    //    Physical Maximum Ch (11d)
+			   0x45,MAX_EFFECTS,    //    Physical Maximum 28h (40d)
 			   0x75,0x08,    //    Report Size 8
 			   0x95,0x01,    //    Report Count 1
-			   0xB1,0x00,    //    Feature
-			0xC0     ,    // End Collection
-			0x05,0x01,         //    Usage Page Generic Desktop
-			0x09,0x3B,         //    Usage Reserved (Byte count)
-			0x15,0x00,         //    Logical Minimum 0
-			0x26,0xFF,0x01,    //    Logical Maximum 1FFh (511d)
-			0x35,0x00,         //    Physical Minimum 0
-			0x46,0xFF,0x01,    //    Physical Maximum 1FFh (511d)
-			0x75,0x0A,         //    Report Size Ah (10d)
-			0x95,0x01,         //    Report Count 1
-			0xB1,0x02,         //    Feature (Variable)
-			0x75,0x06,         //    Report Size 6
-			0xB1,0x01,         //    Feature (Constant)
-			0xC0     ,    //    End Collection
-			0x05,0x0F,    //    Usage Page Physical Interface
-			0x09,0x89,    //    Usage Block Load Report
-			0xA1,0x02,    //    Collection Datalink
-			0x85,HID_ID_BLKLDREP+FFB_ID_OFFSET,    //    Report ID 0x12
-			0x09,0x22,    //    Usage Effect Block Index
-			0x25,MAX_EFFECTS,    //    Logical Maximum 28h (40d)
-			0x15,0x01,    //    Logical Minimum 1
-			0x35,0x01,    //    Physical Minimum 1
-			0x45,MAX_EFFECTS,    //    Physical Maximum 28h (40d)
-			0x75,0x08,    //    Report Size 8
-			0x95,0x01,    //    Report Count 1
-			0xB1,0x02,    //    Feature (Variable)
-			0x09,0x8B,    //    Usage Block Load Status
-			0xA1,0x02,    //    Collection Datalink
-			   0x09,0x8C,    //    Usage Block Load Success
-			   0x09,0x8D,    //    Usage Block Load Full
-			   0x09,0x8E,    //    Usage Block Load Error
-			   0x15,0x01,    //    Logical Minimum 1
+			   0x91,0x02,    //    Output (Variable)
+			   0x09,0x23,    //    Usage Parameter Block Offset
+			   0x15,0x00,    //    Logical Minimum 0
 			   0x25,0x03,    //    Logical Maximum 3
-			   0x35,0x01,    //    Physical Minimum 1
+			   0x35,0x00,    //    Physical Minimum 0
 			   0x45,0x03,    //    Physical Maximum 3
-			   0x75,0x08,    //    Report Size 8
+			   0x75,0x06,    //    Report Size 6
 			   0x95,0x01,    //    Report Count 1
-			   0xB1,0x00,    //    Feature
-			0xC0     ,                   // End Collection
-			0x09,0xAC,                   //    Usage Pool available
-			0x15,0x00,                   //    Logical Minimum 0
-			0x27,0xFF,0xFF,0x00,0x00,    //    Logical Maximum FFFFh (65535d)
-			0x35,0x00,                   //    Physical Minimum 0
-			0x47,0xFF,0xFF,0x00,0x00,    //    Physical Maximum FFFFh (65535d)
-			0x75,0x10,                   //    Report Size 10h (16d)
-			0x95,0x01,                   //    Report Count 1
-			0xB1,0x00,                   //    Feature
+			   0x91,0x02,    //    Output (Variable)
+			   0x09,0x58,    //    Usage Type Specific Block Off...
+			   0xA1,0x02,    //    Collection Datalink
+			      0x0B,0x01,0x00,0x0A,0x00,    //    Usage Ordinals: Instance 1
+//			      0x0B,0x02,0x00,0x0A,0x00,    //    Usage Ordinals: Instance 2
+			      0x75,0x02,                   //    Report Size 2
+			      0x95,0x01,                   //    Report Count 1
+			      0x91,0x02,                   //    Output (Variable)
+			   0xC0     ,         //    End Collection
+			   0x16,0x00, 0x80,    //    Logical Minimum 7FFFh (-32767d)
+			   0x26,0xff, 0x7f,    //    Logical Maximum 7FFFh (32767d)
+			   0x36,0x00, 0x80,    //    Physical Minimum 7FFFh (-32767d)
+			   0x46,0xff, 0x7f,    //    Physical Maximum 7FFFh (32767d)
+
+			   0x09,0x60,         //    Usage CP Offset
+			   0x75,0x10,         //    Report Size 16
+			   0x95,0x01,         //    Report Count 1
+			   0x91,0x02,         //    Output (Variable)
+			   0x36,0x00, 0x80,    //    Physical Minimum  (-32768)
+			   0x46,0xff, 0x7f,    //    Physical Maximum  (32767)
+			   0x09,0x61,         //    Usage Positive Coefficient
+			   0x09,0x62,         //    Usage Negative Coefficient
+			   0x95,0x02,         //    Report Count 2
+			   0x91,0x02,         //    Output (Variable)
+			 0x16,0x00,0x00,    //    Logical Minimum 0
+			 0x26,0xff, 0x7f,	  //    Logical Maximum  (32767)
+			 0x36,0x00,0x00,    //    Physical Minimum 0
+			   0x46,0xff, 0x7f,    //    Physical Maximum  (32767)
+			   0x09,0x63,         //    Usage Positive Saturation
+			   0x09,0x64,         //    Usage Negative Saturation
+			   0x75,0x10,         //    Report Size 16
+			   0x95,0x02,         //    Report Count 2
+			   0x91,0x02,         //    Output (Variable)
+			   0x09,0x65,         //    Usage Dead Band
+			   0x46,0xff, 0x7f,    //    Physical Maximum (32767)
+			   0x95,0x01,         //    Report Count 1
+			   0x91,0x02,         //    Output (Variable)
 			0xC0     ,    //    End Collection
 
-			0x09,0x7F,    //    Usage PID Pool Report
-			0xA1,0x02,    //    Collection Datalink
-				0x85,HID_ID_POOLREP+FFB_ID_OFFSET,                   //    Report ID 0x13
-				0x09,0x80,                   //    Usage RAM Pool size
-				0x75,0x10,                   //    Report Size 10h (16d)
-				0x95,0x01,                   //    Report Count 1
-				0x15,0x00,                   //    Logical Minimum 0
-				0x35,0x00,                   //    Physical Minimum 0
-				0x27,0xFF,0xFF,0x00,0x00,    //    Logical Maximum FFFFh (65535d)
-				0x47,0xFF,0xFF,0x00,0x00,    //    Physical Maximum FFFFh (65535d)
-				0xB1,0x02,                   //    Feature (Variable)
-				0x09,0x83,                   //    Usage Simultaneous Effects Max
-				0x26,0xFF,0x00,              //    Logical Maximum FFh (255d)
-				0x46,0xFF,0x00,              //    Physical Maximum FFh (255d)
-				0x75,0x08,                   //    Report Size 8
-				0x95,0x01,                   //    Report Count 1
-				0xB1,0x02,                   //    Feature (Variable)
-				0x09,0xA9,                   //    Usage Device Managed Pool
-				0x09,0xAA,                   //    Usage Shared Parameter Blocks
-				0x75,0x01,                   //    Report Size 1
-				0x95,0x02,                   //    Report Count 2
-				0x15,0x00,                   //    Logical Minimum 0
-				0x25,0x01,                   //    Logical Maximum 1
-				0x35,0x00,                   //    Physical Minimum 0
-				0x45,0x01,                   //    Physical Maximum 1
-				0xB1,0x02,                   //    Feature (Variable)
-				0x75,0x06,                   //    Report Size 6
-				0x95,0x01,                   //    Report Count 1
-				0xB1,0x03,                   //    Feature (Constant, Variable)
-			0xC0, //    End Collection
+			HIDDESC_FFB_SETPERIODICREP,
+
+			HIDDESC_FFB_SETCFREP,
+
+			HIDDESC_FFB_SETRAMPREP,
+
+			HIDDESC_FFB_EFOPREP,
+
+			HIDDESC_FFB_BLOCKFREEREP,
+
+			HIDDESC_FFB_DEVCTRLREP,
+
+			HIDDESC_FFB_NEWEFREP,
+
+			HIDDESC_FFB_BLOCKLOADREP,
+
+			HIDDESC_FFB_POOLREP,
 
   0xC0    /*     END_COLLECTION	             */
 };
-
 #endif
+
diff --git a/Firmware/FFBoard/UserExtensions/Src/usb_hid_2ffb_desc.c b/Firmware/FFBoard/UserExtensions/Src/usb_hid_2ffb_desc.c
index 79e98bcb0..6083e7e52 100644
--- a/Firmware/FFBoard/UserExtensions/Src/usb_hid_2ffb_desc.c
+++ b/Firmware/FFBoard/UserExtensions/Src/usb_hid_2ffb_desc.c
@@ -12,210 +12,95 @@
 #ifdef AXIS2_FFB_HID_DESC
 __ALIGN_BEGIN const uint8_t hid_2ffb_desc[USB_HID_2FFB_REPORT_DESC_SIZE] __ALIGN_END =
 {
-		   0x05, 0x01,                    // USAGE_PAGE (Generic Desktop)
-		    0x09, 0x04,                    // USAGE (Joystick)
-		    0xa1, 0x01,                    // COLLECTION (Application)
-		    0xa1, 0x00,                    //   COLLECTION (Physical)
-		    0x85, 0x01,                    //     REPORT_ID (1)
-		    0x05, 0x09,                    //     USAGE_PAGE (Button)
-		    0x19, 0x01,                    //     USAGE_MINIMUM (Button 1)
-		    0x29, 0x40,                    //     USAGE_MAXIMUM (Button 64)
-		    0x15, 0x00,                    //     LOGICAL_MINIMUM (0)
-		    0x25, 0x01,                    //     LOGICAL_MAXIMUM (1)
-		    0x95, 0x40,                    //     REPORT_COUNT (64)
-		    0x75, 0x01,                    //     REPORT_SIZE (1)
-		    0x81, 0x02,                    //     INPUT (Data,Var,Abs)
-		    0x05, 0x01,                    //     USAGE_PAGE (Generic Desktop)
-		    0x09, HID_USAGE_X,             //     USAGE (X)
-		    0x09, HID_USAGE_Y,             //     USAGE (Y)
-		    0x09, HID_USAGE_Z,             //     USAGE (Z)
-		    0x09, HID_USAGE_RX,            //     USAGE (Rx)
-		    0x09, HID_USAGE_RY,            //     USAGE (Ry)
-			0x09, HID_USAGE_RZ,            //     USAGE (Rz)
-			0x09, HID_USAGE_SL1,           //     USAGE (Dial)
-			0x09, HID_USAGE_SL0,           //     USAGE (Slider)
-		    0x16, 0x01, 0x80,              //     LOGICAL_MINIMUM (-32767)
-		    0x26, 0xff, 0x7f,              //     LOGICAL_MAXIMUM (32767)
-		    0x75, 0x10,                    //     REPORT_SIZE (16)
-		    0x95, 0x08,                    //     REPORT_COUNT (8)
-		    0x81, 0x02,                    //     INPUT (Data,Var,Abs)
-		    0xc0,                          //   END_COLLECTION
-
-
-			// Control reports
-			0x06, 0x00, 0xFF,                    // USAGE_PAGE (Vendor)
-			0x09, 0x00,                    //   USAGE (Vendor)
-			0xA1, 0x01, // Collection (Application)
-//				0x85,HID_ID_CUSTOMCMD, //    Report ID
-//				0x09, 0x01,                    //   USAGE (Vendor) type
-//				0x15, 0x00,                    //   LOGICAL_MINIMUM (0)
-//				0x26, 0x04,	0x00,			   //   Logical Maximum 4
-//				0x75, 0x08,                    //   REPORT_SIZE (8)
-//				0x95, 0x01,                    //   REPORT_COUNT (1)
-//				0xb1, 0x02,                    //   FEATURE (Data,Var,Abs)
-//
-//				0x09, 0x02,                    //   USAGE (Vendor) cmd
-//				0x09, 0x03,                    //   USAGE (Vendor) addr
-//				0x75, 0x20,                    //   REPORT_SIZE (32)
-//				0x95, 0x02,                    //   REPORT_COUNT (2)
-//				0xb1, 0x02,                    //   FEATURE (Data,Var,Abs)
-//
-//				0x09, 0x04,                    //   USAGE (Vendor) data
-//				0x75, 0x40,                    //   REPORT_SIZE (64)
-//				0x95, 0x01,                    //   REPORT_COUNT (1)
-//				0xb1, 0x02,                    //   FEATURE (Data,Var,Abs)
-//
-//				0x85,HID_ID_CUSTOMCMD, //    Report ID
-//				0x09, 0x01,                    //   USAGE (Vendor)
-//				0x15, 0x00,                    //   LOGICAL_MINIMUM (0)
-//				0x26, 0x04,	0x00,			   //   Logical Maximum 4
-//				0x75, 0x08,                    //   REPORT_SIZE (8)
-//				0x95, 0x01,                    //   REPORT_COUNT (1)
-//				0x91, 0x02,                    //   OUTPUT (Data,Var,Abs)
-//
-//				0x09, 0x02,                    //   USAGE (Vendor)
-//				0x09, 0x03,                    //   USAGE (Vendor)
-//				0x75, 0x20,                    //   REPORT_SIZE (32)
-//				0x95, 0x02,                    //   REPORT_COUNT (2)
-//				0x91, 0x02,                    //   OUTPUT (Data,Var,Abs)
+		0x05, 0x01,                    /* USAGE_PAGE (Generic Desktop)*/
+			0x09, 0x04,                    /* USAGE (Joystick)*/
+			0xa1, 0x01,                    /* COLLECTION (Application)*/
+		HIDDESC_GAMEPAD_16B,
+//		   0x05, 0x01,                    // USAGE_PAGE (Generic Desktop)
+//		    0x09, 0x04,                    // USAGE (Joystick)
+//		    0xa1, 0x01,                    // COLLECTION (Application)
+//		    0xa1, 0x00,                    //   COLLECTION (Physical)
+//		    0x85, 0x01,                    //     REPORT_ID (1)
+//		    0x05, 0x09,                    //     USAGE_PAGE (Button)
+//		    0x19, 0x01,                    //     USAGE_MINIMUM (Button 1)
+//		    0x29, 0x40,                    //     USAGE_MAXIMUM (Button 64)
+//		    0x15, 0x00,                    //     LOGICAL_MINIMUM (0)
+//		    0x25, 0x01,                    //     LOGICAL_MAXIMUM (1)
+//		    0x95, 0x40,                    //     REPORT_COUNT (64)
+//		    0x75, 0x01,                    //     REPORT_SIZE (1)
+//		    0x81, 0x02,                    //     INPUT (Data,Var,Abs)
+//		    0x05, 0x01,                    //     USAGE_PAGE (Generic Desktop)
+//		    0x09, HID_USAGE_DESKTOP_X,             //     USAGE (X)
+//#if defined(HIDAXISRES_32B) && MAX_AXIS == 1
+//			HIDDESC_32B_ENTRY(0x01)
+//#endif
+//		    0x09, HID_USAGE_DESKTOP_Y,             //     USAGE (Y)
+//#if defined(HIDAXISRES_32B) && MAX_AXIS == 2
+//			HIDDESC_32B_ENTRY(0x02)
+//#endif
+//		    0x09, HID_USAGE_DESKTOP_Z,             //     USAGE (Z)
+//#if defined(HIDAXISRES_32B) && MAX_AXIS == 3
+//			HIDDESC_32B_ENTRY(0x03)
+//#endif
+//		    0x09, HID_USAGE_DESKTOP_RX,            //     USAGE (Rx)
+//		    0x09, HID_USAGE_DESKTOP_RY,            //     USAGE (Ry)
+//			0x09, HID_USAGE_DESKTOP_RZ,            //     USAGE (Rz)
+//			0x09, HID_USAGE_DESKTOP_DIAL,           //     USAGE (Dial)
+//			0x09, HID_USAGE_DESKTOP_SLIDER,           //     USAGE (Slider)
+//		    0x16, 0x01, 0x80,              //     LOGICAL_MINIMUM (-32767)
+//		    0x26, 0xff, 0x7f,              //     LOGICAL_MAXIMUM (32767)
+//		    0x75, 0x10,                    //     REPORT_SIZE (16)
+//#if defined(HIDAXISRES_32B)
+//			0x95, 0x08-MAX_AXIS,           //     REPORT_COUNT (8- amount of 32b axes)
+//#else
+//		    0x95, 0x08,                    //     REPORT_COUNT (8)
+//#endif
+//		    0x81, 0x02,                    //     INPUT (Data,Var,Abs)
+//		    0xc0,                          //   END_COLLECTION
+
+			HIDDESC_CTRL_REPORTS, // HID command report support
+
+		// BEGIN PID effects
+//			0x05,0x0F,        //    Usage Page Physical Interface
+//			0x09,0x92,        //    Usage PID State report
+//			0xA1,0x02,        //    Collection Datalink (logical)
+//			   0x85,HID_ID_STATE+FFB_ID_OFFSET,    //    Report ID 2
 //
-//				0x09, 0x04,                    //   USAGE (Vendor)
-//				0x75, 0x40,                    //   REPORT_SIZE (64)
-//				0x95, 0x01,                    //   REPORT_COUNT (1)
-//				0x91, 0x02,                    //   OUTPUT (Data,Var,Abs)
+////			   0x09,0x22,    //    Usage Effect Block Index
+////			   0x15,0x01,    //    Logical Minimum 1
+////			   0x25,MAX_EFFECTS,    //    Logical Maximum 28h (40d)
+////			   0x35,0x01,    //    Physical Minimum 1
+////			   0x45,MAX_EFFECTS,    //    Physical Maximum 28h (40d)
+////			   0x75,0x08,    //    Report Size 8
+////			   0x95,0x01,    //    Report Count 1
+////			   0x81,0x02,    //    Input (Variable)
 //
-//				0x85,HID_ID_CUSTOMCMD, //    Report ID
-//				0x09, 0x01,                    //   USAGE (Vendor)
-//				0x15, 0x00,                    //   LOGICAL_MINIMUM (0)
-//				0x26, 0x04,	0x00,			   //   Logical Maximum 4
-//				0x75, 0x08,                    //   REPORT_SIZE (8)
-//				0x95, 0x01,                    //   REPORT_COUNT (1)
-//				0x81, 0x02,                    //   INPUT (Data,Var,Abs)
+//			   0x09,0x9F,    //    Usage Device is Pause
+//			   0x09,0xA0,    //    Usage Actuators Enabled
+//			   0x09,0xA4,    //    Usage Safety Switch
+//			   0x09,0xA6,    //    Usage Actuator Power
 //
-//				0x09, 0x02,                    //   USAGE (Vendor)
-//				0x09, 0x03,                    //   USAGE (Vendor)
-//				0x75, 0x20,                    //   REPORT_SIZE (32)
-//				0x95, 0x02,                    //   REPORT_COUNT (2)
-//				0x81, 0x02,                    //   INPUT (Data,Var,Abs)
+//			   0x09,0x94,    //    Usage Effect Playing
+//			   /*
+//						   0x15,0x00,    //    Logical Minimum 0
+//						   0x25,0x01,    //    Logical Maximum 1
+//						   0x35,0x00,    //    Physical Minimum 0
+//						   0x45,0x01,    //    Physical Maximum 1
+//						   0x75,0x01,    //    Report Size 1
+//						   0x95,0x01,    //    Report Count 1
+//						   0x81,0x02,    //    Input (Variable)*/ //14
 //
-//				0x09, 0x04,                    //   USAGE (Vendor)
-//				0x75, 0x40,                    //   REPORT_SIZE (64)
-//				0x95, 0x01,                    //   REPORT_COUNT (1)
-//				0x81, 0x02,                    //   INPUT (Data,Var,Abs)
-				0x85,HID_ID_HIDCMD, //    Report ID
-				0x09, 0x01,                    //   USAGE (Vendor)
-				0x15, 0x00,                    //   LOGICAL_MINIMUM (0)
-				0x26, 0x04,	0x00,			   //   Logical Maximum 4
-				0x75, 0x08,                    //   REPORT_SIZE (8)
-				0x95, 0x01,                    //   REPORT_COUNT (1)
-				0x91, 0x02,                    //   OUTPUT (Data,Var,Abs)
-
-				0x09, 0x02,                    //   USAGE (Vendor) class address
-				0x75, 0x10,                    //   REPORT_SIZE (16)
-				0x95, 0x01,                    //   REPORT_COUNT (1)
-				0x91, 0x02,                    //   OUTPUT (Data,Var,Abs)
-
-				0x09, 0x03,                    //   USAGE (Vendor) class instance
-				0x75, 0x08,                    //   REPORT_SIZE (8)
-				0x95, 0x01,                    //   REPORT_COUNT (1)
-				0x91, 0x02,                    //   OUTPUT (Data,Var,Abs)
-
-				0x09, 0x04,                    //   USAGE (Vendor) cmd
-				0x75, 0x20,                    //   REPORT_SIZE (32)
-				0x95, 0x01,                    //   REPORT_COUNT (1)
-				0x91, 0x02,                    //   OUTPUT (Data,Var,Abs)
-
-				0x09, 0x05,                    //   USAGE (Vendor)
-				0x75, 0x40,                    //   REPORT_SIZE (64) value
-				0x95, 0x01,                    //   REPORT_COUNT (1)
-				0x91, 0x02,                    //   OUTPUT (Data,Var,Abs)
-
-				0x09, 0x06,                    //   USAGE (Vendor) address
-				0x75, 0x40,                    //   REPORT_SIZE (64)
-				0x95, 0x01,                    //   REPORT_COUNT (1)
-				0x91, 0x02,                    //   OUTPUT (Data,Var,Abs)
-
-				0x85,HID_ID_HIDCMD, //    Report ID
-				0x09, 0x01,                    //   USAGE (Vendor)
-				0x15, 0x00,                    //   LOGICAL_MINIMUM (0)
-				0x26, 0x04,	0x00,			   //   Logical Maximum 4
-				0x75, 0x08,                    //   REPORT_SIZE (8)
-				0x95, 0x01,                    //   REPORT_COUNT (1)
-				0x81, 0x02,                    //   INPUT (Data,Var,Abs)
-
-				0x09, 0x02,                    //   USAGE (Vendor) class address
-				0x75, 0x10,                    //   REPORT_SIZE (16)
-				0x95, 0x01,                    //   REPORT_COUNT (1)
-				0x81, 0x02,                    //   INPUT (Data,Var,Abs)
-
-				0x09, 0x03,                    //   USAGE (Vendor) class instance
-				0x75, 0x08,                    //   REPORT_SIZE (8)
-				0x95, 0x01,                    //   REPORT_COUNT (1)
-				0x81, 0x02,                    //   INPUT (Data,Var,Abs)
-
-				0x09, 0x04,                    //   USAGE (Vendor) cmd
-				0x75, 0x20,                    //   REPORT_SIZE (32)
-				0x95, 0x01,                    //   REPORT_COUNT (1)
-				0x81, 0x02,                    //   INPUT (Data,Var,Abs)
-
-				0x09, 0x05,                    //   USAGE (Vendor)
-				0x75, 0x40,                    //   REPORT_SIZE (64) value
-				0x95, 0x01,                    //   REPORT_COUNT (1)
-				0x81, 0x02,                    //   INPUT (Data,Var,Abs)
-
-				0x09, 0x06,                    //   USAGE (Vendor) address
-				0x75, 0x40,                    //   REPORT_SIZE (64)
-				0x95, 0x01,                    //   REPORT_COUNT (1)
-				0x81, 0x02,                    //   INPUT (Data,Var,Abs)
-
-
-
-		  0xc0,                          //   END_COLLECTION
-
-
-		// BEGIN PID effects
-			0x05,0x0F,        //    Usage Page Physical Interface
-			0x09,0x92,        //    Usage PID State report
-			0xA1,0x02,        //    Collection Datalink (logical)
-			   0x85,HID_ID_STATE+FFB_ID_OFFSET,    //    Report ID 2
-
-//			   0x09,0x22,    //    Usage Effect Block Index
-//			   0x15,0x01,    //    Logical Minimum 1
-//			   0x25,MAX_EFFECTS,    //    Logical Maximum 28h (40d)
-//			   0x35,0x01,    //    Physical Minimum 1
-//			   0x45,MAX_EFFECTS,    //    Physical Maximum 28h (40d)
-//			   0x75,0x08,    //    Report Size 8
-//			   0x95,0x01,    //    Report Count 1
+//			   0x15,0x00,    //    Logical Minimum 0
+//			   0x25,0x01,    //    Logical Maximum 1
+//			   0x35,0x00,    //    Physical Minimum 0
+//			   0x45,0x01,    //    Physical Maximum 1
+//			   0x75,0x01,    //    Report Size 1
+//			   0x95,0x05,    //    Report Count 4
 //			   0x81,0x02,    //    Input (Variable)
-
-
-
-			   0x09,0x9F,    //    Usage Device is Pause
-			   0x09,0xA0,    //    Usage Actuators Enabled
-			   0x09,0xA4,    //    Usage Safety Switch
-			   0x09,0xA6,    //    Usage Actuator Power
-
-			   0x09,0x94,    //    Usage Effect Playing
-			   			   /*
-			   			   			   0x15,0x00,    //    Logical Minimum 0
-			   			   			   0x25,0x01,    //    Logical Maximum 1
-			   			   			   0x35,0x00,    //    Physical Minimum 0
-			   			   			   0x45,0x01,    //    Physical Maximum 1
-			   			   			   0x75,0x01,    //    Report Size 1
-			   			   			   0x95,0x01,    //    Report Count 1
-			   			   			   0x81,0x02,    //    Input (Variable)*/ //14
-
-			   0x15,0x00,    //    Logical Minimum 0
-			   0x25,0x01,    //    Logical Maximum 1
-			   0x35,0x00,    //    Physical Minimum 0
-			   0x45,0x01,    //    Physical Maximum 1
-			   0x75,0x01,    //    Report Size 1
-			   0x95,0x05,    //    Report Count 4
-			   0x81,0x02,    //    Input (Variable)
-			   0x95,0x03,    //    Report Count 3
-			   0x81,0x03,    //    Input (Constant, Variable)
-			0xC0    ,    // End Collection
-
+//			   0x95,0x03,    //    Report Count 3
+//			   0x81,0x03,    //    Input (Constant, Variable)
+//			0xC0    ,    // End Collection
+			HIDDESC_FFB_STATEREP,
 			/*
 			Output
 			Collection  Datalink:
@@ -228,71 +113,72 @@ __ALIGN_BEGIN const uint8_t hid_2ffb_desc[USB_HID_2FFB_REPORT_DESC_SIZE] __ALIGN
 			12 effect types, 8bit each
 
 			*/
-			0x09,0x21,    //    Usage Set Effect Report
-			0xA1,0x02,    //    Collection Datalink (Logical)
-			   0x85,HID_ID_EFFREP+FFB_ID_OFFSET,    //    Report ID 1
-			   0x09,0x22,    //    Usage Effect Block Index
-			   0x15,0x01,    //    Logical Minimum 1
-			   0x25,MAX_EFFECTS,    //    Logical Maximum 28h (40d)
-			   0x35,0x01,    //    Physical Minimum 1
-			   0x45,MAX_EFFECTS,    //    Physical Maximum 28h (40d)
-			   0x75,0x08,    //    Report Size 8
-			   0x95,0x01,    //    Report Count 1
-			   0x91,0x02,    //    Output (Variable)
-			   0x09,0x25,    //    Usage Effect Type
-			   0xA1,0x02,    //    Collection Datalink
-			 0x09, HID_USAGE_CONST,    //    Usage ET Constant Force
-			 0x09, HID_USAGE_RAMP,    //    Usage ET Ramp
-			 0x09, HID_USAGE_SQUR,    //    Usage ET Square
-			 0x09, HID_USAGE_SINE,    //    Usage ET Sine
-			 0x09, HID_USAGE_TRNG,    //    Usage ET Triangle
-			 0x09, HID_USAGE_STUP,    //    Usage ET Sawtooth Up
-			 0x09, HID_USAGE_STDN,    //    Usage ET Sawtooth Down
-			 0x09, HID_USAGE_SPRNG,    //    Usage ET Spring
-			 0x09, HID_USAGE_DMPR,    //    Usage ET Damper
-			 0x09, HID_USAGE_INRT,    //    Usage ET Inertia
-			 0x09, HID_USAGE_FRIC,    //    Usage ET Friction
-			// 0x09, 0x28,    //    Usage ET Custom Force Data
-			      0x25,0x0B,    //    Logical Maximum Bh (11d)
-			      0x15,0x01,    //    Logical Minimum 1
-			      0x35,0x01,    //    Physical Minimum 1
-			      0x45,0x0B,    //    Physical Maximum Bh (11d)
-			      0x75,0x08,    //    Report Size 8
-			      0x95,0x01,    //    Report Count 1
-			      0x91,0x00,    //    Output
-			   0xC0    ,          //    End Collection
-			   0x09,0x50,         //    Usage Duration
-			   0x09,0x54,         //    Usage Trigger Repeat Interval
-			   0x09,0x51,         //    Usage Sample Period
-			   0x09,0xA7,         //    Usage Start Delay
-			   0x15,0x00,         //    Logical Minimum 0
-			   0x26,0xFF,0x7F,    //    Logical Maximum 7FFFh (32767d)
-			   0x35,0x00,         //    Physical Minimum 0
-			   0x46,0xFF,0x7F,    //    Physical Maximum 7FFFh (32767d)
-			   0x66,0x03,0x10,    //    Unit 1003h (4099d)
-			   0x55,0xFD,         //    Unit Exponent FDh (253d)
-			   0x75,0x10,         //    Report Size 10h (16d)
-			   0x95,0x04,         //    Report Count 4
-			   0x91,0x02,         //    Output (Variable)
-			   0x55,0x00,         //    Unit Exponent 0
-			   0x66,0x00,0x00,    //    Unit 0
-			   0x09,0x52,         //    Usage Gain
-			   0x15,0x00,         //    Logical Minimum 0
-			   0x26,0xFF,0x00,    //    Logical Maximum FFh (255d) // TODO scaling?
-			   0x35,0x00,         //    Physical Minimum 0
-			   0x46,0x10,0x27,    //    Physical Maximum 2710h (10000d)
-			   0x75,0x08,         //    Report Size 8
-			   0x95,0x01,         //    Report Count 1
-			   0x91,0x02,         //    Output (Variable)
-			   0x09,0x53,         //    Usage Trigger Button
-			   0x15,0x01,         //    Logical Minimum 1
-			   0x25,0x08,         //    Logical Maximum 8
-			   0x35,0x01,         //    Physical Minimum 1
-			   0x45,0x08,         //    Physical Maximum 8
-			   0x75,0x08,         //    Report Size 8
-			   0x95,0x01,         //    Report Count 1
-			   0x91,0x02,         //    Output (Variable)
-
+			HIDDESC_FFB_SETEFREP,
+//			0x09,0x21,    //    Usage Set Effect Report
+//			0xA1,0x02,    //    Collection Datalink (Logical)
+//			   0x85,HID_ID_EFFREP+FFB_ID_OFFSET,    //    Report ID 1
+//			   0x09,0x22,    //    Usage Effect Block Index
+//			   0x15,0x01,    //    Logical Minimum 1
+//			   0x25,MAX_EFFECTS,    //    Logical Maximum 28h (40d)
+//			   0x35,0x01,    //    Physical Minimum 1
+//			   0x45,MAX_EFFECTS,    //    Physical Maximum 28h (40d)
+//			   0x75,0x08,    //    Report Size 8
+//			   0x95,0x01,    //    Report Count 1
+//			   0x91,0x02,    //    Output (Variable)
+//			   0x09,0x25,    //    Usage Effect Type
+//			   0xA1,0x02,    //    Collection Datalink
+//			 0x09, HID_USAGE_CONST,    //    Usage ET Constant Force
+//			 0x09, HID_USAGE_RAMP,    //    Usage ET Ramp
+//			 0x09, HID_USAGE_SQUR,    //    Usage ET Square
+//			 0x09, HID_USAGE_SINE,    //    Usage ET Sine
+//			 0x09, HID_USAGE_TRNG,    //    Usage ET Triangle
+//			 0x09, HID_USAGE_STUP,    //    Usage ET Sawtooth Up
+//			 0x09, HID_USAGE_STDN,    //    Usage ET Sawtooth Down
+//			 0x09, HID_USAGE_SPRNG,    //    Usage ET Spring
+//			 0x09, HID_USAGE_DMPR,    //    Usage ET Damper
+//			 0x09, HID_USAGE_INRT,    //    Usage ET Inertia
+//			 0x09, HID_USAGE_FRIC,    //    Usage ET Friction
+//			// 0x09, 0x28,    //    Usage ET Custom Force Data
+//			      0x25,0x0B,    //    Logical Maximum Bh (11d)
+//			      0x15,0x01,    //    Logical Minimum 1
+//			      0x35,0x01,    //    Physical Minimum 1
+//			      0x45,0x0B,    //    Physical Maximum Bh (11d)
+//			      0x75,0x08,    //    Report Size 8
+//			      0x95,0x01,    //    Report Count 1
+//			      0x91,0x00,    //    Output
+//			   0xC0    ,          //    End Collection
+//			   0x09,0x50,         //    Usage Duration
+//			   0x09,0x54,         //    Usage Trigger Repeat Interval
+//			   0x09,0x51,         //    Usage Sample Period
+//			   0x09,0xA7,         //    Usage Start Delay
+//			   0x15,0x00,         //    Logical Minimum 0
+//			   0x26,0xFF,0x7F,    //    Logical Maximum 7FFFh (32767d)
+//			   0x35,0x00,         //    Physical Minimum 0
+//			   0x46,0xFF,0x7F,    //    Physical Maximum 7FFFh (32767d)
+//			   0x66,0x03,0x10,    //    Unit 1003h (4099d)
+//			   0x55,0xFD,         //    Unit Exponent FDh (253d)
+//			   0x75,0x10,         //    Report Size 10h (16d)
+//			   0x95,0x04,         //    Report Count 4
+//			   0x91,0x02,         //    Output (Variable)
+//			   0x55,0x00,         //    Unit Exponent 0
+//			   0x66,0x00,0x00,    //    Unit 0
+//			   0x09,0x52,         //    Usage Gain
+//			   0x15,0x00,         //    Logical Minimum 0
+//			   0x26,0xFF,0x00,    //    Logical Maximum FFh (255d) // TODO scaling?
+//			   0x35,0x00,         //    Physical Minimum 0
+//			   0x46,0x10,0x27,    //    Physical Maximum 2710h (10000d)
+//			   0x75,0x08,         //    Report Size 8
+//			   0x95,0x01,         //    Report Count 1
+//			   0x91,0x02,         //    Output (Variable)
+//			   0x09,0x53,         //    Usage Trigger Button
+//			   0x15,0x01,         //    Logical Minimum 1
+//			   0x25,0x08,         //    Logical Maximum 8
+//			   0x35,0x01,         //    Physical Minimum 1
+//			   0x45,0x08,         //    Physical Maximum 8
+//			   0x75,0x08,         //    Report Size 8
+//			   0x95,0x01,         //    Report Count 1
+//			   0x91,0x02,         //    Output (Variable)
+// Len 108 bytes following
 			   0x09,0x55,       //    Usage Axes Enable TODO multi axis
 			   0xA1,0x02,       //    Collection Datalink
 			      0x05,0x01,    //    Usage Page Generic Desktop
@@ -344,39 +230,44 @@ __ALIGN_BEGIN const uint8_t hid_2ffb_desc[USB_HID_2FFB_REPORT_DESC_SIZE] __ALIGN
 			   0xC0,              //     END_COLLECTION
 			0xC0,                 //     END_COLLECTION
 
-			// Envelope Report Definition
-			0x09,0x5A,    //    Usage Set Envelope Report
-			0xA1,0x02,    //    Collection Datalink
-			   0x85,HID_ID_ENVREP+FFB_ID_OFFSET,         //    Report ID 2
-			   0x09,0x22,         //    Usage Effect Block Index
-			   0x15,0x01,         //    Logical Minimum 1
-			   0x25,MAX_EFFECTS,         //    Logical Maximum 28h (40d)
-			   0x35,0x01,         //    Physical Minimum 1
-			   0x45,MAX_EFFECTS,         //    Physical Maximum 28h (40d)
-			   0x75,0x08,         //    Report Size 8
-			   0x95,0x01,         //    Report Count 1
-			   0x91,0x02,         //    Output (Variable)
-			   0x09,0x5B,         //    Usage Attack Level
-			   0x09,0x5D,         //    Usage Fade Level
-			 0x16,0x00,0x00,    //    Logical Minimum 0
-			 0x26,0xFF,0x7F,    //    Logical Maximum 7FFFh (32767d)
-			 0x36,0x00,0x00,    //    Physical Minimum 0
-			 0x46,0xFF,0x7F,    //    Physical Maximum 7FFFh (32767d)
-			 0x75,0x10,         //    Report Size 16
-			 0x95,0x02,         //    Report Count 2
-			   0x91,0x02,         //    Output (Variable)
-			 0x09, 0x5C,         //    Usage Attack Time
-			 0x09, 0x5E,         //    Usage Fade Time
-			 0x66, 0x03, 0x10,    //    Unit 1003h (English Linear, Seconds)
-			 0x55, 0xFD,         //    Unit Exponent FDh (X10^-3 ==> Milisecond)
-			 0x27, 0xFF, 0x7F, 0x00, 0x00,    //    Logical Maximum FFFFFFFFh (4294967295)
-			 0x47, 0xFF, 0x7F, 0x00, 0x00,    //    Physical Maximum FFFFFFFFh (4294967295)
-			 0x75, 0x20,         //    Report Size 20h (32d)
-			 0x91, 0x02,         //    Output (Variable)
-			 0x45, 0x00,         //    Physical Maximum 0
-			   0x66,0x00,0x00,    //    Unit 0
-			   0x55,0x00,         //    Unit Exponent 0
-			0xC0     ,            //    End Collection
+			HIDDESC_FFB_SETENVREP,
+//			// Envelope Report Definition
+//			0x09,0x5A,    //    Usage Set Envelope Report
+//			0xA1,0x02,    //    Collection Datalink
+//			   0x85,HID_ID_ENVREP+FFB_ID_OFFSET,         //    Report ID 2
+//			   0x09,0x22,         //    Usage Effect Block Index
+//			   0x15,0x01,         //    Logical Minimum 1
+//			   0x25,MAX_EFFECTS,         //    Logical Maximum 28h (40d)
+//			   0x35,0x01,         //    Physical Minimum 1
+//			   0x45,MAX_EFFECTS,         //    Physical Maximum 28h (40d)
+//			   0x75,0x08,         //    Report Size 8
+//			   0x95,0x01,         //    Report Count 1
+//			   0x91,0x02,         //    Output (Variable)
+//			   0x09,0x5B,         //    Usage Attack Level
+//			   0x09,0x5D,         //    Usage Fade Level
+//			 0x16,0x00,0x00,    //    Logical Minimum 0
+//			 0x26,0xFF,0x7F,    //    Logical Maximum 7FFFh (32767d)
+//			 0x36,0x00,0x00,    //    Physical Minimum 0
+//			 0x46,0xFF,0x7F,    //    Physical Maximum 7FFFh (32767d)
+//			 0x75,0x10,         //    Report Size 16
+//			 0x95,0x02,         //    Report Count 2
+//			   0x91,0x02,         //    Output (Variable)
+//			 0x09, 0x5C,         //    Usage Attack Time
+//			 0x09, 0x5E,         //    Usage Fade Time
+//			 0x66, 0x03, 0x10,    //    Unit 1003h (English Linear, Seconds)
+//			 0x55, 0xFD,         //    Unit Exponent FDh (X10^-3 ==> Milisecond)
+//			 0x27, 0xFF, 0x7F, 0x00, 0x00,    //    Logical Maximum FFFFFFFFh (4294967295)
+//			 0x47, 0xFF, 0x7F, 0x00, 0x00,    //    Physical Maximum FFFFFFFFh (4294967295)
+//			 0x75, 0x20,         //    Report Size 20h (32d)
+//			 0x91, 0x02,         //    Output (Variable)
+//			 0x45, 0x00,         //    Physical Maximum 0
+//			   0x66,0x00,0x00,    //    Unit 0
+//			   0x55,0x00,         //    Unit Exponent 0
+//			0xC0     ,            //    End Collection
+//			HIDDESC_FFB_SETCONDREP,
+
+			// Condition report depends on ffb axis count
+			// 125 bytes following
 			0x09,0x5F,    //    Usage Set Condition Report
 			0xA1,0x02,    //    Collection Datalink
 			   0x85,HID_ID_CONDREP+FFB_ID_OFFSET,    //    Report ID 3
@@ -433,102 +324,62 @@ __ALIGN_BEGIN const uint8_t hid_2ffb_desc[USB_HID_2FFB_REPORT_DESC_SIZE] __ALIGN
 			   0x95,0x01,         //    Report Count 1
 			   0x91,0x02,         //    Output (Variable)
 			0xC0     ,    //    End Collection
-			0x09,0x6E,    //    Usage Set Periodic Report
-			0xA1,0x02,    //    Collection Datalink
-			   0x85,HID_ID_PRIDREP+FFB_ID_OFFSET,                   //    Report ID 4
-			   0x09,0x22,                   //    Usage Effect Block Index
-			   0x15,0x01,                   //    Logical Minimum 1
-			   0x25,MAX_EFFECTS,                   //    Logical Maximum 28h (40d)
-			   0x35,0x01,                   //    Physical Minimum 1
-			   0x45,MAX_EFFECTS,                   //    Physical Maximum 28h (40d)
-			   0x75,0x08,                   //    Report Size 8
-			   0x95,0x01,                   //    Report Count 1
-			   0x91,0x02,                   //    Output (Variable)
-			   0x09,0x70,                   //    Usage Magnitude
-			 0x16,0x00,0x00,              //    Logical Minimum 0
-			 0x26,0xff, 0x7f,    //    Logical Maximum 7FFFh (32767d)
-			 0x36,0x00,0x00,              //    Physical Minimum 0
-			 0x26,0xff, 0x7f,    //    Logical Maximum 7FFFh (32767d)
-			   0x75,0x10,                   //    Report Size 16
-			   0x95,0x01,                   //    Report Count 1
-			   0x91,0x02,                   //    Output (Variable)
-			 0x09, 0x6F,                   //    Usage Offset
-			 0x16,0x00, 0x80,    //    Logical Minimum 7FFFh (-32767d)
-		     0x26,0xff, 0x7f,    //    Logical Maximum 7FFFh (32767d)
-		     0x36,0x00, 0x80,    //    Physical Minimum 7FFFh (-32767d)
-		     0x46,0xff, 0x7f,    //    Physical Maximum 7FFFh (32767d)
-			 0x95, 0x01,                   //    Report Count 1
-			 0x75, 0x10,                   //    Report Size 16
-			 0x91, 0x02,                   //    Output (Variable)
-			 0x09, 0x71,                   //    Usage Phase
-			 0x66, 0x14, 0x00,             //    Unit 14h (Eng Rotation, Degrees)
-			 0x55, 0xFE,                   //    Unit Exponent FEh (X10^-2)
-			 0x15, 0x00,                   //    Logical Minimum 0
-			 0x27, 0x9F, 0x8C, 0x00, 0x00, //    Logical Maximum 8C9Fh (35999d)
-			 0x35, 0x00,                   //    Physical Minimum 0
-			 0x47, 0x9F, 0x8C, 0x00, 0x00, //    Physical Maximum 8C9Fh (35999d)
-			 0x75, 0x10,                   //    Report Size 16
-			 0x95, 0x01,                   //    Report Count 1
-			 0x91, 0x02,                   //    Output (Variable)
-			 0x09, 0x72,                   //    Usage Period
-			 0x15, 0x01,                   //    Logical Minimum 1
-			 0x27, 0xFF, 0x7F, 0x00, 0x00, //    Logical Maximum 7FFFh (32K)
-			 0x35, 0x01,                   //    Physical Minimum 1
-			 0x47, 0xFF, 0x7F, 0x00, 0x00, //    Physical Maximum 7FFFh (32K)
-			 0x66, 0x03, 0x10,             //    Unit 1003h (English Linear, Seconds)
-			 0x55, 0xFD,                   //    Unit Exponent FDh (X10^-3 ==> Milisecond)
-			 0x75, 0x20,                   //    Report Size 20h (32)
-			 0x95, 0x01,                   //    Report Count 1
-			 0x91, 0x02,                   //    Output (Variable)
-			 0x66, 0x00, 0x00,              //    Unit 0
-			   0x55,0x00,                   //    Unit Exponent 0
-			0xC0     ,    // End Collection
-			0x09,0x73,    //    Usage Set Constant Force Report
-			0xA1,0x02,    //    Collection Datalink
-			   0x85,HID_ID_CONSTREP+FFB_ID_OFFSET,         //    Report ID 5
-			   0x09,0x22,         //    Usage Effect Block Index
-			   0x15,0x01,         //    Logical Minimum 1
-			   0x25,MAX_EFFECTS,         //    Logical Maximum 28h (40d)
-			   0x35,0x01,         //    Physical Minimum 1
-			   0x45,MAX_EFFECTS,         //    Physical Maximum 28h (40d)
-			   0x75,0x08,         //    Report Size 8
-			   0x95,0x01,         //    Report Count 1
-			   0x91,0x02,         //    Output (Variable)
-			   0x09,0x70,         //    Usage Magnitude
-			   0x16,0x00, 0x80,    //    Logical Minimum 7FFFh (-32767d)
-			   0x26,0xff, 0x7f,    //    Logical Maximum 7FFFh (32767d)
-			   0x36,0x00, 0x80,    //    Physical Minimum 7FFFh (-32767d)
-			   0x46,0xff, 0x7f,    //    Physical Maximum 7FFFh (32767d)
-			 0x75, 0x10,         //    Report Size 10h (16d)
-			   0x95,0x01,         //    Report Count 1
-			   0x91,0x02,         //    Output (Variable)
-			0xC0     ,    //    End Collection
-			0x09,0x74,    //    Usage Set Ramp Force Report
-			0xA1,0x02,    //    Collection Datalink
-			   0x85,HID_ID_RAMPREP+FFB_ID_OFFSET,         //    Report ID 6
-			   0x09,0x22,         //    Usage Effect Block Index
-			   0x15,0x01,         //    Logical Minimum 1
-			   0x25,MAX_EFFECTS,         //    Logical Maximum 28h (40d)
-			   0x35,0x01,         //    Physical Minimum 1
-			   0x45,MAX_EFFECTS,         //    Physical Maximum 28h (40d)
-			   0x75,0x08,         //    Report Size 8
-			   0x95,0x01,         //    Report Count 1
-			   0x91,0x02,         //    Output (Variable)
-			   0x09,0x75,         //    Usage Ramp Start
-			   0x09,0x76,         //    Usage Ramp End
-			   0x16,0x00, 0x80,    //    Logical Minimum 7FFFh (-32767d)
-			   0x26,0xff, 0x7f,    //    Logical Maximum 7FFFh (32767d)
-			   0x36,0x00, 0x80,    //    Physical Minimum 7FFFh (-32767d)
-			   0x46,0xff, 0x7f,    //    Physical Maximum 7FFFh (32767d)
-			   0x75,0x10,         //    Report Size 16
-			   0x95,0x02,         //    Report Count 2
-			   0x91,0x02,         //    Output (Variable)
-			0xC0     ,    //    End Collection
-
 
-//			0x09,0x68,    //    Usage Custom Force Data Report
+			HIDDESC_FFB_SETPERIODICREP,
+//			0x09,0x6E,    //    Usage Set Periodic Report
+//			0xA1,0x02,    //    Collection Datalink
+//			   0x85,HID_ID_PRIDREP+FFB_ID_OFFSET,                   //    Report ID 4
+//			   0x09,0x22,                   //    Usage Effect Block Index
+//			   0x15,0x01,                   //    Logical Minimum 1
+//			   0x25,MAX_EFFECTS,                   //    Logical Maximum 28h (40d)
+//			   0x35,0x01,                   //    Physical Minimum 1
+//			   0x45,MAX_EFFECTS,                   //    Physical Maximum 28h (40d)
+//			   0x75,0x08,                   //    Report Size 8
+//			   0x95,0x01,                   //    Report Count 1
+//			   0x91,0x02,                   //    Output (Variable)
+//			   0x09,0x70,                   //    Usage Magnitude
+//			 0x16,0x00,0x00,              //    Logical Minimum 0
+//			 0x26,0xff, 0x7f,    //    Logical Maximum 7FFFh (32767d)
+//			 0x36,0x00,0x00,              //    Physical Minimum 0
+//			 0x26,0xff, 0x7f,    //    Logical Maximum 7FFFh (32767d)
+//			   0x75,0x10,                   //    Report Size 16
+//			   0x95,0x01,                   //    Report Count 1
+//			   0x91,0x02,                   //    Output (Variable)
+//			 0x09, 0x6F,                   //    Usage Offset
+//			 0x16,0x00, 0x80,    //    Logical Minimum 7FFFh (-32767d)
+//		     0x26,0xff, 0x7f,    //    Logical Maximum 7FFFh (32767d)
+//		     0x36,0x00, 0x80,    //    Physical Minimum 7FFFh (-32767d)
+//		     0x46,0xff, 0x7f,    //    Physical Maximum 7FFFh (32767d)
+//			 0x95, 0x01,                   //    Report Count 1
+//			 0x75, 0x10,                   //    Report Size 16
+//			 0x91, 0x02,                   //    Output (Variable)
+//			 0x09, 0x71,                   //    Usage Phase
+//			 0x66, 0x14, 0x00,             //    Unit 14h (Eng Rotation, Degrees)
+//			 0x55, 0xFE,                   //    Unit Exponent FEh (X10^-2)
+//			 0x15, 0x00,                   //    Logical Minimum 0
+//			 0x27, 0x9F, 0x8C, 0x00, 0x00, //    Logical Maximum 8C9Fh (35999d)
+//			 0x35, 0x00,                   //    Physical Minimum 0
+//			 0x47, 0x9F, 0x8C, 0x00, 0x00, //    Physical Maximum 8C9Fh (35999d)
+//			 0x75, 0x10,                   //    Report Size 16
+//			 0x95, 0x01,                   //    Report Count 1
+//			 0x91, 0x02,                   //    Output (Variable)
+//			 0x09, 0x72,                   //    Usage Period
+//			 0x15, 0x01,                   //    Logical Minimum 1
+//			 0x27, 0xFF, 0x7F, 0x00, 0x00, //    Logical Maximum 7FFFh (32K)
+//			 0x35, 0x01,                   //    Physical Minimum 1
+//			 0x47, 0xFF, 0x7F, 0x00, 0x00, //    Physical Maximum 7FFFh (32K)
+//			 0x66, 0x03, 0x10,             //    Unit 1003h (English Linear, Seconds)
+//			 0x55, 0xFD,                   //    Unit Exponent FDh (X10^-3 ==> Milisecond)
+//			 0x75, 0x20,                   //    Report Size 20h (32)
+//			 0x95, 0x01,                   //    Report Count 1
+//			 0x91, 0x02,                   //    Output (Variable)
+//			 0x66, 0x00, 0x00,              //    Unit 0
+//			   0x55,0x00,                   //    Unit Exponent 0
+//			0xC0     ,    // End Collection
+			HIDDESC_FFB_SETCFREP,
+//			0x09,0x73,    //    Usage Set Constant Force Report
 //			0xA1,0x02,    //    Collection Datalink
-//			   0x85,HID_ID_CSTMREP+FFB_ID_OFFSET,         //    Report ID 7
+//			   0x85,HID_ID_CONSTREP+FFB_ID_OFFSET,         //    Report ID 5
 //			   0x09,0x22,         //    Usage Effect Block Index
 //			   0x15,0x01,         //    Logical Minimum 1
 //			   0x25,MAX_EFFECTS,         //    Logical Maximum 28h (40d)
@@ -537,119 +388,19 @@ __ALIGN_BEGIN const uint8_t hid_2ffb_desc[USB_HID_2FFB_REPORT_DESC_SIZE] __ALIGN
 //			   0x75,0x08,         //    Report Size 8
 //			   0x95,0x01,         //    Report Count 1
 //			   0x91,0x02,         //    Output (Variable)
-//			   0x09,0x6C,         //    Usage Custom Force Data Offset
-//			   0x15,0x00,         //    Logical Minimum 0
-//			   0x26,0x10,0x27,    //    Logical Maximum 2710h (10000d)
-//			   0x35,0x00,         //    Physical Minimum 0
-//			   0x46,0x10,0x27,    //    Physical Maximum 2710h (10000d)
-//			   0x75,0x10,         //    Report Size 10h (16d)
+//			   0x09,0x70,         //    Usage Magnitude
+//			   0x16,0x00, 0x80,    //    Logical Minimum 7FFFh (-32767d)
+//			   0x26,0xff, 0x7f,    //    Logical Maximum 7FFFh (32767d)
+//			   0x36,0x00, 0x80,    //    Physical Minimum 7FFFh (-32767d)
+//			   0x46,0xff, 0x7f,    //    Physical Maximum 7FFFh (32767d)
+//			 0x75, 0x10,         //    Report Size 10h (16d)
 //			   0x95,0x01,         //    Report Count 1
 //			   0x91,0x02,         //    Output (Variable)
-//			   0x09,0x69,         //    Usage Custom Force Data
-//			   0x15,0x81,         //    Logical Minimum 81h (-127d)
-//			   0x25,0x7F,         //    Logical Maximum 7Fh (127d)
-//			   0x35,0x00,         //    Physical Minimum 0
-//			   0x46,0xFF,0x00,    //    Physical Maximum FFh (255d)
-//			   0x75,0x08,         //    Report Size 8
-//			   0x95,0x0C,         //    Report Count Ch (12d)
-//			   0x92,0x02,0x01,    //       Output (Variable, Buffered)
 //			0xC0     ,    //    End Collection
-//			0x09,0x66,    //    Usage Download Force Sample
-//			0xA1,0x02,    //    Collection Datalink
-//			   0x85,HID_ID_SMPLREP+FFB_ID_OFFSET,         //    Report ID 8
-//			   0x05,0x01,         //    Usage Page Generic Desktop
-//			   0x09,0x30,         //    Usage X
-//			   0x09,0x31,         //    Usage Y
-//			   0x15,0x81,         //    Logical Minimum 81h (-127d)
-//			   0x25,0x7F,         //    Logical Maximum 7Fh (127d)
-//			   0x35,0x00,         //    Physical Minimum 0
-//			   0x46,0xFF,0x00,    //    Physical Maximum FFh (255d)
-//			   0x75,0x08,         //    Report Size 8
-//			   0x95,0x02,         //    Report Count 2
-//			   0x91,0x02,         //    Output (Variable)
-//			0xC0     ,   //    End Collection
-
-			0x05,0x0F,   //    Usage Page Physical Interface
-			0x09,0x77,   //    Usage Effect Operation Report
-			0xA1,0x02,   //    Collection Datalink
-			   0x85,HID_ID_EFOPREP+FFB_ID_OFFSET,    //    Report ID Ah (10d)
-			   0x09,0x22,    //    Usage Effect Block Index
-			   0x15,0x01,    //    Logical Minimum 1
-			   0x25,MAX_EFFECTS,    //    Logical Maximum 28h (40d)
-			   0x35,0x01,    //    Physical Minimum 1
-			   0x45,MAX_EFFECTS,    //    Physical Maximum 28h (40d)
-			   0x75,0x08,    //    Report Size 8
-			   0x95,0x01,    //    Report Count 1
-			   0x91,0x02,    //    Output (Variable)
-			   0x09,0x78,    //    Usage Effect Operation
-			   0xA1,0x02,    //    Collection Datalink
-			      0x09,0x79,    //    Usage Op Effect Start
-			      0x09,0x7A,    //    Usage Op Effect Start Solo
-			      0x09,0x7B,    //    Usage Op Effect Stop
-			      0x15,0x01,    //    Logical Minimum 1
-			      0x25,0x03,    //    Logical Maximum 3
-			      0x75,0x08,    //    Report Size 8
-			      0x95,0x01,    //    Report Count 1
-			      0x91,0x00,    //    Output
-			   0xC0     ,         //    End Collection
-			   0x09,0x7C,         //    Usage Loop Count
-			   0x15,0x00,         //    Logical Minimum 0
-			   0x26,0xFF,0x00,    //    Logical Maximum FFh (255d)
-			   0x35,0x00,         //    Physical Minimum 0
-			   0x46,0xFF,0x00,    //    Physical Maximum FFh (255d)
-			   0x91,0x02,         //    Output (Variable)
-			0xC0     ,    //    End Collection
-			0x09,0x90,    //    Usage PID Block Free Report
-			0xA1,0x02,    //    Collection Datalink
-			   0x85,HID_ID_BLKFRREP+FFB_ID_OFFSET,    //    Report ID Bh (11d)
-			   0x09,0x22,    //    Usage Effect Block Index
-			   0x15,0x01,    //    Logical Minimum 1
-			   0x25,MAX_EFFECTS,    //    Logical Maximum 28h (40d)
-			   0x35,0x01,    //    Physical Minimum 1
-			   0x45,MAX_EFFECTS,    //    Physical Maximum 28h (40d)
-			   0x75,0x08,    //    Report Size 8
-			   0x95,0x01,    //    Report Count 1
-			   0x91,0x02,    //    Output (Variable)
-			0xC0     ,    //    End Collection
-
-			0x09,0x95,    //    Usage PID Device Control (0x96?)
-			0xA1,0x02,    //    Collection Datalink
-			0x85,HID_ID_CTRLREP+FFB_ID_OFFSET,    //    Report ID Ch (12d)
-			0x09,0x96,    //    Usage PID Device Control (0x96?)
-			0xA1,0x02,    //    Collection Datalink
-
-			   0x09,0x97,    //    Usage DC Enable Actuators
-			   0x09,0x98,    //    Usage DC Disable Actuators
-			   0x09,0x99,    //    Usage DC Stop All Effects
-			   0x09,0x9A,    //    Usage DC Device Reset
-			   0x09,0x9B,    //    Usage DC Device Pause
-			   0x09,0x9C,    //    Usage DC Device Continue
-
-
-
-			   0x15,0x01,    //    Logical Minimum 1
-			   0x25,0x06,    //    Logical Maximum 6
-			   0x75,0x01,    //    Report Size 1
-			   0x95,0x08,    //    Report Count 8
-			   0x91,0x02,    //    Output
-
-			0xC0     ,    //    End Collection
-			0xC0     ,    //    End Collection
-			0x09,0x7D,    //    Usage Device Gain Report
-			0xA1,0x02,    //    Collection Datalink
-			   0x85,HID_ID_GAINREP+FFB_ID_OFFSET,         //    Report ID Dh (13d)
-			   0x09,0x7E,         //    Usage Device Gain
-			   0x15,0x00,         //    Logical Minimum 0
-			   0x26,0xFF,0x00,    //    Logical Maximum FFh (255d)
-			   0x35,0x00,         //    Physical Minimum 0
-			   0x46,0x10,0x27,    //    Physical Maximum 2710h (10000d)
-			   0x75,0x08,         //    Report Size 8
-			   0x95,0x01,         //    Report Count 1
-			   0x91,0x02,         //    Output (Variable)
-			0xC0     ,            //    End Collection
-//			0x09,0x6B,    //    Usage Set Custom Force Report
+			HIDDESC_FFB_SETRAMPREP,
+//			0x09,0x74,    //    Usage Set Ramp Force Report
 //			0xA1,0x02,    //    Collection Datalink
-//			   0x85,HID_ID_SETCREP+FFB_ID_OFFSET,         //    Report ID Eh (14d)
+//			   0x85,HID_ID_RAMPREP+FFB_ID_OFFSET,         //    Report ID 6
 //			   0x09,0x22,         //    Usage Effect Block Index
 //			   0x15,0x01,         //    Logical Minimum 1
 //			   0x25,MAX_EFFECTS,         //    Logical Maximum 28h (40d)
@@ -658,131 +409,442 @@ __ALIGN_BEGIN const uint8_t hid_2ffb_desc[USB_HID_2FFB_REPORT_DESC_SIZE] __ALIGN
 //			   0x75,0x08,         //    Report Size 8
 //			   0x95,0x01,         //    Report Count 1
 //			   0x91,0x02,         //    Output (Variable)
-//			   0x09,0x6D,         //    Usage Sample Count
+//			   0x09,0x75,         //    Usage Ramp Start
+//			   0x09,0x76,         //    Usage Ramp End
+//			   0x16,0x00, 0x80,    //    Logical Minimum 7FFFh (-32767d)
+//			   0x26,0xff, 0x7f,    //    Logical Maximum 7FFFh (32767d)
+//			   0x36,0x00, 0x80,    //    Physical Minimum 7FFFh (-32767d)
+//			   0x46,0xff, 0x7f,    //    Physical Maximum 7FFFh (32767d)
+//			   0x75,0x10,         //    Report Size 16
+//			   0x95,0x02,         //    Report Count 2
+//			   0x91,0x02,         //    Output (Variable)
+//			0xC0     ,    //    End Collection
+//
+//
+////			0x09,0x68,    //    Usage Custom Force Data Report
+////			0xA1,0x02,    //    Collection Datalink
+////			   0x85,HID_ID_CSTMREP+FFB_ID_OFFSET,         //    Report ID 7
+////			   0x09,0x22,         //    Usage Effect Block Index
+////			   0x15,0x01,         //    Logical Minimum 1
+////			   0x25,MAX_EFFECTS,         //    Logical Maximum 28h (40d)
+////			   0x35,0x01,         //    Physical Minimum 1
+////			   0x45,MAX_EFFECTS,         //    Physical Maximum 28h (40d)
+////			   0x75,0x08,         //    Report Size 8
+////			   0x95,0x01,         //    Report Count 1
+////			   0x91,0x02,         //    Output (Variable)
+////			   0x09,0x6C,         //    Usage Custom Force Data Offset
+////			   0x15,0x00,         //    Logical Minimum 0
+////			   0x26,0x10,0x27,    //    Logical Maximum 2710h (10000d)
+////			   0x35,0x00,         //    Physical Minimum 0
+////			   0x46,0x10,0x27,    //    Physical Maximum 2710h (10000d)
+////			   0x75,0x10,         //    Report Size 10h (16d)
+////			   0x95,0x01,         //    Report Count 1
+////			   0x91,0x02,         //    Output (Variable)
+////			   0x09,0x69,         //    Usage Custom Force Data
+////			   0x15,0x81,         //    Logical Minimum 81h (-127d)
+////			   0x25,0x7F,         //    Logical Maximum 7Fh (127d)
+////			   0x35,0x00,         //    Physical Minimum 0
+////			   0x46,0xFF,0x00,    //    Physical Maximum FFh (255d)
+////			   0x75,0x08,         //    Report Size 8
+////			   0x95,0x0C,         //    Report Count Ch (12d)
+////			   0x92,0x02,0x01,    //       Output (Variable, Buffered)
+////			0xC0     ,    //    End Collection
+////			0x09,0x66,    //    Usage Download Force Sample
+////			0xA1,0x02,    //    Collection Datalink
+////			   0x85,HID_ID_SMPLREP+FFB_ID_OFFSET,         //    Report ID 8
+////			   0x05,0x01,         //    Usage Page Generic Desktop
+////			   0x09,0x30,         //    Usage X
+////			   0x09,0x31,         //    Usage Y
+////			   0x15,0x81,         //    Logical Minimum 81h (-127d)
+////			   0x25,0x7F,         //    Logical Maximum 7Fh (127d)
+////			   0x35,0x00,         //    Physical Minimum 0
+////			   0x46,0xFF,0x00,    //    Physical Maximum FFh (255d)
+////			   0x75,0x08,         //    Report Size 8
+////			   0x95,0x02,         //    Report Count 2
+////			   0x91,0x02,         //    Output (Variable)
+////			0xC0     ,   //    End Collection
+			HIDDESC_FFB_EFOPREP,
+//			0x05,0x0F,   //    Usage Page Physical Interface
+//			0x09,0x77,   //    Usage Effect Operation Report
+//			0xA1,0x02,   //    Collection Datalink
+//			   0x85,HID_ID_EFOPREP+FFB_ID_OFFSET,    //    Report ID Ah (10d)
+//			   0x09,0x22,    //    Usage Effect Block Index
+//			   0x15,0x01,    //    Logical Minimum 1
+//			   0x25,MAX_EFFECTS,    //    Logical Maximum 28h (40d)
+//			   0x35,0x01,    //    Physical Minimum 1
+//			   0x45,MAX_EFFECTS,    //    Physical Maximum 28h (40d)
+//			   0x75,0x08,    //    Report Size 8
+//			   0x95,0x01,    //    Report Count 1
+//			   0x91,0x02,    //    Output (Variable)
+//			   0x09,0x78,    //    Usage Effect Operation
+//			   0xA1,0x02,    //    Collection Datalink
+//			      0x09,0x79,    //    Usage Op Effect Start
+//			      0x09,0x7A,    //    Usage Op Effect Start Solo
+//			      0x09,0x7B,    //    Usage Op Effect Stop
+//			      0x15,0x01,    //    Logical Minimum 1
+//			      0x25,0x03,    //    Logical Maximum 3
+//			      0x75,0x08,    //    Report Size 8
+//			      0x95,0x01,    //    Report Count 1
+//			      0x91,0x00,    //    Output
+//			   0xC0     ,         //    End Collection
+//			   0x09,0x7C,         //    Usage Loop Count
 //			   0x15,0x00,         //    Logical Minimum 0
 //			   0x26,0xFF,0x00,    //    Logical Maximum FFh (255d)
 //			   0x35,0x00,         //    Physical Minimum 0
 //			   0x46,0xFF,0x00,    //    Physical Maximum FFh (255d)
-//			   0x75,0x08,         //    Report Size 8
-//			   0x95,0x01,         //    Report Count 1
 //			   0x91,0x02,         //    Output (Variable)
-//			   0x09,0x51,         //    Usage Sample Period
-//			   0x66,0x03,0x10,    //    Unit 1003h (4099d)
-//			   0x55,0xFD,         //    Unit Exponent FDh (253d)
+//			0xC0     ,    //    End Collection
+			HIDDESC_FFB_BLOCKFREEREP,
+//			0x09,0x90,    //    Usage PID Block Free Report
+//			0xA1,0x02,    //    Collection Datalink
+//			   0x85,HID_ID_BLKFRREP+FFB_ID_OFFSET,    //    Report ID Bh (11d)
+//			   0x09,0x22,    //    Usage Effect Block Index
+//			   0x15,0x01,    //    Logical Minimum 1
+//			   0x25,MAX_EFFECTS,    //    Logical Maximum 28h (40d)
+//			   0x35,0x01,    //    Physical Minimum 1
+//			   0x45,MAX_EFFECTS,    //    Physical Maximum 28h (40d)
+//			   0x75,0x08,    //    Report Size 8
+//			   0x95,0x01,    //    Report Count 1
+//			   0x91,0x02,    //    Output (Variable)
+//			0xC0     ,    //    End Collection
+			HIDDESC_FFB_DEVCTRLREP,
+//			0x09,0x95,    //    Usage PID Device Control (0x96?)
+//			0xA1,0x02,    //    Collection Datalink
+//			0x85,HID_ID_CTRLREP+FFB_ID_OFFSET,    //    Report ID Ch (12d)
+//			0x09,0x96,    //    Usage PID Device Control (0x96?)
+//			0xA1,0x02,    //    Collection Datalink
+//
+//			   0x09,0x97,    //    Usage DC Enable Actuators
+//			   0x09,0x98,    //    Usage DC Disable Actuators
+//			   0x09,0x99,    //    Usage DC Stop All Effects
+//			   0x09,0x9A,    //    Usage DC Device Reset
+//			   0x09,0x9B,    //    Usage DC Device Pause
+//			   0x09,0x9C,    //    Usage DC Device Continue
+//
+//
+//
+//			   0x15,0x01,    //    Logical Minimum 1
+//			   0x25,0x06,    //    Logical Maximum 6
+//			   0x75,0x01,    //    Report Size 1
+//			   0x95,0x08,    //    Report Count 8
+//			   0x91,0x02,    //    Output
+//
+//			0xC0     ,    //    End Collection
+//			0xC0     ,    //    End Collection
+//			0x09,0x7D,    //    Usage Device Gain Report
+//			0xA1,0x02,    //    Collection Datalink
+//			   0x85,HID_ID_GAINREP+FFB_ID_OFFSET,         //    Report ID Dh (13d)
+//			   0x09,0x7E,         //    Usage Device Gain
 //			   0x15,0x00,         //    Logical Minimum 0
-//			   0x26,0xFF,0x7F,    //    Logical Maximum 7FFFh (32767d)
+//			   0x26,0xFF,0x00,    //    Logical Maximum FFh (255d)
 //			   0x35,0x00,         //    Physical Minimum 0
-//			   0x46,0xFF,0x7F,    //    Physical Maximum 7FFFh (32767d)
-//			   0x75,0x10,         //    Report Size 10h (16d)
+//			   0x46,0x10,0x27,    //    Physical Maximum 2710h (10000d)
+//			   0x75,0x08,         //    Report Size 8
 //			   0x95,0x01,         //    Report Count 1
 //			   0x91,0x02,         //    Output (Variable)
-//			   0x55,0x00,         //    Unit Exponent 0
-//			   0x66,0x00,0x00,    //    Unit 0
+//			0xC0     ,            //    End Collection
+
+////			0x09,0x6B,    //    Usage Set Custom Force Report
+////			0xA1,0x02,    //    Collection Datalink
+////			   0x85,HID_ID_SETCREP+FFB_ID_OFFSET,         //    Report ID Eh (14d)
+////			   0x09,0x22,         //    Usage Effect Block Index
+////			   0x15,0x01,         //    Logical Minimum 1
+////			   0x25,MAX_EFFECTS,         //    Logical Maximum 28h (40d)
+////			   0x35,0x01,         //    Physical Minimum 1
+////			   0x45,MAX_EFFECTS,         //    Physical Maximum 28h (40d)
+////			   0x75,0x08,         //    Report Size 8
+////			   0x95,0x01,         //    Report Count 1
+////			   0x91,0x02,         //    Output (Variable)
+////			   0x09,0x6D,         //    Usage Sample Count
+////			   0x15,0x00,         //    Logical Minimum 0
+////			   0x26,0xFF,0x00,    //    Logical Maximum FFh (255d)
+////			   0x35,0x00,         //    Physical Minimum 0
+////			   0x46,0xFF,0x00,    //    Physical Maximum FFh (255d)
+////			   0x75,0x08,         //    Report Size 8
+////			   0x95,0x01,         //    Report Count 1
+////			   0x91,0x02,         //    Output (Variable)
+////			   0x09,0x51,         //    Usage Sample Period
+////			   0x66,0x03,0x10,    //    Unit 1003h (4099d)
+////			   0x55,0xFD,         //    Unit Exponent FDh (253d)
+////			   0x15,0x00,         //    Logical Minimum 0
+////			   0x26,0xFF,0x7F,    //    Logical Maximum 7FFFh (32767d)
+////			   0x35,0x00,         //    Physical Minimum 0
+////			   0x46,0xFF,0x7F,    //    Physical Maximum 7FFFh (32767d)
+////			   0x75,0x10,         //    Report Size 10h (16d)
+////			   0x95,0x01,         //    Report Count 1
+////			   0x91,0x02,         //    Output (Variable)
+////			   0x55,0x00,         //    Unit Exponent 0
+////			   0x66,0x00,0x00,    //    Unit 0
+////			0xC0     ,    //    End Collection
+			HIDDESC_FFB_NEWEFREP,
+//			0x09,0xAB,    //    Usage Create New Effect Report
+//			0xA1,0x02,    //    Collection Datalink
+//			   0x85,HID_ID_NEWEFREP+FFB_ID_OFFSET,    //    Report ID 1
+//			   0x09,0x25,    //    Usage Effect Type
+//			   0xA1,0x02,    //    Collection Datalink
+//			 0x09, HID_USAGE_CONST,    //    Usage ET Constant Force
+//			 0x09, HID_USAGE_RAMP,    //    Usage ET Ramp
+//			 0x09, HID_USAGE_SQUR,    //    Usage ET Square
+//			 0x09, HID_USAGE_SINE,    //    Usage ET Sine
+//			 0x09, HID_USAGE_TRNG,    //    Usage ET Triangle
+//			 0x09, HID_USAGE_STUP,    //    Usage ET Sawtooth Up
+//			 0x09, HID_USAGE_STDN,    //    Usage ET Sawtooth Down
+//			 0x09, HID_USAGE_SPRNG,    //    Usage ET Spring
+//			 0x09, HID_USAGE_DMPR,    //    Usage ET Damper
+//			 0x09, HID_USAGE_INRT,    //    Usage ET Inertia
+//			 0x09, HID_USAGE_FRIC,    //    Usage ET Friction
+////			 0x09, 0x28,    //    Usage ET Custom Force Data
+//			   0x25,0x0B,    //    Logical Maximum Ch (11d)
+//			   0x15,0x01,    //    Logical Minimum 1
+//			   0x35,0x01,    //    Physical Minimum 1
+//			   0x45,0x0B,    //    Physical Maximum Ch (11d)
+//			   0x75,0x08,    //    Report Size 8
+//			   0x95,0x01,    //    Report Count 1
+//			   0xB1,0x00,    //    Feature
+//			0xC0     ,    // End Collection
+//			0x05,0x01,         //    Usage Page Generic Desktop
+//			0x09,0x3B,         //    Usage Reserved (Byte count)
+//			0x15,0x00,         //    Logical Minimum 0
+//			0x26,0xFF,0x01,    //    Logical Maximum 1FFh (511d)
+//			0x35,0x00,         //    Physical Minimum 0
+//			0x46,0xFF,0x01,    //    Physical Maximum 1FFh (511d)
+//			0x75,0x0A,         //    Report Size Ah (10d)
+//			0x95,0x01,         //    Report Count 1
+//			0xB1,0x02,         //    Feature (Variable)
+//			0x75,0x06,         //    Report Size 6
+//			0xB1,0x01,         //    Feature (Constant)
 //			0xC0     ,    //    End Collection
-			0x09,0xAB,    //    Usage Create New Effect Report
-			0xA1,0x02,    //    Collection Datalink
-			   0x85,HID_ID_NEWEFREP+FFB_ID_OFFSET,    //    Report ID 1
-			   0x09,0x25,    //    Usage Effect Type
+//			0x05,0x0F,    //    Usage Page Physical Interface
+			HIDDESC_FFB_BLOCKLOADREP,
+//			0x09,0x89,    //    Usage Block Load Report
+//			0xA1,0x02,    //    Collection Datalink
+//			0x85,HID_ID_BLKLDREP+FFB_ID_OFFSET,    //    Report ID 0x12
+//			0x09,0x22,    //    Usage Effect Block Index
+//			0x25,MAX_EFFECTS,    //    Logical Maximum 28h (40d)
+//			0x15,0x01,    //    Logical Minimum 1
+//			0x35,0x01,    //    Physical Minimum 1
+//			0x45,MAX_EFFECTS,    //    Physical Maximum 28h (40d)
+//			0x75,0x08,    //    Report Size 8
+//			0x95,0x01,    //    Report Count 1
+//			0xB1,0x02,    //    Feature (Variable)
+//			0x09,0x8B,    //    Usage Block Load Status
+//			0xA1,0x02,    //    Collection Datalink
+//			   0x09,0x8C,    //    Usage Block Load Success
+//			   0x09,0x8D,    //    Usage Block Load Full
+//			   0x09,0x8E,    //    Usage Block Load Error
+//			   0x15,0x01,    //    Logical Minimum 1
+//			   0x25,0x03,    //    Logical Maximum 3
+//			   0x35,0x01,    //    Physical Minimum 1
+//			   0x45,0x03,    //    Physical Maximum 3
+//			   0x75,0x08,    //    Report Size 8
+//			   0x95,0x01,    //    Report Count 1
+//			   0xB1,0x00,    //    Feature
+//			0xC0     ,                   // End Collection
+//			0x09,0xAC,                   //    Usage Pool available
+//			0x15,0x00,                   //    Logical Minimum 0
+//			0x27,0xFF,0xFF,0x00,0x00,    //    Logical Maximum FFFFh (65535d)
+//			0x35,0x00,                   //    Physical Minimum 0
+//			0x47,0xFF,0xFF,0x00,0x00,    //    Physical Maximum FFFFh (65535d)
+//			0x75,0x10,                   //    Report Size 10h (16d)
+//			0x95,0x01,                   //    Report Count 1
+//			0xB1,0x00,                   //    Feature
+//			0xC0     ,    //    End Collection
+			HIDDESC_FFB_POOLREP,
+//			0x09,0x7F,    //    Usage PID Pool Report
+//			0xA1,0x02,    //    Collection Datalink
+//				0x85,HID_ID_POOLREP+FFB_ID_OFFSET,                   //    Report ID 0x13
+//				0x09,0x80,                   //    Usage RAM Pool size
+//				0x75,0x10,                   //    Report Size 10h (16d)
+//				0x95,0x01,                   //    Report Count 1
+//				0x15,0x00,                   //    Logical Minimum 0
+//				0x35,0x00,                   //    Physical Minimum 0
+//				0x27,0xFF,0xFF,0x00,0x00,    //    Logical Maximum FFFFh (65535d)
+//				0x47,0xFF,0xFF,0x00,0x00,    //    Physical Maximum FFFFh (65535d)
+//				0xB1,0x02,                   //    Feature (Variable)
+//				0x09,0x83,                   //    Usage Simultaneous Effects Max
+//				0x26,0xFF,0x00,              //    Logical Maximum FFh (255d)
+//				0x46,0xFF,0x00,              //    Physical Maximum FFh (255d)
+//				0x75,0x08,                   //    Report Size 8
+//				0x95,0x01,                   //    Report Count 1
+//				0xB1,0x02,                   //    Feature (Variable)
+//				0x09,0xA9,                   //    Usage Device Managed Pool
+//				0x09,0xAA,                   //    Usage Shared Parameter Blocks
+//				0x75,0x01,                   //    Report Size 1
+//				0x95,0x02,                   //    Report Count 2
+//				0x15,0x00,                   //    Logical Minimum 0
+//				0x25,0x01,                   //    Logical Maximum 1
+//				0x35,0x00,                   //    Physical Minimum 0
+//				0x45,0x01,                   //    Physical Maximum 1
+//				0xB1,0x02,                   //    Feature (Variable)
+//				0x75,0x06,                   //    Report Size 6
+//				0x95,0x01,                   //    Report Count 1
+//				0xB1,0x03,                   //    Feature (Constant, Variable)
+//			0xC0, //    End Collection
+
+  0xC0    /*     END_COLLECTION	             */
+};
+#endif
+
+#ifdef AXIS2_FFB_HID_DESC_32B
+__ALIGN_BEGIN const uint8_t hid_2ffb_desc_32b[USB_HID_2FFB_REPORT_DESC_32B_SIZE] __ALIGN_END =
+{
+		0x05, 0x01,                    /* USAGE_PAGE (Generic Desktop)*/
+			0x09, 0x04,                    /* USAGE (Joystick)*/
+			0xa1, 0x01,                    /* COLLECTION (Application)*/
+			HIDDESC_GAMEPAD_32B,
+
+			HIDDESC_CTRL_REPORTS, // HID command report support
+
+			HIDDESC_FFB_STATEREP,
+			/*
+			Output
+			Collection  Datalink:
+			Usage Set Effect Report
+
+			ID:1
+			Effect Block Index:	8bit
+
+			subcollection Effect Type
+			12 effect types, 8bit each
+
+			*/
+			HIDDESC_FFB_SETEFREP,
+
+// Len 108 bytes following
+			   0x09,0x55,       //    Usage Axes Enable TODO multi axis
+			   0xA1,0x02,       //    Collection Datalink
+			      0x05,0x01,    //    Usage Page Generic Desktop
+			      0x09,0x30,    //    Usage X
+			      0x09,0x31,    //    Usage Y
+			      0x15,0x00,    //    Logical Minimum 0
+			      0x25,0x01,    //    Logical Maximum 1
+			      0x75,0x01,    //    Report Size 1
+			      0x95,0x02,    //    Report Count 2
+			      0x91,0x02,    //    Output (Variable)
+			   0xC0     ,    // End Collection
+			   0x05,0x0F,    //    Usage Page Physical Interface
+			   0x09,0x56,    //    Usage Direction Enable
+			   0x95,0x01,    //    Report Count 1
+			   0x91,0x02,    //    Output (Variable)
+			   0x95,0x05,    //    Report Count 5
+			   0x91,0x03,    //    Output (Constant, Variable)
+
+			   0x09,0x57,    //    Usage Direction
 			   0xA1,0x02,    //    Collection Datalink
-			 0x09, HID_USAGE_CONST,    //    Usage ET Constant Force
-			 0x09, HID_USAGE_RAMP,    //    Usage ET Ramp
-			 0x09, HID_USAGE_SQUR,    //    Usage ET Square
-			 0x09, HID_USAGE_SINE,    //    Usage ET Sine
-			 0x09, HID_USAGE_TRNG,    //    Usage ET Triangle
-			 0x09, HID_USAGE_STUP,    //    Usage ET Sawtooth Up
-			 0x09, HID_USAGE_STDN,    //    Usage ET Sawtooth Down
-			 0x09, HID_USAGE_SPRNG,    //    Usage ET Spring
-			 0x09, HID_USAGE_DMPR,    //    Usage ET Damper
-			 0x09, HID_USAGE_INRT,    //    Usage ET Inertia
-			 0x09, HID_USAGE_FRIC,    //    Usage ET Friction
-//			 0x09, 0x28,    //    Usage ET Custom Force Data
-			   0x25,0x0B,    //    Logical Maximum Ch (11d)
+			      0x0B,0x01,0x00,0x0A,0x00,    //    Usage Ordinals: Instance 1
+			      0x0B,0x02,0x00,0x0A,0x00,    //    Usage Ordinals: Instance 2
+			      0x66,0x14,0x00,              //    Unit 14h (20d) Angular position
+			      0x55,0xFE,                   //    Unit Exponent FEh (254d)
+//			      0x15,0x00,                   //    Logical Minimum 0
+//			      0x26,0xFF,0x00,              //    Logical Maximum FFh (255d)
+				  0x15,0x00,                   //    Logical Minimum 0
+				  0x27,0xA0,0x8C,0x00,0x00,    //    Logical Maximum 8CA0h (36000d)
+			      0x35,0x00,                   //    Physical Minimum 0
+			      0x47,0xA0,0x8C,0x00,0x00,    //    Physical Maximum 8CA0h (36000d)
+			      0x66,0x00,0x00,              //    Unit 0
+			      0x75,0x10,                   //    Report Size 16
+//				  0x95,0x01,                   //    Report Count 1
+			      0x95,0x02,                   //    Report Count 2
+			      0x91,0x02,                   //    Output (Variable)
+			      0x55,0x00,                   //    Unit Exponent 0
+			      0x66,0x00,0x00,              //    Unit 0
+			   0xC0,                           //    End Collection
+
+			   0x05, 0x0F,        //     USAGE_PAGE (Physical Interface)
+			   0x09, 0x58,        //     USAGE (Type Specific Block Offset)
+			   0xA1, 0x02,        //     COLLECTION (Logical)
+			      0x0B, 0x01, 0x00, 0x0A, 0x00, //USAGE (Ordinals:Instance 1
+			      0x0B, 0x02, 0x00, 0x0A, 0x00, //USAGE (Ordinals:Instance 2)
+			      0x26, 0xFD, 0x7F, //   LOGICAL_MAXIMUM (32765) ; 32K RAM or ROM max.
+			      0x75, 0x10,     //     REPORT_SIZE (16)
+			      0x95, 0x02,     //     REPORT_COUNT (2)
+			      0x91, 0x02,     //     OUTPUT (Data,Var,Abs)
+			   0xC0,              //     END_COLLECTION
+			0xC0,                 //     END_COLLECTION
+
+			HIDDESC_FFB_SETENVREP,
+
+//			HIDDESC_FFB_SETCONDREP,
+
+			// Condition report depends on ffb axis count
+			// 125 bytes following
+			0x09,0x5F,    //    Usage Set Condition Report
+			0xA1,0x02,    //    Collection Datalink
+			   0x85,HID_ID_CONDREP+FFB_ID_OFFSET,    //    Report ID 3
+			   0x09,0x22,    //    Usage Effect Block Index
 			   0x15,0x01,    //    Logical Minimum 1
+			   0x25,MAX_EFFECTS,    //    Logical Maximum 28h (40d)
 			   0x35,0x01,    //    Physical Minimum 1
-			   0x45,0x0B,    //    Physical Maximum Ch (11d)
+			   0x45,MAX_EFFECTS,    //    Physical Maximum 28h (40d)
 			   0x75,0x08,    //    Report Size 8
 			   0x95,0x01,    //    Report Count 1
-			   0xB1,0x00,    //    Feature
-			0xC0     ,    // End Collection
-			0x05,0x01,         //    Usage Page Generic Desktop
-			0x09,0x3B,         //    Usage Reserved (Byte count)
-			0x15,0x00,         //    Logical Minimum 0
-			0x26,0xFF,0x01,    //    Logical Maximum 1FFh (511d)
-			0x35,0x00,         //    Physical Minimum 0
-			0x46,0xFF,0x01,    //    Physical Maximum 1FFh (511d)
-			0x75,0x0A,         //    Report Size Ah (10d)
-			0x95,0x01,         //    Report Count 1
-			0xB1,0x02,         //    Feature (Variable)
-			0x75,0x06,         //    Report Size 6
-			0xB1,0x01,         //    Feature (Constant)
-			0xC0     ,    //    End Collection
-			0x05,0x0F,    //    Usage Page Physical Interface
-			0x09,0x89,    //    Usage Block Load Report
-			0xA1,0x02,    //    Collection Datalink
-			0x85,HID_ID_BLKLDREP+FFB_ID_OFFSET,    //    Report ID 0x12
-			0x09,0x22,    //    Usage Effect Block Index
-			0x25,MAX_EFFECTS,    //    Logical Maximum 28h (40d)
-			0x15,0x01,    //    Logical Minimum 1
-			0x35,0x01,    //    Physical Minimum 1
-			0x45,MAX_EFFECTS,    //    Physical Maximum 28h (40d)
-			0x75,0x08,    //    Report Size 8
-			0x95,0x01,    //    Report Count 1
-			0xB1,0x02,    //    Feature (Variable)
-			0x09,0x8B,    //    Usage Block Load Status
-			0xA1,0x02,    //    Collection Datalink
-			   0x09,0x8C,    //    Usage Block Load Success
-			   0x09,0x8D,    //    Usage Block Load Full
-			   0x09,0x8E,    //    Usage Block Load Error
-			   0x15,0x01,    //    Logical Minimum 1
+			   0x91,0x02,    //    Output (Variable)
+			   0x09,0x23,    //    Usage Parameter Block Offset
+			   0x15,0x00,    //    Logical Minimum 0
 			   0x25,0x03,    //    Logical Maximum 3
-			   0x35,0x01,    //    Physical Minimum 1
+			   0x35,0x00,    //    Physical Minimum 0
 			   0x45,0x03,    //    Physical Maximum 3
-			   0x75,0x08,    //    Report Size 8
+			   0x75,0x04,    //    Report Size 4
 			   0x95,0x01,    //    Report Count 1
-			   0xB1,0x00,    //    Feature
-			0xC0     ,                   // End Collection
-			0x09,0xAC,                   //    Usage Pool available
-			0x15,0x00,                   //    Logical Minimum 0
-			0x27,0xFF,0xFF,0x00,0x00,    //    Logical Maximum FFFFh (65535d)
-			0x35,0x00,                   //    Physical Minimum 0
-			0x47,0xFF,0xFF,0x00,0x00,    //    Physical Maximum FFFFh (65535d)
-			0x75,0x10,                   //    Report Size 10h (16d)
-			0x95,0x01,                   //    Report Count 1
-			0xB1,0x00,                   //    Feature
+			   0x91,0x02,    //    Output (Variable)
+			   0x09,0x58,    //    Usage Type Specific Block Off...
+			   0xA1,0x02,    //    Collection Datalink
+			      0x0B,0x01,0x00,0x0A,0x00,    //    Usage Ordinals: Instance 1
+			      0x0B,0x02,0x00,0x0A,0x00,    //    Usage Ordinals: Instance 2
+			      0x75,0x02,                   //    Report Size 2
+			      0x95,0x02,                   //    Report Count 2
+			      0x91,0x02,                   //    Output (Variable)
+			   0xC0     ,         //    End Collection
+			   0x16,0x00, 0x80,    //    Logical Minimum 7FFFh (-32767d)
+			   0x26,0xff, 0x7f,    //    Logical Maximum 7FFFh (32767d)
+			   0x36,0x00, 0x80,    //    Physical Minimum 7FFFh (-32767d)
+			   0x46,0xff, 0x7f,    //    Physical Maximum 7FFFh (32767d)
+
+			   0x09,0x60,         //    Usage CP Offset
+			   0x75,0x10,         //    Report Size 16
+			   0x95,0x01,         //    Report Count 1
+			   0x91,0x02,         //    Output (Variable)
+			   0x36,0x00, 0x80,    //    Physical Minimum  (-32768)
+			   0x46,0xff, 0x7f,    //    Physical Maximum  (32767)
+			   0x09,0x61,         //    Usage Positive Coefficient
+			   0x09,0x62,         //    Usage Negative Coefficient
+			   0x95,0x02,         //    Report Count 2
+			   0x91,0x02,         //    Output (Variable)
+			 0x16,0x00,0x00,    //    Logical Minimum 0
+			 0x26,0xff, 0x7f,	  //    Logical Maximum  (32767)
+			 0x36,0x00,0x00,    //    Physical Minimum 0
+			   0x46,0xff, 0x7f,    //    Physical Maximum  (32767)
+			   0x09,0x63,         //    Usage Positive Saturation
+			   0x09,0x64,         //    Usage Negative Saturation
+			   0x75,0x10,         //    Report Size 16
+			   0x95,0x02,         //    Report Count 2
+			   0x91,0x02,         //    Output (Variable)
+			   0x09,0x65,         //    Usage Dead Band
+			   0x46,0xff, 0x7f,    //    Physical Maximum (32767)
+			   0x95,0x01,         //    Report Count 1
+			   0x91,0x02,         //    Output (Variable)
 			0xC0     ,    //    End Collection
 
-			0x09,0x7F,    //    Usage PID Pool Report
-			0xA1,0x02,    //    Collection Datalink
-				0x85,HID_ID_POOLREP+FFB_ID_OFFSET,                   //    Report ID 0x13
-				0x09,0x80,                   //    Usage RAM Pool size
-				0x75,0x10,                   //    Report Size 10h (16d)
-				0x95,0x01,                   //    Report Count 1
-				0x15,0x00,                   //    Logical Minimum 0
-				0x35,0x00,                   //    Physical Minimum 0
-				0x27,0xFF,0xFF,0x00,0x00,    //    Logical Maximum FFFFh (65535d)
-				0x47,0xFF,0xFF,0x00,0x00,    //    Physical Maximum FFFFh (65535d)
-				0xB1,0x02,                   //    Feature (Variable)
-				0x09,0x83,                   //    Usage Simultaneous Effects Max
-				0x26,0xFF,0x00,              //    Logical Maximum FFh (255d)
-				0x46,0xFF,0x00,              //    Physical Maximum FFh (255d)
-				0x75,0x08,                   //    Report Size 8
-				0x95,0x01,                   //    Report Count 1
-				0xB1,0x02,                   //    Feature (Variable)
-				0x09,0xA9,                   //    Usage Device Managed Pool
-				0x09,0xAA,                   //    Usage Shared Parameter Blocks
-				0x75,0x01,                   //    Report Size 1
-				0x95,0x02,                   //    Report Count 2
-				0x15,0x00,                   //    Logical Minimum 0
-				0x25,0x01,                   //    Logical Maximum 1
-				0x35,0x00,                   //    Physical Minimum 0
-				0x45,0x01,                   //    Physical Maximum 1
-				0xB1,0x02,                   //    Feature (Variable)
-				0x75,0x06,                   //    Report Size 6
-				0x95,0x01,                   //    Report Count 1
-				0xB1,0x03,                   //    Feature (Constant, Variable)
-			0xC0, //    End Collection
+			HIDDESC_FFB_SETPERIODICREP,
+
+			HIDDESC_FFB_SETCFREP,
+
+			HIDDESC_FFB_SETRAMPREP,
+
+			HIDDESC_FFB_EFOPREP,
+
+			HIDDESC_FFB_BLOCKFREEREP,
+
+			HIDDESC_FFB_DEVCTRLREP,
+
+			HIDDESC_FFB_NEWEFREP,
+
+			HIDDESC_FFB_BLOCKLOADREP,
+
+			HIDDESC_FFB_POOLREP,
 
   0xC0    /*     END_COLLECTION	             */
 };
-
 #endif
+
+
diff --git a/Firmware/FFBoard/UserExtensions/Src/usb_hid_gamepad.c b/Firmware/FFBoard/UserExtensions/Src/usb_hid_gamepad.c
index 474fd7bc5..bc56f3781 100644
--- a/Firmware/FFBoard/UserExtensions/Src/usb_hid_gamepad.c
+++ b/Firmware/FFBoard/UserExtensions/Src/usb_hid_gamepad.c
@@ -16,111 +16,31 @@
  */
 __ALIGN_BEGIN const uint8_t hid_gamepad_desc[USB_HID_GAMEPAD_REPORT_DESC_SIZE] __ALIGN_END =
 {
-		   0x05, 0x01,                    // USAGE_PAGE (Generic Desktop)
-		    0x09, 0x04,                    // USAGE (Joystick)
-		    0xa1, 0x01,                    // COLLECTION (Application)
-		    0xa1, 0x00,                    //   COLLECTION (Physical)
-		    0x85, 0x01,                    //     REPORT_ID (1)
-		    0x05, 0x09,                    //     USAGE_PAGE (Button)
-		    0x19, 0x01,                    //     USAGE_MINIMUM (Button 1)
-		    0x29, 0x40,                    //     USAGE_MAXIMUM (Button 64)
-		    0x15, 0x00,                    //     LOGICAL_MINIMUM (0)
-		    0x25, 0x01,                    //     LOGICAL_MAXIMUM (1)
-		    0x95, 0x40,                    //     REPORT_COUNT (64)
-		    0x75, 0x01,                    //     REPORT_SIZE (1)
-		    0x81, 0x02,                    //     INPUT (Data,Var,Abs)
-		    0x05, 0x01,                    //     USAGE_PAGE (Generic Desktop)
-		    0x09, HID_USAGE_X,             //     USAGE (X)
-		    0x09, HID_USAGE_Y,             //     USAGE (Y)
-		    0x09, HID_USAGE_Z,             //     USAGE (Z)
-		    0x09, HID_USAGE_RX,            //     USAGE (Rx)
-		    0x09, HID_USAGE_RY,            //     USAGE (Ry)
-			0x09, HID_USAGE_RZ,            //     USAGE (Rz)
-			0x09, HID_USAGE_SL1,           //     USAGE (Dial)
-			0x09, HID_USAGE_SL0,           //     USAGE (Slider)
-		    0x16, 0x01, 0x80,              //     LOGICAL_MINIMUM (-32767)
-		    0x26, 0xff, 0x7f,              //     LOGICAL_MAXIMUM (32767)
-		    0x75, 0x10,                    //     REPORT_SIZE (16)
-		    0x95, 0x08,                    //     REPORT_COUNT (8)
-		    0x81, 0x02,                    //     INPUT (Data,Var,Abs)
-		    0xc0,                          //   END_COLLECTION
+		0x05, 0x01,                    /* USAGE_PAGE (Generic Desktop)*/
+			0x09, 0x04,                    /* USAGE (Joystick)*/
+			0xa1, 0x01,                    /* COLLECTION (Application)*/
+		HIDDESC_GAMEPAD_16B,
 
+		HIDDESC_CTRL_REPORTS, // HID command report support
 
-			// Control reports
-			0x06, 0x00, 0xFF,                    // USAGE_PAGE (Vendor)
-			0x09, 0x00,                    //   USAGE (Vendor)
-			0xA1, 0x01, // Collection (Application)
-
-				0x85,HID_ID_HIDCMD, //    Report ID
-				0x09, 0x01,                    //   USAGE (Vendor)
-				0x15, 0x00,                    //   LOGICAL_MINIMUM (0)
-				0x26, 0x04,	0x00,			   //   Logical Maximum 4
-				0x75, 0x08,                    //   REPORT_SIZE (8)
-				0x95, 0x01,                    //   REPORT_COUNT (1)
-				0x91, 0x02,                    //   OUTPUT (Data,Var,Abs)
-
-				0x09, 0x02,                    //   USAGE (Vendor) class address
-				0x75, 0x10,                    //   REPORT_SIZE (16)
-				0x95, 0x01,                    //   REPORT_COUNT (1)
-				0x91, 0x02,                    //   OUTPUT (Data,Var,Abs)
-
-				0x09, 0x03,                    //   USAGE (Vendor) class instance
-				0x75, 0x08,                    //   REPORT_SIZE (8)
-				0x95, 0x01,                    //   REPORT_COUNT (1)
-				0x91, 0x02,                    //   OUTPUT (Data,Var,Abs)
-
-				0x09, 0x04,                    //   USAGE (Vendor) cmd
-				0x75, 0x20,                    //   REPORT_SIZE (32)
-				0x95, 0x01,                    //   REPORT_COUNT (1)
-				0x91, 0x02,                    //   OUTPUT (Data,Var,Abs)
-
-				0x09, 0x05,                    //   USAGE (Vendor)
-				0x75, 0x40,                    //   REPORT_SIZE (64) value
-				0x95, 0x01,                    //   REPORT_COUNT (1)
-				0x91, 0x02,                    //   OUTPUT (Data,Var,Abs)
-
-				0x09, 0x06,                    //   USAGE (Vendor) address
-				0x75, 0x40,                    //   REPORT_SIZE (64)
-				0x95, 0x01,                    //   REPORT_COUNT (1)
-				0x91, 0x02,                    //   OUTPUT (Data,Var,Abs)
-
-				0x85,HID_ID_HIDCMD, //    Report ID
-				0x09, 0x01,                    //   USAGE (Vendor)
-				0x15, 0x00,                    //   LOGICAL_MINIMUM (0)
-				0x26, 0x04,	0x00,			   //   Logical Maximum 4
-				0x75, 0x08,                    //   REPORT_SIZE (8)
-				0x95, 0x01,                    //   REPORT_COUNT (1)
-				0x81, 0x02,                    //   INPUT (Data,Var,Abs)
-
-				0x09, 0x02,                    //   USAGE (Vendor) class address
-				0x75, 0x10,                    //   REPORT_SIZE (16)
-				0x95, 0x01,                    //   REPORT_COUNT (1)
-				0x81, 0x02,                    //   INPUT (Data,Var,Abs)
-
-				0x09, 0x03,                    //   USAGE (Vendor) class instance
-				0x75, 0x08,                    //   REPORT_SIZE (8)
-				0x95, 0x01,                    //   REPORT_COUNT (1)
-				0x81, 0x02,                    //   INPUT (Data,Var,Abs)
-
-				0x09, 0x04,                    //   USAGE (Vendor) cmd
-				0x75, 0x20,                    //   REPORT_SIZE (32)
-				0x95, 0x01,                    //   REPORT_COUNT (1)
-				0x81, 0x02,                    //   INPUT (Data,Var,Abs)
-
-				0x09, 0x05,                    //   USAGE (Vendor)
-				0x75, 0x40,                    //   REPORT_SIZE (64) value
-				0x95, 0x01,                    //   REPORT_COUNT (1)
-				0x81, 0x02,                    //   INPUT (Data,Var,Abs)
-
-				0x09, 0x06,                    //   USAGE (Vendor) address
-				0x75, 0x40,                    //   REPORT_SIZE (64)
-				0x95, 0x01,                    //   REPORT_COUNT (1)
-				0x81, 0x02,                    //   INPUT (Data,Var,Abs)
+  0xC0    /*     END_COLLECTION	             */
+};
 
+#endif
 
+#ifdef FFB_HID_DESC_GAMEPAD_32B
 
-		  0xc0,                          //   END_COLLECTION
+/**
+ * USB HID descriptor containing a gamepad definition and the vendor defined reports but no PID FFB
+ */
+__ALIGN_BEGIN const uint8_t hid_gamepad_desc_32b[USB_HID_GAMEPAD_REPORT_DESC_32B_SIZE] __ALIGN_END =
+{
+		0x05, 0x01,                    /* USAGE_PAGE (Generic Desktop)*/
+			0x09, 0x04,                    /* USAGE (Joystick)*/
+			0xa1, 0x01,                    /* COLLECTION (Application)*/
+		HIDDESC_GAMEPAD_32B,
 
+		HIDDESC_CTRL_REPORTS, // HID command report support
 
   0xC0    /*     END_COLLECTION	             */
 };
diff --git a/Firmware/Makefile b/Firmware/Makefile
index 4c50b75b1..b5e4fb33c 100644
--- a/Firmware/Makefile
+++ b/Firmware/Makefile
@@ -26,7 +26,7 @@ BUILD_DIR = build
 ######################################
 
 # Choose your board mcu F407VG or F411RE
-MCU_TARGET=F407VG
+MCU_TARGET ?= F407VG
 # The directory of mcu target
 TARGET_DIR = Targets/$(MCU_TARGET)
 
@@ -36,7 +36,7 @@ TARGET_DIR = Targets/$(MCU_TARGET)
 TARGET = OpenFFBoard_$(MCU_TARGET)
 
 # Output directory for hex/bin files
-OUTPUT_DIR = $(BUILD_DIR)
+OUTPUT_DIR ?= $(BUILD_DIR)
 
 # C sources
 C_SOURCES = $(wildcard $(TARGET_DIR)/Core/Src/*.c)
@@ -229,15 +229,15 @@ $(BUILD_DIR)/$(TARGET).elf: $(OBJECTS) Makefile
 
 $(OUTPUT_DIR)/%.hex: $(BUILD_DIR)/%.elf | $(OUTPUT_DIR)
 	$(HEX) $< $@
-	
+
 $(OUTPUT_DIR)/%.bin: $(BUILD_DIR)/%.elf | $(OUTPUT_DIR)
-	$(BIN) $< $@	
-	
+	$(BIN) $< $@
+
 $(BUILD_DIR):
-	-mkdir $@	
-	
+	-mkdir -p $@
+
 $(OUTPUT_DIR): $(BUILD_DIR)
-	-mkdir $@
+	-mkdir -p $@
 
 #######################################
 # clean up
@@ -256,4 +256,4 @@ upload: $(BUILD_DIR)/$(TARGET).bin
 #######################################
 -include $(wildcard $(BUILD_DIR)/*.d)
 
-# *** EOF ***
\ No newline at end of file
+# *** EOF ***
diff --git a/Firmware/Targets/F407VG/.cproject b/Firmware/Targets/F407VG/.cproject
index f645a46aa..792292535 100644
--- a/Firmware/Targets/F407VG/.cproject
+++ b/Firmware/Targets/F407VG/.cproject
@@ -25,11 +25,11 @@
 							<option id="com.st.stm32cube.ide.mcu.gnu.managedbuild.option.fpu.707765906" name="Floating-point unit" superClass="com.st.stm32cube.ide.mcu.gnu.managedbuild.option.fpu" useByScannerDiscovery="false" value="com.st.stm32cube.ide.mcu.gnu.managedbuild.option.fpu.value.fpv4-sp-d16" valueType="enumerated"/>
 							<option id="com.st.stm32cube.ide.mcu.gnu.managedbuild.option.floatabi.1812098537" name="Floating-point ABI" superClass="com.st.stm32cube.ide.mcu.gnu.managedbuild.option.floatabi" useByScannerDiscovery="false" value="com.st.stm32cube.ide.mcu.gnu.managedbuild.option.floatabi.value.hard" valueType="enumerated"/>
 							<option id="com.st.stm32cube.ide.mcu.gnu.managedbuild.option.target_board.1543989768" name="Board" superClass="com.st.stm32cube.ide.mcu.gnu.managedbuild.option.target_board" useByScannerDiscovery="false" value="genericBoard" valueType="string"/>
-							<option id="com.st.stm32cube.ide.mcu.gnu.managedbuild.option.defaults.1721792342" name="Defaults" superClass="com.st.stm32cube.ide.mcu.gnu.managedbuild.option.defaults" useByScannerDiscovery="false" value="com.st.stm32cube.ide.common.services.build.inputs.revA.1.0.6 || Debug || true || Executable || com.st.stm32cube.ide.mcu.gnu.managedbuild.toolchain.base.gnu-tools-for-stm32 || STM32F407VGTx || 0 || 0 || arm-none-eabi- || ${gnu_tools_for_stm32_compiler_path} || ../Middlewares/Third_Party/FreeRTOS/Source/include | ../Middlewares/Third_Party/FreeRTOS/Source/portable/GCC/ARM_CM4F | ../Drivers/CMSIS/Include | ../Core/Inc | ../Drivers/STM32F4xx_HAL_Driver/Inc | ../Drivers/CMSIS/Device/ST/STM32F4xx/Include | ../Middlewares/Third_Party/FreeRTOS/Source/CMSIS_RTOS_V2 | ../Drivers/STM32F4xx_HAL_Driver/Inc/Legacy | ../Core/ThreadSafe ||  ||  || STM32_THREAD_SAFE_STRATEGY=4 | USE_HAL_DRIVER | STM32F407xx ||  || Core/ThreadSafe | Drivers | Core/Startup | Middlewares | Core ||  ||  || ${workspace_loc:/${ProjName}/STM32F407VGTX_FLASH.ld} || true || NonSecure ||  || secure_nsclib.o ||  || FreeRTOS_AllowLockFromIRQ ||  ||  || " valueType="string"/>
+							<option id="com.st.stm32cube.ide.mcu.gnu.managedbuild.option.defaults.1721792342" name="Defaults" superClass="com.st.stm32cube.ide.mcu.gnu.managedbuild.option.defaults" useByScannerDiscovery="false" value="com.st.stm32cube.ide.common.services.build.inputs.revA.1.0.6 || Debug || true || Executable || com.st.stm32cube.ide.mcu.gnu.managedbuild.toolchain.base.gnu-tools-for-stm32 || STM32F407VGTx || 0 || 0 || arm-none-eabi- || ${gnu_tools_for_stm32_compiler_path} || ../Middlewares/Third_Party/FreeRTOS/Source/include | ../Middlewares/Third_Party/FreeRTOS/Source/portable/GCC/ARM_CM4F | ../Drivers/CMSIS/Include | ../Core/Inc | ../Drivers/STM32F4xx_HAL_Driver/Inc | ../Drivers/CMSIS/Device/ST/STM32F4xx/Include | ../Middlewares/Third_Party/FreeRTOS/Source/CMSIS_RTOS_V2 | ../Drivers/STM32F4xx_HAL_Driver/Inc/Legacy | ../Core/ThreadSafe | ../Middlewares/ST/ARM/DSP/Inc || ../Core/Inc | ../Drivers/STM32F4xx_HAL_Driver/Inc | ../Drivers/STM32F4xx_HAL_Driver/Inc/Legacy | ../Middlewares/Third_Party/FreeRTOS/Source/include | ../Middlewares/Third_Party/FreeRTOS/Source/CMSIS_RTOS_V2 | ../Middlewares/Third_Party/FreeRTOS/Source/portable/GCC/ARM_CM4F | ../Drivers/CMSIS/Device/ST/STM32F4xx/Include | ../Drivers/CMSIS/Include | ../Middlewares/ST/ARM/DSP/Inc ||  || STM32_THREAD_SAFE_STRATEGY=4 | USE_HAL_DRIVER | STM32F407xx ||  || Core/ThreadSafe | Drivers | Core/Startup | Middlewares | Core ||  || ../Middlewares/ST/ARM/DSP/Lib/libarm_cortexM4lf_math.a || ${workspace_loc:/${ProjName}/STM32F407VGTX_FLASH.ld} || true || NonSecure ||  || secure_nsclib.o ||  || FreeRTOS_AllowLockFromIRQ ||  ||  || " valueType="string"/>
 							<option id="com.st.stm32cube.ide.mcu.gnu.managedbuild.option.nanoprintffloat.396811763" name="Use float with printf from newlib-nano (-u _printf_float)" superClass="com.st.stm32cube.ide.mcu.gnu.managedbuild.option.nanoprintffloat" useByScannerDiscovery="false" value="true" valueType="boolean"/>
 							<option id="com.st.stm32cube.ide.mcu.gnu.managedbuild.option.converthex.678535481" name="Convert to Intel Hex file (-O ihex)" superClass="com.st.stm32cube.ide.mcu.gnu.managedbuild.option.converthex" useByScannerDiscovery="false" value="true" valueType="boolean"/>
 							<option id="com.st.stm32cube.ide.mcu.gnu.managedbuild.option.runtimelibrary_cpp.1430587733" name="Runtime library" superClass="com.st.stm32cube.ide.mcu.gnu.managedbuild.option.runtimelibrary_cpp" useByScannerDiscovery="true" value="com.st.stm32cube.ide.mcu.gnu.managedbuild.option.runtimelibrary_cpp.value.standard_c_nano_cpp" valueType="enumerated"/>
-							<option id="com.st.stm32cube.ide.mcu.debug.option.cpuclock.1577055487" superClass="com.st.stm32cube.ide.mcu.debug.option.cpuclock" useByScannerDiscovery="false" value="168" valueType="string"/>
+							<option id="com.st.stm32cube.ide.mcu.debug.option.cpuclock.1577055487" name="Cpu clock frequence" superClass="com.st.stm32cube.ide.mcu.debug.option.cpuclock" useByScannerDiscovery="false" value="168" valueType="string"/>
 							<targetPlatform archList="all" binaryParser="org.eclipse.cdt.core.ELF" id="com.st.stm32cube.ide.mcu.gnu.managedbuild.targetplatform.1473732877" isAbstract="false" osList="all" superClass="com.st.stm32cube.ide.mcu.gnu.managedbuild.targetplatform"/>
 							<builder buildPath="${workspace_loc:/F407VG}/Debug" id="com.st.stm32cube.ide.mcu.gnu.managedbuild.builder.757539434" keepEnvironmentInBuildfile="false" managedBuildOn="true" name="Gnu Make Builder" parallelBuildOn="true" parallelizationNumber="optimal" superClass="com.st.stm32cube.ide.mcu.gnu.managedbuild.builder"/>
 							<tool id="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.assembler.654005408" name="MCU GCC Assembler" superClass="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.assembler">
@@ -37,6 +37,17 @@
 								<option IS_BUILTIN_EMPTY="false" IS_VALUE_EMPTY="false" id="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.assembler.option.definedsymbols.101926958" name="Define symbols (-D)" superClass="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.assembler.option.definedsymbols" useByScannerDiscovery="false" valueType="definedSymbols">
 									<listOptionValue builtIn="false" value="DEBUG"/>
 								</option>
+								<option IS_BUILTIN_EMPTY="false" IS_VALUE_EMPTY="false" id="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.assembler.option.includepaths.1289904115" superClass="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.assembler.option.includepaths" valueType="includePath">
+									<listOptionValue builtIn="false" value="../Core/Inc"/>
+									<listOptionValue builtIn="false" value="../Drivers/STM32F4xx_HAL_Driver/Inc"/>
+									<listOptionValue builtIn="false" value="../Drivers/STM32F4xx_HAL_Driver/Inc/Legacy"/>
+									<listOptionValue builtIn="false" value="../Middlewares/Third_Party/FreeRTOS/Source/include"/>
+									<listOptionValue builtIn="false" value="../Middlewares/Third_Party/FreeRTOS/Source/CMSIS_RTOS_V2"/>
+									<listOptionValue builtIn="false" value="../Middlewares/Third_Party/FreeRTOS/Source/portable/GCC/ARM_CM4F"/>
+									<listOptionValue builtIn="false" value="../Drivers/CMSIS/Device/ST/STM32F4xx/Include"/>
+									<listOptionValue builtIn="false" value="../Drivers/CMSIS/Include"/>
+									<listOptionValue builtIn="false" value="../Middlewares/ST/ARM/DSP/Inc"/>
+								</option>
 								<inputType id="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.assembler.input.672887261" superClass="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.assembler.input"/>
 							</tool>
 							<tool id="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.c.compiler.1195385770" name="MCU GCC Compiler" superClass="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.c.compiler">
@@ -69,6 +80,7 @@
 									<listOptionValue builtIn="false" value="../../../FFBoard/USB/device"/>
 									<listOptionValue builtIn="false" value="../../../FFBoard/USB/osal"/>
 									<listOptionValue builtIn="false" value="../Core/ThreadSafe"/>
+									<listOptionValue builtIn="false" value="../Middlewares/ST/ARM/DSP/Inc"/>
 								</option>
 								<inputType id="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.c.compiler.input.c.1234902516" superClass="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.c.compiler.input.c"/>
 							</tool>
@@ -96,6 +108,7 @@
 									<listOptionValue builtIn="false" value="../../../FFBoard/USB/class/midi"/>
 									<listOptionValue builtIn="false" value="../../../FFBoard/USB/class/audio"/>
 									<listOptionValue builtIn="false" value="../Core/ThreadSafe"/>
+									<listOptionValue builtIn="false" value="../Middlewares/ST/ARM/DSP/Inc"/>
 								</option>
 								<option IS_BUILTIN_EMPTY="false" IS_VALUE_EMPTY="false" id="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.cpp.compiler.option.definedsymbols.36088191" name="Define symbols (-D)" superClass="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.cpp.compiler.option.definedsymbols" useByScannerDiscovery="false" valueType="definedSymbols">
 									<listOptionValue builtIn="false" value="USE_HAL_DRIVER"/>
@@ -110,6 +123,12 @@
 							</tool>
 							<tool id="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.c.linker.1483418087" name="MCU GCC Linker" superClass="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.c.linker">
 								<option id="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.c.linker.option.script.510702054" name="Linker Script (-T)" superClass="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.c.linker.option.script" value="${workspace_loc:/${ProjName}/STM32F407VGTX_FLASH.ld}" valueType="string"/>
+								<option IS_BUILTIN_EMPTY="false" IS_VALUE_EMPTY="false" id="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.c.linker.option.directories.1626202026" superClass="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.c.linker.option.directories" valueType="libPaths">
+									<listOptionValue builtIn="false" value="../Middlewares/ST/ARM/DSP/Lib"/>
+								</option>
+								<option IS_BUILTIN_EMPTY="false" IS_VALUE_EMPTY="false" id="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.c.linker.option.libraries.483798684" superClass="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.c.linker.option.libraries" valueType="libs">
+									<listOptionValue builtIn="false" value=":libarm_cortexM4lf_math.a"/>
+								</option>
 								<inputType id="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.c.linker.input.1194172900" superClass="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.c.linker.input">
 									<additionalInput kind="additionalinputdependency" paths="$(USER_OBJS)"/>
 									<additionalInput kind="additionalinput" paths="$(LIBS)"/>
@@ -120,6 +139,12 @@
 								<option id="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.cpp.linker.option.systemcalls.526908104" name="System calls" superClass="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.cpp.linker.option.systemcalls" useByScannerDiscovery="false" value="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.cpp.linker.option.systemcalls.value.minimalimplementation" valueType="enumerated"/>
 								<option id="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.cpp.linker.option.gcsections.974981920" name="Discard unused sections (-Wl,--gc-sections)" superClass="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.cpp.linker.option.gcsections" useByScannerDiscovery="false" value="true" valueType="boolean"/>
 								<option id="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.cpp.linker.option.cref.1072959917" name="Add symbol cross reference table to map file (-Wl,--cref)" superClass="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.cpp.linker.option.cref" useByScannerDiscovery="false" value="true" valueType="boolean"/>
+								<option IS_BUILTIN_EMPTY="false" IS_VALUE_EMPTY="false" id="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.cpp.linker.option.libraries.966972385" name="Libraries (-l)" superClass="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.cpp.linker.option.libraries" valueType="libs">
+									<listOptionValue builtIn="false" value=":libarm_cortexM4lf_math.a"/>
+								</option>
+								<option IS_BUILTIN_EMPTY="false" IS_VALUE_EMPTY="false" id="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.cpp.linker.option.directories.728597271" name="Library search path (-L)" superClass="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.cpp.linker.option.directories" valueType="libPaths">
+									<listOptionValue builtIn="false" value="../Middlewares/ST/ARM/DSP/Lib"/>
+								</option>
 								<inputType id="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.cpp.linker.input.1351043086" superClass="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.cpp.linker.input">
 									<additionalInput kind="additionalinputdependency" paths="$(USER_OBJS)"/>
 									<additionalInput kind="additionalinput" paths="$(LIBS)"/>
@@ -241,11 +266,11 @@
 							<option id="com.st.stm32cube.ide.mcu.gnu.managedbuild.option.fpu.148418543" name="Floating-point unit" superClass="com.st.stm32cube.ide.mcu.gnu.managedbuild.option.fpu" useByScannerDiscovery="false" value="com.st.stm32cube.ide.mcu.gnu.managedbuild.option.fpu.value.fpv4-sp-d16" valueType="enumerated"/>
 							<option id="com.st.stm32cube.ide.mcu.gnu.managedbuild.option.floatabi.210656568" name="Floating-point ABI" superClass="com.st.stm32cube.ide.mcu.gnu.managedbuild.option.floatabi" useByScannerDiscovery="false" value="com.st.stm32cube.ide.mcu.gnu.managedbuild.option.floatabi.value.hard" valueType="enumerated"/>
 							<option id="com.st.stm32cube.ide.mcu.gnu.managedbuild.option.target_board.1776500793" name="Board" superClass="com.st.stm32cube.ide.mcu.gnu.managedbuild.option.target_board" useByScannerDiscovery="false" value="genericBoard" valueType="string"/>
-							<option id="com.st.stm32cube.ide.mcu.gnu.managedbuild.option.defaults.1132536473" name="Defaults" superClass="com.st.stm32cube.ide.mcu.gnu.managedbuild.option.defaults" useByScannerDiscovery="false" value="com.st.stm32cube.ide.common.services.build.inputs.revA.1.0.6 || Release || true || Executable || com.st.stm32cube.ide.mcu.gnu.managedbuild.toolchain.base.gnu-tools-for-stm32 || STM32F407VGTx || 0 || 0 || arm-none-eabi- || ${gnu_tools_for_stm32_compiler_path} || ../Middlewares/Third_Party/FreeRTOS/Source/include | ../Middlewares/Third_Party/FreeRTOS/Source/portable/GCC/ARM_CM4F | ../Drivers/CMSIS/Include | ../Core/Inc | ../Drivers/STM32F4xx_HAL_Driver/Inc | ../Drivers/CMSIS/Device/ST/STM32F4xx/Include | ../Middlewares/Third_Party/FreeRTOS/Source/CMSIS_RTOS_V2 | ../Drivers/STM32F4xx_HAL_Driver/Inc/Legacy | ../Core/ThreadSafe ||  ||  || STM32_THREAD_SAFE_STRATEGY=4 | USE_HAL_DRIVER | STM32F407xx ||  || Core/ThreadSafe | Drivers | Core/Startup | Middlewares | Core ||  ||  || ${workspace_loc:/${ProjName}/STM32F407VGTX_FLASH.ld} || true || NonSecure ||  || secure_nsclib.o ||  || FreeRTOS_AllowLockFromIRQ ||  ||  || " valueType="string"/>
+							<option id="com.st.stm32cube.ide.mcu.gnu.managedbuild.option.defaults.1132536473" name="Defaults" superClass="com.st.stm32cube.ide.mcu.gnu.managedbuild.option.defaults" useByScannerDiscovery="false" value="com.st.stm32cube.ide.common.services.build.inputs.revA.1.0.6 || Release || true || Executable || com.st.stm32cube.ide.mcu.gnu.managedbuild.toolchain.base.gnu-tools-for-stm32 || STM32F407VGTx || 0 || 0 || arm-none-eabi- || ${gnu_tools_for_stm32_compiler_path} || ../Middlewares/Third_Party/FreeRTOS/Source/include | ../Middlewares/Third_Party/FreeRTOS/Source/portable/GCC/ARM_CM4F | ../Drivers/CMSIS/Include | ../Core/Inc | ../Drivers/STM32F4xx_HAL_Driver/Inc | ../Drivers/CMSIS/Device/ST/STM32F4xx/Include | ../Middlewares/Third_Party/FreeRTOS/Source/CMSIS_RTOS_V2 | ../Drivers/STM32F4xx_HAL_Driver/Inc/Legacy | ../Core/ThreadSafe | ../Middlewares/ST/ARM/DSP/Inc || ../Core/Inc | ../Drivers/STM32F4xx_HAL_Driver/Inc | ../Drivers/STM32F4xx_HAL_Driver/Inc/Legacy | ../Middlewares/Third_Party/FreeRTOS/Source/include | ../Middlewares/Third_Party/FreeRTOS/Source/CMSIS_RTOS_V2 | ../Middlewares/Third_Party/FreeRTOS/Source/portable/GCC/ARM_CM4F | ../Drivers/CMSIS/Device/ST/STM32F4xx/Include | ../Drivers/CMSIS/Include | ../Middlewares/ST/ARM/DSP/Inc ||  || STM32_THREAD_SAFE_STRATEGY=4 | USE_HAL_DRIVER | STM32F407xx ||  || Core/ThreadSafe | Drivers | Core/Startup | Middlewares | Core ||  || ../Middlewares/ST/ARM/DSP/Lib/libarm_cortexM4lf_math.a || ${workspace_loc:/${ProjName}/STM32F407VGTX_FLASH.ld} || true || NonSecure ||  || secure_nsclib.o ||  || FreeRTOS_AllowLockFromIRQ ||  ||  || " valueType="string"/>
 							<option id="com.st.stm32cube.ide.mcu.gnu.managedbuild.option.nanoprintffloat.1586695396" name="Use float with printf from newlib-nano (-u _printf_float)" superClass="com.st.stm32cube.ide.mcu.gnu.managedbuild.option.nanoprintffloat" useByScannerDiscovery="false" value="true" valueType="boolean"/>
 							<option id="com.st.stm32cube.ide.mcu.gnu.managedbuild.option.converthex.1723306711" name="Convert to Intel Hex file (-O ihex)" superClass="com.st.stm32cube.ide.mcu.gnu.managedbuild.option.converthex" useByScannerDiscovery="false" value="true" valueType="boolean"/>
 							<option id="com.st.stm32cube.ide.mcu.gnu.managedbuild.option.runtimelibrary_cpp.692226491" name="Runtime library" superClass="com.st.stm32cube.ide.mcu.gnu.managedbuild.option.runtimelibrary_cpp" useByScannerDiscovery="true" value="com.st.stm32cube.ide.mcu.gnu.managedbuild.option.runtimelibrary_cpp.value.standard_c_nano_cpp" valueType="enumerated"/>
-							<option id="com.st.stm32cube.ide.mcu.debug.option.cpuclock.1545102677" superClass="com.st.stm32cube.ide.mcu.debug.option.cpuclock" useByScannerDiscovery="false" value="168" valueType="string"/>
+							<option id="com.st.stm32cube.ide.mcu.debug.option.cpuclock.1545102677" name="Cpu clock frequence" superClass="com.st.stm32cube.ide.mcu.debug.option.cpuclock" useByScannerDiscovery="false" value="168" valueType="string"/>
 							<targetPlatform archList="all" binaryParser="org.eclipse.cdt.core.ELF" id="com.st.stm32cube.ide.mcu.gnu.managedbuild.targetplatform.830438003" isAbstract="false" osList="all" superClass="com.st.stm32cube.ide.mcu.gnu.managedbuild.targetplatform"/>
 							<builder buildPath="${workspace_loc:/F407VG}/Debug" id="com.st.stm32cube.ide.mcu.gnu.managedbuild.builder.587985951" keepEnvironmentInBuildfile="false" managedBuildOn="true" name="Gnu Make Builder" parallelBuildOn="true" parallelizationNumber="optimal" superClass="com.st.stm32cube.ide.mcu.gnu.managedbuild.builder"/>
 							<tool id="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.assembler.1451593181" name="MCU GCC Assembler" superClass="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.assembler">
@@ -253,6 +278,17 @@
 								<option IS_BUILTIN_EMPTY="false" IS_VALUE_EMPTY="false" id="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.assembler.option.definedsymbols.763722981" name="Define symbols (-D)" superClass="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.assembler.option.definedsymbols" useByScannerDiscovery="false" valueType="definedSymbols">
 									<listOptionValue builtIn="false" value="DEBUG"/>
 								</option>
+								<option IS_BUILTIN_EMPTY="false" IS_VALUE_EMPTY="false" id="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.assembler.option.includepaths.1328579848" superClass="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.assembler.option.includepaths" valueType="includePath">
+									<listOptionValue builtIn="false" value="../Core/Inc"/>
+									<listOptionValue builtIn="false" value="../Drivers/STM32F4xx_HAL_Driver/Inc"/>
+									<listOptionValue builtIn="false" value="../Drivers/STM32F4xx_HAL_Driver/Inc/Legacy"/>
+									<listOptionValue builtIn="false" value="../Middlewares/Third_Party/FreeRTOS/Source/include"/>
+									<listOptionValue builtIn="false" value="../Middlewares/Third_Party/FreeRTOS/Source/CMSIS_RTOS_V2"/>
+									<listOptionValue builtIn="false" value="../Middlewares/Third_Party/FreeRTOS/Source/portable/GCC/ARM_CM4F"/>
+									<listOptionValue builtIn="false" value="../Drivers/CMSIS/Device/ST/STM32F4xx/Include"/>
+									<listOptionValue builtIn="false" value="../Drivers/CMSIS/Include"/>
+									<listOptionValue builtIn="false" value="../Middlewares/ST/ARM/DSP/Inc"/>
+								</option>
 								<inputType id="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.assembler.input.53526781" superClass="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.assembler.input"/>
 							</tool>
 							<tool id="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.c.compiler.452034158" name="MCU GCC Compiler" superClass="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.c.compiler">
@@ -285,6 +321,7 @@
 									<listOptionValue builtIn="false" value="../../../FFBoard/USB/device"/>
 									<listOptionValue builtIn="false" value="../../../FFBoard/USB/osal"/>
 									<listOptionValue builtIn="false" value="../Core/ThreadSafe"/>
+									<listOptionValue builtIn="false" value="../Middlewares/ST/ARM/DSP/Inc"/>
 								</option>
 								<option IS_BUILTIN_EMPTY="false" IS_VALUE_EMPTY="false" id="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.c.compiler.option.otherflags.1019663306" name="Other flags" superClass="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.c.compiler.option.otherflags" useByScannerDiscovery="true" valueType="stringList">
 									<listOptionValue builtIn="false" value="-mno-unaligned-access"/>
@@ -315,6 +352,7 @@
 									<listOptionValue builtIn="false" value="../../../FFBoard/USB/class/midi"/>
 									<listOptionValue builtIn="false" value="../../../FFBoard/USB/class/audio"/>
 									<listOptionValue builtIn="false" value="../Core/ThreadSafe"/>
+									<listOptionValue builtIn="false" value="../Middlewares/ST/ARM/DSP/Inc"/>
 								</option>
 								<option IS_BUILTIN_EMPTY="false" IS_VALUE_EMPTY="false" id="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.cpp.compiler.option.definedsymbols.1842866947" name="Define symbols (-D)" superClass="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.cpp.compiler.option.definedsymbols" useByScannerDiscovery="false" valueType="definedSymbols">
 									<listOptionValue builtIn="false" value="USE_HAL_DRIVER"/>
@@ -333,6 +371,12 @@
 							</tool>
 							<tool id="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.c.linker.1233815650" name="MCU GCC Linker" superClass="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.c.linker">
 								<option id="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.c.linker.option.script.1517368836" name="Linker Script (-T)" superClass="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.c.linker.option.script" value="${workspace_loc:/${ProjName}/STM32F407VGTX_FLASH.ld}" valueType="string"/>
+								<option IS_BUILTIN_EMPTY="false" IS_VALUE_EMPTY="false" id="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.c.linker.option.directories.1255046971" superClass="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.c.linker.option.directories" valueType="libPaths">
+									<listOptionValue builtIn="false" value="../Middlewares/ST/ARM/DSP/Lib"/>
+								</option>
+								<option IS_BUILTIN_EMPTY="false" IS_VALUE_EMPTY="false" id="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.c.linker.option.libraries.568556050" superClass="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.c.linker.option.libraries" valueType="libs">
+									<listOptionValue builtIn="false" value=":libarm_cortexM4lf_math.a"/>
+								</option>
 								<inputType id="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.c.linker.input.2036654442" superClass="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.c.linker.input">
 									<additionalInput kind="additionalinputdependency" paths="$(USER_OBJS)"/>
 									<additionalInput kind="additionalinput" paths="$(LIBS)"/>
@@ -343,6 +387,12 @@
 								<option id="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.cpp.linker.option.systemcalls.1493733321" name="System calls" superClass="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.cpp.linker.option.systemcalls" useByScannerDiscovery="false" value="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.cpp.linker.option.systemcalls.value.minimalimplementation" valueType="enumerated"/>
 								<option id="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.cpp.linker.option.gcsections.342932735" name="Discard unused sections (-Wl,--gc-sections)" superClass="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.cpp.linker.option.gcsections" useByScannerDiscovery="false" value="true" valueType="boolean"/>
 								<option id="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.cpp.linker.option.cref.1953736270" name="Add symbol cross reference table to map file (-Wl,--cref)" superClass="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.cpp.linker.option.cref" useByScannerDiscovery="false" value="true" valueType="boolean"/>
+								<option IS_BUILTIN_EMPTY="false" IS_VALUE_EMPTY="false" id="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.cpp.linker.option.directories.2006090705" superClass="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.cpp.linker.option.directories" valueType="libPaths">
+									<listOptionValue builtIn="false" value="../Middlewares/ST/ARM/DSP/Lib"/>
+								</option>
+								<option IS_BUILTIN_EMPTY="false" IS_VALUE_EMPTY="false" id="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.cpp.linker.option.libraries.1065976636" superClass="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.cpp.linker.option.libraries" valueType="libs">
+									<listOptionValue builtIn="false" value=":libarm_cortexM4lf_math.a"/>
+								</option>
 								<inputType id="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.cpp.linker.input.441406744" superClass="com.st.stm32cube.ide.mcu.gnu.managedbuild.tool.cpp.linker.input">
 									<additionalInput kind="additionalinputdependency" paths="$(USER_OBJS)"/>
 									<additionalInput kind="additionalinput" paths="$(LIBS)"/>
diff --git a/Firmware/Targets/F407VG/.settings/stm32cubeide.project.prefs b/Firmware/Targets/F407VG/.settings/stm32cubeide.project.prefs
index be0603234..7272f8f0e 100644
--- a/Firmware/Targets/F407VG/.settings/stm32cubeide.project.prefs
+++ b/Firmware/Targets/F407VG/.settings/stm32cubeide.project.prefs
@@ -1,4 +1,4 @@
-2F62501ED4689FB349E356AB974DBE57=E2380525C25FCA23F64F38676B957D9B
-8DF89ED150041C4CBC7CB9A9CAA90856=E2380525C25FCA23F64F38676B957D9B
-DC22A860405A8BF2F2C095E5B6529F12=609A53BFF0492F10C829ECAB4963903C
+2F62501ED4689FB349E356AB974DBE57=2E846C232C86F8091E1D1C41786923FD
+8DF89ED150041C4CBC7CB9A9CAA90856=2E846C232C86F8091E1D1C41786923FD
+DC22A860405A8BF2F2C095E5B6529F12=22CA254BACDE848B9B8194C2EFC7A52E
 eclipse.preferences.version=1
diff --git a/Firmware/Targets/F407VG/Core/Inc/FreeRTOSConfig.h b/Firmware/Targets/F407VG/Core/Inc/FreeRTOSConfig.h
index df33746ef..3d718b1e3 100644
--- a/Firmware/Targets/F407VG/Core/Inc/FreeRTOSConfig.h
+++ b/Firmware/Targets/F407VG/Core/Inc/FreeRTOSConfig.h
@@ -51,6 +51,10 @@
 #if defined(__ICCARM__) || defined(__CC_ARM) || defined(__GNUC__)
   #include <stdint.h>
   extern uint32_t SystemCoreClock;
+/* USER CODE BEGIN 0 */
+  extern void configureTimerForRunTimeStats(void);
+  extern unsigned long getRunTimeCounterValue(void);
+/* USER CODE END 0 */
 #endif
 #ifndef CMSIS_device_header
 #define CMSIS_device_header "stm32f4xx.h"
@@ -70,7 +74,9 @@
 #define configMINIMAL_STACK_SIZE                 ((uint16_t)64)
 #define configTOTAL_HEAP_SIZE                    ((size_t)0xffff)
 #define configMAX_TASK_NAME_LEN                  ( 16 )
+#define configGENERATE_RUN_TIME_STATS            1
 #define configUSE_TRACE_FACILITY                 1
+#define configUSE_STATS_FORMATTING_FUNCTIONS     1
 #define configUSE_16_BIT_TICKS                   0
 #define configUSE_MUTEXES                        1
 #define configQUEUE_REGISTRY_SIZE                8
@@ -169,6 +175,12 @@ standard names. */
 
 #define USE_CUSTOM_SYSTICK_HANDLER_IMPLEMENTATION 0
 
+/* USER CODE BEGIN 2 */
+/* Definitions needed when configGENERATE_RUN_TIME_STATS is on */
+#define portCONFIGURE_TIMER_FOR_RUN_TIME_STATS configureTimerForRunTimeStats
+#define portGET_RUN_TIME_COUNTER_VALUE getRunTimeCounterValue
+/* USER CODE END 2 */
+
 /* USER CODE BEGIN Defines */
 #define CPP_FREERTOS_NO_EXCEPTIONS // For freertos cpp addons
 #define configAPPLICATION_ALLOCATED_HEAP 1 // ucHeap allocated in freertos.c
diff --git a/Firmware/Targets/F407VG/Core/Inc/target_constants.h b/Firmware/Targets/F407VG/Core/Inc/target_constants.h
index 860f27682..6aaeb8e34 100644
--- a/Firmware/Targets/F407VG/Core/Inc/target_constants.h
+++ b/Firmware/Targets/F407VG/Core/Inc/target_constants.h
@@ -119,6 +119,9 @@ extern CAN_HandleTypeDef hcan1;
 #define CANPORT hcan1
 #endif
 
+// DEFINE DSP FUNCTION USAGE
+#define USE_DSP_FUNCTIONS
+
 #define DEBUGPIN // GP1 pin. see cpp target constants
 
 //Flash. 2 pages used
diff --git a/Firmware/Targets/F407VG/Core/Src/freertos.c b/Firmware/Targets/F407VG/Core/Src/freertos.c
index 6eadca3d4..6f24b2c27 100644
--- a/Firmware/Targets/F407VG/Core/Src/freertos.c
+++ b/Firmware/Targets/F407VG/Core/Src/freertos.c
@@ -55,10 +55,25 @@ uint8_t ucHeap[ configTOTAL_HEAP_SIZE ]; // rtos heap // __attribute__((section
 /* USER CODE END FunctionPrototypes */
 
 /* Hook prototypes */
+void configureTimerForRunTimeStats(void);
+unsigned long getRunTimeCounterValue(void);
 void vApplicationIdleHook(void);
 void vApplicationStackOverflowHook(xTaskHandle xTask, signed char *pcTaskName);
 void vApplicationMallocFailedHook(void);
 
+/* USER CODE BEGIN 1 */
+/* Functions needed when configGENERATE_RUN_TIME_STATS is on */
+__weak void configureTimerForRunTimeStats(void)
+{
+
+}
+
+__weak unsigned long getRunTimeCounterValue(void)
+{
+return 0;
+}
+/* USER CODE END 1 */
+
 /* USER CODE BEGIN 2 */
 void vApplicationIdleHook( void )
 {
diff --git a/Firmware/Targets/F407VG/Core/ThreadSafe/newlib_lock_glue.c b/Firmware/Targets/F407VG/Core/ThreadSafe/newlib_lock_glue.c
index 8d956e401..3d490072f 100644
--- a/Firmware/Targets/F407VG/Core/ThreadSafe/newlib_lock_glue.c
+++ b/Firmware/Targets/F407VG/Core/ThreadSafe/newlib_lock_glue.c
@@ -19,7 +19,7 @@
   ******************************************************************************
   * @attention
   *
-  * Copyright (c) 2023 STMicroelectronics.
+  * Copyright (c) 2025 STMicroelectronics.
   * All rights reserved.
   *
   * This software is licensed under terms that can be found in the LICENSE file
@@ -36,6 +36,8 @@
 /* Includes ------------------------------------------------------------------*/
 #include <cmsis_compiler.h>
 
+/* Private functions prototypes ----------------------------------------------*/
+__WEAK void Error_Handler(void);
 /* Private functions ---------------------------------------------------------*/
 
 /**
@@ -71,6 +73,12 @@ __WEAK void Error_Handler(void)
 /** See struct __lock definition */
 #define STM32_LOCK_PARAMETER(lock) (&(lock)->lock_data)
 
+/* shared variables for bare metal allow lock ------------------------------------------------------*/
+#if defined(STM32_THREAD_SAFE_BAREMETAL_ALLOW_LOCKS) && (STM32_THREAD_SAFE_BAREMETAL_ALLOW_LOCKS != 0)
+uint32_t gflag = 0;
+uint32_t call_counter = 0;
+#endif /* defined(STM32_THREAD_SAFE_BAREMETAL_ALLOW_LOCKS) && (STM32_THREAD_SAFE_BAREMETAL_ALLOW_LOCKS != 0) */
+
 /* Private variables ---------------------------------------------------------*/
 struct __lock
 {
@@ -341,6 +349,10 @@ typedef struct
 /** Mutex used in __cxa_guard_acquire, __cxa_guard_release and __cxa_guard_abort */
 static LockingData_t __cxa_guard_mutex = LOCKING_DATA_INIT;
 
+/* Private functions prototype ---------------------------------------------------------*/
+int __cxa_guard_acquire(CxaGuardObject_t *guard_object);
+void __cxa_guard_abort(CxaGuardObject_t *guard_object);
+void __cxa_guard_release(CxaGuardObject_t *guard_object);
 /* Private functions ---------------------------------------------------------*/
 
 /**
diff --git a/Firmware/Targets/F407VG/Core/ThreadSafe/stm32_lock.h b/Firmware/Targets/F407VG/Core/ThreadSafe/stm32_lock.h
index 372c5ded9..b661efdda 100644
--- a/Firmware/Targets/F407VG/Core/ThreadSafe/stm32_lock.h
+++ b/Firmware/Targets/F407VG/Core/ThreadSafe/stm32_lock.h
@@ -48,7 +48,7 @@
   ******************************************************************************
   * @attention
   *
-  * Copyright (c) 2023 STMicroelectronics.
+  * Copyright (c) 2025 STMicroelectronics.
   * All rights reserved.
   *
   * This software is licensed under terms that can be found in the LICENSE file
diff --git a/Firmware/Targets/F407VG/Middlewares/ST/ARM/DSP/Inc/arm_math.h b/Firmware/Targets/F407VG/Middlewares/ST/ARM/DSP/Inc/arm_math.h
new file mode 100644
index 000000000..48bee62cd
--- /dev/null
+++ b/Firmware/Targets/F407VG/Middlewares/ST/ARM/DSP/Inc/arm_math.h
@@ -0,0 +1,8970 @@
+/******************************************************************************
+ * @file     arm_math.h
+ * @brief    Public header file for CMSIS DSP Library
+ * @version  V1.7.0
+ * @date     18. March 2019
+ ******************************************************************************/
+/*
+ * Copyright (c) 2010-2019 Arm Limited or its affiliates. All rights reserved.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Licensed under the Apache License, Version 2.0 (the License); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+   \mainpage CMSIS DSP Software Library
+   *
+   * Introduction
+   * ------------
+   *
+   * This user manual describes the CMSIS DSP software library,
+   * a suite of common signal processing functions for use on Cortex-M and Cortex-A processor 
+   * based devices.
+   *
+   * The library is divided into a number of functions each covering a specific category:
+   * - Basic math functions
+   * - Fast math functions
+   * - Complex math functions
+   * - Filtering functions
+   * - Matrix functions
+   * - Transform functions
+   * - Motor control functions
+   * - Statistical functions
+   * - Support functions
+   * - Interpolation functions
+   * - Support Vector Machine functions (SVM)
+   * - Bayes classifier functions
+   * - Distance functions
+   *
+   * The library has generally separate functions for operating on 8-bit integers, 16-bit integers,
+   * 32-bit integer and 32-bit floating-point values.
+   *
+   * Using the Library
+   * ------------
+   *
+   * The library installer contains prebuilt versions of the libraries in the <code>Lib</code> folder.
+   *
+   * Here is the list of pre-built libraries :
+   * - arm_cortexM7lfdp_math.lib (Cortex-M7, Little endian, Double Precision Floating Point Unit)
+   * - arm_cortexM7bfdp_math.lib (Cortex-M7, Big endian, Double Precision Floating Point Unit)
+   * - arm_cortexM7lfsp_math.lib (Cortex-M7, Little endian, Single Precision Floating Point Unit)
+   * - arm_cortexM7bfsp_math.lib (Cortex-M7, Big endian and Single Precision Floating Point Unit on)
+   * - arm_cortexM7l_math.lib (Cortex-M7, Little endian)
+   * - arm_cortexM7b_math.lib (Cortex-M7, Big endian)
+   * - arm_cortexM4lf_math.lib (Cortex-M4, Little endian, Floating Point Unit)
+   * - arm_cortexM4bf_math.lib (Cortex-M4, Big endian, Floating Point Unit)
+   * - arm_cortexM4l_math.lib (Cortex-M4, Little endian)
+   * - arm_cortexM4b_math.lib (Cortex-M4, Big endian)
+   * - arm_cortexM3l_math.lib (Cortex-M3, Little endian)
+   * - arm_cortexM3b_math.lib (Cortex-M3, Big endian)
+   * - arm_cortexM0l_math.lib (Cortex-M0 / Cortex-M0+, Little endian)
+   * - arm_cortexM0b_math.lib (Cortex-M0 / Cortex-M0+, Big endian)
+   * - arm_ARMv8MBLl_math.lib (Armv8-M Baseline, Little endian)
+   * - arm_ARMv8MMLl_math.lib (Armv8-M Mainline, Little endian)
+   * - arm_ARMv8MMLlfsp_math.lib (Armv8-M Mainline, Little endian, Single Precision Floating Point Unit)
+   * - arm_ARMv8MMLld_math.lib (Armv8-M Mainline, Little endian, DSP instructions)
+   * - arm_ARMv8MMLldfsp_math.lib (Armv8-M Mainline, Little endian, DSP instructions, Single Precision Floating Point Unit)
+   *
+   * The library functions are declared in the public file <code>arm_math.h</code> which is placed in the <code>Include</code> folder.
+   * Simply include this file and link the appropriate library in the application and begin calling the library functions. The Library supports single
+   * public header file <code> arm_math.h</code> for Cortex-M cores with little endian and big endian. Same header file will be used for floating point unit(FPU) variants.
+   *
+   *
+   * Examples
+   * --------
+   *
+   * The library ships with a number of examples which demonstrate how to use the library functions.
+   *
+   * Toolchain Support
+   * ------------
+   *
+   * The library is now tested on Fast Models building with cmake.
+   * Core M0, M7, A5 are tested.
+   * 
+   * 
+   *
+   * Building the Library
+   * ------------
+   *
+   * The library installer contains a project file to rebuild libraries on MDK toolchain in the <code>CMSIS\\DSP\\Projects\\ARM</code> folder.
+   * - arm_cortexM_math.uvprojx
+   *
+   *
+   * The libraries can be built by opening the arm_cortexM_math.uvprojx project in MDK-ARM, selecting a specific target, and defining the optional preprocessor macros detailed above.
+   *
+   * There is also a work in progress cmake build. The README file is giving more details.
+   *
+   * Preprocessor Macros
+   * ------------
+   *
+   * Each library project have different preprocessor macros.
+   *
+   * - ARM_MATH_BIG_ENDIAN:
+   *
+   * Define macro ARM_MATH_BIG_ENDIAN to build the library for big endian targets. By default library builds for little endian targets.
+   *
+   * - ARM_MATH_MATRIX_CHECK:
+   *
+   * Define macro ARM_MATH_MATRIX_CHECK for checking on the input and output sizes of matrices
+   *
+   * - ARM_MATH_ROUNDING:
+   *
+   * Define macro ARM_MATH_ROUNDING for rounding on support functions
+   *
+   * - ARM_MATH_LOOPUNROLL:
+   *
+   * Define macro ARM_MATH_LOOPUNROLL to enable manual loop unrolling in DSP functions
+   *
+   * - ARM_MATH_NEON:
+   *
+   * Define macro ARM_MATH_NEON to enable Neon versions of the DSP functions.
+   * It is not enabled by default when Neon is available because performances are 
+   * dependent on the compiler and target architecture.
+   *
+   * - ARM_MATH_NEON_EXPERIMENTAL:
+   *
+   * Define macro ARM_MATH_NEON_EXPERIMENTAL to enable experimental Neon versions of 
+   * of some DSP functions. Experimental Neon versions currently do not have better
+   * performances than the scalar versions.
+   *
+   * - ARM_MATH_HELIUM:
+   *
+   * It implies the flags ARM_MATH_MVEF and ARM_MATH_MVEI and ARM_MATH_FLOAT16.
+   *
+   * - ARM_MATH_MVEF:
+   *
+   * Select Helium versions of the f32 algorithms.
+   * It implies ARM_MATH_FLOAT16 and ARM_MATH_MVEI.
+   *
+   * - ARM_MATH_MVEI:
+   *
+   * Select Helium versions of the int and fixed point algorithms.
+   *
+   * - ARM_MATH_FLOAT16:
+   *
+   * Float16 implementations of some algorithms (Requires MVE extension).
+   *
+   * <hr>
+   * CMSIS-DSP in ARM::CMSIS Pack
+   * -----------------------------
+   *
+   * The following files relevant to CMSIS-DSP are present in the <b>ARM::CMSIS</b> Pack directories:
+   * |File/Folder                      |Content                                                                 |
+   * |---------------------------------|------------------------------------------------------------------------|
+   * |\b CMSIS\\Documentation\\DSP     | This documentation                                                     |
+   * |\b CMSIS\\DSP\\DSP_Lib_TestSuite | DSP_Lib test suite                                                     |
+   * |\b CMSIS\\DSP\\Examples          | Example projects demonstrating the usage of the library functions      |
+   * |\b CMSIS\\DSP\\Include           | DSP_Lib include files                                                  |
+   * |\b CMSIS\\DSP\\Lib               | DSP_Lib binaries                                                       |
+   * |\b CMSIS\\DSP\\Projects          | Projects to rebuild DSP_Lib binaries                                   |
+   * |\b CMSIS\\DSP\\Source            | DSP_Lib source files                                                   |
+   *
+   * <hr>
+   * Revision History of CMSIS-DSP
+   * ------------
+   * Please refer to \ref ChangeLog_pg.
+   */
+
+
+/**
+ * @defgroup groupMath Basic Math Functions
+ */
+
+/**
+ * @defgroup groupFastMath Fast Math Functions
+ * This set of functions provides a fast approximation to sine, cosine, and square root.
+ * As compared to most of the other functions in the CMSIS math library, the fast math functions
+ * operate on individual values and not arrays.
+ * There are separate functions for Q15, Q31, and floating-point data.
+ *
+ */
+
+/**
+ * @defgroup groupCmplxMath Complex Math Functions
+ * This set of functions operates on complex data vectors.
+ * The data in the complex arrays is stored in an interleaved fashion
+ * (real, imag, real, imag, ...).
+ * In the API functions, the number of samples in a complex array refers
+ * to the number of complex values; the array contains twice this number of
+ * real values.
+ */
+
+/**
+ * @defgroup groupFilters Filtering Functions
+ */
+
+/**
+ * @defgroup groupMatrix Matrix Functions
+ *
+ * This set of functions provides basic matrix math operations.
+ * The functions operate on matrix data structures.  For example,
+ * the type
+ * definition for the floating-point matrix structure is shown
+ * below:
+ * <pre>
+ *     typedef struct
+ *     {
+ *       uint16_t numRows;     // number of rows of the matrix.
+ *       uint16_t numCols;     // number of columns of the matrix.
+ *       float32_t *pData;     // points to the data of the matrix.
+ *     } arm_matrix_instance_f32;
+ * </pre>
+ * There are similar definitions for Q15 and Q31 data types.
+ *
+ * The structure specifies the size of the matrix and then points to
+ * an array of data.  The array is of size <code>numRows X numCols</code>
+ * and the values are arranged in row order.  That is, the
+ * matrix element (i, j) is stored at:
+ * <pre>
+ *     pData[i*numCols + j]
+ * </pre>
+ *
+ * \par Init Functions
+ * There is an associated initialization function for each type of matrix
+ * data structure.
+ * The initialization function sets the values of the internal structure fields.
+ * Refer to \ref arm_mat_init_f32(), \ref arm_mat_init_q31() and \ref arm_mat_init_q15()
+ * for floating-point, Q31 and Q15 types,  respectively.
+ *
+ * \par
+ * Use of the initialization function is optional. However, if initialization function is used
+ * then the instance structure cannot be placed into a const data section.
+ * To place the instance structure in a const data
+ * section, manually initialize the data structure.  For example:
+ * <pre>
+ * <code>arm_matrix_instance_f32 S = {nRows, nColumns, pData};</code>
+ * <code>arm_matrix_instance_q31 S = {nRows, nColumns, pData};</code>
+ * <code>arm_matrix_instance_q15 S = {nRows, nColumns, pData};</code>
+ * </pre>
+ * where <code>nRows</code> specifies the number of rows, <code>nColumns</code>
+ * specifies the number of columns, and <code>pData</code> points to the
+ * data array.
+ *
+ * \par Size Checking
+ * By default all of the matrix functions perform size checking on the input and
+ * output matrices. For example, the matrix addition function verifies that the
+ * two input matrices and the output matrix all have the same number of rows and
+ * columns. If the size check fails the functions return:
+ * <pre>
+ *     ARM_MATH_SIZE_MISMATCH
+ * </pre>
+ * Otherwise the functions return
+ * <pre>
+ *     ARM_MATH_SUCCESS
+ * </pre>
+ * There is some overhead associated with this matrix size checking.
+ * The matrix size checking is enabled via the \#define
+ * <pre>
+ *     ARM_MATH_MATRIX_CHECK
+ * </pre>
+ * within the library project settings.  By default this macro is defined
+ * and size checking is enabled. By changing the project settings and
+ * undefining this macro size checking is eliminated and the functions
+ * run a bit faster. With size checking disabled the functions always
+ * return <code>ARM_MATH_SUCCESS</code>.
+ */
+
+/**
+ * @defgroup groupTransforms Transform Functions
+ */
+
+/**
+ * @defgroup groupController Controller Functions
+ */
+
+/**
+ * @defgroup groupStats Statistics Functions
+ */
+
+/**
+ * @defgroup groupSupport Support Functions
+ */
+
+/**
+ * @defgroup groupInterpolation Interpolation Functions
+ * These functions perform 1- and 2-dimensional interpolation of data.
+ * Linear interpolation is used for 1-dimensional data and
+ * bilinear interpolation is used for 2-dimensional data.
+ */
+
+/**
+ * @defgroup groupExamples Examples
+ */
+
+/**
+ * @defgroup groupSVM SVM Functions
+ * This set of functions is implementing SVM classification on 2 classes.
+ * The training must be done from scikit-learn. The parameters can be easily
+ * generated from the scikit-learn object. Some examples are given in
+ * DSP/Testing/PatternGeneration/SVM.py
+ *
+ * If more than 2 classes are needed, the functions in this folder 
+ * will have to be used, as building blocks, to do multi-class classification.
+ *
+ * No multi-class classification is provided in this SVM folder.
+ * 
+ */
+
+
+/**
+ * @defgroup groupBayes Bayesian estimators
+ *
+ * Implement the naive gaussian Bayes estimator.
+ * The training must be done from scikit-learn.
+ *
+ * The parameters can be easily
+ * generated from the scikit-learn object. Some examples are given in
+ * DSP/Testing/PatternGeneration/Bayes.py
+ */
+
+/**
+ * @defgroup groupDistance Distance functions
+ *
+ * Distance functions for use with clustering algorithms.
+ * There are distance functions for float vectors and boolean vectors.
+ *
+ */
+
+
+#ifndef _ARM_MATH_H
+#define _ARM_MATH_H
+
+#ifdef   __cplusplus
+extern "C"
+{
+#endif
+
+/* Compiler specific diagnostic adjustment */
+#if   defined ( __CC_ARM )
+
+#elif defined ( __ARMCC_VERSION ) && ( __ARMCC_VERSION >= 6010050 )
+
+#elif defined ( __GNUC__ )
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wsign-conversion"
+  #pragma GCC diagnostic ignored "-Wconversion"
+  #pragma GCC diagnostic ignored "-Wunused-parameter"
+
+#elif defined ( __ICCARM__ )
+
+#elif defined ( __TI_ARM__ )
+
+#elif defined ( __CSMC__ )
+
+#elif defined ( __TASKING__ )
+
+#elif defined ( _MSC_VER )
+
+#else
+  #error Unknown compiler
+#endif
+
+
+/* Included for instrinsics definitions */
+#if defined (_MSC_VER ) 
+#include <stdint.h>
+#define __STATIC_FORCEINLINE static __forceinline
+#define __STATIC_INLINE static __inline
+#define __ALIGNED(x) __declspec(align(x))
+
+#elif defined (__GNUC_PYTHON__)
+#include <stdint.h>
+#define  __ALIGNED(x) __attribute__((aligned(x)))
+#define __STATIC_FORCEINLINE static __attribute__((inline))
+#define __STATIC_INLINE static __attribute__((inline))
+#pragma GCC diagnostic ignored "-Wunused-function"
+#pragma GCC diagnostic ignored "-Wattributes"
+
+#else
+#include "cmsis_compiler.h"
+#endif
+
+
+
+#include <string.h>
+#include <math.h>
+#include <float.h>
+#include <limits.h>
+
+
+#define F64_MAX   ((float64_t)DBL_MAX)
+#define F32_MAX   ((float32_t)FLT_MAX)
+
+#if defined(ARM_MATH_FLOAT16)
+#define F16_MAX   ((float16_t)FLT_MAX)
+#endif
+
+#define F64_MIN   (-DBL_MAX)
+#define F32_MIN   (-FLT_MAX)
+
+#if defined(ARM_MATH_FLOAT16)
+#define F16_MIN   (-(float16_t)FLT_MAX)
+#endif
+
+#define F64_ABSMAX   ((float64_t)DBL_MAX)
+#define F32_ABSMAX   ((float32_t)FLT_MAX)
+
+#if defined(ARM_MATH_FLOAT16)
+#define F16_ABSMAX   ((float16_t)FLT_MAX)
+#endif
+
+#define F64_ABSMIN   ((float64_t)0.0)
+#define F32_ABSMIN   ((float32_t)0.0)
+
+#if defined(ARM_MATH_FLOAT16)
+#define F16_ABSMIN   ((float16_t)0.0)
+#endif
+
+#define Q31_MAX   ((q31_t)(0x7FFFFFFFL))
+#define Q15_MAX   ((q15_t)(0x7FFF))
+#define Q7_MAX    ((q7_t)(0x7F))
+#define Q31_MIN   ((q31_t)(0x80000000L))
+#define Q15_MIN   ((q15_t)(0x8000))
+#define Q7_MIN    ((q7_t)(0x80))
+
+#define Q31_ABSMAX   ((q31_t)(0x7FFFFFFFL))
+#define Q15_ABSMAX   ((q15_t)(0x7FFF))
+#define Q7_ABSMAX    ((q7_t)(0x7F))
+#define Q31_ABSMIN   ((q31_t)0)
+#define Q15_ABSMIN   ((q15_t)0)
+#define Q7_ABSMIN    ((q7_t)0)
+
+/* evaluate ARM DSP feature */
+#if (defined (__ARM_FEATURE_DSP) && (__ARM_FEATURE_DSP == 1))
+  #define ARM_MATH_DSP                   1
+#endif
+
+#if defined(ARM_MATH_NEON)
+#include <arm_neon.h>
+#endif
+
+#if defined (ARM_MATH_HELIUM)
+  #define ARM_MATH_MVEF
+  #define ARM_MATH_FLOAT16
+#endif
+
+#if defined (ARM_MATH_MVEF)
+  #define ARM_MATH_MVEI
+  #define ARM_MATH_FLOAT16
+#endif
+
+#if defined (ARM_MATH_HELIUM) || defined(ARM_MATH_MVEF) || defined(ARM_MATH_MVEI)
+#include <arm_mve.h>
+#endif
+
+
+  /**
+   * @brief Macros required for reciprocal calculation in Normalized LMS
+   */
+
+#define DELTA_Q31          ((q31_t)(0x100))
+#define DELTA_Q15          ((q15_t)0x5)
+#define INDEX_MASK         0x0000003F
+#ifndef PI
+  #define PI               3.14159265358979f
+#endif
+
+  /**
+   * @brief Macros required for SINE and COSINE Fast math approximations
+   */
+
+#define FAST_MATH_TABLE_SIZE  512
+#define FAST_MATH_Q31_SHIFT   (32 - 10)
+#define FAST_MATH_Q15_SHIFT   (16 - 10)
+#define CONTROLLER_Q31_SHIFT  (32 - 9)
+#define TABLE_SPACING_Q31     0x400000
+#define TABLE_SPACING_Q15     0x80
+
+  /**
+   * @brief Macros required for SINE and COSINE Controller functions
+   */
+  /* 1.31(q31) Fixed value of 2/360 */
+  /* -1 to +1 is divided into 360 values so total spacing is (2/360) */
+#define INPUT_SPACING         0xB60B61
+
+  /**
+   * @brief Macros for complex numbers
+   */
+
+  /* Dimension C vector space */
+  #define CMPLX_DIM 2
+
+  /**
+   * @brief Error status returned by some functions in the library.
+   */
+
+  typedef enum
+  {
+    ARM_MATH_SUCCESS        =  0,        /**< No error */
+    ARM_MATH_ARGUMENT_ERROR = -1,        /**< One or more arguments are incorrect */
+    ARM_MATH_LENGTH_ERROR   = -2,        /**< Length of data buffer is incorrect */
+    ARM_MATH_SIZE_MISMATCH  = -3,        /**< Size of matrices is not compatible with the operation */
+    ARM_MATH_NANINF         = -4,        /**< Not-a-number (NaN) or infinity is generated */
+    ARM_MATH_SINGULAR       = -5,        /**< Input matrix is singular and cannot be inverted */
+    ARM_MATH_TEST_FAILURE   = -6         /**< Test Failed */
+  } arm_status;
+
+  /**
+   * @brief 8-bit fractional data type in 1.7 format.
+   */
+  typedef int8_t q7_t;
+
+  /**
+   * @brief 16-bit fractional data type in 1.15 format.
+   */
+  typedef int16_t q15_t;
+
+  /**
+   * @brief 32-bit fractional data type in 1.31 format.
+   */
+  typedef int32_t q31_t;
+
+  /**
+   * @brief 64-bit fractional data type in 1.63 format.
+   */
+  typedef int64_t q63_t;
+
+  /**
+   * @brief 32-bit floating-point type definition.
+   */
+  typedef float float32_t;
+
+  /**
+   * @brief 64-bit floating-point type definition.
+   */
+  typedef double float64_t;
+
+  /**
+   * @brief vector types
+   */
+#if defined(ARM_MATH_NEON) || defined (ARM_MATH_MVEI)
+  /**
+   * @brief 64-bit fractional 128-bit vector data type in 1.63 format
+   */
+  typedef int64x2_t q63x2_t;
+
+  /**
+   * @brief 32-bit fractional 128-bit vector data type in 1.31 format.
+   */
+  typedef int32x4_t q31x4_t;
+
+  /**
+   * @brief 16-bit fractional 128-bit vector data type with 16-bit alignement in 1.15 format.
+   */
+  typedef __ALIGNED(2) int16x8_t q15x8_t;
+
+ /**
+   * @brief 8-bit fractional 128-bit vector data type with 8-bit alignement in 1.7 format.
+   */
+  typedef __ALIGNED(1) int8x16_t q7x16_t;
+
+    /**
+   * @brief 32-bit fractional 128-bit vector pair data type in 1.31 format.
+   */
+  typedef int32x4x2_t q31x4x2_t;
+
+  /**
+   * @brief 32-bit fractional 128-bit vector quadruplet data type in 1.31 format.
+   */
+  typedef int32x4x4_t q31x4x4_t;
+
+  /**
+   * @brief 16-bit fractional 128-bit vector pair data type in 1.15 format.
+   */
+  typedef int16x8x2_t q15x8x2_t;
+
+  /**
+   * @brief 16-bit fractional 128-bit vector quadruplet data type in 1.15 format.
+   */
+  typedef int16x8x4_t q15x8x4_t;
+
+  /**
+   * @brief 8-bit fractional 128-bit vector pair data type in 1.7 format.
+   */
+  typedef int8x16x2_t q7x16x2_t;
+
+  /**
+   * @brief 8-bit fractional 128-bit vector quadruplet data type in 1.7 format.
+   */
+   typedef int8x16x4_t q7x16x4_t;
+
+  /**
+   * @brief 32-bit fractional data type in 9.23 format.
+   */
+  typedef int32_t q23_t;
+
+  /**
+   * @brief 32-bit fractional 128-bit vector data type in 9.23 format.
+   */
+  typedef int32x4_t q23x4_t;
+
+  /**
+   * @brief 64-bit status 128-bit vector data type.
+   */
+  typedef int64x2_t status64x2_t;
+
+  /**
+   * @brief 32-bit status 128-bit vector data type.
+   */
+  typedef int32x4_t status32x4_t;
+
+  /**
+   * @brief 16-bit status 128-bit vector data type.
+   */
+  typedef int16x8_t status16x8_t;
+
+  /**
+   * @brief 8-bit status 128-bit vector data type.
+   */
+  typedef int8x16_t status8x16_t;
+
+
+#endif
+
+#if defined(ARM_MATH_NEON) || defined(ARM_MATH_MVEF) /* floating point vector*/
+  /**
+   * @brief 32-bit floating-point 128-bit vector type
+   */
+  typedef float32x4_t f32x4_t;
+
+#if defined(ARM_MATH_FLOAT16)
+  /**
+   * @brief 16-bit floating-point 128-bit vector data type
+   */
+  typedef __ALIGNED(2) float16x8_t f16x8_t;
+#endif
+
+  /**
+   * @brief 32-bit floating-point 128-bit vector pair data type
+   */
+  typedef float32x4x2_t f32x4x2_t;
+
+  /**
+   * @brief 32-bit floating-point 128-bit vector quadruplet data type
+   */
+  typedef float32x4x4_t f32x4x4_t;
+
+#if defined(ARM_MATH_FLOAT16)
+  /**
+   * @brief 16-bit floating-point 128-bit vector pair data type
+   */
+  typedef float16x8x2_t f16x8x2_t;
+
+  /**
+   * @brief 16-bit floating-point 128-bit vector quadruplet data type
+   */
+  typedef float16x8x4_t f16x8x4_t;
+#endif
+
+  /**
+   * @brief 32-bit ubiquitous 128-bit vector data type
+   */
+  typedef union _any32x4_t
+  {
+      float32x4_t     f;
+      int32x4_t       i;
+  } any32x4_t;
+
+#if defined(ARM_MATH_FLOAT16)
+  /**
+   * @brief 16-bit ubiquitous 128-bit vector data type
+   */
+  typedef union _any16x8_t
+  {
+      float16x8_t     f;
+      int16x8_t       i;
+  } any16x8_t;
+#endif
+
+#endif
+
+#if defined(ARM_MATH_NEON)
+  /**
+   * @brief 32-bit fractional 64-bit vector data type in 1.31 format.
+   */
+  typedef int32x2_t  q31x2_t;
+
+  /**
+   * @brief 16-bit fractional 64-bit vector data type in 1.15 format.
+   */
+  typedef  __ALIGNED(2) int16x4_t q15x4_t;
+
+  /**
+   * @brief 8-bit fractional 64-bit vector data type in 1.7 format.
+   */
+  typedef  __ALIGNED(1) int8x8_t q7x8_t;
+
+  /**
+   * @brief 32-bit float 64-bit vector data type.
+   */
+  typedef float32x2_t  f32x2_t;
+
+#if defined(ARM_MATH_FLOAT16)
+  /**
+   * @brief 16-bit float 64-bit vector data type.
+   */
+  typedef  __ALIGNED(2) float16x4_t f16x4_t;
+#endif 
+
+  /**
+   * @brief 32-bit floating-point 128-bit vector triplet data type
+   */
+  typedef float32x4x3_t f32x4x3_t;
+
+#if defined(ARM_MATH_FLOAT16)
+  /**
+   * @brief 16-bit floating-point 128-bit vector triplet data type
+   */
+  typedef float16x8x3_t f16x8x3_t;
+#endif
+
+  /**
+   * @brief 32-bit fractional 128-bit vector triplet data type in 1.31 format
+   */
+  typedef int32x4x3_t q31x4x3_t;
+
+  /**
+   * @brief 16-bit fractional 128-bit vector triplet data type in 1.15 format
+   */
+  typedef int16x8x3_t q15x8x3_t;
+
+  /**
+   * @brief 8-bit fractional 128-bit vector triplet data type in 1.7 format
+   */
+  typedef int8x16x3_t q7x16x3_t;
+
+  /**
+   * @brief 32-bit floating-point 64-bit vector pair data type
+   */
+  typedef float32x2x2_t f32x2x2_t;
+
+  /**
+   * @brief 32-bit floating-point 64-bit vector triplet data type
+   */
+  typedef float32x2x3_t f32x2x3_t;
+
+  /**
+   * @brief 32-bit floating-point 64-bit vector quadruplet data type
+   */
+  typedef float32x2x4_t f32x2x4_t;
+
+#if defined(ARM_MATH_FLOAT16)
+  /**
+   * @brief 16-bit floating-point 64-bit vector pair data type
+   */
+  typedef float16x4x2_t f16x4x2_t;
+
+  /**
+   * @brief 16-bit floating-point 64-bit vector triplet data type
+   */
+  typedef float16x4x3_t f16x4x3_t;
+
+  /**
+   * @brief 16-bit floating-point 64-bit vector quadruplet data type
+   */
+  typedef float16x4x4_t f16x4x4_t;
+#endif 
+
+  /**
+   * @brief 32-bit fractional 64-bit vector pair data type in 1.31 format
+   */
+  typedef int32x2x2_t q31x2x2_t;
+
+  /**
+   * @brief 32-bit fractional 64-bit vector triplet data type in 1.31 format
+   */
+  typedef int32x2x3_t q31x2x3_t;
+
+  /**
+   * @brief 32-bit fractional 64-bit vector quadruplet data type in 1.31 format
+   */
+  typedef int32x4x3_t q31x2x4_t;
+
+  /**
+   * @brief 16-bit fractional 64-bit vector pair data type in 1.15 format
+   */
+  typedef int16x4x2_t q15x4x2_t;
+
+  /**
+   * @brief 16-bit fractional 64-bit vector triplet data type in 1.15 format
+   */
+  typedef int16x4x2_t q15x4x3_t;
+
+  /**
+   * @brief 16-bit fractional 64-bit vector quadruplet data type in 1.15 format
+   */
+  typedef int16x4x3_t q15x4x4_t;
+
+  /**
+   * @brief 8-bit fractional 64-bit vector pair data type in 1.7 format
+   */
+  typedef int8x8x2_t q7x8x2_t;
+
+  /**
+   * @brief 8-bit fractional 64-bit vector triplet data type in 1.7 format
+   */
+  typedef int8x8x3_t q7x8x3_t;
+
+  /**
+   * @brief 8-bit fractional 64-bit vector quadruplet data type in 1.7 format
+   */
+  typedef int8x8x4_t q7x8x4_t;
+
+  /**
+   * @brief 32-bit ubiquitous 64-bit vector data type
+   */
+  typedef union _any32x2_t
+  {
+      float32x2_t     f;
+      int32x2_t       i;
+  } any32x2_t;
+
+#if defined(ARM_MATH_FLOAT16)
+  /**
+   * @brief 16-bit ubiquitous 64-bit vector data type
+   */
+  typedef union _any16x4_t
+  {
+      float16x4_t     f;
+      int16x4_t       i;
+  } any16x4_t;
+#endif 
+
+  /**
+   * @brief 32-bit status 64-bit vector data type.
+   */
+  typedef int32x4_t status32x2_t;
+
+  /**
+   * @brief 16-bit status 64-bit vector data type.
+   */
+  typedef int16x8_t status16x4_t;
+
+  /**
+   * @brief 8-bit status 64-bit vector data type.
+   */
+  typedef int8x16_t status8x8_t;
+
+#endif
+
+
+
+/**
+  @brief definition to read/write two 16 bit values.
+  @deprecated
+ */
+#if   defined ( __CC_ARM )
+  #define __SIMD32_TYPE int32_t __packed
+#elif defined ( __ARMCC_VERSION ) && ( __ARMCC_VERSION >= 6010050 )
+  #define __SIMD32_TYPE int32_t
+#elif defined ( __GNUC__ )
+  #define __SIMD32_TYPE int32_t
+#elif defined ( __ICCARM__ )
+  #define __SIMD32_TYPE int32_t __packed
+#elif defined ( __TI_ARM__ )
+  #define __SIMD32_TYPE int32_t
+#elif defined ( __CSMC__ )
+  #define __SIMD32_TYPE int32_t
+#elif defined ( __TASKING__ )
+  #define __SIMD32_TYPE __un(aligned) int32_t
+#elif defined(_MSC_VER )
+  #define __SIMD32_TYPE int32_t
+#else
+  #error Unknown compiler
+#endif
+
+#define __SIMD32(addr)        (*(__SIMD32_TYPE **) & (addr))
+#define __SIMD32_CONST(addr)  ( (__SIMD32_TYPE * )   (addr))
+#define _SIMD32_OFFSET(addr)  (*(__SIMD32_TYPE * )   (addr))
+#define __SIMD64(addr)        (*(      int64_t **) & (addr))
+
+#define STEP(x) (x) <= 0 ? 0 : 1
+#define SQ(x) ((x) * (x))
+
+/* SIMD replacement */
+
+
+/**
+  @brief         Read 2 Q15 from Q15 pointer.
+  @param[in]     pQ15      points to input value
+  @return        Q31 value
+ */
+__STATIC_FORCEINLINE q31_t read_q15x2 (
+  q15_t * pQ15)
+{
+  q31_t val;
+
+#ifdef __ARM_FEATURE_UNALIGNED
+  memcpy (&val, pQ15, 4);
+#else
+  val = (pQ15[1] << 16) | (pQ15[0] & 0x0FFFF) ;
+#endif
+
+  return (val);
+}
+
+/**
+  @brief         Read 2 Q15 from Q15 pointer and increment pointer afterwards.
+  @param[in]     pQ15      points to input value
+  @return        Q31 value
+ */
+__STATIC_FORCEINLINE q31_t read_q15x2_ia (
+  q15_t ** pQ15)
+{
+  q31_t val;
+
+#ifdef __ARM_FEATURE_UNALIGNED
+  memcpy (&val, *pQ15, 4);
+#else
+  val = ((*pQ15)[1] << 16) | ((*pQ15)[0] & 0x0FFFF);
+#endif
+
+ *pQ15 += 2;
+ return (val);
+}
+
+/**
+  @brief         Read 2 Q15 from Q15 pointer and decrement pointer afterwards.
+  @param[in]     pQ15      points to input value
+  @return        Q31 value
+ */
+__STATIC_FORCEINLINE q31_t read_q15x2_da (
+  q15_t ** pQ15)
+{
+  q31_t val;
+
+#ifdef __ARM_FEATURE_UNALIGNED
+  memcpy (&val, *pQ15, 4);
+#else
+  val = ((*pQ15)[1] << 16) | ((*pQ15)[0] & 0x0FFFF);
+#endif
+
+  *pQ15 -= 2;
+  return (val);
+}
+
+/**
+  @brief         Write 2 Q15 to Q15 pointer and increment pointer afterwards.
+  @param[in]     pQ15      points to input value
+  @param[in]     value     Q31 value
+  @return        none
+ */
+__STATIC_FORCEINLINE void write_q15x2_ia (
+  q15_t ** pQ15,
+  q31_t    value)
+{
+  q31_t val = value;
+#ifdef __ARM_FEATURE_UNALIGNED
+  memcpy (*pQ15, &val, 4);
+#else
+  (*pQ15)[0] = (val & 0x0FFFF);
+  (*pQ15)[1] = (val >> 16) & 0x0FFFF;
+#endif
+
+ *pQ15 += 2;
+}
+
+/**
+  @brief         Write 2 Q15 to Q15 pointer.
+  @param[in]     pQ15      points to input value
+  @param[in]     value     Q31 value
+  @return        none
+ */
+__STATIC_FORCEINLINE void write_q15x2 (
+  q15_t * pQ15,
+  q31_t   value)
+{
+  q31_t val = value;
+
+#ifdef __ARM_FEATURE_UNALIGNED
+  memcpy (pQ15, &val, 4);
+#else
+  pQ15[0] = val & 0x0FFFF;
+  pQ15[1] = val >> 16;
+#endif
+}
+
+
+/**
+  @brief         Read 4 Q7 from Q7 pointer and increment pointer afterwards.
+  @param[in]     pQ7       points to input value
+  @return        Q31 value
+ */
+__STATIC_FORCEINLINE q31_t read_q7x4_ia (
+  q7_t ** pQ7)
+{
+  q31_t val;
+
+
+#ifdef __ARM_FEATURE_UNALIGNED
+  memcpy (&val, *pQ7, 4);
+#else
+  val =(((*pQ7)[3] & 0x0FF) << 24)  | (((*pQ7)[2] & 0x0FF) << 16)  | (((*pQ7)[1] & 0x0FF) << 8)  | ((*pQ7)[0] & 0x0FF);
+#endif 
+
+  *pQ7 += 4;
+
+  return (val);
+}
+
+/**
+  @brief         Read 4 Q7 from Q7 pointer and decrement pointer afterwards.
+  @param[in]     pQ7       points to input value
+  @return        Q31 value
+ */
+__STATIC_FORCEINLINE q31_t read_q7x4_da (
+  q7_t ** pQ7)
+{
+  q31_t val;
+#ifdef __ARM_FEATURE_UNALIGNED
+  memcpy (&val, *pQ7, 4);
+#else
+  val = ((((*pQ7)[3]) & 0x0FF) << 24) | ((((*pQ7)[2]) & 0x0FF) << 16)   | ((((*pQ7)[1]) & 0x0FF) << 8)  | ((*pQ7)[0] & 0x0FF);
+#endif 
+  *pQ7 -= 4;
+
+  return (val);
+}
+
+/**
+  @brief         Write 4 Q7 to Q7 pointer and increment pointer afterwards.
+  @param[in]     pQ7       points to input value
+  @param[in]     value     Q31 value
+  @return        none
+ */
+__STATIC_FORCEINLINE void write_q7x4_ia (
+  q7_t ** pQ7,
+  q31_t   value)
+{
+  q31_t val = value;
+#ifdef __ARM_FEATURE_UNALIGNED
+  memcpy (*pQ7, &val, 4);
+#else
+  (*pQ7)[0] = val & 0x0FF;
+  (*pQ7)[1] = (val >> 8) & 0x0FF;
+  (*pQ7)[2] = (val >> 16) & 0x0FF;
+  (*pQ7)[3] = (val >> 24) & 0x0FF;
+
+#endif
+  *pQ7 += 4;
+}
+
+/*
+
+Normally those kind of definitions are in a compiler file
+in Core or Core_A.
+
+But for MSVC compiler it is a bit special. The goal is very specific
+to CMSIS-DSP and only to allow the use of this library from other
+systems like Python or Matlab.
+
+MSVC is not going to be used to cross-compile to ARM. So, having a MSVC
+compiler file in Core or Core_A would not make sense.
+
+*/
+#if defined ( _MSC_VER ) || defined(__GNUC_PYTHON__)
+    __STATIC_FORCEINLINE uint8_t __CLZ(uint32_t data)
+    {
+      if (data == 0U) { return 32U; }
+
+      uint32_t count = 0U;
+      uint32_t mask = 0x80000000U;
+
+      while ((data & mask) == 0U)
+      {
+        count += 1U;
+        mask = mask >> 1U;
+      }
+      return count;
+    }
+
+  __STATIC_FORCEINLINE int32_t __SSAT(int32_t val, uint32_t sat)
+  {
+    if ((sat >= 1U) && (sat <= 32U))
+    {
+      const int32_t max = (int32_t)((1U << (sat - 1U)) - 1U);
+      const int32_t min = -1 - max ;
+      if (val > max)
+      {
+        return max;
+      }
+      else if (val < min)
+      {
+        return min;
+      }
+    }
+    return val;
+  }
+
+  __STATIC_FORCEINLINE uint32_t __USAT(int32_t val, uint32_t sat)
+  {
+    if (sat <= 31U)
+    {
+      const uint32_t max = ((1U << sat) - 1U);
+      if (val > (int32_t)max)
+      {
+        return max;
+      }
+      else if (val < 0)
+      {
+        return 0U;
+      }
+    }
+    return (uint32_t)val;
+  }
+#endif
+
+#ifndef ARM_MATH_DSP
+  /**
+   * @brief definition to pack two 16 bit values.
+   */
+  #define __PKHBT(ARG1, ARG2, ARG3) ( (((int32_t)(ARG1) <<    0) & (int32_t)0x0000FFFF) | \
+                                      (((int32_t)(ARG2) << ARG3) & (int32_t)0xFFFF0000)  )
+  #define __PKHTB(ARG1, ARG2, ARG3) ( (((int32_t)(ARG1) <<    0) & (int32_t)0xFFFF0000) | \
+                                      (((int32_t)(ARG2) >> ARG3) & (int32_t)0x0000FFFF)  )
+#endif
+
+   /**
+   * @brief definition to pack four 8 bit values.
+   */
+#ifndef ARM_MATH_BIG_ENDIAN
+  #define __PACKq7(v0,v1,v2,v3) ( (((int32_t)(v0) <<  0) & (int32_t)0x000000FF) | \
+                                  (((int32_t)(v1) <<  8) & (int32_t)0x0000FF00) | \
+                                  (((int32_t)(v2) << 16) & (int32_t)0x00FF0000) | \
+                                  (((int32_t)(v3) << 24) & (int32_t)0xFF000000)  )
+#else
+  #define __PACKq7(v0,v1,v2,v3) ( (((int32_t)(v3) <<  0) & (int32_t)0x000000FF) | \
+                                  (((int32_t)(v2) <<  8) & (int32_t)0x0000FF00) | \
+                                  (((int32_t)(v1) << 16) & (int32_t)0x00FF0000) | \
+                                  (((int32_t)(v0) << 24) & (int32_t)0xFF000000)  )
+#endif
+
+
+  /**
+   * @brief Clips Q63 to Q31 values.
+   */
+  __STATIC_FORCEINLINE q31_t clip_q63_to_q31(
+  q63_t x)
+  {
+    return ((q31_t) (x >> 32) != ((q31_t) x >> 31)) ?
+      ((0x7FFFFFFF ^ ((q31_t) (x >> 63)))) : (q31_t) x;
+  }
+
+  /**
+   * @brief Clips Q63 to Q15 values.
+   */
+  __STATIC_FORCEINLINE q15_t clip_q63_to_q15(
+  q63_t x)
+  {
+    return ((q31_t) (x >> 32) != ((q31_t) x >> 31)) ?
+      ((0x7FFF ^ ((q15_t) (x >> 63)))) : (q15_t) (x >> 15);
+  }
+
+  /**
+   * @brief Clips Q31 to Q7 values.
+   */
+  __STATIC_FORCEINLINE q7_t clip_q31_to_q7(
+  q31_t x)
+  {
+    return ((q31_t) (x >> 24) != ((q31_t) x >> 23)) ?
+      ((0x7F ^ ((q7_t) (x >> 31)))) : (q7_t) x;
+  }
+
+  /**
+   * @brief Clips Q31 to Q15 values.
+   */
+  __STATIC_FORCEINLINE q15_t clip_q31_to_q15(
+  q31_t x)
+  {
+    return ((q31_t) (x >> 16) != ((q31_t) x >> 15)) ?
+      ((0x7FFF ^ ((q15_t) (x >> 31)))) : (q15_t) x;
+  }
+
+  /**
+   * @brief Multiplies 32 X 64 and returns 32 bit result in 2.30 format.
+   */
+  __STATIC_FORCEINLINE q63_t mult32x64(
+  q63_t x,
+  q31_t y)
+  {
+    return ((((q63_t) (x & 0x00000000FFFFFFFF) * y) >> 32) +
+            (((q63_t) (x >> 32)                * y)      )  );
+  }
+
+  /**
+   * @brief Function to Calculates 1/in (reciprocal) value of Q31 Data type.
+   */
+  __STATIC_FORCEINLINE uint32_t arm_recip_q31(
+        q31_t in,
+        q31_t * dst,
+  const q31_t * pRecipTable)
+  {
+    q31_t out;
+    uint32_t tempVal;
+    uint32_t index, i;
+    uint32_t signBits;
+
+    if (in > 0)
+    {
+      signBits = ((uint32_t) (__CLZ( in) - 1));
+    }
+    else
+    {
+      signBits = ((uint32_t) (__CLZ(-in) - 1));
+    }
+
+    /* Convert input sample to 1.31 format */
+    in = (in << signBits);
+
+    /* calculation of index for initial approximated Val */
+    index = (uint32_t)(in >> 24);
+    index = (index & INDEX_MASK);
+
+    /* 1.31 with exp 1 */
+    out = pRecipTable[index];
+
+    /* calculation of reciprocal value */
+    /* running approximation for two iterations */
+    for (i = 0U; i < 2U; i++)
+    {
+      tempVal = (uint32_t) (((q63_t) in * out) >> 31);
+      tempVal = 0x7FFFFFFFu - tempVal;
+      /*      1.31 with exp 1 */
+      /* out = (q31_t) (((q63_t) out * tempVal) >> 30); */
+      out = clip_q63_to_q31(((q63_t) out * tempVal) >> 30);
+    }
+
+    /* write output */
+    *dst = out;
+
+    /* return num of signbits of out = 1/in value */
+    return (signBits + 1U);
+  }
+
+
+  /**
+   * @brief Function to Calculates 1/in (reciprocal) value of Q15 Data type.
+   */
+  __STATIC_FORCEINLINE uint32_t arm_recip_q15(
+        q15_t in,
+        q15_t * dst,
+  const q15_t * pRecipTable)
+  {
+    q15_t out = 0;
+    uint32_t tempVal = 0;
+    uint32_t index = 0, i = 0;
+    uint32_t signBits = 0;
+
+    if (in > 0)
+    {
+      signBits = ((uint32_t)(__CLZ( in) - 17));
+    }
+    else
+    {
+      signBits = ((uint32_t)(__CLZ(-in) - 17));
+    }
+
+    /* Convert input sample to 1.15 format */
+    in = (in << signBits);
+
+    /* calculation of index for initial approximated Val */
+    index = (uint32_t)(in >>  8);
+    index = (index & INDEX_MASK);
+
+    /*      1.15 with exp 1  */
+    out = pRecipTable[index];
+
+    /* calculation of reciprocal value */
+    /* running approximation for two iterations */
+    for (i = 0U; i < 2U; i++)
+    {
+      tempVal = (uint32_t) (((q31_t) in * out) >> 15);
+      tempVal = 0x7FFFu - tempVal;
+      /*      1.15 with exp 1 */
+      out = (q15_t) (((q31_t) out * tempVal) >> 14);
+      /* out = clip_q31_to_q15(((q31_t) out * tempVal) >> 14); */
+    }
+
+    /* write output */
+    *dst = out;
+
+    /* return num of signbits of out = 1/in value */
+    return (signBits + 1);
+  }
+
+/**
+ * @brief Integer exponentiation
+ * @param[in]    x           value
+ * @param[in]    nb          integer exponent >= 1
+ * @return x^nb
+ *
+ */
+__STATIC_INLINE float32_t arm_exponent_f32(float32_t x, int32_t nb)
+{
+    float32_t r = x;
+    nb --;
+    while(nb > 0)
+    {
+        r = r * x;
+        nb--;
+    }
+    return(r);
+}
+
+/**
+ * @brief  64-bit to 32-bit unsigned normalization
+ * @param[in]  in           is input unsigned long long value
+ * @param[out] normalized   is the 32-bit normalized value
+ * @param[out] norm         is norm scale
+ */
+__STATIC_INLINE  void arm_norm_64_to_32u(uint64_t in, int32_t * normalized, int32_t *norm)
+{
+    int32_t     n1;
+    int32_t     hi = (int32_t) (in >> 32);
+    int32_t     lo = (int32_t) ((in << 32) >> 32);
+
+    n1 = __CLZ(hi) - 32;
+    if (!n1)
+    {
+        /*
+         * input fits in 32-bit
+         */
+        n1 = __CLZ(lo);
+        if (!n1)
+        {
+            /*
+             * MSB set, need to scale down by 1
+             */
+            *norm = -1;
+            *normalized = (((uint32_t) lo) >> 1);
+        } else
+        {
+            if (n1 == 32)
+            {
+                /*
+                 * input is zero
+                 */
+                *norm = 0;
+                *normalized = 0;
+            } else
+            {
+                /*
+                 * 32-bit normalization
+                 */
+                *norm = n1 - 1;
+                *normalized = lo << *norm;
+            }
+        }
+    } else
+    {
+        /*
+         * input fits in 64-bit
+         */
+        n1 = 1 - n1;
+        *norm = -n1;
+        /*
+         * 64 bit normalization
+         */
+        *normalized = (((uint32_t) lo) >> n1) | (hi << (32 - n1));
+    }
+}
+
+__STATIC_INLINE q31_t arm_div_q63_to_q31(q63_t num, q31_t den)
+{
+    q31_t   result;
+    uint64_t   absNum;
+    int32_t   normalized;
+    int32_t   norm;
+
+    /*
+     * if sum fits in 32bits
+     * avoid costly 64-bit division
+     */
+    absNum = num > 0 ? num : -num;
+    arm_norm_64_to_32u(absNum, &normalized, &norm);
+    if (norm > 0)
+        /*
+         * 32-bit division
+         */
+        result = (q31_t) num / den;
+    else
+        /*
+         * 64-bit division
+         */
+        result = (q31_t) (num / den);
+
+    return result;
+}
+
+
+/*
+ * @brief C custom defined intrinsic functions
+ */
+#if !defined (ARM_MATH_DSP)
+
+  /*
+   * @brief C custom defined QADD8
+   */
+  __STATIC_FORCEINLINE uint32_t __QADD8(
+  uint32_t x,
+  uint32_t y)
+  {
+    q31_t r, s, t, u;
+
+    r = __SSAT(((((q31_t)x << 24) >> 24) + (((q31_t)y << 24) >> 24)), 8) & (int32_t)0x000000FF;
+    s = __SSAT(((((q31_t)x << 16) >> 24) + (((q31_t)y << 16) >> 24)), 8) & (int32_t)0x000000FF;
+    t = __SSAT(((((q31_t)x <<  8) >> 24) + (((q31_t)y <<  8) >> 24)), 8) & (int32_t)0x000000FF;
+    u = __SSAT(((((q31_t)x      ) >> 24) + (((q31_t)y      ) >> 24)), 8) & (int32_t)0x000000FF;
+
+    return ((uint32_t)((u << 24) | (t << 16) | (s <<  8) | (r      )));
+  }
+
+
+  /*
+   * @brief C custom defined QSUB8
+   */
+  __STATIC_FORCEINLINE uint32_t __QSUB8(
+  uint32_t x,
+  uint32_t y)
+  {
+    q31_t r, s, t, u;
+
+    r = __SSAT(((((q31_t)x << 24) >> 24) - (((q31_t)y << 24) >> 24)), 8) & (int32_t)0x000000FF;
+    s = __SSAT(((((q31_t)x << 16) >> 24) - (((q31_t)y << 16) >> 24)), 8) & (int32_t)0x000000FF;
+    t = __SSAT(((((q31_t)x <<  8) >> 24) - (((q31_t)y <<  8) >> 24)), 8) & (int32_t)0x000000FF;
+    u = __SSAT(((((q31_t)x      ) >> 24) - (((q31_t)y      ) >> 24)), 8) & (int32_t)0x000000FF;
+
+    return ((uint32_t)((u << 24) | (t << 16) | (s <<  8) | (r      )));
+  }
+
+
+  /*
+   * @brief C custom defined QADD16
+   */
+  __STATIC_FORCEINLINE uint32_t __QADD16(
+  uint32_t x,
+  uint32_t y)
+  {
+/*  q31_t r,     s;  without initialisation 'arm_offset_q15 test' fails  but 'intrinsic' tests pass! for armCC */
+    q31_t r = 0, s = 0;
+
+    r = __SSAT(((((q31_t)x << 16) >> 16) + (((q31_t)y << 16) >> 16)), 16) & (int32_t)0x0000FFFF;
+    s = __SSAT(((((q31_t)x      ) >> 16) + (((q31_t)y      ) >> 16)), 16) & (int32_t)0x0000FFFF;
+
+    return ((uint32_t)((s << 16) | (r      )));
+  }
+
+
+  /*
+   * @brief C custom defined SHADD16
+   */
+  __STATIC_FORCEINLINE uint32_t __SHADD16(
+  uint32_t x,
+  uint32_t y)
+  {
+    q31_t r, s;
+
+    r = (((((q31_t)x << 16) >> 16) + (((q31_t)y << 16) >> 16)) >> 1) & (int32_t)0x0000FFFF;
+    s = (((((q31_t)x      ) >> 16) + (((q31_t)y      ) >> 16)) >> 1) & (int32_t)0x0000FFFF;
+
+    return ((uint32_t)((s << 16) | (r      )));
+  }
+
+
+  /*
+   * @brief C custom defined QSUB16
+   */
+  __STATIC_FORCEINLINE uint32_t __QSUB16(
+  uint32_t x,
+  uint32_t y)
+  {
+    q31_t r, s;
+
+    r = __SSAT(((((q31_t)x << 16) >> 16) - (((q31_t)y << 16) >> 16)), 16) & (int32_t)0x0000FFFF;
+    s = __SSAT(((((q31_t)x      ) >> 16) - (((q31_t)y      ) >> 16)), 16) & (int32_t)0x0000FFFF;
+
+    return ((uint32_t)((s << 16) | (r      )));
+  }
+
+
+  /*
+   * @brief C custom defined SHSUB16
+   */
+  __STATIC_FORCEINLINE uint32_t __SHSUB16(
+  uint32_t x,
+  uint32_t y)
+  {
+    q31_t r, s;
+
+    r = (((((q31_t)x << 16) >> 16) - (((q31_t)y << 16) >> 16)) >> 1) & (int32_t)0x0000FFFF;
+    s = (((((q31_t)x      ) >> 16) - (((q31_t)y      ) >> 16)) >> 1) & (int32_t)0x0000FFFF;
+
+    return ((uint32_t)((s << 16) | (r      )));
+  }
+
+
+  /*
+   * @brief C custom defined QASX
+   */
+  __STATIC_FORCEINLINE uint32_t __QASX(
+  uint32_t x,
+  uint32_t y)
+  {
+    q31_t r, s;
+
+    r = __SSAT(((((q31_t)x << 16) >> 16) - (((q31_t)y      ) >> 16)), 16) & (int32_t)0x0000FFFF;
+    s = __SSAT(((((q31_t)x      ) >> 16) + (((q31_t)y << 16) >> 16)), 16) & (int32_t)0x0000FFFF;
+
+    return ((uint32_t)((s << 16) | (r      )));
+  }
+
+
+  /*
+   * @brief C custom defined SHASX
+   */
+  __STATIC_FORCEINLINE uint32_t __SHASX(
+  uint32_t x,
+  uint32_t y)
+  {
+    q31_t r, s;
+
+    r = (((((q31_t)x << 16) >> 16) - (((q31_t)y      ) >> 16)) >> 1) & (int32_t)0x0000FFFF;
+    s = (((((q31_t)x      ) >> 16) + (((q31_t)y << 16) >> 16)) >> 1) & (int32_t)0x0000FFFF;
+
+    return ((uint32_t)((s << 16) | (r      )));
+  }
+
+
+  /*
+   * @brief C custom defined QSAX
+   */
+  __STATIC_FORCEINLINE uint32_t __QSAX(
+  uint32_t x,
+  uint32_t y)
+  {
+    q31_t r, s;
+
+    r = __SSAT(((((q31_t)x << 16) >> 16) + (((q31_t)y      ) >> 16)), 16) & (int32_t)0x0000FFFF;
+    s = __SSAT(((((q31_t)x      ) >> 16) - (((q31_t)y << 16) >> 16)), 16) & (int32_t)0x0000FFFF;
+
+    return ((uint32_t)((s << 16) | (r      )));
+  }
+
+
+  /*
+   * @brief C custom defined SHSAX
+   */
+  __STATIC_FORCEINLINE uint32_t __SHSAX(
+  uint32_t x,
+  uint32_t y)
+  {
+    q31_t r, s;
+
+    r = (((((q31_t)x << 16) >> 16) + (((q31_t)y      ) >> 16)) >> 1) & (int32_t)0x0000FFFF;
+    s = (((((q31_t)x      ) >> 16) - (((q31_t)y << 16) >> 16)) >> 1) & (int32_t)0x0000FFFF;
+
+    return ((uint32_t)((s << 16) | (r      )));
+  }
+
+
+  /*
+   * @brief C custom defined SMUSDX
+   */
+  __STATIC_FORCEINLINE uint32_t __SMUSDX(
+  uint32_t x,
+  uint32_t y)
+  {
+    return ((uint32_t)(((((q31_t)x << 16) >> 16) * (((q31_t)y      ) >> 16)) -
+                       ((((q31_t)x      ) >> 16) * (((q31_t)y << 16) >> 16))   ));
+  }
+
+  /*
+   * @brief C custom defined SMUADX
+   */
+  __STATIC_FORCEINLINE uint32_t __SMUADX(
+  uint32_t x,
+  uint32_t y)
+  {
+    return ((uint32_t)(((((q31_t)x << 16) >> 16) * (((q31_t)y      ) >> 16)) +
+                       ((((q31_t)x      ) >> 16) * (((q31_t)y << 16) >> 16))   ));
+  }
+
+
+  /*
+   * @brief C custom defined QADD
+   */
+  __STATIC_FORCEINLINE int32_t __QADD(
+  int32_t x,
+  int32_t y)
+  {
+    return ((int32_t)(clip_q63_to_q31((q63_t)x + (q31_t)y)));
+  }
+
+
+  /*
+   * @brief C custom defined QSUB
+   */
+  __STATIC_FORCEINLINE int32_t __QSUB(
+  int32_t x,
+  int32_t y)
+  {
+    return ((int32_t)(clip_q63_to_q31((q63_t)x - (q31_t)y)));
+  }
+
+
+  /*
+   * @brief C custom defined SMLAD
+   */
+  __STATIC_FORCEINLINE uint32_t __SMLAD(
+  uint32_t x,
+  uint32_t y,
+  uint32_t sum)
+  {
+    return ((uint32_t)(((((q31_t)x << 16) >> 16) * (((q31_t)y << 16) >> 16)) +
+                       ((((q31_t)x      ) >> 16) * (((q31_t)y      ) >> 16)) +
+                       ( ((q31_t)sum    )                                  )   ));
+  }
+
+
+  /*
+   * @brief C custom defined SMLADX
+   */
+  __STATIC_FORCEINLINE uint32_t __SMLADX(
+  uint32_t x,
+  uint32_t y,
+  uint32_t sum)
+  {
+    return ((uint32_t)(((((q31_t)x << 16) >> 16) * (((q31_t)y      ) >> 16)) +
+                       ((((q31_t)x      ) >> 16) * (((q31_t)y << 16) >> 16)) +
+                       ( ((q31_t)sum    )                                  )   ));
+  }
+
+
+  /*
+   * @brief C custom defined SMLSDX
+   */
+  __STATIC_FORCEINLINE uint32_t __SMLSDX(
+  uint32_t x,
+  uint32_t y,
+  uint32_t sum)
+  {
+    return ((uint32_t)(((((q31_t)x << 16) >> 16) * (((q31_t)y      ) >> 16)) -
+                       ((((q31_t)x      ) >> 16) * (((q31_t)y << 16) >> 16)) +
+                       ( ((q31_t)sum    )                                  )   ));
+  }
+
+
+  /*
+   * @brief C custom defined SMLALD
+   */
+  __STATIC_FORCEINLINE uint64_t __SMLALD(
+  uint32_t x,
+  uint32_t y,
+  uint64_t sum)
+  {
+/*  return (sum + ((q15_t) (x >> 16) * (q15_t) (y >> 16)) + ((q15_t) x * (q15_t) y)); */
+    return ((uint64_t)(((((q31_t)x << 16) >> 16) * (((q31_t)y << 16) >> 16)) +
+                       ((((q31_t)x      ) >> 16) * (((q31_t)y      ) >> 16)) +
+                       ( ((q63_t)sum    )                                  )   ));
+  }
+
+
+  /*
+   * @brief C custom defined SMLALDX
+   */
+  __STATIC_FORCEINLINE uint64_t __SMLALDX(
+  uint32_t x,
+  uint32_t y,
+  uint64_t sum)
+  {
+/*  return (sum + ((q15_t) (x >> 16) * (q15_t) y)) + ((q15_t) x * (q15_t) (y >> 16)); */
+    return ((uint64_t)(((((q31_t)x << 16) >> 16) * (((q31_t)y      ) >> 16)) +
+                       ((((q31_t)x      ) >> 16) * (((q31_t)y << 16) >> 16)) +
+                       ( ((q63_t)sum    )                                  )   ));
+  }
+
+
+  /*
+   * @brief C custom defined SMUAD
+   */
+  __STATIC_FORCEINLINE uint32_t __SMUAD(
+  uint32_t x,
+  uint32_t y)
+  {
+    return ((uint32_t)(((((q31_t)x << 16) >> 16) * (((q31_t)y << 16) >> 16)) +
+                       ((((q31_t)x      ) >> 16) * (((q31_t)y      ) >> 16))   ));
+  }
+
+
+  /*
+   * @brief C custom defined SMUSD
+   */
+  __STATIC_FORCEINLINE uint32_t __SMUSD(
+  uint32_t x,
+  uint32_t y)
+  {
+    return ((uint32_t)(((((q31_t)x << 16) >> 16) * (((q31_t)y << 16) >> 16)) -
+                       ((((q31_t)x      ) >> 16) * (((q31_t)y      ) >> 16))   ));
+  }
+
+
+  /*
+   * @brief C custom defined SXTB16
+   */
+  __STATIC_FORCEINLINE uint32_t __SXTB16(
+  uint32_t x)
+  {
+    return ((uint32_t)(((((q31_t)x << 24) >> 24) & (q31_t)0x0000FFFF) |
+                       ((((q31_t)x <<  8) >>  8) & (q31_t)0xFFFF0000)  ));
+  }
+
+  /*
+   * @brief C custom defined SMMLA
+   */
+  __STATIC_FORCEINLINE int32_t __SMMLA(
+  int32_t x,
+  int32_t y,
+  int32_t sum)
+  {
+    return (sum + (int32_t) (((int64_t) x * y) >> 32));
+  }
+
+#endif /* !defined (ARM_MATH_DSP) */
+
+
+  /**
+   * @brief Instance structure for the Q7 FIR filter.
+   */
+  typedef struct
+  {
+          uint16_t numTaps;        /**< number of filter coefficients in the filter. */
+          q7_t *pState;            /**< points to the state variable array. The array is of length numTaps+blockSize-1. */
+    const q7_t *pCoeffs;           /**< points to the coefficient array. The array is of length numTaps.*/
+  } arm_fir_instance_q7;
+
+  /**
+   * @brief Instance structure for the Q15 FIR filter.
+   */
+  typedef struct
+  {
+          uint16_t numTaps;         /**< number of filter coefficients in the filter. */
+          q15_t *pState;            /**< points to the state variable array. The array is of length numTaps+blockSize-1. */
+    const q15_t *pCoeffs;           /**< points to the coefficient array. The array is of length numTaps.*/
+  } arm_fir_instance_q15;
+
+  /**
+   * @brief Instance structure for the Q31 FIR filter.
+   */
+  typedef struct
+  {
+          uint16_t numTaps;         /**< number of filter coefficients in the filter. */
+          q31_t *pState;            /**< points to the state variable array. The array is of length numTaps+blockSize-1. */
+    const q31_t *pCoeffs;           /**< points to the coefficient array. The array is of length numTaps. */
+  } arm_fir_instance_q31;
+
+  /**
+   * @brief Instance structure for the floating-point FIR filter.
+   */
+  typedef struct
+  {
+          uint16_t numTaps;     /**< number of filter coefficients in the filter. */
+          float32_t *pState;    /**< points to the state variable array. The array is of length numTaps+blockSize-1. */
+    const float32_t *pCoeffs;   /**< points to the coefficient array. The array is of length numTaps. */
+  } arm_fir_instance_f32;
+
+  /**
+   * @brief Processing function for the Q7 FIR filter.
+   * @param[in]  S          points to an instance of the Q7 FIR filter structure.
+   * @param[in]  pSrc       points to the block of input data.
+   * @param[out] pDst       points to the block of output data.
+   * @param[in]  blockSize  number of samples to process.
+   */
+  void arm_fir_q7(
+  const arm_fir_instance_q7 * S,
+  const q7_t * pSrc,
+        q7_t * pDst,
+        uint32_t blockSize);
+
+  /**
+   * @brief  Initialization function for the Q7 FIR filter.
+   * @param[in,out] S          points to an instance of the Q7 FIR structure.
+   * @param[in]     numTaps    Number of filter coefficients in the filter.
+   * @param[in]     pCoeffs    points to the filter coefficients.
+   * @param[in]     pState     points to the state buffer.
+   * @param[in]     blockSize  number of samples that are processed.
+   */
+  void arm_fir_init_q7(
+        arm_fir_instance_q7 * S,
+        uint16_t numTaps,
+  const q7_t * pCoeffs,
+        q7_t * pState,
+        uint32_t blockSize);
+
+  /**
+   * @brief Processing function for the Q15 FIR filter.
+   * @param[in]  S          points to an instance of the Q15 FIR structure.
+   * @param[in]  pSrc       points to the block of input data.
+   * @param[out] pDst       points to the block of output data.
+   * @param[in]  blockSize  number of samples to process.
+   */
+  void arm_fir_q15(
+  const arm_fir_instance_q15 * S,
+  const q15_t * pSrc,
+        q15_t * pDst,
+        uint32_t blockSize);
+
+  /**
+   * @brief Processing function for the fast Q15 FIR filter (fast version).
+   * @param[in]  S          points to an instance of the Q15 FIR filter structure.
+   * @param[in]  pSrc       points to the block of input data.
+   * @param[out] pDst       points to the block of output data.
+   * @param[in]  blockSize  number of samples to process.
+   */
+  void arm_fir_fast_q15(
+  const arm_fir_instance_q15 * S,
+  const q15_t * pSrc,
+        q15_t * pDst,
+        uint32_t blockSize);
+
+  /**
+   * @brief  Initialization function for the Q15 FIR filter.
+   * @param[in,out] S          points to an instance of the Q15 FIR filter structure.
+   * @param[in]     numTaps    Number of filter coefficients in the filter. Must be even and greater than or equal to 4.
+   * @param[in]     pCoeffs    points to the filter coefficients.
+   * @param[in]     pState     points to the state buffer.
+   * @param[in]     blockSize  number of samples that are processed at a time.
+   * @return     The function returns either
+   * <code>ARM_MATH_SUCCESS</code> if initialization was successful or
+   * <code>ARM_MATH_ARGUMENT_ERROR</code> if <code>numTaps</code> is not a supported value.
+   */
+  arm_status arm_fir_init_q15(
+        arm_fir_instance_q15 * S,
+        uint16_t numTaps,
+  const q15_t * pCoeffs,
+        q15_t * pState,
+        uint32_t blockSize);
+
+  /**
+   * @brief Processing function for the Q31 FIR filter.
+   * @param[in]  S          points to an instance of the Q31 FIR filter structure.
+   * @param[in]  pSrc       points to the block of input data.
+   * @param[out] pDst       points to the block of output data.
+   * @param[in]  blockSize  number of samples to process.
+   */
+  void arm_fir_q31(
+  const arm_fir_instance_q31 * S,
+  const q31_t * pSrc,
+        q31_t * pDst,
+        uint32_t blockSize);
+
+  /**
+   * @brief Processing function for the fast Q31 FIR filter (fast version).
+   * @param[in]  S          points to an instance of the Q31 FIR filter structure.
+   * @param[in]  pSrc       points to the block of input data.
+   * @param[out] pDst       points to the block of output data.
+   * @param[in]  blockSize  number of samples to process.
+   */
+  void arm_fir_fast_q31(
+  const arm_fir_instance_q31 * S,
+  const q31_t * pSrc,
+        q31_t * pDst,
+        uint32_t blockSize);
+
+  /**
+   * @brief  Initialization function for the Q31 FIR filter.
+   * @param[in,out] S          points to an instance of the Q31 FIR structure.
+   * @param[in]     numTaps    Number of filter coefficients in the filter.
+   * @param[in]     pCoeffs    points to the filter coefficients.
+   * @param[in]     pState     points to the state buffer.
+   * @param[in]     blockSize  number of samples that are processed at a time.
+   */
+  void arm_fir_init_q31(
+        arm_fir_instance_q31 * S,
+        uint16_t numTaps,
+  const q31_t * pCoeffs,
+        q31_t * pState,
+        uint32_t blockSize);
+
+  /**
+   * @brief Processing function for the floating-point FIR filter.
+   * @param[in]  S          points to an instance of the floating-point FIR structure.
+   * @param[in]  pSrc       points to the block of input data.
+   * @param[out] pDst       points to the block of output data.
+   * @param[in]  blockSize  number of samples to process.
+   */
+  void arm_fir_f32(
+  const arm_fir_instance_f32 * S,
+  const float32_t * pSrc,
+        float32_t * pDst,
+        uint32_t blockSize);
+
+  /**
+   * @brief  Initialization function for the floating-point FIR filter.
+   * @param[in,out] S          points to an instance of the floating-point FIR filter structure.
+   * @param[in]     numTaps    Number of filter coefficients in the filter.
+   * @param[in]     pCoeffs    points to the filter coefficients.
+   * @param[in]     pState     points to the state buffer.
+   * @param[in]     blockSize  number of samples that are processed at a time.
+   */
+  void arm_fir_init_f32(
+        arm_fir_instance_f32 * S,
+        uint16_t numTaps,
+  const float32_t * pCoeffs,
+        float32_t * pState,
+        uint32_t blockSize);
+
+  /**
+   * @brief Instance structure for the Q15 Biquad cascade filter.
+   */
+  typedef struct
+  {
+          int8_t numStages;        /**< number of 2nd order stages in the filter.  Overall order is 2*numStages. */
+          q15_t *pState;           /**< Points to the array of state coefficients.  The array is of length 4*numStages. */
+    const q15_t *pCoeffs;          /**< Points to the array of coefficients.  The array is of length 5*numStages. */
+          int8_t postShift;        /**< Additional shift, in bits, applied to each output sample. */
+  } arm_biquad_casd_df1_inst_q15;
+
+  /**
+   * @brief Instance structure for the Q31 Biquad cascade filter.
+   */
+  typedef struct
+  {
+          uint32_t numStages;      /**< number of 2nd order stages in the filter.  Overall order is 2*numStages. */
+          q31_t *pState;           /**< Points to the array of state coefficients.  The array is of length 4*numStages. */
+    const q31_t *pCoeffs;          /**< Points to the array of coefficients.  The array is of length 5*numStages. */
+          uint8_t postShift;       /**< Additional shift, in bits, applied to each output sample. */
+  } arm_biquad_casd_df1_inst_q31;
+
+  /**
+   * @brief Instance structure for the floating-point Biquad cascade filter.
+   */
+  typedef struct
+  {
+          uint32_t numStages;      /**< number of 2nd order stages in the filter.  Overall order is 2*numStages. */
+          float32_t *pState;       /**< Points to the array of state coefficients.  The array is of length 4*numStages. */
+    const float32_t *pCoeffs;      /**< Points to the array of coefficients.  The array is of length 5*numStages. */
+  } arm_biquad_casd_df1_inst_f32;
+
+#if defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE)
+  /**
+   * @brief Instance structure for the modified Biquad coefs required by vectorized code.
+   */
+  typedef struct
+  {
+      float32_t coeffs[8][4]; /**< Points to the array of modified coefficients.  The array is of length 32. There is one per stage */
+  } arm_biquad_mod_coef_f32;
+#endif 
+
+  /**
+   * @brief Processing function for the Q15 Biquad cascade filter.
+   * @param[in]  S          points to an instance of the Q15 Biquad cascade structure.
+   * @param[in]  pSrc       points to the block of input data.
+   * @param[out] pDst       points to the block of output data.
+   * @param[in]  blockSize  number of samples to process.
+   */
+  void arm_biquad_cascade_df1_q15(
+  const arm_biquad_casd_df1_inst_q15 * S,
+  const q15_t * pSrc,
+        q15_t * pDst,
+        uint32_t blockSize);
+
+  /**
+   * @brief  Initialization function for the Q15 Biquad cascade filter.
+   * @param[in,out] S          points to an instance of the Q15 Biquad cascade structure.
+   * @param[in]     numStages  number of 2nd order stages in the filter.
+   * @param[in]     pCoeffs    points to the filter coefficients.
+   * @param[in]     pState     points to the state buffer.
+   * @param[in]     postShift  Shift to be applied to the output. Varies according to the coefficients format
+   */
+  void arm_biquad_cascade_df1_init_q15(
+        arm_biquad_casd_df1_inst_q15 * S,
+        uint8_t numStages,
+  const q15_t * pCoeffs,
+        q15_t * pState,
+        int8_t postShift);
+
+  /**
+   * @brief Fast but less precise processing function for the Q15 Biquad cascade filter for Cortex-M3 and Cortex-M4.
+   * @param[in]  S          points to an instance of the Q15 Biquad cascade structure.
+   * @param[in]  pSrc       points to the block of input data.
+   * @param[out] pDst       points to the block of output data.
+   * @param[in]  blockSize  number of samples to process.
+   */
+  void arm_biquad_cascade_df1_fast_q15(
+  const arm_biquad_casd_df1_inst_q15 * S,
+  const q15_t * pSrc,
+        q15_t * pDst,
+        uint32_t blockSize);
+
+  /**
+   * @brief Processing function for the Q31 Biquad cascade filter
+   * @param[in]  S          points to an instance of the Q31 Biquad cascade structure.
+   * @param[in]  pSrc       points to the block of input data.
+   * @param[out] pDst       points to the block of output data.
+   * @param[in]  blockSize  number of samples to process.
+   */
+  void arm_biquad_cascade_df1_q31(
+  const arm_biquad_casd_df1_inst_q31 * S,
+  const q31_t * pSrc,
+        q31_t * pDst,
+        uint32_t blockSize);
+
+  /**
+   * @brief Fast but less precise processing function for the Q31 Biquad cascade filter for Cortex-M3 and Cortex-M4.
+   * @param[in]  S          points to an instance of the Q31 Biquad cascade structure.
+   * @param[in]  pSrc       points to the block of input data.
+   * @param[out] pDst       points to the block of output data.
+   * @param[in]  blockSize  number of samples to process.
+   */
+  void arm_biquad_cascade_df1_fast_q31(
+  const arm_biquad_casd_df1_inst_q31 * S,
+  const q31_t * pSrc,
+        q31_t * pDst,
+        uint32_t blockSize);
+
+  /**
+   * @brief  Initialization function for the Q31 Biquad cascade filter.
+   * @param[in,out] S          points to an instance of the Q31 Biquad cascade structure.
+   * @param[in]     numStages  number of 2nd order stages in the filter.
+   * @param[in]     pCoeffs    points to the filter coefficients.
+   * @param[in]     pState     points to the state buffer.
+   * @param[in]     postShift  Shift to be applied to the output. Varies according to the coefficients format
+   */
+  void arm_biquad_cascade_df1_init_q31(
+        arm_biquad_casd_df1_inst_q31 * S,
+        uint8_t numStages,
+  const q31_t * pCoeffs,
+        q31_t * pState,
+        int8_t postShift);
+
+  /**
+   * @brief Processing function for the floating-point Biquad cascade filter.
+   * @param[in]  S          points to an instance of the floating-point Biquad cascade structure.
+   * @param[in]  pSrc       points to the block of input data.
+   * @param[out] pDst       points to the block of output data.
+   * @param[in]  blockSize  number of samples to process.
+   */
+  void arm_biquad_cascade_df1_f32(
+  const arm_biquad_casd_df1_inst_f32 * S,
+  const float32_t * pSrc,
+        float32_t * pDst,
+        uint32_t blockSize);
+
+  /**
+   * @brief  Initialization function for the floating-point Biquad cascade filter.
+   * @param[in,out] S          points to an instance of the floating-point Biquad cascade structure.
+   * @param[in]     numStages  number of 2nd order stages in the filter.
+   * @param[in]     pCoeffs    points to the filter coefficients.
+   * @param[in]     pCoeffsMod points to the modified filter coefficients (only MVE version).
+   * @param[in]     pState     points to the state buffer.
+   */
+#if defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE)
+  void arm_biquad_cascade_df1_mve_init_f32(
+      arm_biquad_casd_df1_inst_f32 * S,
+      uint8_t numStages,
+      const float32_t * pCoeffs, 
+      arm_biquad_mod_coef_f32 * pCoeffsMod, 
+      float32_t * pState);
+#endif
+  
+  void arm_biquad_cascade_df1_init_f32(
+        arm_biquad_casd_df1_inst_f32 * S,
+        uint8_t numStages,
+  const float32_t * pCoeffs,
+        float32_t * pState);
+
+
+  /**
+   * @brief         Compute the logical bitwise AND of two fixed-point vectors.
+   * @param[in]     pSrcA      points to input vector A
+   * @param[in]     pSrcB      points to input vector B
+   * @param[out]    pDst       points to output vector
+   * @param[in]     blockSize  number of samples in each vector
+   * @return        none
+   */
+  void arm_and_u16(
+    const uint16_t * pSrcA,
+    const uint16_t * pSrcB,
+          uint16_t * pDst,
+          uint32_t blockSize);
+
+  /**
+   * @brief         Compute the logical bitwise AND of two fixed-point vectors.
+   * @param[in]     pSrcA      points to input vector A
+   * @param[in]     pSrcB      points to input vector B
+   * @param[out]    pDst       points to output vector
+   * @param[in]     blockSize  number of samples in each vector
+   * @return        none
+   */
+  void arm_and_u32(
+    const uint32_t * pSrcA,
+    const uint32_t * pSrcB,
+          uint32_t * pDst,
+          uint32_t blockSize);
+
+  /**
+   * @brief         Compute the logical bitwise AND of two fixed-point vectors.
+   * @param[in]     pSrcA      points to input vector A
+   * @param[in]     pSrcB      points to input vector B
+   * @param[out]    pDst       points to output vector
+   * @param[in]     blockSize  number of samples in each vector
+   * @return        none
+   */
+  void arm_and_u8(
+    const uint8_t * pSrcA,
+    const uint8_t * pSrcB,
+          uint8_t * pDst,
+          uint32_t blockSize);
+
+  /**
+   * @brief         Compute the logical bitwise OR of two fixed-point vectors.
+   * @param[in]     pSrcA      points to input vector A
+   * @param[in]     pSrcB      points to input vector B
+   * @param[out]    pDst       points to output vector
+   * @param[in]     blockSize  number of samples in each vector
+   * @return        none
+   */
+  void arm_or_u16(
+    const uint16_t * pSrcA,
+    const uint16_t * pSrcB,
+          uint16_t * pDst,
+          uint32_t blockSize);
+
+  /**
+   * @brief         Compute the logical bitwise OR of two fixed-point vectors.
+   * @param[in]     pSrcA      points to input vector A
+   * @param[in]     pSrcB      points to input vector B
+   * @param[out]    pDst       points to output vector
+   * @param[in]     blockSize  number of samples in each vector
+   * @return        none
+   */
+  void arm_or_u32(
+    const uint32_t * pSrcA,
+    const uint32_t * pSrcB,
+          uint32_t * pDst,
+          uint32_t blockSize);
+
+  /**
+   * @brief         Compute the logical bitwise OR of two fixed-point vectors.
+   * @param[in]     pSrcA      points to input vector A
+   * @param[in]     pSrcB      points to input vector B
+   * @param[out]    pDst       points to output vector
+   * @param[in]     blockSize  number of samples in each vector
+   * @return        none
+   */
+  void arm_or_u8(
+    const uint8_t * pSrcA,
+    const uint8_t * pSrcB,
+          uint8_t * pDst,
+          uint32_t blockSize);
+
+  /**
+   * @brief         Compute the logical bitwise NOT of a fixed-point vector.
+   * @param[in]     pSrc       points to input vector 
+   * @param[out]    pDst       points to output vector
+   * @param[in]     blockSize  number of samples in each vector
+   * @return        none
+   */
+  void arm_not_u16(
+    const uint16_t * pSrc,
+          uint16_t * pDst,
+          uint32_t blockSize);
+
+  /**
+   * @brief         Compute the logical bitwise NOT of a fixed-point vector.
+   * @param[in]     pSrc       points to input vector 
+   * @param[out]    pDst       points to output vector
+   * @param[in]     blockSize  number of samples in each vector
+   * @return        none
+   */
+  void arm_not_u32(
+    const uint32_t * pSrc,
+          uint32_t * pDst,
+          uint32_t blockSize);
+
+  /**
+   * @brief         Compute the logical bitwise NOT of a fixed-point vector.
+   * @param[in]     pSrc       points to input vector 
+   * @param[out]    pDst       points to output vector
+   * @param[in]     blockSize  number of samples in each vector
+   * @return        none
+   */
+  void arm_not_u8(
+    const uint8_t * pSrc,
+          uint8_t * pDst,
+          uint32_t blockSize);
+
+/**
+   * @brief         Compute the logical bitwise XOR of two fixed-point vectors.
+   * @param[in]     pSrcA      points to input vector A
+   * @param[in]     pSrcB      points to input vector B
+   * @param[out]    pDst       points to output vector
+   * @param[in]     blockSize  number of samples in each vector
+   * @return        none
+   */
+  void arm_xor_u16(
+    const uint16_t * pSrcA,
+    const uint16_t * pSrcB,
+          uint16_t * pDst,
+          uint32_t blockSize);
+
+  /**
+   * @brief         Compute the logical bitwise XOR of two fixed-point vectors.
+   * @param[in]     pSrcA      points to input vector A
+   * @param[in]     pSrcB      points to input vector B
+   * @param[out]    pDst       points to output vector
+   * @param[in]     blockSize  number of samples in each vector
+   * @return        none
+   */
+  void arm_xor_u32(
+    const uint32_t * pSrcA,
+    const uint32_t * pSrcB,
+          uint32_t * pDst,
+          uint32_t blockSize);
+
+  /**
+   * @brief         Compute the logical bitwise XOR of two fixed-point vectors.
+   * @param[in]     pSrcA      points to input vector A
+   * @param[in]     pSrcB      points to input vector B
+   * @param[out]    pDst       points to output vector
+   * @param[in]     blockSize  number of samples in each vector
+   * @return        none
+   */
+  void arm_xor_u8(
+    const uint8_t * pSrcA,
+    const uint8_t * pSrcB,
+          uint8_t * pDst,
+    uint32_t blockSize);
+
+  /**
+   * @brief Struct for specifying sorting algorithm
+   */
+  typedef enum
+  {
+    ARM_SORT_BITONIC   = 0,
+             /**< Bitonic sort   */
+    ARM_SORT_BUBBLE    = 1,
+             /**< Bubble sort    */
+    ARM_SORT_HEAP      = 2,
+             /**< Heap sort      */
+    ARM_SORT_INSERTION = 3,
+             /**< Insertion sort */
+    ARM_SORT_QUICK     = 4,
+             /**< Quick sort     */
+    ARM_SORT_SELECTION = 5
+             /**< Selection sort */
+  } arm_sort_alg;
+
+  /**
+   * @brief Struct for specifying sorting algorithm
+   */
+  typedef enum
+  {
+    ARM_SORT_DESCENDING = 0,
+             /**< Descending order (9 to 0) */
+    ARM_SORT_ASCENDING = 1
+             /**< Ascending order (0 to 9) */
+  } arm_sort_dir;
+
+  /**
+   * @brief Instance structure for the sorting algorithms.
+   */
+  typedef struct            
+  {
+    arm_sort_alg alg;        /**< Sorting algorithm selected */
+    arm_sort_dir dir;        /**< Sorting order (direction)  */
+  } arm_sort_instance_f32;  
+
+  /**
+   * @param[in]  S          points to an instance of the sorting structure.
+   * @param[in]  pSrc       points to the block of input data.
+   * @param[out] pDst       points to the block of output data.
+   * @param[in]  blockSize  number of samples to process.
+   */
+  void arm_sort_f32(
+    const arm_sort_instance_f32 * S, 
+          float32_t * pSrc, 
+          float32_t * pDst, 
+          uint32_t blockSize);
+
+  /**
+   * @param[in,out]  S            points to an instance of the sorting structure.
+   * @param[in]      alg          Selected algorithm.
+   * @param[in]      dir          Sorting order.
+   */
+  void arm_sort_init_f32(
+    arm_sort_instance_f32 * S, 
+    arm_sort_alg alg, 
+    arm_sort_dir dir); 
+
+  /**
+   * @brief Instance structure for the sorting algorithms.
+   */
+  typedef struct            
+  {
+    arm_sort_dir dir;        /**< Sorting order (direction)  */
+    float32_t * buffer;      /**< Working buffer */
+  } arm_merge_sort_instance_f32;  
+
+  /**
+   * @param[in]      S          points to an instance of the sorting structure.
+   * @param[in,out]  pSrc       points to the block of input data.
+   * @param[out]     pDst       points to the block of output data
+   * @param[in]      blockSize  number of samples to process.
+   */
+  void arm_merge_sort_f32(
+    const arm_merge_sort_instance_f32 * S,
+          float32_t *pSrc,
+          float32_t *pDst,
+          uint32_t blockSize);
+
+  /**
+   * @param[in,out]  S            points to an instance of the sorting structure.
+   * @param[in]      dir          Sorting order.
+   * @param[in]      buffer       Working buffer.
+   */
+  void arm_merge_sort_init_f32(
+    arm_merge_sort_instance_f32 * S,
+    arm_sort_dir dir,
+    float32_t * buffer);
+
+  /**
+   * @brief Struct for specifying cubic spline type
+   */
+  typedef enum
+  {
+    ARM_SPLINE_NATURAL = 0,           /**< Natural spline */
+    ARM_SPLINE_PARABOLIC_RUNOUT = 1   /**< Parabolic runout spline */
+  } arm_spline_type;
+
+  /**
+   * @brief Instance structure for the floating-point cubic spline interpolation.
+   */
+  typedef struct
+  {
+    arm_spline_type type;      /**< Type (boundary conditions) */
+    const float32_t * x;       /**< x values */
+    const float32_t * y;       /**< y values */
+    uint32_t n_x;              /**< Number of known data points */
+    float32_t * coeffs;        /**< Coefficients buffer (b,c, and d) */
+  } arm_spline_instance_f32;
+
+  /**
+   * @brief Processing function for the floating-point cubic spline interpolation.
+   * @param[in]  S          points to an instance of the floating-point spline structure.
+   * @param[in]  xq         points to the x values ot the interpolated data points.
+   * @param[out] pDst       points to the block of output data.
+   * @param[in]  blockSize  number of samples of output data.
+   */
+  void arm_spline_f32(
+        arm_spline_instance_f32 * S, 
+  const float32_t * xq,
+        float32_t * pDst,
+        uint32_t blockSize);
+
+  /**
+   * @brief Initialization function for the floating-point cubic spline interpolation.
+   * @param[in,out] S        points to an instance of the floating-point spline structure.
+   * @param[in]     type     type of cubic spline interpolation (boundary conditions)
+   * @param[in]     x        points to the x values of the known data points.
+   * @param[in]     y        points to the y values of the known data points.
+   * @param[in]     n        number of known data points.
+   * @param[in]     coeffs   coefficients array for b, c, and d
+   * @param[in]     tempBuffer   buffer array for internal computations
+   */
+  void arm_spline_init_f32(
+          arm_spline_instance_f32 * S,
+          arm_spline_type type,
+    const float32_t * x,
+    const float32_t * y,
+          uint32_t n, 
+          float32_t * coeffs,
+          float32_t * tempBuffer);
+
+  /**
+   * @brief Instance structure for the floating-point matrix structure.
+   */
+  typedef struct
+  {
+    uint16_t numRows;     /**< number of rows of the matrix.     */
+    uint16_t numCols;     /**< number of columns of the matrix.  */
+    float32_t *pData;     /**< points to the data of the matrix. */
+  } arm_matrix_instance_f32;
+ 
+ /**
+   * @brief Instance structure for the floating-point matrix structure.
+   */
+  typedef struct
+  {
+    uint16_t numRows;     /**< number of rows of the matrix.     */
+    uint16_t numCols;     /**< number of columns of the matrix.  */
+    float64_t *pData;     /**< points to the data of the matrix. */
+  } arm_matrix_instance_f64;
+
+  /**
+   * @brief Instance structure for the Q15 matrix structure.
+   */
+  typedef struct
+  {
+    uint16_t numRows;     /**< number of rows of the matrix.     */
+    uint16_t numCols;     /**< number of columns of the matrix.  */
+    q15_t *pData;         /**< points to the data of the matrix. */
+  } arm_matrix_instance_q15;
+
+  /**
+   * @brief Instance structure for the Q31 matrix structure.
+   */
+  typedef struct
+  {
+    uint16_t numRows;     /**< number of rows of the matrix.     */
+    uint16_t numCols;     /**< number of columns of the matrix.  */
+    q31_t *pData;         /**< points to the data of the matrix. */
+  } arm_matrix_instance_q31;
+
+  /**
+   * @brief Floating-point matrix addition.
+   * @param[in]  pSrcA  points to the first input matrix structure
+   * @param[in]  pSrcB  points to the second input matrix structure
+   * @param[out] pDst   points to output matrix structure
+   * @return     The function returns either
+   * <code>ARM_MATH_SIZE_MISMATCH</code> or <code>ARM_MATH_SUCCESS</code> based on the outcome of size checking.
+   */
+arm_status arm_mat_add_f32(
+  const arm_matrix_instance_f32 * pSrcA,
+  const arm_matrix_instance_f32 * pSrcB,
+        arm_matrix_instance_f32 * pDst);
+
+  /**
+   * @brief Q15 matrix addition.
+   * @param[in]   pSrcA  points to the first input matrix structure
+   * @param[in]   pSrcB  points to the second input matrix structure
+   * @param[out]  pDst   points to output matrix structure
+   * @return     The function returns either
+   * <code>ARM_MATH_SIZE_MISMATCH</code> or <code>ARM_MATH_SUCCESS</code> based on the outcome of size checking.
+   */
+arm_status arm_mat_add_q15(
+  const arm_matrix_instance_q15 * pSrcA,
+  const arm_matrix_instance_q15 * pSrcB,
+        arm_matrix_instance_q15 * pDst);
+
+  /**
+   * @brief Q31 matrix addition.
+   * @param[in]  pSrcA  points to the first input matrix structure
+   * @param[in]  pSrcB  points to the second input matrix structure
+   * @param[out] pDst   points to output matrix structure
+   * @return     The function returns either
+   * <code>ARM_MATH_SIZE_MISMATCH</code> or <code>ARM_MATH_SUCCESS</code> based on the outcome of size checking.
+   */
+arm_status arm_mat_add_q31(
+  const arm_matrix_instance_q31 * pSrcA,
+  const arm_matrix_instance_q31 * pSrcB,
+        arm_matrix_instance_q31 * pDst);
+
+  /**
+   * @brief Floating-point, complex, matrix multiplication.
+   * @param[in]  pSrcA  points to the first input matrix structure
+   * @param[in]  pSrcB  points to the second input matrix structure
+   * @param[out] pDst   points to output matrix structure
+   * @return     The function returns either
+   * <code>ARM_MATH_SIZE_MISMATCH</code> or <code>ARM_MATH_SUCCESS</code> based on the outcome of size checking.
+   */
+arm_status arm_mat_cmplx_mult_f32(
+  const arm_matrix_instance_f32 * pSrcA,
+  const arm_matrix_instance_f32 * pSrcB,
+        arm_matrix_instance_f32 * pDst);
+
+  /**
+   * @brief Q15, complex,  matrix multiplication.
+   * @param[in]  pSrcA  points to the first input matrix structure
+   * @param[in]  pSrcB  points to the second input matrix structure
+   * @param[out] pDst   points to output matrix structure
+   * @return     The function returns either
+   * <code>ARM_MATH_SIZE_MISMATCH</code> or <code>ARM_MATH_SUCCESS</code> based on the outcome of size checking.
+   */
+arm_status arm_mat_cmplx_mult_q15(
+  const arm_matrix_instance_q15 * pSrcA,
+  const arm_matrix_instance_q15 * pSrcB,
+        arm_matrix_instance_q15 * pDst,
+        q15_t * pScratch);
+
+  /**
+   * @brief Q31, complex, matrix multiplication.
+   * @param[in]  pSrcA  points to the first input matrix structure
+   * @param[in]  pSrcB  points to the second input matrix structure
+   * @param[out] pDst   points to output matrix structure
+   * @return     The function returns either
+   * <code>ARM_MATH_SIZE_MISMATCH</code> or <code>ARM_MATH_SUCCESS</code> based on the outcome of size checking.
+   */
+arm_status arm_mat_cmplx_mult_q31(
+  const arm_matrix_instance_q31 * pSrcA,
+  const arm_matrix_instance_q31 * pSrcB,
+        arm_matrix_instance_q31 * pDst);
+
+  /**
+   * @brief Floating-point matrix transpose.
+   * @param[in]  pSrc  points to the input matrix
+   * @param[out] pDst  points to the output matrix
+   * @return    The function returns either  <code>ARM_MATH_SIZE_MISMATCH</code>
+   * or <code>ARM_MATH_SUCCESS</code> based on the outcome of size checking.
+   */
+arm_status arm_mat_trans_f32(
+  const arm_matrix_instance_f32 * pSrc,
+        arm_matrix_instance_f32 * pDst);
+
+  /**
+   * @brief Q15 matrix transpose.
+   * @param[in]  pSrc  points to the input matrix
+   * @param[out] pDst  points to the output matrix
+   * @return    The function returns either  <code>ARM_MATH_SIZE_MISMATCH</code>
+   * or <code>ARM_MATH_SUCCESS</code> based on the outcome of size checking.
+   */
+arm_status arm_mat_trans_q15(
+  const arm_matrix_instance_q15 * pSrc,
+        arm_matrix_instance_q15 * pDst);
+
+  /**
+   * @brief Q31 matrix transpose.
+   * @param[in]  pSrc  points to the input matrix
+   * @param[out] pDst  points to the output matrix
+   * @return    The function returns either  <code>ARM_MATH_SIZE_MISMATCH</code>
+   * or <code>ARM_MATH_SUCCESS</code> based on the outcome of size checking.
+   */
+arm_status arm_mat_trans_q31(
+  const arm_matrix_instance_q31 * pSrc,
+        arm_matrix_instance_q31 * pDst);
+
+  /**
+   * @brief Floating-point matrix multiplication
+   * @param[in]  pSrcA  points to the first input matrix structure
+   * @param[in]  pSrcB  points to the second input matrix structure
+   * @param[out] pDst   points to output matrix structure
+   * @return     The function returns either
+   * <code>ARM_MATH_SIZE_MISMATCH</code> or <code>ARM_MATH_SUCCESS</code> based on the outcome of size checking.
+   */
+arm_status arm_mat_mult_f32(
+  const arm_matrix_instance_f32 * pSrcA,
+  const arm_matrix_instance_f32 * pSrcB,
+        arm_matrix_instance_f32 * pDst);
+
+  /**
+   * @brief Q15 matrix multiplication
+   * @param[in]  pSrcA   points to the first input matrix structure
+   * @param[in]  pSrcB   points to the second input matrix structure
+   * @param[out] pDst    points to output matrix structure
+   * @param[in]  pState  points to the array for storing intermediate results
+   * @return     The function returns either
+   * <code>ARM_MATH_SIZE_MISMATCH</code> or <code>ARM_MATH_SUCCESS</code> based on the outcome of size checking.
+   */
+arm_status arm_mat_mult_q15(
+  const arm_matrix_instance_q15 * pSrcA,
+  const arm_matrix_instance_q15 * pSrcB,
+        arm_matrix_instance_q15 * pDst,
+        q15_t * pState);
+
+  /**
+   * @brief Q15 matrix multiplication (fast variant) for Cortex-M3 and Cortex-M4
+   * @param[in]  pSrcA   points to the first input matrix structure
+   * @param[in]  pSrcB   points to the second input matrix structure
+   * @param[out] pDst    points to output matrix structure
+   * @param[in]  pState  points to the array for storing intermediate results
+   * @return     The function returns either
+   * <code>ARM_MATH_SIZE_MISMATCH</code> or <code>ARM_MATH_SUCCESS</code> based on the outcome of size checking.
+   */
+arm_status arm_mat_mult_fast_q15(
+  const arm_matrix_instance_q15 * pSrcA,
+  const arm_matrix_instance_q15 * pSrcB,
+        arm_matrix_instance_q15 * pDst,
+        q15_t * pState);
+
+  /**
+   * @brief Q31 matrix multiplication
+   * @param[in]  pSrcA  points to the first input matrix structure
+   * @param[in]  pSrcB  points to the second input matrix structure
+   * @param[out] pDst   points to output matrix structure
+   * @return     The function returns either
+   * <code>ARM_MATH_SIZE_MISMATCH</code> or <code>ARM_MATH_SUCCESS</code> based on the outcome of size checking.
+   */
+arm_status arm_mat_mult_q31(
+  const arm_matrix_instance_q31 * pSrcA,
+  const arm_matrix_instance_q31 * pSrcB,
+        arm_matrix_instance_q31 * pDst);
+
+  /**
+   * @brief Q31 matrix multiplication (fast variant) for Cortex-M3 and Cortex-M4
+   * @param[in]  pSrcA  points to the first input matrix structure
+   * @param[in]  pSrcB  points to the second input matrix structure
+   * @param[out] pDst   points to output matrix structure
+   * @return     The function returns either
+   * <code>ARM_MATH_SIZE_MISMATCH</code> or <code>ARM_MATH_SUCCESS</code> based on the outcome of size checking.
+   */
+arm_status arm_mat_mult_fast_q31(
+  const arm_matrix_instance_q31 * pSrcA,
+  const arm_matrix_instance_q31 * pSrcB,
+        arm_matrix_instance_q31 * pDst);
+
+  /**
+   * @brief Floating-point matrix subtraction
+   * @param[in]  pSrcA  points to the first input matrix structure
+   * @param[in]  pSrcB  points to the second input matrix structure
+   * @param[out] pDst   points to output matrix structure
+   * @return     The function returns either
+   * <code>ARM_MATH_SIZE_MISMATCH</code> or <code>ARM_MATH_SUCCESS</code> based on the outcome of size checking.
+   */
+arm_status arm_mat_sub_f32(
+  const arm_matrix_instance_f32 * pSrcA,
+  const arm_matrix_instance_f32 * pSrcB,
+        arm_matrix_instance_f32 * pDst);
+
+  /**
+   * @brief Q15 matrix subtraction
+   * @param[in]  pSrcA  points to the first input matrix structure
+   * @param[in]  pSrcB  points to the second input matrix structure
+   * @param[out] pDst   points to output matrix structure
+   * @return     The function returns either
+   * <code>ARM_MATH_SIZE_MISMATCH</code> or <code>ARM_MATH_SUCCESS</code> based on the outcome of size checking.
+   */
+arm_status arm_mat_sub_q15(
+  const arm_matrix_instance_q15 * pSrcA,
+  const arm_matrix_instance_q15 * pSrcB,
+        arm_matrix_instance_q15 * pDst);
+
+  /**
+   * @brief Q31 matrix subtraction
+   * @param[in]  pSrcA  points to the first input matrix structure
+   * @param[in]  pSrcB  points to the second input matrix structure
+   * @param[out] pDst   points to output matrix structure
+   * @return     The function returns either
+   * <code>ARM_MATH_SIZE_MISMATCH</code> or <code>ARM_MATH_SUCCESS</code> based on the outcome of size checking.
+   */
+arm_status arm_mat_sub_q31(
+  const arm_matrix_instance_q31 * pSrcA,
+  const arm_matrix_instance_q31 * pSrcB,
+        arm_matrix_instance_q31 * pDst);
+
+  /**
+   * @brief Floating-point matrix scaling.
+   * @param[in]  pSrc   points to the input matrix
+   * @param[in]  scale  scale factor
+   * @param[out] pDst   points to the output matrix
+   * @return     The function returns either
+   * <code>ARM_MATH_SIZE_MISMATCH</code> or <code>ARM_MATH_SUCCESS</code> based on the outcome of size checking.
+   */
+arm_status arm_mat_scale_f32(
+  const arm_matrix_instance_f32 * pSrc,
+        float32_t scale,
+        arm_matrix_instance_f32 * pDst);
+
+  /**
+   * @brief Q15 matrix scaling.
+   * @param[in]  pSrc        points to input matrix
+   * @param[in]  scaleFract  fractional portion of the scale factor
+   * @param[in]  shift       number of bits to shift the result by
+   * @param[out] pDst        points to output matrix
+   * @return     The function returns either
+   * <code>ARM_MATH_SIZE_MISMATCH</code> or <code>ARM_MATH_SUCCESS</code> based on the outcome of size checking.
+   */
+arm_status arm_mat_scale_q15(
+  const arm_matrix_instance_q15 * pSrc,
+        q15_t scaleFract,
+        int32_t shift,
+        arm_matrix_instance_q15 * pDst);
+
+  /**
+   * @brief Q31 matrix scaling.
+   * @param[in]  pSrc        points to input matrix
+   * @param[in]  scaleFract  fractional portion of the scale factor
+   * @param[in]  shift       number of bits to shift the result by
+   * @param[out] pDst        points to output matrix structure
+   * @return     The function returns either
+   * <code>ARM_MATH_SIZE_MISMATCH</code> or <code>ARM_MATH_SUCCESS</code> based on the outcome of size checking.
+   */
+arm_status arm_mat_scale_q31(
+  const arm_matrix_instance_q31 * pSrc,
+        q31_t scaleFract,
+        int32_t shift,
+        arm_matrix_instance_q31 * pDst);
+
+  /**
+   * @brief  Q31 matrix initialization.
+   * @param[in,out] S         points to an instance of the floating-point matrix structure.
+   * @param[in]     nRows     number of rows in the matrix.
+   * @param[in]     nColumns  number of columns in the matrix.
+   * @param[in]     pData     points to the matrix data array.
+   */
+void arm_mat_init_q31(
+        arm_matrix_instance_q31 * S,
+        uint16_t nRows,
+        uint16_t nColumns,
+        q31_t * pData);
+
+  /**
+   * @brief  Q15 matrix initialization.
+   * @param[in,out] S         points to an instance of the floating-point matrix structure.
+   * @param[in]     nRows     number of rows in the matrix.
+   * @param[in]     nColumns  number of columns in the matrix.
+   * @param[in]     pData     points to the matrix data array.
+   */
+void arm_mat_init_q15(
+        arm_matrix_instance_q15 * S,
+        uint16_t nRows,
+        uint16_t nColumns,
+        q15_t * pData);
+
+  /**
+   * @brief  Floating-point matrix initialization.
+   * @param[in,out] S         points to an instance of the floating-point matrix structure.
+   * @param[in]     nRows     number of rows in the matrix.
+   * @param[in]     nColumns  number of columns in the matrix.
+   * @param[in]     pData     points to the matrix data array.
+   */
+void arm_mat_init_f32(
+        arm_matrix_instance_f32 * S,
+        uint16_t nRows,
+        uint16_t nColumns,
+        float32_t * pData);
+
+
+  /**
+   * @brief Instance structure for the Q15 PID Control.
+   */
+  typedef struct
+  {
+          q15_t A0;           /**< The derived gain, A0 = Kp + Ki + Kd . */
+#if !defined (ARM_MATH_DSP)
+          q15_t A1;
+          q15_t A2;
+#else
+          q31_t A1;           /**< The derived gain A1 = -Kp - 2Kd | Kd.*/
+#endif
+          q15_t state[3];     /**< The state array of length 3. */
+          q15_t Kp;           /**< The proportional gain. */
+          q15_t Ki;           /**< The integral gain. */
+          q15_t Kd;           /**< The derivative gain. */
+  } arm_pid_instance_q15;
+
+  /**
+   * @brief Instance structure for the Q31 PID Control.
+   */
+  typedef struct
+  {
+          q31_t A0;            /**< The derived gain, A0 = Kp + Ki + Kd . */
+          q31_t A1;            /**< The derived gain, A1 = -Kp - 2Kd. */
+          q31_t A2;            /**< The derived gain, A2 = Kd . */
+          q31_t state[3];      /**< The state array of length 3. */
+          q31_t Kp;            /**< The proportional gain. */
+          q31_t Ki;            /**< The integral gain. */
+          q31_t Kd;            /**< The derivative gain. */
+  } arm_pid_instance_q31;
+
+  /**
+   * @brief Instance structure for the floating-point PID Control.
+   */
+  typedef struct
+  {
+          float32_t A0;          /**< The derived gain, A0 = Kp + Ki + Kd . */
+          float32_t A1;          /**< The derived gain, A1 = -Kp - 2Kd. */
+          float32_t A2;          /**< The derived gain, A2 = Kd . */
+          float32_t state[3];    /**< The state array of length 3. */
+          float32_t Kp;          /**< The proportional gain. */
+          float32_t Ki;          /**< The integral gain. */
+          float32_t Kd;          /**< The derivative gain. */
+  } arm_pid_instance_f32;
+
+
+
+  /**
+   * @brief  Initialization function for the floating-point PID Control.
+   * @param[in,out] S               points to an instance of the PID structure.
+   * @param[in]     resetStateFlag  flag to reset the state. 0 = no change in state 1 = reset the state.
+   */
+  void arm_pid_init_f32(
+        arm_pid_instance_f32 * S,
+        int32_t resetStateFlag);
+
+
+  /**
+   * @brief  Reset function for the floating-point PID Control.
+   * @param[in,out] S  is an instance of the floating-point PID Control structure
+   */
+  void arm_pid_reset_f32(
+        arm_pid_instance_f32 * S);
+
+
+  /**
+   * @brief  Initialization function for the Q31 PID Control.
+   * @param[in,out] S               points to an instance of the Q15 PID structure.
+   * @param[in]     resetStateFlag  flag to reset the state. 0 = no change in state 1 = reset the state.
+   */
+  void arm_pid_init_q31(
+        arm_pid_instance_q31 * S,
+        int32_t resetStateFlag);
+
+
+  /**
+   * @brief  Reset function for the Q31 PID Control.
+   * @param[in,out] S   points to an instance of the Q31 PID Control structure
+   */
+
+  void arm_pid_reset_q31(
+        arm_pid_instance_q31 * S);
+
+
+  /**
+   * @brief  Initialization function for the Q15 PID Control.
+   * @param[in,out] S               points to an instance of the Q15 PID structure.
+   * @param[in]     resetStateFlag  flag to reset the state. 0 = no change in state 1 = reset the state.
+   */
+  void arm_pid_init_q15(
+        arm_pid_instance_q15 * S,
+        int32_t resetStateFlag);
+
+
+  /**
+   * @brief  Reset function for the Q15 PID Control.
+   * @param[in,out] S  points to an instance of the q15 PID Control structure
+   */
+  void arm_pid_reset_q15(
+        arm_pid_instance_q15 * S);
+
+
+  /**
+   * @brief Instance structure for the floating-point Linear Interpolate function.
+   */
+  typedef struct
+  {
+          uint32_t nValues;           /**< nValues */
+          float32_t x1;               /**< x1 */
+          float32_t xSpacing;         /**< xSpacing */
+          float32_t *pYData;          /**< pointer to the table of Y values */
+  } arm_linear_interp_instance_f32;
+
+  /**
+   * @brief Instance structure for the floating-point bilinear interpolation function.
+   */
+  typedef struct
+  {
+          uint16_t numRows;   /**< number of rows in the data table. */
+          uint16_t numCols;   /**< number of columns in the data table. */
+          float32_t *pData;   /**< points to the data table. */
+  } arm_bilinear_interp_instance_f32;
+
+   /**
+   * @brief Instance structure for the Q31 bilinear interpolation function.
+   */
+  typedef struct
+  {
+          uint16_t numRows;   /**< number of rows in the data table. */
+          uint16_t numCols;   /**< number of columns in the data table. */
+          q31_t *pData;       /**< points to the data table. */
+  } arm_bilinear_interp_instance_q31;
+
+   /**
+   * @brief Instance structure for the Q15 bilinear interpolation function.
+   */
+  typedef struct
+  {
+          uint16_t numRows;   /**< number of rows in the data table. */
+          uint16_t numCols;   /**< number of columns in the data table. */
+          q15_t *pData;       /**< points to the data table. */
+  } arm_bilinear_interp_instance_q15;
+
+   /**
+   * @brief Instance structure for the Q15 bilinear interpolation function.
+   */
+  typedef struct
+  {
+          uint16_t numRows;   /**< number of rows in the data table. */
+          uint16_t numCols;   /**< number of columns in the data table. */
+          q7_t *pData;        /**< points to the data table. */
+  } arm_bilinear_interp_instance_q7;
+
+
+  /**
+   * @brief Q7 vector multiplication.
+   * @param[in]  pSrcA      points to the first input vector
+   * @param[in]  pSrcB      points to the second input vector
+   * @param[out] pDst       points to the output vector
+   * @param[in]  blockSize  number of samples in each vector
+   */
+  void arm_mult_q7(
+  const q7_t * pSrcA,
+  const q7_t * pSrcB,
+        q7_t * pDst,
+        uint32_t blockSize);
+
+
+  /**
+   * @brief Q15 vector multiplication.
+   * @param[in]  pSrcA      points to the first input vector
+   * @param[in]  pSrcB      points to the second input vector
+   * @param[out] pDst       points to the output vector
+   * @param[in]  blockSize  number of samples in each vector
+   */
+  void arm_mult_q15(
+  const q15_t * pSrcA,
+  const q15_t * pSrcB,
+        q15_t * pDst,
+        uint32_t blockSize);
+
+
+  /**
+   * @brief Q31 vector multiplication.
+   * @param[in]  pSrcA      points to the first input vector
+   * @param[in]  pSrcB      points to the second input vector
+   * @param[out] pDst       points to the output vector
+   * @param[in]  blockSize  number of samples in each vector
+   */
+  void arm_mult_q31(
+  const q31_t * pSrcA,
+  const q31_t * pSrcB,
+        q31_t * pDst,
+        uint32_t blockSize);
+
+
+  /**
+   * @brief Floating-point vector multiplication.
+   * @param[in]  pSrcA      points to the first input vector
+   * @param[in]  pSrcB      points to the second input vector
+   * @param[out] pDst       points to the output vector
+   * @param[in]  blockSize  number of samples in each vector
+   */
+  void arm_mult_f32(
+  const float32_t * pSrcA,
+  const float32_t * pSrcB,
+        float32_t * pDst,
+        uint32_t blockSize);
+
+
+  /**
+   * @brief Instance structure for the Q15 CFFT/CIFFT function.
+   */
+  typedef struct
+  {
+          uint16_t fftLen;                 /**< length of the FFT. */
+          uint8_t ifftFlag;                /**< flag that selects forward (ifftFlag=0) or inverse (ifftFlag=1) transform. */
+          uint8_t bitReverseFlag;          /**< flag that enables (bitReverseFlag=1) or disables (bitReverseFlag=0) bit reversal of output. */
+    const q15_t *pTwiddle;                 /**< points to the Sin twiddle factor table. */
+    const uint16_t *pBitRevTable;          /**< points to the bit reversal table. */
+          uint16_t twidCoefModifier;       /**< twiddle coefficient modifier that supports different size FFTs with the same twiddle factor table. */
+          uint16_t bitRevFactor;           /**< bit reversal modifier that supports different size FFTs with the same bit reversal table. */
+  } arm_cfft_radix2_instance_q15;
+
+/* Deprecated */
+  arm_status arm_cfft_radix2_init_q15(
+        arm_cfft_radix2_instance_q15 * S,
+        uint16_t fftLen,
+        uint8_t ifftFlag,
+        uint8_t bitReverseFlag);
+
+/* Deprecated */
+  void arm_cfft_radix2_q15(
+  const arm_cfft_radix2_instance_q15 * S,
+        q15_t * pSrc);
+
+
+  /**
+   * @brief Instance structure for the Q15 CFFT/CIFFT function.
+   */
+  typedef struct
+  {
+          uint16_t fftLen;                 /**< length of the FFT. */
+          uint8_t ifftFlag;                /**< flag that selects forward (ifftFlag=0) or inverse (ifftFlag=1) transform. */
+          uint8_t bitReverseFlag;          /**< flag that enables (bitReverseFlag=1) or disables (bitReverseFlag=0) bit reversal of output. */
+    const q15_t *pTwiddle;                 /**< points to the twiddle factor table. */
+    const uint16_t *pBitRevTable;          /**< points to the bit reversal table. */
+          uint16_t twidCoefModifier;       /**< twiddle coefficient modifier that supports different size FFTs with the same twiddle factor table. */
+          uint16_t bitRevFactor;           /**< bit reversal modifier that supports different size FFTs with the same bit reversal table. */
+  } arm_cfft_radix4_instance_q15;
+
+/* Deprecated */
+  arm_status arm_cfft_radix4_init_q15(
+        arm_cfft_radix4_instance_q15 * S,
+        uint16_t fftLen,
+        uint8_t ifftFlag,
+        uint8_t bitReverseFlag);
+
+/* Deprecated */
+  void arm_cfft_radix4_q15(
+  const arm_cfft_radix4_instance_q15 * S,
+        q15_t * pSrc);
+
+  /**
+   * @brief Instance structure for the Radix-2 Q31 CFFT/CIFFT function.
+   */
+  typedef struct
+  {
+          uint16_t fftLen;                 /**< length of the FFT. */
+          uint8_t ifftFlag;                /**< flag that selects forward (ifftFlag=0) or inverse (ifftFlag=1) transform. */
+          uint8_t bitReverseFlag;          /**< flag that enables (bitReverseFlag=1) or disables (bitReverseFlag=0) bit reversal of output. */
+    const q31_t *pTwiddle;                 /**< points to the Twiddle factor table. */
+    const uint16_t *pBitRevTable;          /**< points to the bit reversal table. */
+          uint16_t twidCoefModifier;       /**< twiddle coefficient modifier that supports different size FFTs with the same twiddle factor table. */
+          uint16_t bitRevFactor;           /**< bit reversal modifier that supports different size FFTs with the same bit reversal table. */
+  } arm_cfft_radix2_instance_q31;
+
+/* Deprecated */
+  arm_status arm_cfft_radix2_init_q31(
+        arm_cfft_radix2_instance_q31 * S,
+        uint16_t fftLen,
+        uint8_t ifftFlag,
+        uint8_t bitReverseFlag);
+
+/* Deprecated */
+  void arm_cfft_radix2_q31(
+  const arm_cfft_radix2_instance_q31 * S,
+        q31_t * pSrc);
+
+  /**
+   * @brief Instance structure for the Q31 CFFT/CIFFT function.
+   */
+  typedef struct
+  {
+          uint16_t fftLen;                 /**< length of the FFT. */
+          uint8_t ifftFlag;                /**< flag that selects forward (ifftFlag=0) or inverse (ifftFlag=1) transform. */
+          uint8_t bitReverseFlag;          /**< flag that enables (bitReverseFlag=1) or disables (bitReverseFlag=0) bit reversal of output. */
+    const q31_t *pTwiddle;                 /**< points to the twiddle factor table. */
+    const uint16_t *pBitRevTable;          /**< points to the bit reversal table. */
+          uint16_t twidCoefModifier;       /**< twiddle coefficient modifier that supports different size FFTs with the same twiddle factor table. */
+          uint16_t bitRevFactor;           /**< bit reversal modifier that supports different size FFTs with the same bit reversal table. */
+  } arm_cfft_radix4_instance_q31;
+
+/* Deprecated */
+  void arm_cfft_radix4_q31(
+  const arm_cfft_radix4_instance_q31 * S,
+        q31_t * pSrc);
+
+/* Deprecated */
+  arm_status arm_cfft_radix4_init_q31(
+        arm_cfft_radix4_instance_q31 * S,
+        uint16_t fftLen,
+        uint8_t ifftFlag,
+        uint8_t bitReverseFlag);
+
+  /**
+   * @brief Instance structure for the floating-point CFFT/CIFFT function.
+   */
+  typedef struct
+  {
+          uint16_t fftLen;                   /**< length of the FFT. */
+          uint8_t ifftFlag;                  /**< flag that selects forward (ifftFlag=0) or inverse (ifftFlag=1) transform. */
+          uint8_t bitReverseFlag;            /**< flag that enables (bitReverseFlag=1) or disables (bitReverseFlag=0) bit reversal of output. */
+    const float32_t *pTwiddle;               /**< points to the Twiddle factor table. */
+    const uint16_t *pBitRevTable;            /**< points to the bit reversal table. */
+          uint16_t twidCoefModifier;         /**< twiddle coefficient modifier that supports different size FFTs with the same twiddle factor table. */
+          uint16_t bitRevFactor;             /**< bit reversal modifier that supports different size FFTs with the same bit reversal table. */
+          float32_t onebyfftLen;             /**< value of 1/fftLen. */
+  } arm_cfft_radix2_instance_f32;
+
+/* Deprecated */
+  arm_status arm_cfft_radix2_init_f32(
+        arm_cfft_radix2_instance_f32 * S,
+        uint16_t fftLen,
+        uint8_t ifftFlag,
+        uint8_t bitReverseFlag);
+
+/* Deprecated */
+  void arm_cfft_radix2_f32(
+  const arm_cfft_radix2_instance_f32 * S,
+        float32_t * pSrc);
+
+  /**
+   * @brief Instance structure for the floating-point CFFT/CIFFT function.
+   */
+  typedef struct
+  {
+          uint16_t fftLen;                   /**< length of the FFT. */
+          uint8_t ifftFlag;                  /**< flag that selects forward (ifftFlag=0) or inverse (ifftFlag=1) transform. */
+          uint8_t bitReverseFlag;            /**< flag that enables (bitReverseFlag=1) or disables (bitReverseFlag=0) bit reversal of output. */
+    const float32_t *pTwiddle;               /**< points to the Twiddle factor table. */
+    const uint16_t *pBitRevTable;            /**< points to the bit reversal table. */
+          uint16_t twidCoefModifier;         /**< twiddle coefficient modifier that supports different size FFTs with the same twiddle factor table. */
+          uint16_t bitRevFactor;             /**< bit reversal modifier that supports different size FFTs with the same bit reversal table. */
+          float32_t onebyfftLen;             /**< value of 1/fftLen. */
+  } arm_cfft_radix4_instance_f32;
+
+/* Deprecated */
+  arm_status arm_cfft_radix4_init_f32(
+        arm_cfft_radix4_instance_f32 * S,
+        uint16_t fftLen,
+        uint8_t ifftFlag,
+        uint8_t bitReverseFlag);
+
+/* Deprecated */
+  void arm_cfft_radix4_f32(
+  const arm_cfft_radix4_instance_f32 * S,
+        float32_t * pSrc);
+
+  /**
+   * @brief Instance structure for the fixed-point CFFT/CIFFT function.
+   */
+  typedef struct
+  {
+          uint16_t fftLen;                   /**< length of the FFT. */
+    const q15_t *pTwiddle;             /**< points to the Twiddle factor table. */
+    const uint16_t *pBitRevTable;      /**< points to the bit reversal table. */
+          uint16_t bitRevLength;             /**< bit reversal table length. */
+#if defined(ARM_MATH_MVEI)
+   const uint32_t *rearranged_twiddle_tab_stride1_arr;        /**< Per stage reordered twiddle pointer (offset 1) */                                                       \
+   const uint32_t *rearranged_twiddle_tab_stride2_arr;        /**< Per stage reordered twiddle pointer (offset 2) */                                                       \
+   const uint32_t *rearranged_twiddle_tab_stride3_arr;        /**< Per stage reordered twiddle pointer (offset 3) */                                                       \
+   const q15_t *rearranged_twiddle_stride1; /**< reordered twiddle offset 1 storage */                                                                   \
+   const q15_t *rearranged_twiddle_stride2; /**< reordered twiddle offset 2 storage */                                                                   \
+   const q15_t *rearranged_twiddle_stride3;
+#endif
+  } arm_cfft_instance_q15;
+
+arm_status arm_cfft_init_q15(
+  arm_cfft_instance_q15 * S,
+  uint16_t fftLen);
+
+void arm_cfft_q15(
+    const arm_cfft_instance_q15 * S,
+          q15_t * p1,
+          uint8_t ifftFlag,
+          uint8_t bitReverseFlag);
+
+  /**
+   * @brief Instance structure for the fixed-point CFFT/CIFFT function.
+   */
+  typedef struct
+  {
+          uint16_t fftLen;                   /**< length of the FFT. */
+    const q31_t *pTwiddle;             /**< points to the Twiddle factor table. */
+    const uint16_t *pBitRevTable;      /**< points to the bit reversal table. */
+          uint16_t bitRevLength;             /**< bit reversal table length. */
+#if defined(ARM_MATH_MVEI)
+   const uint32_t *rearranged_twiddle_tab_stride1_arr;        /**< Per stage reordered twiddle pointer (offset 1) */                                                       \
+   const uint32_t *rearranged_twiddle_tab_stride2_arr;        /**< Per stage reordered twiddle pointer (offset 2) */                                                       \
+   const uint32_t *rearranged_twiddle_tab_stride3_arr;        /**< Per stage reordered twiddle pointer (offset 3) */                                                       \
+   const q31_t *rearranged_twiddle_stride1; /**< reordered twiddle offset 1 storage */                                                                   \
+   const q31_t *rearranged_twiddle_stride2; /**< reordered twiddle offset 2 storage */                                                                   \
+   const q31_t *rearranged_twiddle_stride3;
+#endif
+  } arm_cfft_instance_q31;
+
+arm_status arm_cfft_init_q31(
+  arm_cfft_instance_q31 * S,
+  uint16_t fftLen);
+
+void arm_cfft_q31(
+    const arm_cfft_instance_q31 * S,
+          q31_t * p1,
+          uint8_t ifftFlag,
+          uint8_t bitReverseFlag);
+
+  /**
+   * @brief Instance structure for the floating-point CFFT/CIFFT function.
+   */
+  typedef struct
+  {
+          uint16_t fftLen;                   /**< length of the FFT. */
+    const float32_t *pTwiddle;         /**< points to the Twiddle factor table. */
+    const uint16_t *pBitRevTable;      /**< points to the bit reversal table. */
+          uint16_t bitRevLength;             /**< bit reversal table length. */
+#if defined(ARM_MATH_MVEF) && !defined(ARM_MATH_AUTOVECTORIZE)
+   const uint32_t *rearranged_twiddle_tab_stride1_arr;        /**< Per stage reordered twiddle pointer (offset 1) */                                                       \
+   const uint32_t *rearranged_twiddle_tab_stride2_arr;        /**< Per stage reordered twiddle pointer (offset 2) */                                                       \
+   const uint32_t *rearranged_twiddle_tab_stride3_arr;        /**< Per stage reordered twiddle pointer (offset 3) */                                                       \
+   const float32_t *rearranged_twiddle_stride1; /**< reordered twiddle offset 1 storage */                                                                   \
+   const float32_t *rearranged_twiddle_stride2; /**< reordered twiddle offset 2 storage */                                                                   \
+   const float32_t *rearranged_twiddle_stride3;
+#endif
+  } arm_cfft_instance_f32;
+
+
+  arm_status arm_cfft_init_f32(
+  arm_cfft_instance_f32 * S,
+  uint16_t fftLen);
+
+  void arm_cfft_f32(
+  const arm_cfft_instance_f32 * S,
+        float32_t * p1,
+        uint8_t ifftFlag,
+        uint8_t bitReverseFlag);
+
+
+  /**
+   * @brief Instance structure for the Double Precision Floating-point CFFT/CIFFT function.
+   */
+  typedef struct
+  {
+          uint16_t fftLen;                   /**< length of the FFT. */
+    const float64_t *pTwiddle;         /**< points to the Twiddle factor table. */
+    const uint16_t *pBitRevTable;      /**< points to the bit reversal table. */
+          uint16_t bitRevLength;             /**< bit reversal table length. */
+  } arm_cfft_instance_f64;
+
+  void arm_cfft_f64(
+  const arm_cfft_instance_f64 * S,
+        float64_t * p1,
+        uint8_t ifftFlag,
+        uint8_t bitReverseFlag);
+
+  /**
+   * @brief Instance structure for the Q15 RFFT/RIFFT function.
+   */
+  typedef struct
+  {
+          uint32_t fftLenReal;                      /**< length of the real FFT. */
+          uint8_t ifftFlagR;                        /**< flag that selects forward (ifftFlagR=0) or inverse (ifftFlagR=1) transform. */
+          uint8_t bitReverseFlagR;                  /**< flag that enables (bitReverseFlagR=1) or disables (bitReverseFlagR=0) bit reversal of output. */
+          uint32_t twidCoefRModifier;               /**< twiddle coefficient modifier that supports different size FFTs with the same twiddle factor table. */
+    const q15_t *pTwiddleAReal;                     /**< points to the real twiddle factor table. */
+    const q15_t *pTwiddleBReal;                     /**< points to the imag twiddle factor table. */
+#if defined(ARM_MATH_MVEI)
+    arm_cfft_instance_q15 cfftInst;
+#else
+    const arm_cfft_instance_q15 *pCfft;       /**< points to the complex FFT instance. */
+#endif
+  } arm_rfft_instance_q15;
+
+  arm_status arm_rfft_init_q15(
+        arm_rfft_instance_q15 * S,
+        uint32_t fftLenReal,
+        uint32_t ifftFlagR,
+        uint32_t bitReverseFlag);
+
+  void arm_rfft_q15(
+  const arm_rfft_instance_q15 * S,
+        q15_t * pSrc,
+        q15_t * pDst);
+
+  /**
+   * @brief Instance structure for the Q31 RFFT/RIFFT function.
+   */
+  typedef struct
+  {
+          uint32_t fftLenReal;                        /**< length of the real FFT. */
+          uint8_t ifftFlagR;                          /**< flag that selects forward (ifftFlagR=0) or inverse (ifftFlagR=1) transform. */
+          uint8_t bitReverseFlagR;                    /**< flag that enables (bitReverseFlagR=1) or disables (bitReverseFlagR=0) bit reversal of output. */
+          uint32_t twidCoefRModifier;                 /**< twiddle coefficient modifier that supports different size FFTs with the same twiddle factor table. */
+    const q31_t *pTwiddleAReal;                       /**< points to the real twiddle factor table. */
+    const q31_t *pTwiddleBReal;                       /**< points to the imag twiddle factor table. */
+#if defined(ARM_MATH_MVEI)
+    arm_cfft_instance_q31 cfftInst;
+#else
+    const arm_cfft_instance_q31 *pCfft;         /**< points to the complex FFT instance. */
+#endif
+  } arm_rfft_instance_q31;
+
+  arm_status arm_rfft_init_q31(
+        arm_rfft_instance_q31 * S,
+        uint32_t fftLenReal,
+        uint32_t ifftFlagR,
+        uint32_t bitReverseFlag);
+
+  void arm_rfft_q31(
+  const arm_rfft_instance_q31 * S,
+        q31_t * pSrc,
+        q31_t * pDst);
+
+  /**
+   * @brief Instance structure for the floating-point RFFT/RIFFT function.
+   */
+  typedef struct
+  {
+          uint32_t fftLenReal;                        /**< length of the real FFT. */
+          uint16_t fftLenBy2;                         /**< length of the complex FFT. */
+          uint8_t ifftFlagR;                          /**< flag that selects forward (ifftFlagR=0) or inverse (ifftFlagR=1) transform. */
+          uint8_t bitReverseFlagR;                    /**< flag that enables (bitReverseFlagR=1) or disables (bitReverseFlagR=0) bit reversal of output. */
+          uint32_t twidCoefRModifier;                     /**< twiddle coefficient modifier that supports different size FFTs with the same twiddle factor table. */
+    const float32_t *pTwiddleAReal;                   /**< points to the real twiddle factor table. */
+    const float32_t *pTwiddleBReal;                   /**< points to the imag twiddle factor table. */
+          arm_cfft_radix4_instance_f32 *pCfft;        /**< points to the complex FFT instance. */
+  } arm_rfft_instance_f32;
+
+  arm_status arm_rfft_init_f32(
+        arm_rfft_instance_f32 * S,
+        arm_cfft_radix4_instance_f32 * S_CFFT,
+        uint32_t fftLenReal,
+        uint32_t ifftFlagR,
+        uint32_t bitReverseFlag);
+
+  void arm_rfft_f32(
+  const arm_rfft_instance_f32 * S,
+        float32_t * pSrc,
+        float32_t * pDst);
+
+  /**
+   * @brief Instance structure for the Double Precision Floating-point RFFT/RIFFT function.
+   */
+typedef struct
+  {
+          arm_cfft_instance_f64 Sint;      /**< Internal CFFT structure. */
+          uint16_t fftLenRFFT;             /**< length of the real sequence */
+    const float64_t * pTwiddleRFFT;        /**< Twiddle factors real stage  */
+  } arm_rfft_fast_instance_f64 ;
+
+arm_status arm_rfft_fast_init_f64 (
+         arm_rfft_fast_instance_f64 * S,
+         uint16_t fftLen);
+
+
+void arm_rfft_fast_f64(
+    arm_rfft_fast_instance_f64 * S,
+    float64_t * p, float64_t * pOut,
+    uint8_t ifftFlag);
+
+
+  /**
+   * @brief Instance structure for the floating-point RFFT/RIFFT function.
+   */
+typedef struct
+  {
+          arm_cfft_instance_f32 Sint;      /**< Internal CFFT structure. */
+          uint16_t fftLenRFFT;             /**< length of the real sequence */
+    const float32_t * pTwiddleRFFT;        /**< Twiddle factors real stage  */
+  } arm_rfft_fast_instance_f32 ;
+
+arm_status arm_rfft_fast_init_f32 (
+         arm_rfft_fast_instance_f32 * S,
+         uint16_t fftLen);
+
+
+  void arm_rfft_fast_f32(
+        const arm_rfft_fast_instance_f32 * S,
+        float32_t * p, float32_t * pOut,
+        uint8_t ifftFlag);
+
+  /**
+   * @brief Instance structure for the floating-point DCT4/IDCT4 function.
+   */
+  typedef struct
+  {
+          uint16_t N;                          /**< length of the DCT4. */
+          uint16_t Nby2;                       /**< half of the length of the DCT4. */
+          float32_t normalize;                 /**< normalizing factor. */
+    const float32_t *pTwiddle;                 /**< points to the twiddle factor table. */
+    const float32_t *pCosFactor;               /**< points to the cosFactor table. */
+          arm_rfft_instance_f32 *pRfft;        /**< points to the real FFT instance. */
+          arm_cfft_radix4_instance_f32 *pCfft; /**< points to the complex FFT instance. */
+  } arm_dct4_instance_f32;
+
+
+  /**
+   * @brief  Initialization function for the floating-point DCT4/IDCT4.
+   * @param[in,out] S          points to an instance of floating-point DCT4/IDCT4 structure.
+   * @param[in]     S_RFFT     points to an instance of floating-point RFFT/RIFFT structure.
+   * @param[in]     S_CFFT     points to an instance of floating-point CFFT/CIFFT structure.
+   * @param[in]     N          length of the DCT4.
+   * @param[in]     Nby2       half of the length of the DCT4.
+   * @param[in]     normalize  normalizing factor.
+   * @return      arm_status function returns ARM_MATH_SUCCESS if initialization is successful or ARM_MATH_ARGUMENT_ERROR if <code>fftLenReal</code> is not a supported transform length.
+   */
+  arm_status arm_dct4_init_f32(
+        arm_dct4_instance_f32 * S,
+        arm_rfft_instance_f32 * S_RFFT,
+        arm_cfft_radix4_instance_f32 * S_CFFT,
+        uint16_t N,
+        uint16_t Nby2,
+        float32_t normalize);
+
+
+  /**
+   * @brief Processing function for the floating-point DCT4/IDCT4.
+   * @param[in]     S              points to an instance of the floating-point DCT4/IDCT4 structure.
+   * @param[in]     pState         points to state buffer.
+   * @param[in,out] pInlineBuffer  points to the in-place input and output buffer.
+   */
+  void arm_dct4_f32(
+  const arm_dct4_instance_f32 * S,
+        float32_t * pState,
+        float32_t * pInlineBuffer);
+
+
+  /**
+   * @brief Instance structure for the Q31 DCT4/IDCT4 function.
+   */
+  typedef struct
+  {
+          uint16_t N;                          /**< length of the DCT4. */
+          uint16_t Nby2;                       /**< half of the length of the DCT4. */
+          q31_t normalize;                     /**< normalizing factor. */
+    const q31_t *pTwiddle;                     /**< points to the twiddle factor table. */
+    const q31_t *pCosFactor;                   /**< points to the cosFactor table. */
+          arm_rfft_instance_q31 *pRfft;        /**< points to the real FFT instance. */
+          arm_cfft_radix4_instance_q31 *pCfft; /**< points to the complex FFT instance. */
+  } arm_dct4_instance_q31;
+
+
+  /**
+   * @brief  Initialization function for the Q31 DCT4/IDCT4.
+   * @param[in,out] S          points to an instance of Q31 DCT4/IDCT4 structure.
+   * @param[in]     S_RFFT     points to an instance of Q31 RFFT/RIFFT structure
+   * @param[in]     S_CFFT     points to an instance of Q31 CFFT/CIFFT structure
+   * @param[in]     N          length of the DCT4.
+   * @param[in]     Nby2       half of the length of the DCT4.
+   * @param[in]     normalize  normalizing factor.
+   * @return      arm_status function returns ARM_MATH_SUCCESS if initialization is successful or ARM_MATH_ARGUMENT_ERROR if <code>N</code> is not a supported transform length.
+   */
+  arm_status arm_dct4_init_q31(
+        arm_dct4_instance_q31 * S,
+        arm_rfft_instance_q31 * S_RFFT,
+        arm_cfft_radix4_instance_q31 * S_CFFT,
+        uint16_t N,
+        uint16_t Nby2,
+        q31_t normalize);
+
+
+  /**
+   * @brief Processing function for the Q31 DCT4/IDCT4.
+   * @param[in]     S              points to an instance of the Q31 DCT4 structure.
+   * @param[in]     pState         points to state buffer.
+   * @param[in,out] pInlineBuffer  points to the in-place input and output buffer.
+   */
+  void arm_dct4_q31(
+  const arm_dct4_instance_q31 * S,
+        q31_t * pState,
+        q31_t * pInlineBuffer);
+
+
+  /**
+   * @brief Instance structure for the Q15 DCT4/IDCT4 function.
+   */
+  typedef struct
+  {
+          uint16_t N;                          /**< length of the DCT4. */
+          uint16_t Nby2;                       /**< half of the length of the DCT4. */
+          q15_t normalize;                     /**< normalizing factor. */
+    const q15_t *pTwiddle;                     /**< points to the twiddle factor table. */
+    const q15_t *pCosFactor;                   /**< points to the cosFactor table. */
+          arm_rfft_instance_q15 *pRfft;        /**< points to the real FFT instance. */
+          arm_cfft_radix4_instance_q15 *pCfft; /**< points to the complex FFT instance. */
+  } arm_dct4_instance_q15;
+
+
+  /**
+   * @brief  Initialization function for the Q15 DCT4/IDCT4.
+   * @param[in,out] S          points to an instance of Q15 DCT4/IDCT4 structure.
+   * @param[in]     S_RFFT     points to an instance of Q15 RFFT/RIFFT structure.
+   * @param[in]     S_CFFT     points to an instance of Q15 CFFT/CIFFT structure.
+   * @param[in]     N          length of the DCT4.
+   * @param[in]     Nby2       half of the length of the DCT4.
+   * @param[in]     normalize  normalizing factor.
+   * @return      arm_status function returns ARM_MATH_SUCCESS if initialization is successful or ARM_MATH_ARGUMENT_ERROR if <code>N</code> is not a supported transform length.
+   */
+  arm_status arm_dct4_init_q15(
+        arm_dct4_instance_q15 * S,
+        arm_rfft_instance_q15 * S_RFFT,
+        arm_cfft_radix4_instance_q15 * S_CFFT,
+        uint16_t N,
+        uint16_t Nby2,
+        q15_t normalize);
+
+
+  /**
+   * @brief Processing function for the Q15 DCT4/IDCT4.
+   * @param[in]     S              points to an instance of the Q15 DCT4 structure.
+   * @param[in]     pState         points to state buffer.
+   * @param[in,out] pInlineBuffer  points to the in-place input and output buffer.
+   */
+  void arm_dct4_q15(
+  const arm_dct4_instance_q15 * S,
+        q15_t * pState,
+        q15_t * pInlineBuffer);
+
+
+  /**
+   * @brief Floating-point vector addition.
+   * @param[in]  pSrcA      points to the first input vector
+   * @param[in]  pSrcB      points to the second input vector
+   * @param[out] pDst       points to the output vector
+   * @param[in]  blockSize  number of samples in each vector
+   */
+  void arm_add_f32(
+  const float32_t * pSrcA,
+  const float32_t * pSrcB,
+        float32_t * pDst,
+        uint32_t blockSize);
+
+
+  /**
+   * @brief Q7 vector addition.
+   * @param[in]  pSrcA      points to the first input vector
+   * @param[in]  pSrcB      points to the second input vector
+   * @param[out] pDst       points to the output vector
+   * @param[in]  blockSize  number of samples in each vector
+   */
+  void arm_add_q7(
+  const q7_t * pSrcA,
+  const q7_t * pSrcB,
+        q7_t * pDst,
+        uint32_t blockSize);
+
+
+  /**
+   * @brief Q15 vector addition.
+   * @param[in]  pSrcA      points to the first input vector
+   * @param[in]  pSrcB      points to the second input vector
+   * @param[out] pDst       points to the output vector
+   * @param[in]  blockSize  number of samples in each vector
+   */
+  void arm_add_q15(
+  const q15_t * pSrcA,
+  const q15_t * pSrcB,
+        q15_t * pDst,
+        uint32_t blockSize);
+
+
+  /**
+   * @brief Q31 vector addition.
+   * @param[in]  pSrcA      points to the first input vector
+   * @param[in]  pSrcB      points to the second input vector
+   * @param[out] pDst       points to the output vector
+   * @param[in]  blockSize  number of samples in each vector
+   */
+  void arm_add_q31(
+  const q31_t * pSrcA,
+  const q31_t * pSrcB,
+        q31_t * pDst,
+        uint32_t blockSize);
+
+
+  /**
+   * @brief Floating-point vector subtraction.
+   * @param[in]  pSrcA      points to the first input vector
+   * @param[in]  pSrcB      points to the second input vector
+   * @param[out] pDst       points to the output vector
+   * @param[in]  blockSize  number of samples in each vector
+   */
+  void arm_sub_f32(
+  const float32_t * pSrcA,
+  const float32_t * pSrcB,
+        float32_t * pDst,
+        uint32_t blockSize);
+
+
+  /**
+   * @brief Q7 vector subtraction.
+   * @param[in]  pSrcA      points to the first input vector
+   * @param[in]  pSrcB      points to the second input vector
+   * @param[out] pDst       points to the output vector
+   * @param[in]  blockSize  number of samples in each vector
+   */
+  void arm_sub_q7(
+  const q7_t * pSrcA,
+  const q7_t * pSrcB,
+        q7_t * pDst,
+        uint32_t blockSize);
+
+
+  /**
+   * @brief Q15 vector subtraction.
+   * @param[in]  pSrcA      points to the first input vector
+   * @param[in]  pSrcB      points to the second input vector
+   * @param[out] pDst       points to the output vector
+   * @param[in]  blockSize  number of samples in each vector
+   */
+  void arm_sub_q15(
+  const q15_t * pSrcA,
+  const q15_t * pSrcB,
+        q15_t * pDst,
+        uint32_t blockSize);
+
+
+  /**
+   * @brief Q31 vector subtraction.
+   * @param[in]  pSrcA      points to the first input vector
+   * @param[in]  pSrcB      points to the second input vector
+   * @param[out] pDst       points to the output vector
+   * @param[in]  blockSize  number of samples in each vector
+   */
+  void arm_sub_q31(
+  const q31_t * pSrcA,
+  const q31_t * pSrcB,
+        q31_t * pDst,
+        uint32_t blockSize);
+
+
+  /**
+   * @brief Multiplies a floating-point vector by a scalar.
+   * @param[in]  pSrc       points to the input vector
+   * @param[in]  scale      scale factor to be applied
+   * @param[out] pDst       points to the output vector
+   * @param[in]  blockSize  number of samples in the vector
+   */
+  void arm_scale_f32(
+  const float32_t * pSrc,
+        float32_t scale,
+        float32_t * pDst,
+        uint32_t blockSize);
+
+
+  /**
+   * @brief Multiplies a Q7 vector by a scalar.
+   * @param[in]  pSrc        points to the input vector
+   * @param[in]  scaleFract  fractional portion of the scale value
+   * @param[in]  shift       number of bits to shift the result by
+   * @param[out] pDst        points to the output vector
+   * @param[in]  blockSize   number of samples in the vector
+   */
+  void arm_scale_q7(
+  const q7_t * pSrc,
+        q7_t scaleFract,
+        int8_t shift,
+        q7_t * pDst,
+        uint32_t blockSize);
+
+
+  /**
+   * @brief Multiplies a Q15 vector by a scalar.
+   * @param[in]  pSrc        points to the input vector
+   * @param[in]  scaleFract  fractional portion of the scale value
+   * @param[in]  shift       number of bits to shift the result by
+   * @param[out] pDst        points to the output vector
+   * @param[in]  blockSize   number of samples in the vector
+   */
+  void arm_scale_q15(
+  const q15_t * pSrc,
+        q15_t scaleFract,
+        int8_t shift,
+        q15_t * pDst,
+        uint32_t blockSize);
+
+
+  /**
+   * @brief Multiplies a Q31 vector by a scalar.
+   * @param[in]  pSrc        points to the input vector
+   * @param[in]  scaleFract  fractional portion of the scale value
+   * @param[in]  shift       number of bits to shift the result by
+   * @param[out] pDst        points to the output vector
+   * @param[in]  blockSize   number of samples in the vector
+   */
+  void arm_scale_q31(
+  const q31_t * pSrc,
+        q31_t scaleFract,
+        int8_t shift,
+        q31_t * pDst,
+        uint32_t blockSize);
+
+
+  /**
+   * @brief Q7 vector absolute value.
+   * @param[in]  pSrc       points to the input buffer
+   * @param[out] pDst       points to the output buffer
+   * @param[in]  blockSize  number of samples in each vector
+   */
+  void arm_abs_q7(
+  const q7_t * pSrc,
+        q7_t * pDst,
+        uint32_t blockSize);
+
+
+  /**
+   * @brief Floating-point vector absolute value.
+   * @param[in]  pSrc       points to the input buffer
+   * @param[out] pDst       points to the output buffer
+   * @param[in]  blockSize  number of samples in each vector
+   */
+  void arm_abs_f32(
+  const float32_t * pSrc,
+        float32_t * pDst,
+        uint32_t blockSize);
+
+
+  /**
+   * @brief Q15 vector absolute value.
+   * @param[in]  pSrc       points to the input buffer
+   * @param[out] pDst       points to the output buffer
+   * @param[in]  blockSize  number of samples in each vector
+   */
+  void arm_abs_q15(
+  const q15_t * pSrc,
+        q15_t * pDst,
+        uint32_t blockSize);
+
+
+  /**
+   * @brief Q31 vector absolute value.
+   * @param[in]  pSrc       points to the input buffer
+   * @param[out] pDst       points to the output buffer
+   * @param[in]  blockSize  number of samples in each vector
+   */
+  void arm_abs_q31(
+  const q31_t * pSrc,
+        q31_t * pDst,
+        uint32_t blockSize);
+
+
+  /**
+   * @brief Dot product of floating-point vectors.
+   * @param[in]  pSrcA      points to the first input vector
+   * @param[in]  pSrcB      points to the second input vector
+   * @param[in]  blockSize  number of samples in each vector
+   * @param[out] result     output result returned here
+   */
+  void arm_dot_prod_f32(
+  const float32_t * pSrcA,
+  const float32_t * pSrcB,
+        uint32_t blockSize,
+        float32_t * result);
+
+
+  /**
+   * @brief Dot product of Q7 vectors.
+   * @param[in]  pSrcA      points to the first input vector
+   * @param[in]  pSrcB      points to the second input vector
+   * @param[in]  blockSize  number of samples in each vector
+   * @param[out] result     output result returned here
+   */
+  void arm_dot_prod_q7(
+  const q7_t * pSrcA,
+  const q7_t * pSrcB,
+        uint32_t blockSize,
+        q31_t * result);
+
+
+  /**
+   * @brief Dot product of Q15 vectors.
+   * @param[in]  pSrcA      points to the first input vector
+   * @param[in]  pSrcB      points to the second input vector
+   * @param[in]  blockSize  number of samples in each vector
+   * @param[out] result     output result returned here
+   */
+  void arm_dot_prod_q15(
+  const q15_t * pSrcA,
+  const q15_t * pSrcB,
+        uint32_t blockSize,
+        q63_t * result);
+
+
+  /**
+   * @brief Dot product of Q31 vectors.
+   * @param[in]  pSrcA      points to the first input vector
+   * @param[in]  pSrcB      points to the second input vector
+   * @param[in]  blockSize  number of samples in each vector
+   * @param[out] result     output result returned here
+   */
+  void arm_dot_prod_q31(
+  const q31_t * pSrcA,
+  const q31_t * pSrcB,
+        uint32_t blockSize,
+        q63_t * result);
+
+
+  /**
+   * @brief  Shifts the elements of a Q7 vector a specified number of bits.
+   * @param[in]  pSrc       points to the input vector
+   * @param[in]  shiftBits  number of bits to shift.  A positive value shifts left; a negative value shifts right.
+   * @param[out] pDst       points to the output vector
+   * @param[in]  blockSize  number of samples in the vector
+   */
+  void arm_shift_q7(
+  const q7_t * pSrc,
+        int8_t shiftBits,
+        q7_t * pDst,
+        uint32_t blockSize);
+
+
+  /**
+   * @brief  Shifts the elements of a Q15 vector a specified number of bits.
+   * @param[in]  pSrc       points to the input vector
+   * @param[in]  shiftBits  number of bits to shift.  A positive value shifts left; a negative value shifts right.
+   * @param[out] pDst       points to the output vector
+   * @param[in]  blockSize  number of samples in the vector
+   */
+  void arm_shift_q15(
+  const q15_t * pSrc,
+        int8_t shiftBits,
+        q15_t * pDst,
+        uint32_t blockSize);
+
+
+  /**
+   * @brief  Shifts the elements of a Q31 vector a specified number of bits.
+   * @param[in]  pSrc       points to the input vector
+   * @param[in]  shiftBits  number of bits to shift.  A positive value shifts left; a negative value shifts right.
+   * @param[out] pDst       points to the output vector
+   * @param[in]  blockSize  number of samples in the vector
+   */
+  void arm_shift_q31(
+  const q31_t * pSrc,
+        int8_t shiftBits,
+        q31_t * pDst,
+        uint32_t blockSize);
+
+
+  /**
+   * @brief  Adds a constant offset to a floating-point vector.
+   * @param[in]  pSrc       points to the input vector
+   * @param[in]  offset     is the offset to be added
+   * @param[out] pDst       points to the output vector
+   * @param[in]  blockSize  number of samples in the vector
+   */
+  void arm_offset_f32(
+  const float32_t * pSrc,
+        float32_t offset,
+        float32_t * pDst,
+        uint32_t blockSize);
+
+
+  /**
+   * @brief  Adds a constant offset to a Q7 vector.
+   * @param[in]  pSrc       points to the input vector
+   * @param[in]  offset     is the offset to be added
+   * @param[out] pDst       points to the output vector
+   * @param[in]  blockSize  number of samples in the vector
+   */
+  void arm_offset_q7(
+  const q7_t * pSrc,
+        q7_t offset,
+        q7_t * pDst,
+        uint32_t blockSize);
+
+
+  /**
+   * @brief  Adds a constant offset to a Q15 vector.
+   * @param[in]  pSrc       points to the input vector
+   * @param[in]  offset     is the offset to be added
+   * @param[out] pDst       points to the output vector
+   * @param[in]  blockSize  number of samples in the vector
+   */
+  void arm_offset_q15(
+  const q15_t * pSrc,
+        q15_t offset,
+        q15_t * pDst,
+        uint32_t blockSize);
+
+
+  /**
+   * @brief  Adds a constant offset to a Q31 vector.
+   * @param[in]  pSrc       points to the input vector
+   * @param[in]  offset     is the offset to be added
+   * @param[out] pDst       points to the output vector
+   * @param[in]  blockSize  number of samples in the vector
+   */
+  void arm_offset_q31(
+  const q31_t * pSrc,
+        q31_t offset,
+        q31_t * pDst,
+        uint32_t blockSize);
+
+
+  /**
+   * @brief  Negates the elements of a floating-point vector.
+   * @param[in]  pSrc       points to the input vector
+   * @param[out] pDst       points to the output vector
+   * @param[in]  blockSize  number of samples in the vector
+   */
+  void arm_negate_f32(
+  const float32_t * pSrc,
+        float32_t * pDst,
+        uint32_t blockSize);
+
+
+  /**
+   * @brief  Negates the elements of a Q7 vector.
+   * @param[in]  pSrc       points to the input vector
+   * @param[out] pDst       points to the output vector
+   * @param[in]  blockSize  number of samples in the vector
+   */
+  void arm_negate_q7(
+  const q7_t * pSrc,
+        q7_t * pDst,
+        uint32_t blockSize);
+
+
+  /**
+   * @brief  Negates the elements of a Q15 vector.
+   * @param[in]  pSrc       points to the input vector
+   * @param[out] pDst       points to the output vector
+   * @param[in]  blockSize  number of samples in the vector
+   */
+  void arm_negate_q15(
+  const q15_t * pSrc,
+        q15_t * pDst,
+        uint32_t blockSize);
+
+
+  /**
+   * @brief  Negates the elements of a Q31 vector.
+   * @param[in]  pSrc       points to the input vector
+   * @param[out] pDst       points to the output vector
+   * @param[in]  blockSize  number of samples in the vector
+   */
+  void arm_negate_q31(
+  const q31_t * pSrc,
+        q31_t * pDst,
+        uint32_t blockSize);
+
+
+  /**
+   * @brief  Copies the elements of a floating-point vector.
+   * @param[in]  pSrc       input pointer
+   * @param[out] pDst       output pointer
+   * @param[in]  blockSize  number of samples to process
+   */
+  void arm_copy_f32(
+  const float32_t * pSrc,
+        float32_t * pDst,
+        uint32_t blockSize);
+
+
+  /**
+   * @brief  Copies the elements of a Q7 vector.
+   * @param[in]  pSrc       input pointer
+   * @param[out] pDst       output pointer
+   * @param[in]  blockSize  number of samples to process
+   */
+  void arm_copy_q7(
+  const q7_t * pSrc,
+        q7_t * pDst,
+        uint32_t blockSize);
+
+
+  /**
+   * @brief  Copies the elements of a Q15 vector.
+   * @param[in]  pSrc       input pointer
+   * @param[out] pDst       output pointer
+   * @param[in]  blockSize  number of samples to process
+   */
+  void arm_copy_q15(
+  const q15_t * pSrc,
+        q15_t * pDst,
+        uint32_t blockSize);
+
+
+  /**
+   * @brief  Copies the elements of a Q31 vector.
+   * @param[in]  pSrc       input pointer
+   * @param[out] pDst       output pointer
+   * @param[in]  blockSize  number of samples to process
+   */
+  void arm_copy_q31(
+  const q31_t * pSrc,
+        q31_t * pDst,
+        uint32_t blockSize);
+
+
+  /**
+   * @brief  Fills a constant value into a floating-point vector.
+   * @param[in]  value      input value to be filled
+   * @param[out] pDst       output pointer
+   * @param[in]  blockSize  number of samples to process
+   */
+  void arm_fill_f32(
+        float32_t value,
+        float32_t * pDst,
+        uint32_t blockSize);
+
+
+  /**
+   * @brief  Fills a constant value into a Q7 vector.
+   * @param[in]  value      input value to be filled
+   * @param[out] pDst       output pointer
+   * @param[in]  blockSize  number of samples to process
+   */
+  void arm_fill_q7(
+        q7_t value,
+        q7_t * pDst,
+        uint32_t blockSize);
+
+
+  /**
+   * @brief  Fills a constant value into a Q15 vector.
+   * @param[in]  value      input value to be filled
+   * @param[out] pDst       output pointer
+   * @param[in]  blockSize  number of samples to process
+   */
+  void arm_fill_q15(
+        q15_t value,
+        q15_t * pDst,
+        uint32_t blockSize);
+
+
+  /**
+   * @brief  Fills a constant value into a Q31 vector.
+   * @param[in]  value      input value to be filled
+   * @param[out] pDst       output pointer
+   * @param[in]  blockSize  number of samples to process
+   */
+  void arm_fill_q31(
+        q31_t value,
+        q31_t * pDst,
+        uint32_t blockSize);
+
+
+/**
+ * @brief Convolution of floating-point sequences.
+ * @param[in]  pSrcA    points to the first input sequence.
+ * @param[in]  srcALen  length of the first input sequence.
+ * @param[in]  pSrcB    points to the second input sequence.
+ * @param[in]  srcBLen  length of the second input sequence.
+ * @param[out] pDst     points to the location where the output result is written.  Length srcALen+srcBLen-1.
+ */
+  void arm_conv_f32(
+  const float32_t * pSrcA,
+        uint32_t srcALen,
+  const float32_t * pSrcB,
+        uint32_t srcBLen,
+        float32_t * pDst);
+
+
+  /**
+   * @brief Convolution of Q15 sequences.
+   * @param[in]  pSrcA      points to the first input sequence.
+   * @param[in]  srcALen    length of the first input sequence.
+   * @param[in]  pSrcB      points to the second input sequence.
+   * @param[in]  srcBLen    length of the second input sequence.
+   * @param[out] pDst       points to the block of output data  Length srcALen+srcBLen-1.
+   * @param[in]  pScratch1  points to scratch buffer of size max(srcALen, srcBLen) + 2*min(srcALen, srcBLen) - 2.
+   * @param[in]  pScratch2  points to scratch buffer of size min(srcALen, srcBLen).
+   */
+  void arm_conv_opt_q15(
+  const q15_t * pSrcA,
+        uint32_t srcALen,
+  const q15_t * pSrcB,
+        uint32_t srcBLen,
+        q15_t * pDst,
+        q15_t * pScratch1,
+        q15_t * pScratch2);
+
+
+/**
+ * @brief Convolution of Q15 sequences.
+ * @param[in]  pSrcA    points to the first input sequence.
+ * @param[in]  srcALen  length of the first input sequence.
+ * @param[in]  pSrcB    points to the second input sequence.
+ * @param[in]  srcBLen  length of the second input sequence.
+ * @param[out] pDst     points to the location where the output result is written.  Length srcALen+srcBLen-1.
+ */
+  void arm_conv_q15(
+  const q15_t * pSrcA,
+        uint32_t srcALen,
+  const q15_t * pSrcB,
+        uint32_t srcBLen,
+        q15_t * pDst);
+
+
+  /**
+   * @brief Convolution of Q15 sequences (fast version) for Cortex-M3 and Cortex-M4
+   * @param[in]  pSrcA    points to the first input sequence.
+   * @param[in]  srcALen  length of the first input sequence.
+   * @param[in]  pSrcB    points to the second input sequence.
+   * @param[in]  srcBLen  length of the second input sequence.
+   * @param[out] pDst     points to the block of output data  Length srcALen+srcBLen-1.
+   */
+  void arm_conv_fast_q15(
+  const q15_t * pSrcA,
+        uint32_t srcALen,
+  const q15_t * pSrcB,
+        uint32_t srcBLen,
+        q15_t * pDst);
+
+
+  /**
+   * @brief Convolution of Q15 sequences (fast version) for Cortex-M3 and Cortex-M4
+   * @param[in]  pSrcA      points to the first input sequence.
+   * @param[in]  srcALen    length of the first input sequence.
+   * @param[in]  pSrcB      points to the second input sequence.
+   * @param[in]  srcBLen    length of the second input sequence.
+   * @param[out] pDst       points to the block of output data  Length srcALen+srcBLen-1.
+   * @param[in]  pScratch1  points to scratch buffer of size max(srcALen, srcBLen) + 2*min(srcALen, srcBLen) - 2.
+   * @param[in]  pScratch2  points to scratch buffer of size min(srcALen, srcBLen).
+   */
+  void arm_conv_fast_opt_q15(
+  const q15_t * pSrcA,
+        uint32_t srcALen,
+  const q15_t * pSrcB,
+        uint32_t srcBLen,
+        q15_t * pDst,
+        q15_t * pScratch1,
+        q15_t * pScratch2);
+
+
+  /**
+   * @brief Convolution of Q31 sequences.
+   * @param[in]  pSrcA    points to the first input sequence.
+   * @param[in]  srcALen  length of the first input sequence.
+   * @param[in]  pSrcB    points to the second input sequence.
+   * @param[in]  srcBLen  length of the second input sequence.
+   * @param[out] pDst     points to the block of output data  Length srcALen+srcBLen-1.
+   */
+  void arm_conv_q31(
+  const q31_t * pSrcA,
+        uint32_t srcALen,
+  const q31_t * pSrcB,
+        uint32_t srcBLen,
+        q31_t * pDst);
+
+
+  /**
+   * @brief Convolution of Q31 sequences (fast version) for Cortex-M3 and Cortex-M4
+   * @param[in]  pSrcA    points to the first input sequence.
+   * @param[in]  srcALen  length of the first input sequence.
+   * @param[in]  pSrcB    points to the second input sequence.
+   * @param[in]  srcBLen  length of the second input sequence.
+   * @param[out] pDst     points to the block of output data  Length srcALen+srcBLen-1.
+   */
+  void arm_conv_fast_q31(
+  const q31_t * pSrcA,
+        uint32_t srcALen,
+  const q31_t * pSrcB,
+        uint32_t srcBLen,
+        q31_t * pDst);
+
+
+    /**
+   * @brief Convolution of Q7 sequences.
+   * @param[in]  pSrcA      points to the first input sequence.
+   * @param[in]  srcALen    length of the first input sequence.
+   * @param[in]  pSrcB      points to the second input sequence.
+   * @param[in]  srcBLen    length of the second input sequence.
+   * @param[out] pDst       points to the block of output data  Length srcALen+srcBLen-1.
+   * @param[in]  pScratch1  points to scratch buffer(of type q15_t) of size max(srcALen, srcBLen) + 2*min(srcALen, srcBLen) - 2.
+   * @param[in]  pScratch2  points to scratch buffer (of type q15_t) of size min(srcALen, srcBLen).
+   */
+  void arm_conv_opt_q7(
+  const q7_t * pSrcA,
+        uint32_t srcALen,
+  const q7_t * pSrcB,
+        uint32_t srcBLen,
+        q7_t * pDst,
+        q15_t * pScratch1,
+        q15_t * pScratch2);
+
+
+  /**
+   * @brief Convolution of Q7 sequences.
+   * @param[in]  pSrcA    points to the first input sequence.
+   * @param[in]  srcALen  length of the first input sequence.
+   * @param[in]  pSrcB    points to the second input sequence.
+   * @param[in]  srcBLen  length of the second input sequence.
+   * @param[out] pDst     points to the block of output data  Length srcALen+srcBLen-1.
+   */
+  void arm_conv_q7(
+  const q7_t * pSrcA,
+        uint32_t srcALen,
+  const q7_t * pSrcB,
+        uint32_t srcBLen,
+        q7_t * pDst);
+
+
+  /**
+   * @brief Partial convolution of floating-point sequences.
+   * @param[in]  pSrcA       points to the first input sequence.
+   * @param[in]  srcALen     length of the first input sequence.
+   * @param[in]  pSrcB       points to the second input sequence.
+   * @param[in]  srcBLen     length of the second input sequence.
+   * @param[out] pDst        points to the block of output data
+   * @param[in]  firstIndex  is the first output sample to start with.
+   * @param[in]  numPoints   is the number of output points to be computed.
+   * @return  Returns either ARM_MATH_SUCCESS if the function completed correctly or ARM_MATH_ARGUMENT_ERROR if the requested subset is not in the range [0 srcALen+srcBLen-2].
+   */
+  arm_status arm_conv_partial_f32(
+  const float32_t * pSrcA,
+        uint32_t srcALen,
+  const float32_t * pSrcB,
+        uint32_t srcBLen,
+        float32_t * pDst,
+        uint32_t firstIndex,
+        uint32_t numPoints);
+
+
+  /**
+   * @brief Partial convolution of Q15 sequences.
+   * @param[in]  pSrcA       points to the first input sequence.
+   * @param[in]  srcALen     length of the first input sequence.
+   * @param[in]  pSrcB       points to the second input sequence.
+   * @param[in]  srcBLen     length of the second input sequence.
+   * @param[out] pDst        points to the block of output data
+   * @param[in]  firstIndex  is the first output sample to start with.
+   * @param[in]  numPoints   is the number of output points to be computed.
+   * @param[in]  pScratch1   points to scratch buffer of size max(srcALen, srcBLen) + 2*min(srcALen, srcBLen) - 2.
+   * @param[in]  pScratch2   points to scratch buffer of size min(srcALen, srcBLen).
+   * @return  Returns either ARM_MATH_SUCCESS if the function completed correctly or ARM_MATH_ARGUMENT_ERROR if the requested subset is not in the range [0 srcALen+srcBLen-2].
+   */
+  arm_status arm_conv_partial_opt_q15(
+  const q15_t * pSrcA,
+        uint32_t srcALen,
+  const q15_t * pSrcB,
+        uint32_t srcBLen,
+        q15_t * pDst,
+        uint32_t firstIndex,
+        uint32_t numPoints,
+        q15_t * pScratch1,
+        q15_t * pScratch2);
+
+
+  /**
+   * @brief Partial convolution of Q15 sequences.
+   * @param[in]  pSrcA       points to the first input sequence.
+   * @param[in]  srcALen     length of the first input sequence.
+   * @param[in]  pSrcB       points to the second input sequence.
+   * @param[in]  srcBLen     length of the second input sequence.
+   * @param[out] pDst        points to the block of output data
+   * @param[in]  firstIndex  is the first output sample to start with.
+   * @param[in]  numPoints   is the number of output points to be computed.
+   * @return  Returns either ARM_MATH_SUCCESS if the function completed correctly or ARM_MATH_ARGUMENT_ERROR if the requested subset is not in the range [0 srcALen+srcBLen-2].
+   */
+  arm_status arm_conv_partial_q15(
+  const q15_t * pSrcA,
+        uint32_t srcALen,
+  const q15_t * pSrcB,
+        uint32_t srcBLen,
+        q15_t * pDst,
+        uint32_t firstIndex,
+        uint32_t numPoints);
+
+
+  /**
+   * @brief Partial convolution of Q15 sequences (fast version) for Cortex-M3 and Cortex-M4
+   * @param[in]  pSrcA       points to the first input sequence.
+   * @param[in]  srcALen     length of the first input sequence.
+   * @param[in]  pSrcB       points to the second input sequence.
+   * @param[in]  srcBLen     length of the second input sequence.
+   * @param[out] pDst        points to the block of output data
+   * @param[in]  firstIndex  is the first output sample to start with.
+   * @param[in]  numPoints   is the number of output points to be computed.
+   * @return  Returns either ARM_MATH_SUCCESS if the function completed correctly or ARM_MATH_ARGUMENT_ERROR if the requested subset is not in the range [0 srcALen+srcBLen-2].
+   */
+  arm_status arm_conv_partial_fast_q15(
+  const q15_t * pSrcA,
+        uint32_t srcALen,
+  const q15_t * pSrcB,
+        uint32_t srcBLen,
+        q15_t * pDst,
+        uint32_t firstIndex,
+        uint32_t numPoints);
+
+
+  /**
+   * @brief Partial convolution of Q15 sequences (fast version) for Cortex-M3 and Cortex-M4
+   * @param[in]  pSrcA       points to the first input sequence.
+   * @param[in]  srcALen     length of the first input sequence.
+   * @param[in]  pSrcB       points to the second input sequence.
+   * @param[in]  srcBLen     length of the second input sequence.
+   * @param[out] pDst        points to the block of output data
+   * @param[in]  firstIndex  is the first output sample to start with.
+   * @param[in]  numPoints   is the number of output points to be computed.
+   * @param[in]  pScratch1   points to scratch buffer of size max(srcALen, srcBLen) + 2*min(srcALen, srcBLen) - 2.
+   * @param[in]  pScratch2   points to scratch buffer of size min(srcALen, srcBLen).
+   * @return  Returns either ARM_MATH_SUCCESS if the function completed correctly or ARM_MATH_ARGUMENT_ERROR if the requested subset is not in the range [0 srcALen+srcBLen-2].
+   */
+  arm_status arm_conv_partial_fast_opt_q15(
+  const q15_t * pSrcA,
+        uint32_t srcALen,
+  const q15_t * pSrcB,
+        uint32_t srcBLen,
+        q15_t * pDst,
+        uint32_t firstIndex,
+        uint32_t numPoints,
+        q15_t * pScratch1,
+        q15_t * pScratch2);
+
+
+  /**
+   * @brief Partial convolution of Q31 sequences.
+   * @param[in]  pSrcA       points to the first input sequence.
+   * @param[in]  srcALen     length of the first input sequence.
+   * @param[in]  pSrcB       points to the second input sequence.
+   * @param[in]  srcBLen     length of the second input sequence.
+   * @param[out] pDst        points to the block of output data
+   * @param[in]  firstIndex  is the first output sample to start with.
+   * @param[in]  numPoints   is the number of output points to be computed.
+   * @return  Returns either ARM_MATH_SUCCESS if the function completed correctly or ARM_MATH_ARGUMENT_ERROR if the requested subset is not in the range [0 srcALen+srcBLen-2].
+   */
+  arm_status arm_conv_partial_q31(
+  const q31_t * pSrcA,
+        uint32_t srcALen,
+  const q31_t * pSrcB,
+        uint32_t srcBLen,
+        q31_t * pDst,
+        uint32_t firstIndex,
+        uint32_t numPoints);
+
+
+  /**
+   * @brief Partial convolution of Q31 sequences (fast version) for Cortex-M3 and Cortex-M4
+   * @param[in]  pSrcA       points to the first input sequence.
+   * @param[in]  srcALen     length of the first input sequence.
+   * @param[in]  pSrcB       points to the second input sequence.
+   * @param[in]  srcBLen     length of the second input sequence.
+   * @param[out] pDst        points to the block of output data
+   * @param[in]  firstIndex  is the first output sample to start with.
+   * @param[in]  numPoints   is the number of output points to be computed.
+   * @return  Returns either ARM_MATH_SUCCESS if the function completed correctly or ARM_MATH_ARGUMENT_ERROR if the requested subset is not in the range [0 srcALen+srcBLen-2].
+   */
+  arm_status arm_conv_partial_fast_q31(
+  const q31_t * pSrcA,
+        uint32_t srcALen,
+  const q31_t * pSrcB,
+        uint32_t srcBLen,
+        q31_t * pDst,
+        uint32_t firstIndex,
+        uint32_t numPoints);
+
+
+  /**
+   * @brief Partial convolution of Q7 sequences
+   * @param[in]  pSrcA       points to the first input sequence.
+   * @param[in]  srcALen     length of the first input sequence.
+   * @param[in]  pSrcB       points to the second input sequence.
+   * @param[in]  srcBLen     length of the second input sequence.
+   * @param[out] pDst        points to the block of output data
+   * @param[in]  firstIndex  is the first output sample to start with.
+   * @param[in]  numPoints   is the number of output points to be computed.
+   * @param[in]  pScratch1   points to scratch buffer(of type q15_t) of size max(srcALen, srcBLen) + 2*min(srcALen, srcBLen) - 2.
+   * @param[in]  pScratch2   points to scratch buffer (of type q15_t) of size min(srcALen, srcBLen).
+   * @return  Returns either ARM_MATH_SUCCESS if the function completed correctly or ARM_MATH_ARGUMENT_ERROR if the requested subset is not in the range [0 srcALen+srcBLen-2].
+   */
+  arm_status arm_conv_partial_opt_q7(
+  const q7_t * pSrcA,
+        uint32_t srcALen,
+  const q7_t * pSrcB,
+        uint32_t srcBLen,
+        q7_t * pDst,
+        uint32_t firstIndex,
+        uint32_t numPoints,
+        q15_t * pScratch1,
+        q15_t * pScratch2);
+
+
+/**
+   * @brief Partial convolution of Q7 sequences.
+   * @param[in]  pSrcA       points to the first input sequence.
+   * @param[in]  srcALen     length of the first input sequence.
+   * @param[in]  pSrcB       points to the second input sequence.
+   * @param[in]  srcBLen     length of the second input sequence.
+   * @param[out] pDst        points to the block of output data
+   * @param[in]  firstIndex  is the first output sample to start with.
+   * @param[in]  numPoints   is the number of output points to be computed.
+   * @return  Returns either ARM_MATH_SUCCESS if the function completed correctly or ARM_MATH_ARGUMENT_ERROR if the requested subset is not in the range [0 srcALen+srcBLen-2].
+   */
+  arm_status arm_conv_partial_q7(
+  const q7_t * pSrcA,
+        uint32_t srcALen,
+  const q7_t * pSrcB,
+        uint32_t srcBLen,
+        q7_t * pDst,
+        uint32_t firstIndex,
+        uint32_t numPoints);
+
+
+  /**
+   * @brief Instance structure for the Q15 FIR decimator.
+   */
+  typedef struct
+  {
+          uint8_t M;                  /**< decimation factor. */
+          uint16_t numTaps;           /**< number of coefficients in the filter. */
+    const q15_t *pCoeffs;             /**< points to the coefficient array. The array is of length numTaps.*/
+          q15_t *pState;              /**< points to the state variable array. The array is of length numTaps+blockSize-1. */
+  } arm_fir_decimate_instance_q15;
+
+  /**
+   * @brief Instance structure for the Q31 FIR decimator.
+   */
+  typedef struct
+  {
+          uint8_t M;                  /**< decimation factor. */
+          uint16_t numTaps;           /**< number of coefficients in the filter. */
+    const q31_t *pCoeffs;             /**< points to the coefficient array. The array is of length numTaps.*/
+          q31_t *pState;              /**< points to the state variable array. The array is of length numTaps+blockSize-1. */
+  } arm_fir_decimate_instance_q31;
+
+/**
+  @brief Instance structure for floating-point FIR decimator.
+ */
+typedef struct
+  {
+          uint8_t M;                  /**< decimation factor. */
+          uint16_t numTaps;           /**< number of coefficients in the filter. */
+    const float32_t *pCoeffs;         /**< points to the coefficient array. The array is of length numTaps.*/
+          float32_t *pState;          /**< points to the state variable array. The array is of length numTaps+blockSize-1. */
+  } arm_fir_decimate_instance_f32;
+
+
+/**
+  @brief         Processing function for floating-point FIR decimator.
+  @param[in]     S         points to an instance of the floating-point FIR decimator structure
+  @param[in]     pSrc      points to the block of input data
+  @param[out]    pDst      points to the block of output data
+  @param[in]     blockSize number of samples to process
+ */
+void arm_fir_decimate_f32(
+  const arm_fir_decimate_instance_f32 * S,
+  const float32_t * pSrc,
+        float32_t * pDst,
+        uint32_t blockSize);
+
+
+/**
+  @brief         Initialization function for the floating-point FIR decimator.
+  @param[in,out] S          points to an instance of the floating-point FIR decimator structure
+  @param[in]     numTaps    number of coefficients in the filter
+  @param[in]     M          decimation factor
+  @param[in]     pCoeffs    points to the filter coefficients
+  @param[in]     pState     points to the state buffer
+  @param[in]     blockSize  number of input samples to process per call
+  @return        execution status
+                   - \ref ARM_MATH_SUCCESS      : Operation successful
+                   - \ref ARM_MATH_LENGTH_ERROR : <code>blockSize</code> is not a multiple of <code>M</code>
+ */
+arm_status arm_fir_decimate_init_f32(
+        arm_fir_decimate_instance_f32 * S,
+        uint16_t numTaps,
+        uint8_t M,
+  const float32_t * pCoeffs,
+        float32_t * pState,
+        uint32_t blockSize);
+
+
+  /**
+   * @brief Processing function for the Q15 FIR decimator.
+   * @param[in]  S          points to an instance of the Q15 FIR decimator structure.
+   * @param[in]  pSrc       points to the block of input data.
+   * @param[out] pDst       points to the block of output data
+   * @param[in]  blockSize  number of input samples to process per call.
+   */
+  void arm_fir_decimate_q15(
+  const arm_fir_decimate_instance_q15 * S,
+  const q15_t * pSrc,
+        q15_t * pDst,
+        uint32_t blockSize);
+
+
+  /**
+   * @brief Processing function for the Q15 FIR decimator (fast variant) for Cortex-M3 and Cortex-M4.
+   * @param[in]  S          points to an instance of the Q15 FIR decimator structure.
+   * @param[in]  pSrc       points to the block of input data.
+   * @param[out] pDst       points to the block of output data
+   * @param[in]  blockSize  number of input samples to process per call.
+   */
+  void arm_fir_decimate_fast_q15(
+  const arm_fir_decimate_instance_q15 * S,
+  const q15_t * pSrc,
+        q15_t * pDst,
+        uint32_t blockSize);
+
+
+  /**
+   * @brief  Initialization function for the Q15 FIR decimator.
+   * @param[in,out] S          points to an instance of the Q15 FIR decimator structure.
+   * @param[in]     numTaps    number of coefficients in the filter.
+   * @param[in]     M          decimation factor.
+   * @param[in]     pCoeffs    points to the filter coefficients.
+   * @param[in]     pState     points to the state buffer.
+   * @param[in]     blockSize  number of input samples to process per call.
+   * @return    The function returns ARM_MATH_SUCCESS if initialization is successful or ARM_MATH_LENGTH_ERROR if
+   * <code>blockSize</code> is not a multiple of <code>M</code>.
+   */
+  arm_status arm_fir_decimate_init_q15(
+        arm_fir_decimate_instance_q15 * S,
+        uint16_t numTaps,
+        uint8_t M,
+  const q15_t * pCoeffs,
+        q15_t * pState,
+        uint32_t blockSize);
+
+
+  /**
+   * @brief Processing function for the Q31 FIR decimator.
+   * @param[in]  S     points to an instance of the Q31 FIR decimator structure.
+   * @param[in]  pSrc  points to the block of input data.
+   * @param[out] pDst  points to the block of output data
+   * @param[in] blockSize number of input samples to process per call.
+   */
+  void arm_fir_decimate_q31(
+  const arm_fir_decimate_instance_q31 * S,
+  const q31_t * pSrc,
+        q31_t * pDst,
+        uint32_t blockSize);
+
+  /**
+   * @brief Processing function for the Q31 FIR decimator (fast variant) for Cortex-M3 and Cortex-M4.
+   * @param[in]  S          points to an instance of the Q31 FIR decimator structure.
+   * @param[in]  pSrc       points to the block of input data.
+   * @param[out] pDst       points to the block of output data
+   * @param[in]  blockSize  number of input samples to process per call.
+   */
+  void arm_fir_decimate_fast_q31(
+  const arm_fir_decimate_instance_q31 * S,
+  const q31_t * pSrc,
+        q31_t * pDst,
+        uint32_t blockSize);
+
+
+  /**
+   * @brief  Initialization function for the Q31 FIR decimator.
+   * @param[in,out] S          points to an instance of the Q31 FIR decimator structure.
+   * @param[in]     numTaps    number of coefficients in the filter.
+   * @param[in]     M          decimation factor.
+   * @param[in]     pCoeffs    points to the filter coefficients.
+   * @param[in]     pState     points to the state buffer.
+   * @param[in]     blockSize  number of input samples to process per call.
+   * @return    The function returns ARM_MATH_SUCCESS if initialization is successful or ARM_MATH_LENGTH_ERROR if
+   * <code>blockSize</code> is not a multiple of <code>M</code>.
+   */
+  arm_status arm_fir_decimate_init_q31(
+        arm_fir_decimate_instance_q31 * S,
+        uint16_t numTaps,
+        uint8_t M,
+  const q31_t * pCoeffs,
+        q31_t * pState,
+        uint32_t blockSize);
+
+
+  /**
+   * @brief Instance structure for the Q15 FIR interpolator.
+   */
+  typedef struct
+  {
+        uint8_t L;                      /**< upsample factor. */
+        uint16_t phaseLength;           /**< length of each polyphase filter component. */
+  const q15_t *pCoeffs;                 /**< points to the coefficient array. The array is of length L*phaseLength. */
+        q15_t *pState;                  /**< points to the state variable array. The array is of length blockSize+phaseLength-1. */
+  } arm_fir_interpolate_instance_q15;
+
+  /**
+   * @brief Instance structure for the Q31 FIR interpolator.
+   */
+  typedef struct
+  {
+        uint8_t L;                      /**< upsample factor. */
+        uint16_t phaseLength;           /**< length of each polyphase filter component. */
+  const q31_t *pCoeffs;                 /**< points to the coefficient array. The array is of length L*phaseLength. */
+        q31_t *pState;                  /**< points to the state variable array. The array is of length blockSize+phaseLength-1. */
+  } arm_fir_interpolate_instance_q31;
+
+  /**
+   * @brief Instance structure for the floating-point FIR interpolator.
+   */
+  typedef struct
+  {
+        uint8_t L;                     /**< upsample factor. */
+        uint16_t phaseLength;          /**< length of each polyphase filter component. */
+  const float32_t *pCoeffs;            /**< points to the coefficient array. The array is of length L*phaseLength. */
+        float32_t *pState;             /**< points to the state variable array. The array is of length phaseLength+numTaps-1. */
+  } arm_fir_interpolate_instance_f32;
+
+
+  /**
+   * @brief Processing function for the Q15 FIR interpolator.
+   * @param[in]  S          points to an instance of the Q15 FIR interpolator structure.
+   * @param[in]  pSrc       points to the block of input data.
+   * @param[out] pDst       points to the block of output data.
+   * @param[in]  blockSize  number of input samples to process per call.
+   */
+  void arm_fir_interpolate_q15(
+  const arm_fir_interpolate_instance_q15 * S,
+  const q15_t * pSrc,
+        q15_t * pDst,
+        uint32_t blockSize);
+
+
+  /**
+   * @brief  Initialization function for the Q15 FIR interpolator.
+   * @param[in,out] S          points to an instance of the Q15 FIR interpolator structure.
+   * @param[in]     L          upsample factor.
+   * @param[in]     numTaps    number of filter coefficients in the filter.
+   * @param[in]     pCoeffs    points to the filter coefficient buffer.
+   * @param[in]     pState     points to the state buffer.
+   * @param[in]     blockSize  number of input samples to process per call.
+   * @return        The function returns ARM_MATH_SUCCESS if initialization is successful or ARM_MATH_LENGTH_ERROR if
+   * the filter length <code>numTaps</code> is not a multiple of the interpolation factor <code>L</code>.
+   */
+  arm_status arm_fir_interpolate_init_q15(
+        arm_fir_interpolate_instance_q15 * S,
+        uint8_t L,
+        uint16_t numTaps,
+  const q15_t * pCoeffs,
+        q15_t * pState,
+        uint32_t blockSize);
+
+
+  /**
+   * @brief Processing function for the Q31 FIR interpolator.
+   * @param[in]  S          points to an instance of the Q15 FIR interpolator structure.
+   * @param[in]  pSrc       points to the block of input data.
+   * @param[out] pDst       points to the block of output data.
+   * @param[in]  blockSize  number of input samples to process per call.
+   */
+  void arm_fir_interpolate_q31(
+  const arm_fir_interpolate_instance_q31 * S,
+  const q31_t * pSrc,
+        q31_t * pDst,
+        uint32_t blockSize);
+
+
+  /**
+   * @brief  Initialization function for the Q31 FIR interpolator.
+   * @param[in,out] S          points to an instance of the Q31 FIR interpolator structure.
+   * @param[in]     L          upsample factor.
+   * @param[in]     numTaps    number of filter coefficients in the filter.
+   * @param[in]     pCoeffs    points to the filter coefficient buffer.
+   * @param[in]     pState     points to the state buffer.
+   * @param[in]     blockSize  number of input samples to process per call.
+   * @return        The function returns ARM_MATH_SUCCESS if initialization is successful or ARM_MATH_LENGTH_ERROR if
+   * the filter length <code>numTaps</code> is not a multiple of the interpolation factor <code>L</code>.
+   */
+  arm_status arm_fir_interpolate_init_q31(
+        arm_fir_interpolate_instance_q31 * S,
+        uint8_t L,
+        uint16_t numTaps,
+  const q31_t * pCoeffs,
+        q31_t * pState,
+        uint32_t blockSize);
+
+
+  /**
+   * @brief Processing function for the floating-point FIR interpolator.
+   * @param[in]  S          points to an instance of the floating-point FIR interpolator structure.
+   * @param[in]  pSrc       points to the block of input data.
+   * @param[out] pDst       points to the block of output data.
+   * @param[in]  blockSize  number of input samples to process per call.
+   */
+  void arm_fir_interpolate_f32(
+  const arm_fir_interpolate_instance_f32 * S,
+  const float32_t * pSrc,
+        float32_t * pDst,
+        uint32_t blockSize);
+
+
+  /**
+   * @brief  Initialization function for the floating-point FIR interpolator.
+   * @param[in,out] S          points to an instance of the floating-point FIR interpolator structure.
+   * @param[in]     L          upsample factor.
+   * @param[in]     numTaps    number of filter coefficients in the filter.
+   * @param[in]     pCoeffs    points to the filter coefficient buffer.
+   * @param[in]     pState     points to the state buffer.
+   * @param[in]     blockSize  number of input samples to process per call.
+   * @return        The function returns ARM_MATH_SUCCESS if initialization is successful or ARM_MATH_LENGTH_ERROR if
+   * the filter length <code>numTaps</code> is not a multiple of the interpolation factor <code>L</code>.
+   */
+  arm_status arm_fir_interpolate_init_f32(
+        arm_fir_interpolate_instance_f32 * S,
+        uint8_t L,
+        uint16_t numTaps,
+  const float32_t * pCoeffs,
+        float32_t * pState,
+        uint32_t blockSize);
+
+
+  /**
+   * @brief Instance structure for the high precision Q31 Biquad cascade filter.
+   */
+  typedef struct
+  {
+          uint8_t numStages;       /**< number of 2nd order stages in the filter.  Overall order is 2*numStages. */
+          q63_t *pState;           /**< points to the array of state coefficients.  The array is of length 4*numStages. */
+    const q31_t *pCoeffs;          /**< points to the array of coefficients.  The array is of length 5*numStages. */
+          uint8_t postShift;       /**< additional shift, in bits, applied to each output sample. */
+  } arm_biquad_cas_df1_32x64_ins_q31;
+
+
+  /**
+   * @param[in]  S          points to an instance of the high precision Q31 Biquad cascade filter structure.
+   * @param[in]  pSrc       points to the block of input data.
+   * @param[out] pDst       points to the block of output data
+   * @param[in]  blockSize  number of samples to process.
+   */
+  void arm_biquad_cas_df1_32x64_q31(
+  const arm_biquad_cas_df1_32x64_ins_q31 * S,
+  const q31_t * pSrc,
+        q31_t * pDst,
+        uint32_t blockSize);
+
+
+  /**
+   * @param[in,out] S          points to an instance of the high precision Q31 Biquad cascade filter structure.
+   * @param[in]     numStages  number of 2nd order stages in the filter.
+   * @param[in]     pCoeffs    points to the filter coefficients.
+   * @param[in]     pState     points to the state buffer.
+   * @param[in]     postShift  shift to be applied to the output. Varies according to the coefficients format
+   */
+  void arm_biquad_cas_df1_32x64_init_q31(
+        arm_biquad_cas_df1_32x64_ins_q31 * S,
+        uint8_t numStages,
+  const q31_t * pCoeffs,
+        q63_t * pState,
+        uint8_t postShift);
+
+
+  /**
+   * @brief Instance structure for the floating-point transposed direct form II Biquad cascade filter.
+   */
+  typedef struct
+  {
+          uint8_t numStages;         /**< number of 2nd order stages in the filter.  Overall order is 2*numStages. */
+          float32_t *pState;         /**< points to the array of state coefficients.  The array is of length 2*numStages. */
+    const float32_t *pCoeffs;        /**< points to the array of coefficients.  The array is of length 5*numStages. */
+  } arm_biquad_cascade_df2T_instance_f32;
+
+  /**
+   * @brief Instance structure for the floating-point transposed direct form II Biquad cascade filter.
+   */
+  typedef struct
+  {
+          uint8_t numStages;         /**< number of 2nd order stages in the filter.  Overall order is 2*numStages. */
+          float32_t *pState;         /**< points to the array of state coefficients.  The array is of length 4*numStages. */
+    const float32_t *pCoeffs;        /**< points to the array of coefficients.  The array is of length 5*numStages. */
+  } arm_biquad_cascade_stereo_df2T_instance_f32;
+
+  /**
+   * @brief Instance structure for the floating-point transposed direct form II Biquad cascade filter.
+   */
+  typedef struct
+  {
+          uint8_t numStages;         /**< number of 2nd order stages in the filter.  Overall order is 2*numStages. */
+          float64_t *pState;         /**< points to the array of state coefficients.  The array is of length 2*numStages. */
+    const float64_t *pCoeffs;        /**< points to the array of coefficients.  The array is of length 5*numStages. */
+  } arm_biquad_cascade_df2T_instance_f64;
+
+
+  /**
+   * @brief Processing function for the floating-point transposed direct form II Biquad cascade filter.
+   * @param[in]  S          points to an instance of the filter data structure.
+   * @param[in]  pSrc       points to the block of input data.
+   * @param[out] pDst       points to the block of output data
+   * @param[in]  blockSize  number of samples to process.
+   */
+  void arm_biquad_cascade_df2T_f32(
+  const arm_biquad_cascade_df2T_instance_f32 * S,
+  const float32_t * pSrc,
+        float32_t * pDst,
+        uint32_t blockSize);
+
+
+  /**
+   * @brief Processing function for the floating-point transposed direct form II Biquad cascade filter. 2 channels
+   * @param[in]  S          points to an instance of the filter data structure.
+   * @param[in]  pSrc       points to the block of input data.
+   * @param[out] pDst       points to the block of output data
+   * @param[in]  blockSize  number of samples to process.
+   */
+  void arm_biquad_cascade_stereo_df2T_f32(
+  const arm_biquad_cascade_stereo_df2T_instance_f32 * S,
+  const float32_t * pSrc,
+        float32_t * pDst,
+        uint32_t blockSize);
+
+
+  /**
+   * @brief Processing function for the floating-point transposed direct form II Biquad cascade filter.
+   * @param[in]  S          points to an instance of the filter data structure.
+   * @param[in]  pSrc       points to the block of input data.
+   * @param[out] pDst       points to the block of output data
+   * @param[in]  blockSize  number of samples to process.
+   */
+  void arm_biquad_cascade_df2T_f64(
+  const arm_biquad_cascade_df2T_instance_f64 * S,
+  const float64_t * pSrc,
+        float64_t * pDst,
+        uint32_t blockSize);
+
+
+#if defined(ARM_MATH_NEON) 
+void arm_biquad_cascade_df2T_compute_coefs_f32(
+  arm_biquad_cascade_df2T_instance_f32 * S,
+  uint8_t numStages,
+  float32_t * pCoeffs);
+#endif
+  /**
+   * @brief  Initialization function for the floating-point transposed direct form II Biquad cascade filter.
+   * @param[in,out] S          points to an instance of the filter data structure.
+   * @param[in]     numStages  number of 2nd order stages in the filter.
+   * @param[in]     pCoeffs    points to the filter coefficients.
+   * @param[in]     pState     points to the state buffer.
+   */
+  void arm_biquad_cascade_df2T_init_f32(
+        arm_biquad_cascade_df2T_instance_f32 * S,
+        uint8_t numStages,
+  const float32_t * pCoeffs,
+        float32_t * pState);
+
+
+  /**
+   * @brief  Initialization function for the floating-point transposed direct form II Biquad cascade filter.
+   * @param[in,out] S          points to an instance of the filter data structure.
+   * @param[in]     numStages  number of 2nd order stages in the filter.
+   * @param[in]     pCoeffs    points to the filter coefficients.
+   * @param[in]     pState     points to the state buffer.
+   */
+  void arm_biquad_cascade_stereo_df2T_init_f32(
+        arm_biquad_cascade_stereo_df2T_instance_f32 * S,
+        uint8_t numStages,
+  const float32_t * pCoeffs,
+        float32_t * pState);
+
+
+  /**
+   * @brief  Initialization function for the floating-point transposed direct form II Biquad cascade filter.
+   * @param[in,out] S          points to an instance of the filter data structure.
+   * @param[in]     numStages  number of 2nd order stages in the filter.
+   * @param[in]     pCoeffs    points to the filter coefficients.
+   * @param[in]     pState     points to the state buffer.
+   */
+  void arm_biquad_cascade_df2T_init_f64(
+        arm_biquad_cascade_df2T_instance_f64 * S,
+        uint8_t numStages,
+        const float64_t * pCoeffs,
+        float64_t * pState);
+
+
+  /**
+   * @brief Instance structure for the Q15 FIR lattice filter.
+   */
+  typedef struct
+  {
+          uint16_t numStages;                  /**< number of filter stages. */
+          q15_t *pState;                       /**< points to the state variable array. The array is of length numStages. */
+    const q15_t *pCoeffs;                      /**< points to the coefficient array. The array is of length numStages. */
+  } arm_fir_lattice_instance_q15;
+
+  /**
+   * @brief Instance structure for the Q31 FIR lattice filter.
+   */
+  typedef struct
+  {
+          uint16_t numStages;                  /**< number of filter stages. */
+          q31_t *pState;                       /**< points to the state variable array. The array is of length numStages. */
+    const q31_t *pCoeffs;                      /**< points to the coefficient array. The array is of length numStages. */
+  } arm_fir_lattice_instance_q31;
+
+  /**
+   * @brief Instance structure for the floating-point FIR lattice filter.
+   */
+  typedef struct
+  {
+          uint16_t numStages;                  /**< number of filter stages. */
+          float32_t *pState;                   /**< points to the state variable array. The array is of length numStages. */
+    const float32_t *pCoeffs;                  /**< points to the coefficient array. The array is of length numStages. */
+  } arm_fir_lattice_instance_f32;
+
+
+  /**
+   * @brief Initialization function for the Q15 FIR lattice filter.
+   * @param[in] S          points to an instance of the Q15 FIR lattice structure.
+   * @param[in] numStages  number of filter stages.
+   * @param[in] pCoeffs    points to the coefficient buffer.  The array is of length numStages.
+   * @param[in] pState     points to the state buffer.  The array is of length numStages.
+   */
+  void arm_fir_lattice_init_q15(
+        arm_fir_lattice_instance_q15 * S,
+        uint16_t numStages,
+  const q15_t * pCoeffs,
+        q15_t * pState);
+
+
+  /**
+   * @brief Processing function for the Q15 FIR lattice filter.
+   * @param[in]  S          points to an instance of the Q15 FIR lattice structure.
+   * @param[in]  pSrc       points to the block of input data.
+   * @param[out] pDst       points to the block of output data.
+   * @param[in]  blockSize  number of samples to process.
+   */
+  void arm_fir_lattice_q15(
+  const arm_fir_lattice_instance_q15 * S,
+  const q15_t * pSrc,
+        q15_t * pDst,
+        uint32_t blockSize);
+
+
+  /**
+   * @brief Initialization function for the Q31 FIR lattice filter.
+   * @param[in] S          points to an instance of the Q31 FIR lattice structure.
+   * @param[in] numStages  number of filter stages.
+   * @param[in] pCoeffs    points to the coefficient buffer.  The array is of length numStages.
+   * @param[in] pState     points to the state buffer.   The array is of length numStages.
+   */
+  void arm_fir_lattice_init_q31(
+        arm_fir_lattice_instance_q31 * S,
+        uint16_t numStages,
+  const q31_t * pCoeffs,
+        q31_t * pState);
+
+
+  /**
+   * @brief Processing function for the Q31 FIR lattice filter.
+   * @param[in]  S          points to an instance of the Q31 FIR lattice structure.
+   * @param[in]  pSrc       points to the block of input data.
+   * @param[out] pDst       points to the block of output data
+   * @param[in]  blockSize  number of samples to process.
+   */
+  void arm_fir_lattice_q31(
+  const arm_fir_lattice_instance_q31 * S,
+  const q31_t * pSrc,
+        q31_t * pDst,
+        uint32_t blockSize);
+
+
+/**
+ * @brief Initialization function for the floating-point FIR lattice filter.
+ * @param[in] S          points to an instance of the floating-point FIR lattice structure.
+ * @param[in] numStages  number of filter stages.
+ * @param[in] pCoeffs    points to the coefficient buffer.  The array is of length numStages.
+ * @param[in] pState     points to the state buffer.  The array is of length numStages.
+ */
+  void arm_fir_lattice_init_f32(
+        arm_fir_lattice_instance_f32 * S,
+        uint16_t numStages,
+  const float32_t * pCoeffs,
+        float32_t * pState);
+
+
+  /**
+   * @brief Processing function for the floating-point FIR lattice filter.
+   * @param[in]  S          points to an instance of the floating-point FIR lattice structure.
+   * @param[in]  pSrc       points to the block of input data.
+   * @param[out] pDst       points to the block of output data
+   * @param[in]  blockSize  number of samples to process.
+   */
+  void arm_fir_lattice_f32(
+  const arm_fir_lattice_instance_f32 * S,
+  const float32_t * pSrc,
+        float32_t * pDst,
+        uint32_t blockSize);
+
+
+  /**
+   * @brief Instance structure for the Q15 IIR lattice filter.
+   */
+  typedef struct
+  {
+          uint16_t numStages;                  /**< number of stages in the filter. */
+          q15_t *pState;                       /**< points to the state variable array. The array is of length numStages+blockSize. */
+          q15_t *pkCoeffs;                     /**< points to the reflection coefficient array. The array is of length numStages. */
+          q15_t *pvCoeffs;                     /**< points to the ladder coefficient array. The array is of length numStages+1. */
+  } arm_iir_lattice_instance_q15;
+
+  /**
+   * @brief Instance structure for the Q31 IIR lattice filter.
+   */
+  typedef struct
+  {
+          uint16_t numStages;                  /**< number of stages in the filter. */
+          q31_t *pState;                       /**< points to the state variable array. The array is of length numStages+blockSize. */
+          q31_t *pkCoeffs;                     /**< points to the reflection coefficient array. The array is of length numStages. */
+          q31_t *pvCoeffs;                     /**< points to the ladder coefficient array. The array is of length numStages+1. */
+  } arm_iir_lattice_instance_q31;
+
+  /**
+   * @brief Instance structure for the floating-point IIR lattice filter.
+   */
+  typedef struct
+  {
+          uint16_t numStages;                  /**< number of stages in the filter. */
+          float32_t *pState;                   /**< points to the state variable array. The array is of length numStages+blockSize. */
+          float32_t *pkCoeffs;                 /**< points to the reflection coefficient array. The array is of length numStages. */
+          float32_t *pvCoeffs;                 /**< points to the ladder coefficient array. The array is of length numStages+1. */
+  } arm_iir_lattice_instance_f32;
+
+
+  /**
+   * @brief Processing function for the floating-point IIR lattice filter.
+   * @param[in]  S          points to an instance of the floating-point IIR lattice structure.
+   * @param[in]  pSrc       points to the block of input data.
+   * @param[out] pDst       points to the block of output data.
+   * @param[in]  blockSize  number of samples to process.
+   */
+  void arm_iir_lattice_f32(
+  const arm_iir_lattice_instance_f32 * S,
+  const float32_t * pSrc,
+        float32_t * pDst,
+        uint32_t blockSize);
+
+
+  /**
+   * @brief Initialization function for the floating-point IIR lattice filter.
+   * @param[in] S          points to an instance of the floating-point IIR lattice structure.
+   * @param[in] numStages  number of stages in the filter.
+   * @param[in] pkCoeffs   points to the reflection coefficient buffer.  The array is of length numStages.
+   * @param[in] pvCoeffs   points to the ladder coefficient buffer.  The array is of length numStages+1.
+   * @param[in] pState     points to the state buffer.  The array is of length numStages+blockSize-1.
+   * @param[in] blockSize  number of samples to process.
+   */
+  void arm_iir_lattice_init_f32(
+        arm_iir_lattice_instance_f32 * S,
+        uint16_t numStages,
+        float32_t * pkCoeffs,
+        float32_t * pvCoeffs,
+        float32_t * pState,
+        uint32_t blockSize);
+
+
+  /**
+   * @brief Processing function for the Q31 IIR lattice filter.
+   * @param[in]  S          points to an instance of the Q31 IIR lattice structure.
+   * @param[in]  pSrc       points to the block of input data.
+   * @param[out] pDst       points to the block of output data.
+   * @param[in]  blockSize  number of samples to process.
+   */
+  void arm_iir_lattice_q31(
+  const arm_iir_lattice_instance_q31 * S,
+  const q31_t * pSrc,
+        q31_t * pDst,
+        uint32_t blockSize);
+
+
+  /**
+   * @brief Initialization function for the Q31 IIR lattice filter.
+   * @param[in] S          points to an instance of the Q31 IIR lattice structure.
+   * @param[in] numStages  number of stages in the filter.
+   * @param[in] pkCoeffs   points to the reflection coefficient buffer.  The array is of length numStages.
+   * @param[in] pvCoeffs   points to the ladder coefficient buffer.  The array is of length numStages+1.
+   * @param[in] pState     points to the state buffer.  The array is of length numStages+blockSize.
+   * @param[in] blockSize  number of samples to process.
+   */
+  void arm_iir_lattice_init_q31(
+        arm_iir_lattice_instance_q31 * S,
+        uint16_t numStages,
+        q31_t * pkCoeffs,
+        q31_t * pvCoeffs,
+        q31_t * pState,
+        uint32_t blockSize);
+
+
+  /**
+   * @brief Processing function for the Q15 IIR lattice filter.
+   * @param[in]  S          points to an instance of the Q15 IIR lattice structure.
+   * @param[in]  pSrc       points to the block of input data.
+   * @param[out] pDst       points to the block of output data.
+   * @param[in]  blockSize  number of samples to process.
+   */
+  void arm_iir_lattice_q15(
+  const arm_iir_lattice_instance_q15 * S,
+  const q15_t * pSrc,
+        q15_t * pDst,
+        uint32_t blockSize);
+
+
+/**
+ * @brief Initialization function for the Q15 IIR lattice filter.
+ * @param[in] S          points to an instance of the fixed-point Q15 IIR lattice structure.
+ * @param[in] numStages  number of stages in the filter.
+ * @param[in] pkCoeffs   points to reflection coefficient buffer.  The array is of length numStages.
+ * @param[in] pvCoeffs   points to ladder coefficient buffer.  The array is of length numStages+1.
+ * @param[in] pState     points to state buffer.  The array is of length numStages+blockSize.
+ * @param[in] blockSize  number of samples to process per call.
+ */
+  void arm_iir_lattice_init_q15(
+        arm_iir_lattice_instance_q15 * S,
+        uint16_t numStages,
+        q15_t * pkCoeffs,
+        q15_t * pvCoeffs,
+        q15_t * pState,
+        uint32_t blockSize);
+
+
+  /**
+   * @brief Instance structure for the floating-point LMS filter.
+   */
+  typedef struct
+  {
+          uint16_t numTaps;    /**< number of coefficients in the filter. */
+          float32_t *pState;   /**< points to the state variable array. The array is of length numTaps+blockSize-1. */
+          float32_t *pCoeffs;  /**< points to the coefficient array. The array is of length numTaps. */
+          float32_t mu;        /**< step size that controls filter coefficient updates. */
+  } arm_lms_instance_f32;
+
+
+  /**
+   * @brief Processing function for floating-point LMS filter.
+   * @param[in]  S          points to an instance of the floating-point LMS filter structure.
+   * @param[in]  pSrc       points to the block of input data.
+   * @param[in]  pRef       points to the block of reference data.
+   * @param[out] pOut       points to the block of output data.
+   * @param[out] pErr       points to the block of error data.
+   * @param[in]  blockSize  number of samples to process.
+   */
+  void arm_lms_f32(
+  const arm_lms_instance_f32 * S,
+  const float32_t * pSrc,
+        float32_t * pRef,
+        float32_t * pOut,
+        float32_t * pErr,
+        uint32_t blockSize);
+
+
+  /**
+   * @brief Initialization function for floating-point LMS filter.
+   * @param[in] S          points to an instance of the floating-point LMS filter structure.
+   * @param[in] numTaps    number of filter coefficients.
+   * @param[in] pCoeffs    points to the coefficient buffer.
+   * @param[in] pState     points to state buffer.
+   * @param[in] mu         step size that controls filter coefficient updates.
+   * @param[in] blockSize  number of samples to process.
+   */
+  void arm_lms_init_f32(
+        arm_lms_instance_f32 * S,
+        uint16_t numTaps,
+        float32_t * pCoeffs,
+        float32_t * pState,
+        float32_t mu,
+        uint32_t blockSize);
+
+
+  /**
+   * @brief Instance structure for the Q15 LMS filter.
+   */
+  typedef struct
+  {
+          uint16_t numTaps;    /**< number of coefficients in the filter. */
+          q15_t *pState;       /**< points to the state variable array. The array is of length numTaps+blockSize-1. */
+          q15_t *pCoeffs;      /**< points to the coefficient array. The array is of length numTaps. */
+          q15_t mu;            /**< step size that controls filter coefficient updates. */
+          uint32_t postShift;  /**< bit shift applied to coefficients. */
+  } arm_lms_instance_q15;
+
+
+  /**
+   * @brief Initialization function for the Q15 LMS filter.
+   * @param[in] S          points to an instance of the Q15 LMS filter structure.
+   * @param[in] numTaps    number of filter coefficients.
+   * @param[in] pCoeffs    points to the coefficient buffer.
+   * @param[in] pState     points to the state buffer.
+   * @param[in] mu         step size that controls filter coefficient updates.
+   * @param[in] blockSize  number of samples to process.
+   * @param[in] postShift  bit shift applied to coefficients.
+   */
+  void arm_lms_init_q15(
+        arm_lms_instance_q15 * S,
+        uint16_t numTaps,
+        q15_t * pCoeffs,
+        q15_t * pState,
+        q15_t mu,
+        uint32_t blockSize,
+        uint32_t postShift);
+
+
+  /**
+   * @brief Processing function for Q15 LMS filter.
+   * @param[in]  S          points to an instance of the Q15 LMS filter structure.
+   * @param[in]  pSrc       points to the block of input data.
+   * @param[in]  pRef       points to the block of reference data.
+   * @param[out] pOut       points to the block of output data.
+   * @param[out] pErr       points to the block of error data.
+   * @param[in]  blockSize  number of samples to process.
+   */
+  void arm_lms_q15(
+  const arm_lms_instance_q15 * S,
+  const q15_t * pSrc,
+        q15_t * pRef,
+        q15_t * pOut,
+        q15_t * pErr,
+        uint32_t blockSize);
+
+
+  /**
+   * @brief Instance structure for the Q31 LMS filter.
+   */
+  typedef struct
+  {
+          uint16_t numTaps;    /**< number of coefficients in the filter. */
+          q31_t *pState;       /**< points to the state variable array. The array is of length numTaps+blockSize-1. */
+          q31_t *pCoeffs;      /**< points to the coefficient array. The array is of length numTaps. */
+          q31_t mu;            /**< step size that controls filter coefficient updates. */
+          uint32_t postShift;  /**< bit shift applied to coefficients. */
+  } arm_lms_instance_q31;
+
+
+  /**
+   * @brief Processing function for Q31 LMS filter.
+   * @param[in]  S          points to an instance of the Q15 LMS filter structure.
+   * @param[in]  pSrc       points to the block of input data.
+   * @param[in]  pRef       points to the block of reference data.
+   * @param[out] pOut       points to the block of output data.
+   * @param[out] pErr       points to the block of error data.
+   * @param[in]  blockSize  number of samples to process.
+   */
+  void arm_lms_q31(
+  const arm_lms_instance_q31 * S,
+  const q31_t * pSrc,
+        q31_t * pRef,
+        q31_t * pOut,
+        q31_t * pErr,
+        uint32_t blockSize);
+
+
+  /**
+   * @brief Initialization function for Q31 LMS filter.
+   * @param[in] S          points to an instance of the Q31 LMS filter structure.
+   * @param[in] numTaps    number of filter coefficients.
+   * @param[in] pCoeffs    points to coefficient buffer.
+   * @param[in] pState     points to state buffer.
+   * @param[in] mu         step size that controls filter coefficient updates.
+   * @param[in] blockSize  number of samples to process.
+   * @param[in] postShift  bit shift applied to coefficients.
+   */
+  void arm_lms_init_q31(
+        arm_lms_instance_q31 * S,
+        uint16_t numTaps,
+        q31_t * pCoeffs,
+        q31_t * pState,
+        q31_t mu,
+        uint32_t blockSize,
+        uint32_t postShift);
+
+
+  /**
+   * @brief Instance structure for the floating-point normalized LMS filter.
+   */
+  typedef struct
+  {
+          uint16_t numTaps;     /**< number of coefficients in the filter. */
+          float32_t *pState;    /**< points to the state variable array. The array is of length numTaps+blockSize-1. */
+          float32_t *pCoeffs;   /**< points to the coefficient array. The array is of length numTaps. */
+          float32_t mu;         /**< step size that control filter coefficient updates. */
+          float32_t energy;     /**< saves previous frame energy. */
+          float32_t x0;         /**< saves previous input sample. */
+  } arm_lms_norm_instance_f32;
+
+
+  /**
+   * @brief Processing function for floating-point normalized LMS filter.
+   * @param[in]  S          points to an instance of the floating-point normalized LMS filter structure.
+   * @param[in]  pSrc       points to the block of input data.
+   * @param[in]  pRef       points to the block of reference data.
+   * @param[out] pOut       points to the block of output data.
+   * @param[out] pErr       points to the block of error data.
+   * @param[in]  blockSize  number of samples to process.
+   */
+  void arm_lms_norm_f32(
+        arm_lms_norm_instance_f32 * S,
+  const float32_t * pSrc,
+        float32_t * pRef,
+        float32_t * pOut,
+        float32_t * pErr,
+        uint32_t blockSize);
+
+
+  /**
+   * @brief Initialization function for floating-point normalized LMS filter.
+   * @param[in] S          points to an instance of the floating-point LMS filter structure.
+   * @param[in] numTaps    number of filter coefficients.
+   * @param[in] pCoeffs    points to coefficient buffer.
+   * @param[in] pState     points to state buffer.
+   * @param[in] mu         step size that controls filter coefficient updates.
+   * @param[in] blockSize  number of samples to process.
+   */
+  void arm_lms_norm_init_f32(
+        arm_lms_norm_instance_f32 * S,
+        uint16_t numTaps,
+        float32_t * pCoeffs,
+        float32_t * pState,
+        float32_t mu,
+        uint32_t blockSize);
+
+
+  /**
+   * @brief Instance structure for the Q31 normalized LMS filter.
+   */
+  typedef struct
+  {
+          uint16_t numTaps;     /**< number of coefficients in the filter. */
+          q31_t *pState;        /**< points to the state variable array. The array is of length numTaps+blockSize-1. */
+          q31_t *pCoeffs;       /**< points to the coefficient array. The array is of length numTaps. */
+          q31_t mu;             /**< step size that controls filter coefficient updates. */
+          uint8_t postShift;    /**< bit shift applied to coefficients. */
+    const q31_t *recipTable;    /**< points to the reciprocal initial value table. */
+          q31_t energy;         /**< saves previous frame energy. */
+          q31_t x0;             /**< saves previous input sample. */
+  } arm_lms_norm_instance_q31;
+
+
+  /**
+   * @brief Processing function for Q31 normalized LMS filter.
+   * @param[in]  S          points to an instance of the Q31 normalized LMS filter structure.
+   * @param[in]  pSrc       points to the block of input data.
+   * @param[in]  pRef       points to the block of reference data.
+   * @param[out] pOut       points to the block of output data.
+   * @param[out] pErr       points to the block of error data.
+   * @param[in]  blockSize  number of samples to process.
+   */
+  void arm_lms_norm_q31(
+        arm_lms_norm_instance_q31 * S,
+  const q31_t * pSrc,
+        q31_t * pRef,
+        q31_t * pOut,
+        q31_t * pErr,
+        uint32_t blockSize);
+
+
+  /**
+   * @brief Initialization function for Q31 normalized LMS filter.
+   * @param[in] S          points to an instance of the Q31 normalized LMS filter structure.
+   * @param[in] numTaps    number of filter coefficients.
+   * @param[in] pCoeffs    points to coefficient buffer.
+   * @param[in] pState     points to state buffer.
+   * @param[in] mu         step size that controls filter coefficient updates.
+   * @param[in] blockSize  number of samples to process.
+   * @param[in] postShift  bit shift applied to coefficients.
+   */
+  void arm_lms_norm_init_q31(
+        arm_lms_norm_instance_q31 * S,
+        uint16_t numTaps,
+        q31_t * pCoeffs,
+        q31_t * pState,
+        q31_t mu,
+        uint32_t blockSize,
+        uint8_t postShift);
+
+
+  /**
+   * @brief Instance structure for the Q15 normalized LMS filter.
+   */
+  typedef struct
+  {
+          uint16_t numTaps;     /**< Number of coefficients in the filter. */
+          q15_t *pState;        /**< points to the state variable array. The array is of length numTaps+blockSize-1. */
+          q15_t *pCoeffs;       /**< points to the coefficient array. The array is of length numTaps. */
+          q15_t mu;             /**< step size that controls filter coefficient updates. */
+          uint8_t postShift;    /**< bit shift applied to coefficients. */
+    const q15_t *recipTable;    /**< Points to the reciprocal initial value table. */
+          q15_t energy;         /**< saves previous frame energy. */
+          q15_t x0;             /**< saves previous input sample. */
+  } arm_lms_norm_instance_q15;
+
+
+  /**
+   * @brief Processing function for Q15 normalized LMS filter.
+   * @param[in]  S          points to an instance of the Q15 normalized LMS filter structure.
+   * @param[in]  pSrc       points to the block of input data.
+   * @param[in]  pRef       points to the block of reference data.
+   * @param[out] pOut       points to the block of output data.
+   * @param[out] pErr       points to the block of error data.
+   * @param[in]  blockSize  number of samples to process.
+   */
+  void arm_lms_norm_q15(
+        arm_lms_norm_instance_q15 * S,
+  const q15_t * pSrc,
+        q15_t * pRef,
+        q15_t * pOut,
+        q15_t * pErr,
+        uint32_t blockSize);
+
+
+  /**
+   * @brief Initialization function for Q15 normalized LMS filter.
+   * @param[in] S          points to an instance of the Q15 normalized LMS filter structure.
+   * @param[in] numTaps    number of filter coefficients.
+   * @param[in] pCoeffs    points to coefficient buffer.
+   * @param[in] pState     points to state buffer.
+   * @param[in] mu         step size that controls filter coefficient updates.
+   * @param[in] blockSize  number of samples to process.
+   * @param[in] postShift  bit shift applied to coefficients.
+   */
+  void arm_lms_norm_init_q15(
+        arm_lms_norm_instance_q15 * S,
+        uint16_t numTaps,
+        q15_t * pCoeffs,
+        q15_t * pState,
+        q15_t mu,
+        uint32_t blockSize,
+        uint8_t postShift);
+
+
+  /**
+   * @brief Correlation of floating-point sequences.
+   * @param[in]  pSrcA    points to the first input sequence.
+   * @param[in]  srcALen  length of the first input sequence.
+   * @param[in]  pSrcB    points to the second input sequence.
+   * @param[in]  srcBLen  length of the second input sequence.
+   * @param[out] pDst     points to the block of output data  Length 2 * max(srcALen, srcBLen) - 1.
+   */
+  void arm_correlate_f32(
+  const float32_t * pSrcA,
+        uint32_t srcALen,
+  const float32_t * pSrcB,
+        uint32_t srcBLen,
+        float32_t * pDst);
+
+
+/**
+ @brief Correlation of Q15 sequences
+ @param[in]  pSrcA     points to the first input sequence
+ @param[in]  srcALen   length of the first input sequence
+ @param[in]  pSrcB     points to the second input sequence
+ @param[in]  srcBLen   length of the second input sequence
+ @param[out] pDst      points to the block of output data  Length 2 * max(srcALen, srcBLen) - 1.
+ @param[in]  pScratch  points to scratch buffer of size max(srcALen, srcBLen) + 2*min(srcALen, srcBLen) - 2.
+*/
+void arm_correlate_opt_q15(
+  const q15_t * pSrcA,
+        uint32_t srcALen,
+  const q15_t * pSrcB,
+        uint32_t srcBLen,
+        q15_t * pDst,
+        q15_t * pScratch);
+
+
+/**
+  @brief Correlation of Q15 sequences.
+  @param[in]  pSrcA    points to the first input sequence
+  @param[in]  srcALen  length of the first input sequence
+  @param[in]  pSrcB    points to the second input sequence
+  @param[in]  srcBLen  length of the second input sequence
+  @param[out] pDst     points to the block of output data  Length 2 * max(srcALen, srcBLen) - 1.
+ */
+  void arm_correlate_q15(
+  const q15_t * pSrcA,
+        uint32_t srcALen,
+  const q15_t * pSrcB,
+        uint32_t srcBLen,
+        q15_t * pDst);
+
+
+/**
+  @brief         Correlation of Q15 sequences (fast version).
+  @param[in]     pSrcA      points to the first input sequence
+  @param[in]     srcALen    length of the first input sequence
+  @param[in]     pSrcB      points to the second input sequence
+  @param[in]     srcBLen    length of the second input sequence
+  @param[out]    pDst       points to the location where the output result is written.  Length 2 * max(srcALen, srcBLen) - 1.
+  @return        none
+ */
+void arm_correlate_fast_q15(
+  const q15_t * pSrcA,
+        uint32_t srcALen,
+  const q15_t * pSrcB,
+        uint32_t srcBLen,
+        q15_t * pDst);
+
+
+/**
+  @brief Correlation of Q15 sequences (fast version).
+  @param[in]  pSrcA     points to the first input sequence.
+  @param[in]  srcALen   length of the first input sequence.
+  @param[in]  pSrcB     points to the second input sequence.
+  @param[in]  srcBLen   length of the second input sequence.
+  @param[out] pDst      points to the block of output data  Length 2 * max(srcALen, srcBLen) - 1.
+  @param[in]  pScratch  points to scratch buffer of size max(srcALen, srcBLen) + 2*min(srcALen, srcBLen) - 2.
+ */
+void arm_correlate_fast_opt_q15(
+  const q15_t * pSrcA,
+        uint32_t srcALen,
+  const q15_t * pSrcB,
+        uint32_t srcBLen,
+        q15_t * pDst,
+        q15_t * pScratch);
+
+
+  /**
+   * @brief Correlation of Q31 sequences.
+   * @param[in]  pSrcA    points to the first input sequence.
+   * @param[in]  srcALen  length of the first input sequence.
+   * @param[in]  pSrcB    points to the second input sequence.
+   * @param[in]  srcBLen  length of the second input sequence.
+   * @param[out] pDst     points to the block of output data  Length 2 * max(srcALen, srcBLen) - 1.
+   */
+  void arm_correlate_q31(
+  const q31_t * pSrcA,
+        uint32_t srcALen,
+  const q31_t * pSrcB,
+        uint32_t srcBLen,
+        q31_t * pDst);
+
+
+/**
+  @brief Correlation of Q31 sequences (fast version).
+  @param[in]  pSrcA    points to the first input sequence
+  @param[in]  srcALen  length of the first input sequence
+  @param[in]  pSrcB    points to the second input sequence
+  @param[in]  srcBLen  length of the second input sequence
+  @param[out] pDst     points to the block of output data  Length 2 * max(srcALen, srcBLen) - 1.
+ */
+void arm_correlate_fast_q31(
+  const q31_t * pSrcA,
+        uint32_t srcALen,
+  const q31_t * pSrcB,
+        uint32_t srcBLen,
+        q31_t * pDst);
+
+
+ /**
+   * @brief Correlation of Q7 sequences.
+   * @param[in]  pSrcA      points to the first input sequence.
+   * @param[in]  srcALen    length of the first input sequence.
+   * @param[in]  pSrcB      points to the second input sequence.
+   * @param[in]  srcBLen    length of the second input sequence.
+   * @param[out] pDst       points to the block of output data  Length 2 * max(srcALen, srcBLen) - 1.
+   * @param[in]  pScratch1  points to scratch buffer(of type q15_t) of size max(srcALen, srcBLen) + 2*min(srcALen, srcBLen) - 2.
+   * @param[in]  pScratch2  points to scratch buffer (of type q15_t) of size min(srcALen, srcBLen).
+   */
+  void arm_correlate_opt_q7(
+  const q7_t * pSrcA,
+        uint32_t srcALen,
+  const q7_t * pSrcB,
+        uint32_t srcBLen,
+        q7_t * pDst,
+        q15_t * pScratch1,
+        q15_t * pScratch2);
+
+
+  /**
+   * @brief Correlation of Q7 sequences.
+   * @param[in]  pSrcA    points to the first input sequence.
+   * @param[in]  srcALen  length of the first input sequence.
+   * @param[in]  pSrcB    points to the second input sequence.
+   * @param[in]  srcBLen  length of the second input sequence.
+   * @param[out] pDst     points to the block of output data  Length 2 * max(srcALen, srcBLen) - 1.
+   */
+  void arm_correlate_q7(
+  const q7_t * pSrcA,
+        uint32_t srcALen,
+  const q7_t * pSrcB,
+        uint32_t srcBLen,
+        q7_t * pDst);
+
+
+  /**
+   * @brief Instance structure for the floating-point sparse FIR filter.
+   */
+  typedef struct
+  {
+          uint16_t numTaps;             /**< number of coefficients in the filter. */
+          uint16_t stateIndex;          /**< state buffer index.  Points to the oldest sample in the state buffer. */
+          float32_t *pState;            /**< points to the state buffer array. The array is of length maxDelay+blockSize-1. */
+    const float32_t *pCoeffs;           /**< points to the coefficient array. The array is of length numTaps.*/
+          uint16_t maxDelay;            /**< maximum offset specified by the pTapDelay array. */
+          int32_t *pTapDelay;           /**< points to the array of delay values.  The array is of length numTaps. */
+  } arm_fir_sparse_instance_f32;
+
+  /**
+   * @brief Instance structure for the Q31 sparse FIR filter.
+   */
+  typedef struct
+  {
+          uint16_t numTaps;             /**< number of coefficients in the filter. */
+          uint16_t stateIndex;          /**< state buffer index.  Points to the oldest sample in the state buffer. */
+          q31_t *pState;                /**< points to the state buffer array. The array is of length maxDelay+blockSize-1. */
+    const q31_t *pCoeffs;               /**< points to the coefficient array. The array is of length numTaps.*/
+          uint16_t maxDelay;            /**< maximum offset specified by the pTapDelay array. */
+          int32_t *pTapDelay;           /**< points to the array of delay values.  The array is of length numTaps. */
+  } arm_fir_sparse_instance_q31;
+
+  /**
+   * @brief Instance structure for the Q15 sparse FIR filter.
+   */
+  typedef struct
+  {
+          uint16_t numTaps;             /**< number of coefficients in the filter. */
+          uint16_t stateIndex;          /**< state buffer index.  Points to the oldest sample in the state buffer. */
+          q15_t *pState;                /**< points to the state buffer array. The array is of length maxDelay+blockSize-1. */
+    const q15_t *pCoeffs;               /**< points to the coefficient array. The array is of length numTaps.*/
+          uint16_t maxDelay;            /**< maximum offset specified by the pTapDelay array. */
+          int32_t *pTapDelay;           /**< points to the array of delay values.  The array is of length numTaps. */
+  } arm_fir_sparse_instance_q15;
+
+  /**
+   * @brief Instance structure for the Q7 sparse FIR filter.
+   */
+  typedef struct
+  {
+          uint16_t numTaps;             /**< number of coefficients in the filter. */
+          uint16_t stateIndex;          /**< state buffer index.  Points to the oldest sample in the state buffer. */
+          q7_t *pState;                 /**< points to the state buffer array. The array is of length maxDelay+blockSize-1. */
+    const q7_t *pCoeffs;                /**< points to the coefficient array. The array is of length numTaps.*/
+          uint16_t maxDelay;            /**< maximum offset specified by the pTapDelay array. */
+          int32_t *pTapDelay;           /**< points to the array of delay values.  The array is of length numTaps. */
+  } arm_fir_sparse_instance_q7;
+
+
+  /**
+   * @brief Processing function for the floating-point sparse FIR filter.
+   * @param[in]  S           points to an instance of the floating-point sparse FIR structure.
+   * @param[in]  pSrc        points to the block of input data.
+   * @param[out] pDst        points to the block of output data
+   * @param[in]  pScratchIn  points to a temporary buffer of size blockSize.
+   * @param[in]  blockSize   number of input samples to process per call.
+   */
+  void arm_fir_sparse_f32(
+        arm_fir_sparse_instance_f32 * S,
+  const float32_t * pSrc,
+        float32_t * pDst,
+        float32_t * pScratchIn,
+        uint32_t blockSize);
+
+
+  /**
+   * @brief  Initialization function for the floating-point sparse FIR filter.
+   * @param[in,out] S          points to an instance of the floating-point sparse FIR structure.
+   * @param[in]     numTaps    number of nonzero coefficients in the filter.
+   * @param[in]     pCoeffs    points to the array of filter coefficients.
+   * @param[in]     pState     points to the state buffer.
+   * @param[in]     pTapDelay  points to the array of offset times.
+   * @param[in]     maxDelay   maximum offset time supported.
+   * @param[in]     blockSize  number of samples that will be processed per block.
+   */
+  void arm_fir_sparse_init_f32(
+        arm_fir_sparse_instance_f32 * S,
+        uint16_t numTaps,
+  const float32_t * pCoeffs,
+        float32_t * pState,
+        int32_t * pTapDelay,
+        uint16_t maxDelay,
+        uint32_t blockSize);
+
+
+  /**
+   * @brief Processing function for the Q31 sparse FIR filter.
+   * @param[in]  S           points to an instance of the Q31 sparse FIR structure.
+   * @param[in]  pSrc        points to the block of input data.
+   * @param[out] pDst        points to the block of output data
+   * @param[in]  pScratchIn  points to a temporary buffer of size blockSize.
+   * @param[in]  blockSize   number of input samples to process per call.
+   */
+  void arm_fir_sparse_q31(
+        arm_fir_sparse_instance_q31 * S,
+  const q31_t * pSrc,
+        q31_t * pDst,
+        q31_t * pScratchIn,
+        uint32_t blockSize);
+
+
+  /**
+   * @brief  Initialization function for the Q31 sparse FIR filter.
+   * @param[in,out] S          points to an instance of the Q31 sparse FIR structure.
+   * @param[in]     numTaps    number of nonzero coefficients in the filter.
+   * @param[in]     pCoeffs    points to the array of filter coefficients.
+   * @param[in]     pState     points to the state buffer.
+   * @param[in]     pTapDelay  points to the array of offset times.
+   * @param[in]     maxDelay   maximum offset time supported.
+   * @param[in]     blockSize  number of samples that will be processed per block.
+   */
+  void arm_fir_sparse_init_q31(
+        arm_fir_sparse_instance_q31 * S,
+        uint16_t numTaps,
+  const q31_t * pCoeffs,
+        q31_t * pState,
+        int32_t * pTapDelay,
+        uint16_t maxDelay,
+        uint32_t blockSize);
+
+
+  /**
+   * @brief Processing function for the Q15 sparse FIR filter.
+   * @param[in]  S            points to an instance of the Q15 sparse FIR structure.
+   * @param[in]  pSrc         points to the block of input data.
+   * @param[out] pDst         points to the block of output data
+   * @param[in]  pScratchIn   points to a temporary buffer of size blockSize.
+   * @param[in]  pScratchOut  points to a temporary buffer of size blockSize.
+   * @param[in]  blockSize    number of input samples to process per call.
+   */
+  void arm_fir_sparse_q15(
+        arm_fir_sparse_instance_q15 * S,
+  const q15_t * pSrc,
+        q15_t * pDst,
+        q15_t * pScratchIn,
+        q31_t * pScratchOut,
+        uint32_t blockSize);
+
+
+  /**
+   * @brief  Initialization function for the Q15 sparse FIR filter.
+   * @param[in,out] S          points to an instance of the Q15 sparse FIR structure.
+   * @param[in]     numTaps    number of nonzero coefficients in the filter.
+   * @param[in]     pCoeffs    points to the array of filter coefficients.
+   * @param[in]     pState     points to the state buffer.
+   * @param[in]     pTapDelay  points to the array of offset times.
+   * @param[in]     maxDelay   maximum offset time supported.
+   * @param[in]     blockSize  number of samples that will be processed per block.
+   */
+  void arm_fir_sparse_init_q15(
+        arm_fir_sparse_instance_q15 * S,
+        uint16_t numTaps,
+  const q15_t * pCoeffs,
+        q15_t * pState,
+        int32_t * pTapDelay,
+        uint16_t maxDelay,
+        uint32_t blockSize);
+
+
+  /**
+   * @brief Processing function for the Q7 sparse FIR filter.
+   * @param[in]  S            points to an instance of the Q7 sparse FIR structure.
+   * @param[in]  pSrc         points to the block of input data.
+   * @param[out] pDst         points to the block of output data
+   * @param[in]  pScratchIn   points to a temporary buffer of size blockSize.
+   * @param[in]  pScratchOut  points to a temporary buffer of size blockSize.
+   * @param[in]  blockSize    number of input samples to process per call.
+   */
+  void arm_fir_sparse_q7(
+        arm_fir_sparse_instance_q7 * S,
+  const q7_t * pSrc,
+        q7_t * pDst,
+        q7_t * pScratchIn,
+        q31_t * pScratchOut,
+        uint32_t blockSize);
+
+
+  /**
+   * @brief  Initialization function for the Q7 sparse FIR filter.
+   * @param[in,out] S          points to an instance of the Q7 sparse FIR structure.
+   * @param[in]     numTaps    number of nonzero coefficients in the filter.
+   * @param[in]     pCoeffs    points to the array of filter coefficients.
+   * @param[in]     pState     points to the state buffer.
+   * @param[in]     pTapDelay  points to the array of offset times.
+   * @param[in]     maxDelay   maximum offset time supported.
+   * @param[in]     blockSize  number of samples that will be processed per block.
+   */
+  void arm_fir_sparse_init_q7(
+        arm_fir_sparse_instance_q7 * S,
+        uint16_t numTaps,
+  const q7_t * pCoeffs,
+        q7_t * pState,
+        int32_t * pTapDelay,
+        uint16_t maxDelay,
+        uint32_t blockSize);
+
+
+  /**
+   * @brief  Floating-point sin_cos function.
+   * @param[in]  theta   input value in degrees
+   * @param[out] pSinVal  points to the processed sine output.
+   * @param[out] pCosVal  points to the processed cos output.
+   */
+  void arm_sin_cos_f32(
+        float32_t theta,
+        float32_t * pSinVal,
+        float32_t * pCosVal);
+
+
+  /**
+   * @brief  Q31 sin_cos function.
+   * @param[in]  theta    scaled input value in degrees
+   * @param[out] pSinVal  points to the processed sine output.
+   * @param[out] pCosVal  points to the processed cosine output.
+   */
+  void arm_sin_cos_q31(
+        q31_t theta,
+        q31_t * pSinVal,
+        q31_t * pCosVal);
+
+
+  /**
+   * @brief  Floating-point complex conjugate.
+   * @param[in]  pSrc        points to the input vector
+   * @param[out] pDst        points to the output vector
+   * @param[in]  numSamples  number of complex samples in each vector
+   */
+  void arm_cmplx_conj_f32(
+  const float32_t * pSrc,
+        float32_t * pDst,
+        uint32_t numSamples);
+
+  /**
+   * @brief  Q31 complex conjugate.
+   * @param[in]  pSrc        points to the input vector
+   * @param[out] pDst        points to the output vector
+   * @param[in]  numSamples  number of complex samples in each vector
+   */
+  void arm_cmplx_conj_q31(
+  const q31_t * pSrc,
+        q31_t * pDst,
+        uint32_t numSamples);
+
+
+  /**
+   * @brief  Q15 complex conjugate.
+   * @param[in]  pSrc        points to the input vector
+   * @param[out] pDst        points to the output vector
+   * @param[in]  numSamples  number of complex samples in each vector
+   */
+  void arm_cmplx_conj_q15(
+  const q15_t * pSrc,
+        q15_t * pDst,
+        uint32_t numSamples);
+
+
+  /**
+   * @brief  Floating-point complex magnitude squared
+   * @param[in]  pSrc        points to the complex input vector
+   * @param[out] pDst        points to the real output vector
+   * @param[in]  numSamples  number of complex samples in the input vector
+   */
+  void arm_cmplx_mag_squared_f32(
+  const float32_t * pSrc,
+        float32_t * pDst,
+        uint32_t numSamples);
+
+
+  /**
+   * @brief  Q31 complex magnitude squared
+   * @param[in]  pSrc        points to the complex input vector
+   * @param[out] pDst        points to the real output vector
+   * @param[in]  numSamples  number of complex samples in the input vector
+   */
+  void arm_cmplx_mag_squared_q31(
+  const q31_t * pSrc,
+        q31_t * pDst,
+        uint32_t numSamples);
+
+
+  /**
+   * @brief  Q15 complex magnitude squared
+   * @param[in]  pSrc        points to the complex input vector
+   * @param[out] pDst        points to the real output vector
+   * @param[in]  numSamples  number of complex samples in the input vector
+   */
+  void arm_cmplx_mag_squared_q15(
+  const q15_t * pSrc,
+        q15_t * pDst,
+        uint32_t numSamples);
+
+
+ /**
+   * @ingroup groupController
+   */
+
+  /**
+   * @defgroup PID PID Motor Control
+   *
+   * A Proportional Integral Derivative (PID) controller is a generic feedback control
+   * loop mechanism widely used in industrial control systems.
+   * A PID controller is the most commonly used type of feedback controller.
+   *
+   * This set of functions implements (PID) controllers
+   * for Q15, Q31, and floating-point data types.  The functions operate on a single sample
+   * of data and each call to the function returns a single processed value.
+   * <code>S</code> points to an instance of the PID control data structure.  <code>in</code>
+   * is the input sample value. The functions return the output value.
+   *
+   * \par Algorithm:
+   * <pre>
+   *    y[n] = y[n-1] + A0 * x[n] + A1 * x[n-1] + A2 * x[n-2]
+   *    A0 = Kp + Ki + Kd
+   *    A1 = (-Kp ) - (2 * Kd )
+   *    A2 = Kd
+   * </pre>
+   *
+   * \par
+   * where \c Kp is proportional constant, \c Ki is Integral constant and \c Kd is Derivative constant
+   *
+   * \par
+   * \image html PID.gif "Proportional Integral Derivative Controller"
+   *
+   * \par
+   * The PID controller calculates an "error" value as the difference between
+   * the measured output and the reference input.
+   * The controller attempts to minimize the error by adjusting the process control inputs.
+   * The proportional value determines the reaction to the current error,
+   * the integral value determines the reaction based on the sum of recent errors,
+   * and the derivative value determines the reaction based on the rate at which the error has been changing.
+   *
+   * \par Instance Structure
+   * The Gains A0, A1, A2 and state variables for a PID controller are stored together in an instance data structure.
+   * A separate instance structure must be defined for each PID Controller.
+   * There are separate instance structure declarations for each of the 3 supported data types.
+   *
+   * \par Reset Functions
+   * There is also an associated reset function for each data type which clears the state array.
+   *
+   * \par Initialization Functions
+   * There is also an associated initialization function for each data type.
+   * The initialization function performs the following operations:
+   * - Initializes the Gains A0, A1, A2 from Kp,Ki, Kd gains.
+   * - Zeros out the values in the state buffer.
+   *
+   * \par
+   * Instance structure cannot be placed into a const data section and it is recommended to use the initialization function.
+   *
+   * \par Fixed-Point Behavior
+   * Care must be taken when using the fixed-point versions of the PID Controller functions.
+   * In particular, the overflow and saturation behavior of the accumulator used in each function must be considered.
+   * Refer to the function specific documentation below for usage guidelines.
+   */
+
+  /**
+   * @addtogroup PID
+   * @{
+   */
+
+  /**
+   * @brief         Process function for the floating-point PID Control.
+   * @param[in,out] S   is an instance of the floating-point PID Control structure
+   * @param[in]     in  input sample to process
+   * @return        processed output sample.
+   */
+  __STATIC_FORCEINLINE float32_t arm_pid_f32(
+  arm_pid_instance_f32 * S,
+  float32_t in)
+  {
+    float32_t out;
+
+    /* y[n] = y[n-1] + A0 * x[n] + A1 * x[n-1] + A2 * x[n-2]  */
+    out = (S->A0 * in) +
+      (S->A1 * S->state[0]) + (S->A2 * S->state[1]) + (S->state[2]);
+
+    /* Update state */
+    S->state[1] = S->state[0];
+    S->state[0] = in;
+    S->state[2] = out;
+
+    /* return to application */
+    return (out);
+
+  }
+
+/**
+  @brief         Process function for the Q31 PID Control.
+  @param[in,out] S  points to an instance of the Q31 PID Control structure
+  @param[in]     in  input sample to process
+  @return        processed output sample.
+
+  \par Scaling and Overflow Behavior
+         The function is implemented using an internal 64-bit accumulator.
+         The accumulator has a 2.62 format and maintains full precision of the intermediate multiplication results but provides only a single guard bit.
+         Thus, if the accumulator result overflows it wraps around rather than clip.
+         In order to avoid overflows completely the input signal must be scaled down by 2 bits as there are four additions.
+         After all multiply-accumulates are performed, the 2.62 accumulator is truncated to 1.32 format and then saturated to 1.31 format.
+ */
+__STATIC_FORCEINLINE q31_t arm_pid_q31(
+  arm_pid_instance_q31 * S,
+  q31_t in)
+  {
+    q63_t acc;
+    q31_t out;
+
+    /* acc = A0 * x[n]  */
+    acc = (q63_t) S->A0 * in;
+
+    /* acc += A1 * x[n-1] */
+    acc += (q63_t) S->A1 * S->state[0];
+
+    /* acc += A2 * x[n-2]  */
+    acc += (q63_t) S->A2 * S->state[1];
+
+    /* convert output to 1.31 format to add y[n-1] */
+    out = (q31_t) (acc >> 31U);
+
+    /* out += y[n-1] */
+    out += S->state[2];
+
+    /* Update state */
+    S->state[1] = S->state[0];
+    S->state[0] = in;
+    S->state[2] = out;
+
+    /* return to application */
+    return (out);
+  }
+
+
+/**
+  @brief         Process function for the Q15 PID Control.
+  @param[in,out] S   points to an instance of the Q15 PID Control structure
+  @param[in]     in  input sample to process
+  @return        processed output sample.
+
+  \par Scaling and Overflow Behavior
+         The function is implemented using a 64-bit internal accumulator.
+         Both Gains and state variables are represented in 1.15 format and multiplications yield a 2.30 result.
+         The 2.30 intermediate results are accumulated in a 64-bit accumulator in 34.30 format.
+         There is no risk of internal overflow with this approach and the full precision of intermediate multiplications is preserved.
+         After all additions have been performed, the accumulator is truncated to 34.15 format by discarding low 15 bits.
+         Lastly, the accumulator is saturated to yield a result in 1.15 format.
+ */
+__STATIC_FORCEINLINE q15_t arm_pid_q15(
+  arm_pid_instance_q15 * S,
+  q15_t in)
+  {
+    q63_t acc;
+    q15_t out;
+
+#if defined (ARM_MATH_DSP)
+    /* Implementation of PID controller */
+
+    /* acc = A0 * x[n]  */
+    acc = (q31_t) __SMUAD((uint32_t)S->A0, (uint32_t)in);
+
+    /* acc += A1 * x[n-1] + A2 * x[n-2]  */
+    acc = (q63_t)__SMLALD((uint32_t)S->A1, (uint32_t)read_q15x2 (S->state), (uint64_t)acc);
+#else
+    /* acc = A0 * x[n]  */
+    acc = ((q31_t) S->A0) * in;
+
+    /* acc += A1 * x[n-1] + A2 * x[n-2]  */
+    acc += (q31_t) S->A1 * S->state[0];
+    acc += (q31_t) S->A2 * S->state[1];
+#endif
+
+    /* acc += y[n-1] */
+    acc += (q31_t) S->state[2] << 15;
+
+    /* saturate the output */
+    out = (q15_t) (__SSAT((q31_t)(acc >> 15), 16));
+
+    /* Update state */
+    S->state[1] = S->state[0];
+    S->state[0] = in;
+    S->state[2] = out;
+
+    /* return to application */
+    return (out);
+  }
+
+  /**
+   * @} end of PID group
+   */
+
+
+  /**
+   * @brief Floating-point matrix inverse.
+   * @param[in]  src   points to the instance of the input floating-point matrix structure.
+   * @param[out] dst   points to the instance of the output floating-point matrix structure.
+   * @return The function returns ARM_MATH_SIZE_MISMATCH, if the dimensions do not match.
+   * If the input matrix is singular (does not have an inverse), then the algorithm terminates and returns error status ARM_MATH_SINGULAR.
+   */
+  arm_status arm_mat_inverse_f32(
+  const arm_matrix_instance_f32 * src,
+  arm_matrix_instance_f32 * dst);
+
+
+  /**
+   * @brief Floating-point matrix inverse.
+   * @param[in]  src   points to the instance of the input floating-point matrix structure.
+   * @param[out] dst   points to the instance of the output floating-point matrix structure.
+   * @return The function returns ARM_MATH_SIZE_MISMATCH, if the dimensions do not match.
+   * If the input matrix is singular (does not have an inverse), then the algorithm terminates and returns error status ARM_MATH_SINGULAR.
+   */
+  arm_status arm_mat_inverse_f64(
+  const arm_matrix_instance_f64 * src,
+  arm_matrix_instance_f64 * dst);
+
+
+
+  /**
+   * @ingroup groupController
+   */
+
+  /**
+   * @defgroup clarke Vector Clarke Transform
+   * Forward Clarke transform converts the instantaneous stator phases into a two-coordinate time invariant vector.
+   * Generally the Clarke transform uses three-phase currents <code>Ia, Ib and Ic</code> to calculate currents
+   * in the two-phase orthogonal stator axis <code>Ialpha</code> and <code>Ibeta</code>.
+   * When <code>Ialpha</code> is superposed with <code>Ia</code> as shown in the figure below
+   * \image html clarke.gif Stator current space vector and its components in (a,b).
+   * and <code>Ia + Ib + Ic = 0</code>, in this condition <code>Ialpha</code> and <code>Ibeta</code>
+   * can be calculated using only <code>Ia</code> and <code>Ib</code>.
+   *
+   * The function operates on a single sample of data and each call to the function returns the processed output.
+   * The library provides separate functions for Q31 and floating-point data types.
+   * \par Algorithm
+   * \image html clarkeFormula.gif
+   * where <code>Ia</code> and <code>Ib</code> are the instantaneous stator phases and
+   * <code>pIalpha</code> and <code>pIbeta</code> are the two coordinates of time invariant vector.
+   * \par Fixed-Point Behavior
+   * Care must be taken when using the Q31 version of the Clarke transform.
+   * In particular, the overflow and saturation behavior of the accumulator used must be considered.
+   * Refer to the function specific documentation below for usage guidelines.
+   */
+
+  /**
+   * @addtogroup clarke
+   * @{
+   */
+
+  /**
+   *
+   * @brief  Floating-point Clarke transform
+   * @param[in]  Ia       input three-phase coordinate <code>a</code>
+   * @param[in]  Ib       input three-phase coordinate <code>b</code>
+   * @param[out] pIalpha  points to output two-phase orthogonal vector axis alpha
+   * @param[out] pIbeta   points to output two-phase orthogonal vector axis beta
+   * @return        none
+   */
+  __STATIC_FORCEINLINE void arm_clarke_f32(
+  float32_t Ia,
+  float32_t Ib,
+  float32_t * pIalpha,
+  float32_t * pIbeta)
+  {
+    /* Calculate pIalpha using the equation, pIalpha = Ia */
+    *pIalpha = Ia;
+
+    /* Calculate pIbeta using the equation, pIbeta = (1/sqrt(3)) * Ia + (2/sqrt(3)) * Ib */
+    *pIbeta = ((float32_t) 0.57735026919 * Ia + (float32_t) 1.15470053838 * Ib);
+  }
+
+
+/**
+  @brief  Clarke transform for Q31 version
+  @param[in]  Ia       input three-phase coordinate <code>a</code>
+  @param[in]  Ib       input three-phase coordinate <code>b</code>
+  @param[out] pIalpha  points to output two-phase orthogonal vector axis alpha
+  @param[out] pIbeta   points to output two-phase orthogonal vector axis beta
+  @return     none
+
+  \par Scaling and Overflow Behavior
+         The function is implemented using an internal 32-bit accumulator.
+         The accumulator maintains 1.31 format by truncating lower 31 bits of the intermediate multiplication in 2.62 format.
+         There is saturation on the addition, hence there is no risk of overflow.
+ */
+__STATIC_FORCEINLINE void arm_clarke_q31(
+  q31_t Ia,
+  q31_t Ib,
+  q31_t * pIalpha,
+  q31_t * pIbeta)
+  {
+    q31_t product1, product2;                    /* Temporary variables used to store intermediate results */
+
+    /* Calculating pIalpha from Ia by equation pIalpha = Ia */
+    *pIalpha = Ia;
+
+    /* Intermediate product is calculated by (1/(sqrt(3)) * Ia) */
+    product1 = (q31_t) (((q63_t) Ia * 0x24F34E8B) >> 30);
+
+    /* Intermediate product is calculated by (2/sqrt(3) * Ib) */
+    product2 = (q31_t) (((q63_t) Ib * 0x49E69D16) >> 30);
+
+    /* pIbeta is calculated by adding the intermediate products */
+    *pIbeta = __QADD(product1, product2);
+  }
+
+  /**
+   * @} end of clarke group
+   */
+
+
+  /**
+   * @ingroup groupController
+   */
+
+  /**
+   * @defgroup inv_clarke Vector Inverse Clarke Transform
+   * Inverse Clarke transform converts the two-coordinate time invariant vector into instantaneous stator phases.
+   *
+   * The function operates on a single sample of data and each call to the function returns the processed output.
+   * The library provides separate functions for Q31 and floating-point data types.
+   * \par Algorithm
+   * \image html clarkeInvFormula.gif
+   * where <code>pIa</code> and <code>pIb</code> are the instantaneous stator phases and
+   * <code>Ialpha</code> and <code>Ibeta</code> are the two coordinates of time invariant vector.
+   * \par Fixed-Point Behavior
+   * Care must be taken when using the Q31 version of the Clarke transform.
+   * In particular, the overflow and saturation behavior of the accumulator used must be considered.
+   * Refer to the function specific documentation below for usage guidelines.
+   */
+
+  /**
+   * @addtogroup inv_clarke
+   * @{
+   */
+
+   /**
+   * @brief  Floating-point Inverse Clarke transform
+   * @param[in]  Ialpha  input two-phase orthogonal vector axis alpha
+   * @param[in]  Ibeta   input two-phase orthogonal vector axis beta
+   * @param[out] pIa     points to output three-phase coordinate <code>a</code>
+   * @param[out] pIb     points to output three-phase coordinate <code>b</code>
+   * @return     none
+   */
+  __STATIC_FORCEINLINE void arm_inv_clarke_f32(
+  float32_t Ialpha,
+  float32_t Ibeta,
+  float32_t * pIa,
+  float32_t * pIb)
+  {
+    /* Calculating pIa from Ialpha by equation pIa = Ialpha */
+    *pIa = Ialpha;
+
+    /* Calculating pIb from Ialpha and Ibeta by equation pIb = -(1/2) * Ialpha + (sqrt(3)/2) * Ibeta */
+    *pIb = -0.5f * Ialpha + 0.8660254039f * Ibeta;
+  }
+
+
+/**
+  @brief  Inverse Clarke transform for Q31 version
+  @param[in]  Ialpha  input two-phase orthogonal vector axis alpha
+  @param[in]  Ibeta   input two-phase orthogonal vector axis beta
+  @param[out] pIa     points to output three-phase coordinate <code>a</code>
+  @param[out] pIb     points to output three-phase coordinate <code>b</code>
+  @return     none
+
+  \par Scaling and Overflow Behavior
+         The function is implemented using an internal 32-bit accumulator.
+         The accumulator maintains 1.31 format by truncating lower 31 bits of the intermediate multiplication in 2.62 format.
+         There is saturation on the subtraction, hence there is no risk of overflow.
+ */
+__STATIC_FORCEINLINE void arm_inv_clarke_q31(
+  q31_t Ialpha,
+  q31_t Ibeta,
+  q31_t * pIa,
+  q31_t * pIb)
+  {
+    q31_t product1, product2;                    /* Temporary variables used to store intermediate results */
+
+    /* Calculating pIa from Ialpha by equation pIa = Ialpha */
+    *pIa = Ialpha;
+
+    /* Intermediate product is calculated by (1/(2*sqrt(3)) * Ia) */
+    product1 = (q31_t) (((q63_t) (Ialpha) * (0x40000000)) >> 31);
+
+    /* Intermediate product is calculated by (1/sqrt(3) * pIb) */
+    product2 = (q31_t) (((q63_t) (Ibeta) * (0x6ED9EBA1)) >> 31);
+
+    /* pIb is calculated by subtracting the products */
+    *pIb = __QSUB(product2, product1);
+  }
+
+  /**
+   * @} end of inv_clarke group
+   */
+
+
+
+  /**
+   * @ingroup groupController
+   */
+
+  /**
+   * @defgroup park Vector Park Transform
+   *
+   * Forward Park transform converts the input two-coordinate vector to flux and torque components.
+   * The Park transform can be used to realize the transformation of the <code>Ialpha</code> and the <code>Ibeta</code> currents
+   * from the stationary to the moving reference frame and control the spatial relationship between
+   * the stator vector current and rotor flux vector.
+   * If we consider the d axis aligned with the rotor flux, the diagram below shows the
+   * current vector and the relationship from the two reference frames:
+   * \image html park.gif "Stator current space vector and its component in (a,b) and in the d,q rotating reference frame"
+   *
+   * The function operates on a single sample of data and each call to the function returns the processed output.
+   * The library provides separate functions for Q31 and floating-point data types.
+   * \par Algorithm
+   * \image html parkFormula.gif
+   * where <code>Ialpha</code> and <code>Ibeta</code> are the stator vector components,
+   * <code>pId</code> and <code>pIq</code> are rotor vector components and <code>cosVal</code> and <code>sinVal</code> are the
+   * cosine and sine values of theta (rotor flux position).
+   * \par Fixed-Point Behavior
+   * Care must be taken when using the Q31 version of the Park transform.
+   * In particular, the overflow and saturation behavior of the accumulator used must be considered.
+   * Refer to the function specific documentation below for usage guidelines.
+   */
+
+  /**
+   * @addtogroup park
+   * @{
+   */
+
+  /**
+   * @brief Floating-point Park transform
+   * @param[in]  Ialpha  input two-phase vector coordinate alpha
+   * @param[in]  Ibeta   input two-phase vector coordinate beta
+   * @param[out] pId     points to output   rotor reference frame d
+   * @param[out] pIq     points to output   rotor reference frame q
+   * @param[in]  sinVal  sine value of rotation angle theta
+   * @param[in]  cosVal  cosine value of rotation angle theta
+   * @return     none
+   *
+   * The function implements the forward Park transform.
+   *
+   */
+  __STATIC_FORCEINLINE void arm_park_f32(
+  float32_t Ialpha,
+  float32_t Ibeta,
+  float32_t * pId,
+  float32_t * pIq,
+  float32_t sinVal,
+  float32_t cosVal)
+  {
+    /* Calculate pId using the equation, pId = Ialpha * cosVal + Ibeta * sinVal */
+    *pId = Ialpha * cosVal + Ibeta * sinVal;
+
+    /* Calculate pIq using the equation, pIq = - Ialpha * sinVal + Ibeta * cosVal */
+    *pIq = -Ialpha * sinVal + Ibeta * cosVal;
+  }
+
+
+/**
+  @brief  Park transform for Q31 version
+  @param[in]  Ialpha  input two-phase vector coordinate alpha
+  @param[in]  Ibeta   input two-phase vector coordinate beta
+  @param[out] pId     points to output rotor reference frame d
+  @param[out] pIq     points to output rotor reference frame q
+  @param[in]  sinVal  sine value of rotation angle theta
+  @param[in]  cosVal  cosine value of rotation angle theta
+  @return     none
+
+  \par Scaling and Overflow Behavior
+         The function is implemented using an internal 32-bit accumulator.
+         The accumulator maintains 1.31 format by truncating lower 31 bits of the intermediate multiplication in 2.62 format.
+         There is saturation on the addition and subtraction, hence there is no risk of overflow.
+ */
+__STATIC_FORCEINLINE void arm_park_q31(
+  q31_t Ialpha,
+  q31_t Ibeta,
+  q31_t * pId,
+  q31_t * pIq,
+  q31_t sinVal,
+  q31_t cosVal)
+  {
+    q31_t product1, product2;                    /* Temporary variables used to store intermediate results */
+    q31_t product3, product4;                    /* Temporary variables used to store intermediate results */
+
+    /* Intermediate product is calculated by (Ialpha * cosVal) */
+    product1 = (q31_t) (((q63_t) (Ialpha) * (cosVal)) >> 31);
+
+    /* Intermediate product is calculated by (Ibeta * sinVal) */
+    product2 = (q31_t) (((q63_t) (Ibeta) * (sinVal)) >> 31);
+
+
+    /* Intermediate product is calculated by (Ialpha * sinVal) */
+    product3 = (q31_t) (((q63_t) (Ialpha) * (sinVal)) >> 31);
+
+    /* Intermediate product is calculated by (Ibeta * cosVal) */
+    product4 = (q31_t) (((q63_t) (Ibeta) * (cosVal)) >> 31);
+
+    /* Calculate pId by adding the two intermediate products 1 and 2 */
+    *pId = __QADD(product1, product2);
+
+    /* Calculate pIq by subtracting the two intermediate products 3 from 4 */
+    *pIq = __QSUB(product4, product3);
+  }
+
+  /**
+   * @} end of park group
+   */
+
+
+  /**
+   * @ingroup groupController
+   */
+
+  /**
+   * @defgroup inv_park Vector Inverse Park transform
+   * Inverse Park transform converts the input flux and torque components to two-coordinate vector.
+   *
+   * The function operates on a single sample of data and each call to the function returns the processed output.
+   * The library provides separate functions for Q31 and floating-point data types.
+   * \par Algorithm
+   * \image html parkInvFormula.gif
+   * where <code>pIalpha</code> and <code>pIbeta</code> are the stator vector components,
+   * <code>Id</code> and <code>Iq</code> are rotor vector components and <code>cosVal</code> and <code>sinVal</code> are the
+   * cosine and sine values of theta (rotor flux position).
+   * \par Fixed-Point Behavior
+   * Care must be taken when using the Q31 version of the Park transform.
+   * In particular, the overflow and saturation behavior of the accumulator used must be considered.
+   * Refer to the function specific documentation below for usage guidelines.
+   */
+
+  /**
+   * @addtogroup inv_park
+   * @{
+   */
+
+   /**
+   * @brief  Floating-point Inverse Park transform
+   * @param[in]  Id       input coordinate of rotor reference frame d
+   * @param[in]  Iq       input coordinate of rotor reference frame q
+   * @param[out] pIalpha  points to output two-phase orthogonal vector axis alpha
+   * @param[out] pIbeta   points to output two-phase orthogonal vector axis beta
+   * @param[in]  sinVal   sine value of rotation angle theta
+   * @param[in]  cosVal   cosine value of rotation angle theta
+   * @return     none
+   */
+  __STATIC_FORCEINLINE void arm_inv_park_f32(
+  float32_t Id,
+  float32_t Iq,
+  float32_t * pIalpha,
+  float32_t * pIbeta,
+  float32_t sinVal,
+  float32_t cosVal)
+  {
+    /* Calculate pIalpha using the equation, pIalpha = Id * cosVal - Iq * sinVal */
+    *pIalpha = Id * cosVal - Iq * sinVal;
+
+    /* Calculate pIbeta using the equation, pIbeta = Id * sinVal + Iq * cosVal */
+    *pIbeta = Id * sinVal + Iq * cosVal;
+  }
+
+
+/**
+  @brief  Inverse Park transform for   Q31 version
+  @param[in]  Id       input coordinate of rotor reference frame d
+  @param[in]  Iq       input coordinate of rotor reference frame q
+  @param[out] pIalpha  points to output two-phase orthogonal vector axis alpha
+  @param[out] pIbeta   points to output two-phase orthogonal vector axis beta
+  @param[in]  sinVal   sine value of rotation angle theta
+  @param[in]  cosVal   cosine value of rotation angle theta
+  @return     none
+
+  @par Scaling and Overflow Behavior
+         The function is implemented using an internal 32-bit accumulator.
+         The accumulator maintains 1.31 format by truncating lower 31 bits of the intermediate multiplication in 2.62 format.
+         There is saturation on the addition, hence there is no risk of overflow.
+ */
+__STATIC_FORCEINLINE void arm_inv_park_q31(
+  q31_t Id,
+  q31_t Iq,
+  q31_t * pIalpha,
+  q31_t * pIbeta,
+  q31_t sinVal,
+  q31_t cosVal)
+  {
+    q31_t product1, product2;                    /* Temporary variables used to store intermediate results */
+    q31_t product3, product4;                    /* Temporary variables used to store intermediate results */
+
+    /* Intermediate product is calculated by (Id * cosVal) */
+    product1 = (q31_t) (((q63_t) (Id) * (cosVal)) >> 31);
+
+    /* Intermediate product is calculated by (Iq * sinVal) */
+    product2 = (q31_t) (((q63_t) (Iq) * (sinVal)) >> 31);
+
+
+    /* Intermediate product is calculated by (Id * sinVal) */
+    product3 = (q31_t) (((q63_t) (Id) * (sinVal)) >> 31);
+
+    /* Intermediate product is calculated by (Iq * cosVal) */
+    product4 = (q31_t) (((q63_t) (Iq) * (cosVal)) >> 31);
+
+    /* Calculate pIalpha by using the two intermediate products 1 and 2 */
+    *pIalpha = __QSUB(product1, product2);
+
+    /* Calculate pIbeta by using the two intermediate products 3 and 4 */
+    *pIbeta = __QADD(product4, product3);
+  }
+
+  /**
+   * @} end of Inverse park group
+   */
+
+
+  /**
+   * @ingroup groupInterpolation
+   */
+
+  /**
+   * @defgroup LinearInterpolate Linear Interpolation
+   *
+   * Linear interpolation is a method of curve fitting using linear polynomials.
+   * Linear interpolation works by effectively drawing a straight line between two neighboring samples and returning the appropriate point along that line
+   *
+   * \par
+   * \image html LinearInterp.gif "Linear interpolation"
+   *
+   * \par
+   * A  Linear Interpolate function calculates an output value(y), for the input(x)
+   * using linear interpolation of the input values x0, x1( nearest input values) and the output values y0 and y1(nearest output values)
+   *
+   * \par Algorithm:
+   * <pre>
+   *       y = y0 + (x - x0) * ((y1 - y0)/(x1-x0))
+   *       where x0, x1 are nearest values of input x
+   *             y0, y1 are nearest values to output y
+   * </pre>
+   *
+   * \par
+   * This set of functions implements Linear interpolation process
+   * for Q7, Q15, Q31, and floating-point data types.  The functions operate on a single
+   * sample of data and each call to the function returns a single processed value.
+   * <code>S</code> points to an instance of the Linear Interpolate function data structure.
+   * <code>x</code> is the input sample value. The functions returns the output value.
+   *
+   * \par
+   * if x is outside of the table boundary, Linear interpolation returns first value of the table
+   * if x is below input range and returns last value of table if x is above range.
+   */
+
+  /**
+   * @addtogroup LinearInterpolate
+   * @{
+   */
+
+  /**
+   * @brief  Process function for the floating-point Linear Interpolation Function.
+   * @param[in,out] S  is an instance of the floating-point Linear Interpolation structure
+   * @param[in]     x  input sample to process
+   * @return y processed output sample.
+   *
+   */
+  __STATIC_FORCEINLINE float32_t arm_linear_interp_f32(
+  arm_linear_interp_instance_f32 * S,
+  float32_t x)
+  {
+    float32_t y;
+    float32_t x0, x1;                            /* Nearest input values */
+    float32_t y0, y1;                            /* Nearest output values */
+    float32_t xSpacing = S->xSpacing;            /* spacing between input values */
+    int32_t i;                                   /* Index variable */
+    float32_t *pYData = S->pYData;               /* pointer to output table */
+
+    /* Calculation of index */
+    i = (int32_t) ((x - S->x1) / xSpacing);
+
+    if (i < 0)
+    {
+      /* Iniatilize output for below specified range as least output value of table */
+      y = pYData[0];
+    }
+    else if ((uint32_t)i >= (S->nValues - 1))
+    {
+      /* Iniatilize output for above specified range as last output value of table */
+      y = pYData[S->nValues - 1];
+    }
+    else
+    {
+      /* Calculation of nearest input values */
+      x0 = S->x1 +  i      * xSpacing;
+      x1 = S->x1 + (i + 1) * xSpacing;
+
+      /* Read of nearest output values */
+      y0 = pYData[i];
+      y1 = pYData[i + 1];
+
+      /* Calculation of output */
+      y = y0 + (x - x0) * ((y1 - y0) / (x1 - x0));
+
+    }
+
+    /* returns output value */
+    return (y);
+  }
+
+
+   /**
+   *
+   * @brief  Process function for the Q31 Linear Interpolation Function.
+   * @param[in] pYData   pointer to Q31 Linear Interpolation table
+   * @param[in] x        input sample to process
+   * @param[in] nValues  number of table values
+   * @return y processed output sample.
+   *
+   * \par
+   * Input sample <code>x</code> is in 12.20 format which contains 12 bits for table index and 20 bits for fractional part.
+   * This function can support maximum of table size 2^12.
+   *
+   */
+  __STATIC_FORCEINLINE q31_t arm_linear_interp_q31(
+  q31_t * pYData,
+  q31_t x,
+  uint32_t nValues)
+  {
+    q31_t y;                                     /* output */
+    q31_t y0, y1;                                /* Nearest output values */
+    q31_t fract;                                 /* fractional part */
+    int32_t index;                               /* Index to read nearest output values */
+
+    /* Input is in 12.20 format */
+    /* 12 bits for the table index */
+    /* Index value calculation */
+    index = ((x & (q31_t)0xFFF00000) >> 20);
+
+    if (index >= (int32_t)(nValues - 1))
+    {
+      return (pYData[nValues - 1]);
+    }
+    else if (index < 0)
+    {
+      return (pYData[0]);
+    }
+    else
+    {
+      /* 20 bits for the fractional part */
+      /* shift left by 11 to keep fract in 1.31 format */
+      fract = (x & 0x000FFFFF) << 11;
+
+      /* Read two nearest output values from the index in 1.31(q31) format */
+      y0 = pYData[index];
+      y1 = pYData[index + 1];
+
+      /* Calculation of y0 * (1-fract) and y is in 2.30 format */
+      y = ((q31_t) ((q63_t) y0 * (0x7FFFFFFF - fract) >> 32));
+
+      /* Calculation of y0 * (1-fract) + y1 *fract and y is in 2.30 format */
+      y += ((q31_t) (((q63_t) y1 * fract) >> 32));
+
+      /* Convert y to 1.31 format */
+      return (y << 1U);
+    }
+  }
+
+
+  /**
+   *
+   * @brief  Process function for the Q15 Linear Interpolation Function.
+   * @param[in] pYData   pointer to Q15 Linear Interpolation table
+   * @param[in] x        input sample to process
+   * @param[in] nValues  number of table values
+   * @return y processed output sample.
+   *
+   * \par
+   * Input sample <code>x</code> is in 12.20 format which contains 12 bits for table index and 20 bits for fractional part.
+   * This function can support maximum of table size 2^12.
+   *
+   */
+  __STATIC_FORCEINLINE q15_t arm_linear_interp_q15(
+  q15_t * pYData,
+  q31_t x,
+  uint32_t nValues)
+  {
+    q63_t y;                                     /* output */
+    q15_t y0, y1;                                /* Nearest output values */
+    q31_t fract;                                 /* fractional part */
+    int32_t index;                               /* Index to read nearest output values */
+
+    /* Input is in 12.20 format */
+    /* 12 bits for the table index */
+    /* Index value calculation */
+    index = ((x & (int32_t)0xFFF00000) >> 20);
+
+    if (index >= (int32_t)(nValues - 1))
+    {
+      return (pYData[nValues - 1]);
+    }
+    else if (index < 0)
+    {
+      return (pYData[0]);
+    }
+    else
+    {
+      /* 20 bits for the fractional part */
+      /* fract is in 12.20 format */
+      fract = (x & 0x000FFFFF);
+
+      /* Read two nearest output values from the index */
+      y0 = pYData[index];
+      y1 = pYData[index + 1];
+
+      /* Calculation of y0 * (1-fract) and y is in 13.35 format */
+      y = ((q63_t) y0 * (0xFFFFF - fract));
+
+      /* Calculation of (y0 * (1-fract) + y1 * fract) and y is in 13.35 format */
+      y += ((q63_t) y1 * (fract));
+
+      /* convert y to 1.15 format */
+      return (q15_t) (y >> 20);
+    }
+  }
+
+
+  /**
+   *
+   * @brief  Process function for the Q7 Linear Interpolation Function.
+   * @param[in] pYData   pointer to Q7 Linear Interpolation table
+   * @param[in] x        input sample to process
+   * @param[in] nValues  number of table values
+   * @return y processed output sample.
+   *
+   * \par
+   * Input sample <code>x</code> is in 12.20 format which contains 12 bits for table index and 20 bits for fractional part.
+   * This function can support maximum of table size 2^12.
+   */
+  __STATIC_FORCEINLINE q7_t arm_linear_interp_q7(
+  q7_t * pYData,
+  q31_t x,
+  uint32_t nValues)
+  {
+    q31_t y;                                     /* output */
+    q7_t y0, y1;                                 /* Nearest output values */
+    q31_t fract;                                 /* fractional part */
+    uint32_t index;                              /* Index to read nearest output values */
+
+    /* Input is in 12.20 format */
+    /* 12 bits for the table index */
+    /* Index value calculation */
+    if (x < 0)
+    {
+      return (pYData[0]);
+    }
+    index = (x >> 20) & 0xfff;
+
+    if (index >= (nValues - 1))
+    {
+      return (pYData[nValues - 1]);
+    }
+    else
+    {
+      /* 20 bits for the fractional part */
+      /* fract is in 12.20 format */
+      fract = (x & 0x000FFFFF);
+
+      /* Read two nearest output values from the index and are in 1.7(q7) format */
+      y0 = pYData[index];
+      y1 = pYData[index + 1];
+
+      /* Calculation of y0 * (1-fract ) and y is in 13.27(q27) format */
+      y = ((y0 * (0xFFFFF - fract)));
+
+      /* Calculation of y1 * fract + y0 * (1-fract) and y is in 13.27(q27) format */
+      y += (y1 * fract);
+
+      /* convert y to 1.7(q7) format */
+      return (q7_t) (y >> 20);
+     }
+  }
+
+  /**
+   * @} end of LinearInterpolate group
+   */
+
+  /**
+   * @brief  Fast approximation to the trigonometric sine function for floating-point data.
+   * @param[in] x  input value in radians.
+   * @return  sin(x).
+   */
+  float32_t arm_sin_f32(
+  float32_t x);
+
+
+  /**
+   * @brief  Fast approximation to the trigonometric sine function for Q31 data.
+   * @param[in] x  Scaled input value in radians.
+   * @return  sin(x).
+   */
+  q31_t arm_sin_q31(
+  q31_t x);
+
+
+  /**
+   * @brief  Fast approximation to the trigonometric sine function for Q15 data.
+   * @param[in] x  Scaled input value in radians.
+   * @return  sin(x).
+   */
+  q15_t arm_sin_q15(
+  q15_t x);
+
+
+  /**
+   * @brief  Fast approximation to the trigonometric cosine function for floating-point data.
+   * @param[in] x  input value in radians.
+   * @return  cos(x).
+   */
+  float32_t arm_cos_f32(
+  float32_t x);
+
+
+  /**
+   * @brief Fast approximation to the trigonometric cosine function for Q31 data.
+   * @param[in] x  Scaled input value in radians.
+   * @return  cos(x).
+   */
+  q31_t arm_cos_q31(
+  q31_t x);
+
+
+  /**
+   * @brief  Fast approximation to the trigonometric cosine function for Q15 data.
+   * @param[in] x  Scaled input value in radians.
+   * @return  cos(x).
+   */
+  q15_t arm_cos_q15(
+  q15_t x);
+
+
+/**
+  @brief         Floating-point vector of log values.
+  @param[in]     pSrc       points to the input vector
+  @param[out]    pDst       points to the output vector
+  @param[in]     blockSize  number of samples in each vector
+  @return        none
+ */
+  void arm_vlog_f32(
+  const float32_t * pSrc,
+        float32_t * pDst,
+        uint32_t blockSize);
+
+/**
+  @brief         Floating-point vector of exp values.
+  @param[in]     pSrc       points to the input vector
+  @param[out]    pDst       points to the output vector
+  @param[in]     blockSize  number of samples in each vector
+  @return        none
+ */
+  void arm_vexp_f32(
+  const float32_t * pSrc,
+        float32_t * pDst,
+        uint32_t blockSize);
+
+  /**
+   * @ingroup groupFastMath
+   */
+
+
+  /**
+   * @defgroup SQRT Square Root
+   *
+   * Computes the square root of a number.
+   * There are separate functions for Q15, Q31, and floating-point data types.
+   * The square root function is computed using the Newton-Raphson algorithm.
+   * This is an iterative algorithm of the form:
+   * <pre>
+   *      x1 = x0 - f(x0)/f'(x0)
+   * </pre>
+   * where <code>x1</code> is the current estimate,
+   * <code>x0</code> is the previous estimate, and
+   * <code>f'(x0)</code> is the derivative of <code>f()</code> evaluated at <code>x0</code>.
+   * For the square root function, the algorithm reduces to:
+   * <pre>
+   *     x0 = in/2                         [initial guess]
+   *     x1 = 1/2 * ( x0 + in / x0)        [each iteration]
+   * </pre>
+   */
+
+
+  /**
+   * @addtogroup SQRT
+   * @{
+   */
+
+/**
+  @brief         Floating-point square root function.
+  @param[in]     in    input value
+  @param[out]    pOut  square root of input value
+  @return        execution status
+                   - \ref ARM_MATH_SUCCESS        : input value is positive
+                   - \ref ARM_MATH_ARGUMENT_ERROR : input value is negative; *pOut is set to 0
+ */
+__STATIC_FORCEINLINE arm_status arm_sqrt_f32(
+  float32_t in,
+  float32_t * pOut)
+  {
+    if (in >= 0.0f)
+    {
+#if defined ( __CC_ARM )
+  #if defined __TARGET_FPU_VFP
+      *pOut = __sqrtf(in);
+  #else
+      *pOut = sqrtf(in);
+  #endif
+
+#elif defined ( __ICCARM__ )
+  #if defined __ARMVFP__
+      __ASM("VSQRT.F32 %0,%1" : "=t"(*pOut) : "t"(in));
+  #else
+      *pOut = sqrtf(in);
+  #endif
+
+#else
+      *pOut = sqrtf(in);
+#endif
+
+      return (ARM_MATH_SUCCESS);
+    }
+    else
+    {
+      *pOut = 0.0f;
+      return (ARM_MATH_ARGUMENT_ERROR);
+    }
+  }
+
+
+/**
+  @brief         Q31 square root function.
+  @param[in]     in    input value.  The range of the input value is [0 +1) or 0x00000000 to 0x7FFFFFFF
+  @param[out]    pOut  points to square root of input value
+  @return        execution status
+                   - \ref ARM_MATH_SUCCESS        : input value is positive
+                   - \ref ARM_MATH_ARGUMENT_ERROR : input value is negative; *pOut is set to 0
+ */
+arm_status arm_sqrt_q31(
+  q31_t in,
+  q31_t * pOut);
+
+
+/**
+  @brief         Q15 square root function.
+  @param[in]     in    input value.  The range of the input value is [0 +1) or 0x0000 to 0x7FFF
+  @param[out]    pOut  points to square root of input value
+  @return        execution status
+                   - \ref ARM_MATH_SUCCESS        : input value is positive
+                   - \ref ARM_MATH_ARGUMENT_ERROR : input value is negative; *pOut is set to 0
+ */
+arm_status arm_sqrt_q15(
+  q15_t in,
+  q15_t * pOut);
+
+  /**
+   * @brief  Vector Floating-point square root function.
+   * @param[in]  pIn   input vector.
+   * @param[out] pOut  vector of square roots of input elements.
+   * @param[in]  len   length of input vector.
+   * @return The function returns ARM_MATH_SUCCESS if input value is positive value or ARM_MATH_ARGUMENT_ERROR if
+   * <code>in</code> is negative value and returns zero output for negative values.
+   */
+  void arm_vsqrt_f32(
+  float32_t * pIn,
+  float32_t * pOut,
+  uint16_t len);
+
+  void arm_vsqrt_q31(
+  q31_t * pIn,
+  q31_t * pOut,
+  uint16_t len);
+
+  void arm_vsqrt_q15(
+  q15_t * pIn,
+  q15_t * pOut,
+  uint16_t len);
+
+  /**
+   * @} end of SQRT group
+   */
+
+
+  /**
+   * @brief floating-point Circular write function.
+   */
+  __STATIC_FORCEINLINE void arm_circularWrite_f32(
+  int32_t * circBuffer,
+  int32_t L,
+  uint16_t * writeOffset,
+  int32_t bufferInc,
+  const int32_t * src,
+  int32_t srcInc,
+  uint32_t blockSize)
+  {
+    uint32_t i = 0U;
+    int32_t wOffset;
+
+    /* Copy the value of Index pointer that points
+     * to the current location where the input samples to be copied */
+    wOffset = *writeOffset;
+
+    /* Loop over the blockSize */
+    i = blockSize;
+
+    while (i > 0U)
+    {
+      /* copy the input sample to the circular buffer */
+      circBuffer[wOffset] = *src;
+
+      /* Update the input pointer */
+      src += srcInc;
+
+      /* Circularly update wOffset.  Watch out for positive and negative value */
+      wOffset += bufferInc;
+      if (wOffset >= L)
+        wOffset -= L;
+
+      /* Decrement the loop counter */
+      i--;
+    }
+
+    /* Update the index pointer */
+    *writeOffset = (uint16_t)wOffset;
+  }
+
+
+
+  /**
+   * @brief floating-point Circular Read function.
+   */
+  __STATIC_FORCEINLINE void arm_circularRead_f32(
+  int32_t * circBuffer,
+  int32_t L,
+  int32_t * readOffset,
+  int32_t bufferInc,
+  int32_t * dst,
+  int32_t * dst_base,
+  int32_t dst_length,
+  int32_t dstInc,
+  uint32_t blockSize)
+  {
+    uint32_t i = 0U;
+    int32_t rOffset;
+    int32_t* dst_end;
+
+    /* Copy the value of Index pointer that points
+     * to the current location from where the input samples to be read */
+    rOffset = *readOffset;
+    dst_end = dst_base + dst_length;
+
+    /* Loop over the blockSize */
+    i = blockSize;
+
+    while (i > 0U)
+    {
+      /* copy the sample from the circular buffer to the destination buffer */
+      *dst = circBuffer[rOffset];
+
+      /* Update the input pointer */
+      dst += dstInc;
+
+      if (dst == dst_end)
+      {
+        dst = dst_base;
+      }
+
+      /* Circularly update rOffset.  Watch out for positive and negative value  */
+      rOffset += bufferInc;
+
+      if (rOffset >= L)
+      {
+        rOffset -= L;
+      }
+
+      /* Decrement the loop counter */
+      i--;
+    }
+
+    /* Update the index pointer */
+    *readOffset = rOffset;
+  }
+
+
+  /**
+   * @brief Q15 Circular write function.
+   */
+  __STATIC_FORCEINLINE void arm_circularWrite_q15(
+  q15_t * circBuffer,
+  int32_t L,
+  uint16_t * writeOffset,
+  int32_t bufferInc,
+  const q15_t * src,
+  int32_t srcInc,
+  uint32_t blockSize)
+  {
+    uint32_t i = 0U;
+    int32_t wOffset;
+
+    /* Copy the value of Index pointer that points
+     * to the current location where the input samples to be copied */
+    wOffset = *writeOffset;
+
+    /* Loop over the blockSize */
+    i = blockSize;
+
+    while (i > 0U)
+    {
+      /* copy the input sample to the circular buffer */
+      circBuffer[wOffset] = *src;
+
+      /* Update the input pointer */
+      src += srcInc;
+
+      /* Circularly update wOffset.  Watch out for positive and negative value */
+      wOffset += bufferInc;
+      if (wOffset >= L)
+        wOffset -= L;
+
+      /* Decrement the loop counter */
+      i--;
+    }
+
+    /* Update the index pointer */
+    *writeOffset = (uint16_t)wOffset;
+  }
+
+
+  /**
+   * @brief Q15 Circular Read function.
+   */
+  __STATIC_FORCEINLINE void arm_circularRead_q15(
+  q15_t * circBuffer,
+  int32_t L,
+  int32_t * readOffset,
+  int32_t bufferInc,
+  q15_t * dst,
+  q15_t * dst_base,
+  int32_t dst_length,
+  int32_t dstInc,
+  uint32_t blockSize)
+  {
+    uint32_t i = 0;
+    int32_t rOffset;
+    q15_t* dst_end;
+
+    /* Copy the value of Index pointer that points
+     * to the current location from where the input samples to be read */
+    rOffset = *readOffset;
+
+    dst_end = dst_base + dst_length;
+
+    /* Loop over the blockSize */
+    i = blockSize;
+
+    while (i > 0U)
+    {
+      /* copy the sample from the circular buffer to the destination buffer */
+      *dst = circBuffer[rOffset];
+
+      /* Update the input pointer */
+      dst += dstInc;
+
+      if (dst == dst_end)
+      {
+        dst = dst_base;
+      }
+
+      /* Circularly update wOffset.  Watch out for positive and negative value */
+      rOffset += bufferInc;
+
+      if (rOffset >= L)
+      {
+        rOffset -= L;
+      }
+
+      /* Decrement the loop counter */
+      i--;
+    }
+
+    /* Update the index pointer */
+    *readOffset = rOffset;
+  }
+
+
+  /**
+   * @brief Q7 Circular write function.
+   */
+  __STATIC_FORCEINLINE void arm_circularWrite_q7(
+  q7_t * circBuffer,
+  int32_t L,
+  uint16_t * writeOffset,
+  int32_t bufferInc,
+  const q7_t * src,
+  int32_t srcInc,
+  uint32_t blockSize)
+  {
+    uint32_t i = 0U;
+    int32_t wOffset;
+
+    /* Copy the value of Index pointer that points
+     * to the current location where the input samples to be copied */
+    wOffset = *writeOffset;
+
+    /* Loop over the blockSize */
+    i = blockSize;
+
+    while (i > 0U)
+    {
+      /* copy the input sample to the circular buffer */
+      circBuffer[wOffset] = *src;
+
+      /* Update the input pointer */
+      src += srcInc;
+
+      /* Circularly update wOffset.  Watch out for positive and negative value */
+      wOffset += bufferInc;
+      if (wOffset >= L)
+        wOffset -= L;
+
+      /* Decrement the loop counter */
+      i--;
+    }
+
+    /* Update the index pointer */
+    *writeOffset = (uint16_t)wOffset;
+  }
+
+
+  /**
+   * @brief Q7 Circular Read function.
+   */
+  __STATIC_FORCEINLINE void arm_circularRead_q7(
+  q7_t * circBuffer,
+  int32_t L,
+  int32_t * readOffset,
+  int32_t bufferInc,
+  q7_t * dst,
+  q7_t * dst_base,
+  int32_t dst_length,
+  int32_t dstInc,
+  uint32_t blockSize)
+  {
+    uint32_t i = 0;
+    int32_t rOffset;
+    q7_t* dst_end;
+
+    /* Copy the value of Index pointer that points
+     * to the current location from where the input samples to be read */
+    rOffset = *readOffset;
+
+    dst_end = dst_base + dst_length;
+
+    /* Loop over the blockSize */
+    i = blockSize;
+
+    while (i > 0U)
+    {
+      /* copy the sample from the circular buffer to the destination buffer */
+      *dst = circBuffer[rOffset];
+
+      /* Update the input pointer */
+      dst += dstInc;
+
+      if (dst == dst_end)
+      {
+        dst = dst_base;
+      }
+
+      /* Circularly update rOffset.  Watch out for positive and negative value */
+      rOffset += bufferInc;
+
+      if (rOffset >= L)
+      {
+        rOffset -= L;
+      }
+
+      /* Decrement the loop counter */
+      i--;
+    }
+
+    /* Update the index pointer */
+    *readOffset = rOffset;
+  }
+
+
+  /**
+   * @brief  Sum of the squares of the elements of a Q31 vector.
+   * @param[in]  pSrc       is input pointer
+   * @param[in]  blockSize  is the number of samples to process
+   * @param[out] pResult    is output value.
+   */
+  void arm_power_q31(
+  const q31_t * pSrc,
+        uint32_t blockSize,
+        q63_t * pResult);
+
+
+  /**
+   * @brief  Sum of the squares of the elements of a floating-point vector.
+   * @param[in]  pSrc       is input pointer
+   * @param[in]  blockSize  is the number of samples to process
+   * @param[out] pResult    is output value.
+   */
+  void arm_power_f32(
+  const float32_t * pSrc,
+        uint32_t blockSize,
+        float32_t * pResult);
+
+
+  /**
+   * @brief  Sum of the squares of the elements of a Q15 vector.
+   * @param[in]  pSrc       is input pointer
+   * @param[in]  blockSize  is the number of samples to process
+   * @param[out] pResult    is output value.
+   */
+  void arm_power_q15(
+  const q15_t * pSrc,
+        uint32_t blockSize,
+        q63_t * pResult);
+
+
+  /**
+   * @brief  Sum of the squares of the elements of a Q7 vector.
+   * @param[in]  pSrc       is input pointer
+   * @param[in]  blockSize  is the number of samples to process
+   * @param[out] pResult    is output value.
+   */
+  void arm_power_q7(
+  const q7_t * pSrc,
+        uint32_t blockSize,
+        q31_t * pResult);
+
+
+  /**
+   * @brief  Mean value of a Q7 vector.
+   * @param[in]  pSrc       is input pointer
+   * @param[in]  blockSize  is the number of samples to process
+   * @param[out] pResult    is output value.
+   */
+  void arm_mean_q7(
+  const q7_t * pSrc,
+        uint32_t blockSize,
+        q7_t * pResult);
+
+
+  /**
+   * @brief  Mean value of a Q15 vector.
+   * @param[in]  pSrc       is input pointer
+   * @param[in]  blockSize  is the number of samples to process
+   * @param[out] pResult    is output value.
+   */
+  void arm_mean_q15(
+  const q15_t * pSrc,
+        uint32_t blockSize,
+        q15_t * pResult);
+
+
+  /**
+   * @brief  Mean value of a Q31 vector.
+   * @param[in]  pSrc       is input pointer
+   * @param[in]  blockSize  is the number of samples to process
+   * @param[out] pResult    is output value.
+   */
+  void arm_mean_q31(
+  const q31_t * pSrc,
+        uint32_t blockSize,
+        q31_t * pResult);
+
+
+  /**
+   * @brief  Mean value of a floating-point vector.
+   * @param[in]  pSrc       is input pointer
+   * @param[in]  blockSize  is the number of samples to process
+   * @param[out] pResult    is output value.
+   */
+  void arm_mean_f32(
+  const float32_t * pSrc,
+        uint32_t blockSize,
+        float32_t * pResult);
+
+
+  /**
+   * @brief  Variance of the elements of a floating-point vector.
+   * @param[in]  pSrc       is input pointer
+   * @param[in]  blockSize  is the number of samples to process
+   * @param[out] pResult    is output value.
+   */
+  void arm_var_f32(
+  const float32_t * pSrc,
+        uint32_t blockSize,
+        float32_t * pResult);
+
+
+  /**
+   * @brief  Variance of the elements of a Q31 vector.
+   * @param[in]  pSrc       is input pointer
+   * @param[in]  blockSize  is the number of samples to process
+   * @param[out] pResult    is output value.
+   */
+  void arm_var_q31(
+  const q31_t * pSrc,
+        uint32_t blockSize,
+        q31_t * pResult);
+
+
+  /**
+   * @brief  Variance of the elements of a Q15 vector.
+   * @param[in]  pSrc       is input pointer
+   * @param[in]  blockSize  is the number of samples to process
+   * @param[out] pResult    is output value.
+   */
+  void arm_var_q15(
+  const q15_t * pSrc,
+        uint32_t blockSize,
+        q15_t * pResult);
+
+
+  /**
+   * @brief  Root Mean Square of the elements of a floating-point vector.
+   * @param[in]  pSrc       is input pointer
+   * @param[in]  blockSize  is the number of samples to process
+   * @param[out] pResult    is output value.
+   */
+  void arm_rms_f32(
+  const float32_t * pSrc,
+        uint32_t blockSize,
+        float32_t * pResult);
+
+
+  /**
+   * @brief  Root Mean Square of the elements of a Q31 vector.
+   * @param[in]  pSrc       is input pointer
+   * @param[in]  blockSize  is the number of samples to process
+   * @param[out] pResult    is output value.
+   */
+  void arm_rms_q31(
+  const q31_t * pSrc,
+        uint32_t blockSize,
+        q31_t * pResult);
+
+
+  /**
+   * @brief  Root Mean Square of the elements of a Q15 vector.
+   * @param[in]  pSrc       is input pointer
+   * @param[in]  blockSize  is the number of samples to process
+   * @param[out] pResult    is output value.
+   */
+  void arm_rms_q15(
+  const q15_t * pSrc,
+        uint32_t blockSize,
+        q15_t * pResult);
+
+
+  /**
+   * @brief  Standard deviation of the elements of a floating-point vector.
+   * @param[in]  pSrc       is input pointer
+   * @param[in]  blockSize  is the number of samples to process
+   * @param[out] pResult    is output value.
+   */
+  void arm_std_f32(
+  const float32_t * pSrc,
+        uint32_t blockSize,
+        float32_t * pResult);
+
+
+  /**
+   * @brief  Standard deviation of the elements of a Q31 vector.
+   * @param[in]  pSrc       is input pointer
+   * @param[in]  blockSize  is the number of samples to process
+   * @param[out] pResult    is output value.
+   */
+  void arm_std_q31(
+  const q31_t * pSrc,
+        uint32_t blockSize,
+        q31_t * pResult);
+
+
+  /**
+   * @brief  Standard deviation of the elements of a Q15 vector.
+   * @param[in]  pSrc       is input pointer
+   * @param[in]  blockSize  is the number of samples to process
+   * @param[out] pResult    is output value.
+   */
+  void arm_std_q15(
+  const q15_t * pSrc,
+        uint32_t blockSize,
+        q15_t * pResult);
+
+
+  /**
+   * @brief  Floating-point complex magnitude
+   * @param[in]  pSrc        points to the complex input vector
+   * @param[out] pDst        points to the real output vector
+   * @param[in]  numSamples  number of complex samples in the input vector
+   */
+  void arm_cmplx_mag_f32(
+  const float32_t * pSrc,
+        float32_t * pDst,
+        uint32_t numSamples);
+
+
+  /**
+   * @brief  Q31 complex magnitude
+   * @param[in]  pSrc        points to the complex input vector
+   * @param[out] pDst        points to the real output vector
+   * @param[in]  numSamples  number of complex samples in the input vector
+   */
+  void arm_cmplx_mag_q31(
+  const q31_t * pSrc,
+        q31_t * pDst,
+        uint32_t numSamples);
+
+
+  /**
+   * @brief  Q15 complex magnitude
+   * @param[in]  pSrc        points to the complex input vector
+   * @param[out] pDst        points to the real output vector
+   * @param[in]  numSamples  number of complex samples in the input vector
+   */
+  void arm_cmplx_mag_q15(
+  const q15_t * pSrc,
+        q15_t * pDst,
+        uint32_t numSamples);
+
+
+  /**
+   * @brief  Q15 complex dot product
+   * @param[in]  pSrcA       points to the first input vector
+   * @param[in]  pSrcB       points to the second input vector
+   * @param[in]  numSamples  number of complex samples in each vector
+   * @param[out] realResult  real part of the result returned here
+   * @param[out] imagResult  imaginary part of the result returned here
+   */
+  void arm_cmplx_dot_prod_q15(
+  const q15_t * pSrcA,
+  const q15_t * pSrcB,
+        uint32_t numSamples,
+        q31_t * realResult,
+        q31_t * imagResult);
+
+
+  /**
+   * @brief  Q31 complex dot product
+   * @param[in]  pSrcA       points to the first input vector
+   * @param[in]  pSrcB       points to the second input vector
+   * @param[in]  numSamples  number of complex samples in each vector
+   * @param[out] realResult  real part of the result returned here
+   * @param[out] imagResult  imaginary part of the result returned here
+   */
+  void arm_cmplx_dot_prod_q31(
+  const q31_t * pSrcA,
+  const q31_t * pSrcB,
+        uint32_t numSamples,
+        q63_t * realResult,
+        q63_t * imagResult);
+
+
+  /**
+   * @brief  Floating-point complex dot product
+   * @param[in]  pSrcA       points to the first input vector
+   * @param[in]  pSrcB       points to the second input vector
+   * @param[in]  numSamples  number of complex samples in each vector
+   * @param[out] realResult  real part of the result returned here
+   * @param[out] imagResult  imaginary part of the result returned here
+   */
+  void arm_cmplx_dot_prod_f32(
+  const float32_t * pSrcA,
+  const float32_t * pSrcB,
+        uint32_t numSamples,
+        float32_t * realResult,
+        float32_t * imagResult);
+
+
+  /**
+   * @brief  Q15 complex-by-real multiplication
+   * @param[in]  pSrcCmplx   points to the complex input vector
+   * @param[in]  pSrcReal    points to the real input vector
+   * @param[out] pCmplxDst   points to the complex output vector
+   * @param[in]  numSamples  number of samples in each vector
+   */
+  void arm_cmplx_mult_real_q15(
+  const q15_t * pSrcCmplx,
+  const q15_t * pSrcReal,
+        q15_t * pCmplxDst,
+        uint32_t numSamples);
+
+
+  /**
+   * @brief  Q31 complex-by-real multiplication
+   * @param[in]  pSrcCmplx   points to the complex input vector
+   * @param[in]  pSrcReal    points to the real input vector
+   * @param[out] pCmplxDst   points to the complex output vector
+   * @param[in]  numSamples  number of samples in each vector
+   */
+  void arm_cmplx_mult_real_q31(
+  const q31_t * pSrcCmplx,
+  const q31_t * pSrcReal,
+        q31_t * pCmplxDst,
+        uint32_t numSamples);
+
+
+  /**
+   * @brief  Floating-point complex-by-real multiplication
+   * @param[in]  pSrcCmplx   points to the complex input vector
+   * @param[in]  pSrcReal    points to the real input vector
+   * @param[out] pCmplxDst   points to the complex output vector
+   * @param[in]  numSamples  number of samples in each vector
+   */
+  void arm_cmplx_mult_real_f32(
+  const float32_t * pSrcCmplx,
+  const float32_t * pSrcReal,
+        float32_t * pCmplxDst,
+        uint32_t numSamples);
+
+
+  /**
+   * @brief  Minimum value of a Q7 vector.
+   * @param[in]  pSrc       is input pointer
+   * @param[in]  blockSize  is the number of samples to process
+   * @param[out] result     is output pointer
+   * @param[in]  index      is the array index of the minimum value in the input buffer.
+   */
+  void arm_min_q7(
+  const q7_t * pSrc,
+        uint32_t blockSize,
+        q7_t * result,
+        uint32_t * index);
+
+
+  /**
+   * @brief  Minimum value of a Q15 vector.
+   * @param[in]  pSrc       is input pointer
+   * @param[in]  blockSize  is the number of samples to process
+   * @param[out] pResult    is output pointer
+   * @param[in]  pIndex     is the array index of the minimum value in the input buffer.
+   */
+  void arm_min_q15(
+  const q15_t * pSrc,
+        uint32_t blockSize,
+        q15_t * pResult,
+        uint32_t * pIndex);
+
+
+  /**
+   * @brief  Minimum value of a Q31 vector.
+   * @param[in]  pSrc       is input pointer
+   * @param[in]  blockSize  is the number of samples to process
+   * @param[out] pResult    is output pointer
+   * @param[out] pIndex     is the array index of the minimum value in the input buffer.
+   */
+  void arm_min_q31(
+  const q31_t * pSrc,
+        uint32_t blockSize,
+        q31_t * pResult,
+        uint32_t * pIndex);
+
+
+  /**
+   * @brief  Minimum value of a floating-point vector.
+   * @param[in]  pSrc       is input pointer
+   * @param[in]  blockSize  is the number of samples to process
+   * @param[out] pResult    is output pointer
+   * @param[out] pIndex     is the array index of the minimum value in the input buffer.
+   */
+  void arm_min_f32(
+  const float32_t * pSrc,
+        uint32_t blockSize,
+        float32_t * pResult,
+        uint32_t * pIndex);
+
+
+/**
+ * @brief Maximum value of a Q7 vector.
+ * @param[in]  pSrc       points to the input buffer
+ * @param[in]  blockSize  length of the input vector
+ * @param[out] pResult    maximum value returned here
+ * @param[out] pIndex     index of maximum value returned here
+ */
+  void arm_max_q7(
+  const q7_t * pSrc,
+        uint32_t blockSize,
+        q7_t * pResult,
+        uint32_t * pIndex);
+
+
+/**
+ * @brief Maximum value of a Q15 vector.
+ * @param[in]  pSrc       points to the input buffer
+ * @param[in]  blockSize  length of the input vector
+ * @param[out] pResult    maximum value returned here
+ * @param[out] pIndex     index of maximum value returned here
+ */
+  void arm_max_q15(
+  const q15_t * pSrc,
+        uint32_t blockSize,
+        q15_t * pResult,
+        uint32_t * pIndex);
+
+
+/**
+ * @brief Maximum value of a Q31 vector.
+ * @param[in]  pSrc       points to the input buffer
+ * @param[in]  blockSize  length of the input vector
+ * @param[out] pResult    maximum value returned here
+ * @param[out] pIndex     index of maximum value returned here
+ */
+  void arm_max_q31(
+  const q31_t * pSrc,
+        uint32_t blockSize,
+        q31_t * pResult,
+        uint32_t * pIndex);
+
+
+/**
+ * @brief Maximum value of a floating-point vector.
+ * @param[in]  pSrc       points to the input buffer
+ * @param[in]  blockSize  length of the input vector
+ * @param[out] pResult    maximum value returned here
+ * @param[out] pIndex     index of maximum value returned here
+ */
+  void arm_max_f32(
+  const float32_t * pSrc,
+        uint32_t blockSize,
+        float32_t * pResult,
+        uint32_t * pIndex);
+
+  /**
+    @brief         Maximum value of a floating-point vector.
+    @param[in]     pSrc       points to the input vector
+    @param[in]     blockSize  number of samples in input vector
+    @param[out]    pResult    maximum value returned here
+    @return        none
+   */
+  void arm_max_no_idx_f32(
+      const float32_t *pSrc,
+      uint32_t   blockSize,
+      float32_t *pResult);
+
+  /**
+   * @brief  Q15 complex-by-complex multiplication
+   * @param[in]  pSrcA       points to the first input vector
+   * @param[in]  pSrcB       points to the second input vector
+   * @param[out] pDst        points to the output vector
+   * @param[in]  numSamples  number of complex samples in each vector
+   */
+  void arm_cmplx_mult_cmplx_q15(
+  const q15_t * pSrcA,
+  const q15_t * pSrcB,
+        q15_t * pDst,
+        uint32_t numSamples);
+
+
+  /**
+   * @brief  Q31 complex-by-complex multiplication
+   * @param[in]  pSrcA       points to the first input vector
+   * @param[in]  pSrcB       points to the second input vector
+   * @param[out] pDst        points to the output vector
+   * @param[in]  numSamples  number of complex samples in each vector
+   */
+  void arm_cmplx_mult_cmplx_q31(
+  const q31_t * pSrcA,
+  const q31_t * pSrcB,
+        q31_t * pDst,
+        uint32_t numSamples);
+
+
+  /**
+   * @brief  Floating-point complex-by-complex multiplication
+   * @param[in]  pSrcA       points to the first input vector
+   * @param[in]  pSrcB       points to the second input vector
+   * @param[out] pDst        points to the output vector
+   * @param[in]  numSamples  number of complex samples in each vector
+   */
+  void arm_cmplx_mult_cmplx_f32(
+  const float32_t * pSrcA,
+  const float32_t * pSrcB,
+        float32_t * pDst,
+        uint32_t numSamples);
+
+
+  /**
+   * @brief Converts the elements of the floating-point vector to Q31 vector.
+   * @param[in]  pSrc       points to the floating-point input vector
+   * @param[out] pDst       points to the Q31 output vector
+   * @param[in]  blockSize  length of the input vector
+   */
+  void arm_float_to_q31(
+  const float32_t * pSrc,
+        q31_t * pDst,
+        uint32_t blockSize);
+
+
+  /**
+   * @brief Converts the elements of the floating-point vector to Q15 vector.
+   * @param[in]  pSrc       points to the floating-point input vector
+   * @param[out] pDst       points to the Q15 output vector
+   * @param[in]  blockSize  length of the input vector
+   */
+  void arm_float_to_q15(
+  const float32_t * pSrc,
+        q15_t * pDst,
+        uint32_t blockSize);
+
+
+  /**
+   * @brief Converts the elements of the floating-point vector to Q7 vector.
+   * @param[in]  pSrc       points to the floating-point input vector
+   * @param[out] pDst       points to the Q7 output vector
+   * @param[in]  blockSize  length of the input vector
+   */
+  void arm_float_to_q7(
+  const float32_t * pSrc,
+        q7_t * pDst,
+        uint32_t blockSize);
+
+
+  /**
+   * @brief  Converts the elements of the Q31 vector to floating-point vector.
+   * @param[in]  pSrc       is input pointer
+   * @param[out] pDst       is output pointer
+   * @param[in]  blockSize  is the number of samples to process
+   */
+  void arm_q31_to_float(
+  const q31_t * pSrc,
+        float32_t * pDst,
+        uint32_t blockSize);
+
+
+  /**
+   * @brief  Converts the elements of the Q31 vector to Q15 vector.
+   * @param[in]  pSrc       is input pointer
+   * @param[out] pDst       is output pointer
+   * @param[in]  blockSize  is the number of samples to process
+   */
+  void arm_q31_to_q15(
+  const q31_t * pSrc,
+        q15_t * pDst,
+        uint32_t blockSize);
+
+
+  /**
+   * @brief  Converts the elements of the Q31 vector to Q7 vector.
+   * @param[in]  pSrc       is input pointer
+   * @param[out] pDst       is output pointer
+   * @param[in]  blockSize  is the number of samples to process
+   */
+  void arm_q31_to_q7(
+  const q31_t * pSrc,
+        q7_t * pDst,
+        uint32_t blockSize);
+
+
+  /**
+   * @brief  Converts the elements of the Q15 vector to floating-point vector.
+   * @param[in]  pSrc       is input pointer
+   * @param[out] pDst       is output pointer
+   * @param[in]  blockSize  is the number of samples to process
+   */
+  void arm_q15_to_float(
+  const q15_t * pSrc,
+        float32_t * pDst,
+        uint32_t blockSize);
+
+
+  /**
+   * @brief  Converts the elements of the Q15 vector to Q31 vector.
+   * @param[in]  pSrc       is input pointer
+   * @param[out] pDst       is output pointer
+   * @param[in]  blockSize  is the number of samples to process
+   */
+  void arm_q15_to_q31(
+  const q15_t * pSrc,
+        q31_t * pDst,
+        uint32_t blockSize);
+
+
+  /**
+   * @brief  Converts the elements of the Q15 vector to Q7 vector.
+   * @param[in]  pSrc       is input pointer
+   * @param[out] pDst       is output pointer
+   * @param[in]  blockSize  is the number of samples to process
+   */
+  void arm_q15_to_q7(
+  const q15_t * pSrc,
+        q7_t * pDst,
+        uint32_t blockSize);
+
+
+  /**
+   * @brief  Converts the elements of the Q7 vector to floating-point vector.
+   * @param[in]  pSrc       is input pointer
+   * @param[out] pDst       is output pointer
+   * @param[in]  blockSize  is the number of samples to process
+   */
+  void arm_q7_to_float(
+  const q7_t * pSrc,
+        float32_t * pDst,
+        uint32_t blockSize);
+
+
+  /**
+   * @brief  Converts the elements of the Q7 vector to Q31 vector.
+   * @param[in]  pSrc       input pointer
+   * @param[out] pDst       output pointer
+   * @param[in]  blockSize  number of samples to process
+   */
+  void arm_q7_to_q31(
+  const q7_t * pSrc,
+        q31_t * pDst,
+        uint32_t blockSize);
+
+
+  /**
+   * @brief  Converts the elements of the Q7 vector to Q15 vector.
+   * @param[in]  pSrc       input pointer
+   * @param[out] pDst       output pointer
+   * @param[in]  blockSize  number of samples to process
+   */
+  void arm_q7_to_q15(
+  const q7_t * pSrc,
+        q15_t * pDst,
+        uint32_t blockSize);
+
+/**
+ * @brief Struct for specifying SVM Kernel
+ */
+typedef enum
+{
+    ARM_ML_KERNEL_LINEAR = 0,
+             /**< Linear kernel */
+    ARM_ML_KERNEL_POLYNOMIAL = 1,
+             /**< Polynomial kernel */
+    ARM_ML_KERNEL_RBF = 2,
+             /**< Radial Basis Function kernel */
+    ARM_ML_KERNEL_SIGMOID = 3
+             /**< Sigmoid kernel */
+} arm_ml_kernel_type;
+
+
+/**
+ * @brief Instance structure for linear SVM prediction function.
+ */
+typedef struct
+{
+  uint32_t        nbOfSupportVectors;     /**< Number of support vectors */
+  uint32_t        vectorDimension;        /**< Dimension of vector space */
+  float32_t       intercept;              /**< Intercept */
+  const float32_t *dualCoefficients;      /**< Dual coefficients */
+  const float32_t *supportVectors;        /**< Support vectors */
+  const int32_t   *classes;               /**< The two SVM classes */
+} arm_svm_linear_instance_f32;
+
+
+/**
+ * @brief Instance structure for polynomial SVM prediction function.
+ */
+typedef struct
+{
+  uint32_t        nbOfSupportVectors;     /**< Number of support vectors */
+  uint32_t        vectorDimension;        /**< Dimension of vector space */
+  float32_t       intercept;              /**< Intercept */
+  const float32_t *dualCoefficients;      /**< Dual coefficients */
+  const float32_t *supportVectors;        /**< Support vectors */
+  const int32_t   *classes;               /**< The two SVM classes */
+  int32_t         degree;                 /**< Polynomial degree */
+  float32_t       coef0;                  /**< Polynomial constant */
+  float32_t       gamma;                  /**< Gamma factor */
+} arm_svm_polynomial_instance_f32;
+
+/**
+ * @brief Instance structure for rbf SVM prediction function.
+ */
+typedef struct
+{
+  uint32_t        nbOfSupportVectors;     /**< Number of support vectors */
+  uint32_t        vectorDimension;        /**< Dimension of vector space */
+  float32_t       intercept;              /**< Intercept */
+  const float32_t *dualCoefficients;      /**< Dual coefficients */
+  const float32_t *supportVectors;        /**< Support vectors */
+  const int32_t   *classes;               /**< The two SVM classes */
+  float32_t       gamma;                  /**< Gamma factor */
+} arm_svm_rbf_instance_f32;
+
+/**
+ * @brief Instance structure for sigmoid SVM prediction function.
+ */
+typedef struct
+{
+  uint32_t        nbOfSupportVectors;     /**< Number of support vectors */
+  uint32_t        vectorDimension;        /**< Dimension of vector space */
+  float32_t       intercept;              /**< Intercept */
+  const float32_t *dualCoefficients;      /**< Dual coefficients */
+  const float32_t *supportVectors;        /**< Support vectors */
+  const int32_t   *classes;               /**< The two SVM classes */
+  float32_t       coef0;                  /**< Independant constant */
+  float32_t       gamma;                  /**< Gamma factor */
+} arm_svm_sigmoid_instance_f32;
+
+/**
+ * @brief        SVM linear instance init function
+ * @param[in]    S                      Parameters for SVM functions
+ * @param[in]    nbOfSupportVectors     Number of support vectors
+ * @param[in]    vectorDimension        Dimension of vector space
+ * @param[in]    intercept              Intercept
+ * @param[in]    dualCoefficients       Array of dual coefficients
+ * @param[in]    supportVectors         Array of support vectors
+ * @param[in]    classes                Array of 2 classes ID
+ * @return none.
+ *
+ */
+
+
+void arm_svm_linear_init_f32(arm_svm_linear_instance_f32 *S, 
+  uint32_t nbOfSupportVectors,
+  uint32_t vectorDimension,
+  float32_t intercept,
+  const float32_t *dualCoefficients,
+  const float32_t *supportVectors,
+  const int32_t  *classes);
+
+/**
+ * @brief SVM linear prediction
+ * @param[in]    S          Pointer to an instance of the linear SVM structure.
+ * @param[in]    in         Pointer to input vector
+ * @param[out]   pResult    Decision value
+ * @return none.
+ *
+ */
+  
+void arm_svm_linear_predict_f32(const arm_svm_linear_instance_f32 *S, 
+   const float32_t * in, 
+   int32_t * pResult);
+
+
+/**
+ * @brief        SVM polynomial instance init function
+ * @param[in]    S                      points to an instance of the polynomial SVM structure.
+ * @param[in]    nbOfSupportVectors     Number of support vectors
+ * @param[in]    vectorDimension        Dimension of vector space
+ * @param[in]    intercept              Intercept
+ * @param[in]    dualCoefficients       Array of dual coefficients
+ * @param[in]    supportVectors         Array of support vectors
+ * @param[in]    classes                Array of 2 classes ID
+ * @param[in]    degree                 Polynomial degree
+ * @param[in]    coef0                  coeff0 (scikit-learn terminology)
+ * @param[in]    gamma                  gamma (scikit-learn terminology)
+ * @return none.
+ *
+ */
+
+
+void arm_svm_polynomial_init_f32(arm_svm_polynomial_instance_f32 *S, 
+  uint32_t nbOfSupportVectors,
+  uint32_t vectorDimension,
+  float32_t intercept,
+  const float32_t *dualCoefficients,
+  const float32_t *supportVectors,
+  const int32_t   *classes,
+  int32_t      degree,
+  float32_t coef0,
+  float32_t gamma
+  );
+
+/**
+ * @brief SVM polynomial prediction
+ * @param[in]    S          Pointer to an instance of the polynomial SVM structure.
+ * @param[in]    in         Pointer to input vector
+ * @param[out]   pResult    Decision value
+ * @return none.
+ *
+ */
+void arm_svm_polynomial_predict_f32(const arm_svm_polynomial_instance_f32 *S, 
+   const float32_t * in, 
+   int32_t * pResult);
+
+
+/**
+ * @brief        SVM radial basis function instance init function
+ * @param[in]    S                      points to an instance of the polynomial SVM structure.
+ * @param[in]    nbOfSupportVectors     Number of support vectors
+ * @param[in]    vectorDimension        Dimension of vector space
+ * @param[in]    intercept              Intercept
+ * @param[in]    dualCoefficients       Array of dual coefficients
+ * @param[in]    supportVectors         Array of support vectors
+ * @param[in]    classes                Array of 2 classes ID
+ * @param[in]    gamma                  gamma (scikit-learn terminology)
+ * @return none.
+ *
+ */
+
+void arm_svm_rbf_init_f32(arm_svm_rbf_instance_f32 *S, 
+  uint32_t nbOfSupportVectors,
+  uint32_t vectorDimension,
+  float32_t intercept,
+  const float32_t *dualCoefficients,
+  const float32_t *supportVectors,
+  const int32_t   *classes,
+  float32_t gamma
+  );
+
+/**
+ * @brief SVM rbf prediction
+ * @param[in]    S         Pointer to an instance of the rbf SVM structure.
+ * @param[in]    in        Pointer to input vector
+ * @param[out]   pResult   decision value
+ * @return none.
+ *
+ */
+void arm_svm_rbf_predict_f32(const arm_svm_rbf_instance_f32 *S, 
+   const float32_t * in, 
+   int32_t * pResult);
+
+/**
+ * @brief        SVM sigmoid instance init function
+ * @param[in]    S                      points to an instance of the rbf SVM structure.
+ * @param[in]    nbOfSupportVectors     Number of support vectors
+ * @param[in]    vectorDimension        Dimension of vector space
+ * @param[in]    intercept              Intercept
+ * @param[in]    dualCoefficients       Array of dual coefficients
+ * @param[in]    supportVectors         Array of support vectors
+ * @param[in]    classes                Array of 2 classes ID
+ * @param[in]    coef0                  coeff0 (scikit-learn terminology)
+ * @param[in]    gamma                  gamma (scikit-learn terminology)
+ * @return none.
+ *
+ */
+
+void arm_svm_sigmoid_init_f32(arm_svm_sigmoid_instance_f32 *S, 
+  uint32_t nbOfSupportVectors,
+  uint32_t vectorDimension,
+  float32_t intercept,
+  const float32_t *dualCoefficients,
+  const float32_t *supportVectors,
+  const int32_t   *classes,
+  float32_t coef0,
+  float32_t gamma
+  );
+
+/**
+ * @brief SVM sigmoid prediction
+ * @param[in]    S        Pointer to an instance of the rbf SVM structure.
+ * @param[in]    in       Pointer to input vector
+ * @param[out]   pResult  Decision value
+ * @return none.
+ *
+ */
+void arm_svm_sigmoid_predict_f32(const arm_svm_sigmoid_instance_f32 *S, 
+   const float32_t * in, 
+   int32_t * pResult);
+
+
+
+/**
+ * @brief Instance structure for Naive Gaussian Bayesian estimator.
+ */
+typedef struct
+{
+  uint32_t vectorDimension;  /**< Dimension of vector space */
+  uint32_t numberOfClasses;  /**< Number of different classes  */
+  const float32_t *theta;          /**< Mean values for the Gaussians */
+  const float32_t *sigma;          /**< Variances for the Gaussians */
+  const float32_t *classPriors;    /**< Class prior probabilities */
+  float32_t epsilon;         /**< Additive value to variances */
+} arm_gaussian_naive_bayes_instance_f32;
+
+/**
+ * @brief Naive Gaussian Bayesian Estimator
+ *
+ * @param[in]  S         points to a naive bayes instance structure
+ * @param[in]  in        points to the elements of the input vector.
+ * @param[in]  pBuffer   points to a buffer of length numberOfClasses
+ * @return The predicted class
+ *
+ */
+
+
+uint32_t arm_gaussian_naive_bayes_predict_f32(const arm_gaussian_naive_bayes_instance_f32 *S, 
+   const float32_t * in, 
+   float32_t *pBuffer);
+
+/**
+ * @brief Computation of the LogSumExp
+ *
+ * In probabilistic computations, the dynamic of the probability values can be very
+ * wide because they come from gaussian functions.
+ * To avoid underflow and overflow issues, the values are represented by their log.
+ * In this representation, multiplying the original exp values is easy : their logs are added.
+ * But adding the original exp values is requiring some special handling and it is the
+ * goal of the LogSumExp function.
+ *
+ * If the values are x1...xn, the function is computing:
+ *
+ * ln(exp(x1) + ... + exp(xn)) and the computation is done in such a way that
+ * rounding issues are minimised.
+ *
+ * The max xm of the values is extracted and the function is computing:
+ * xm + ln(exp(x1 - xm) + ... + exp(xn - xm))
+ *
+ * @param[in]  *in         Pointer to an array of input values.
+ * @param[in]  blockSize   Number of samples in the input array.
+ * @return LogSumExp
+ *
+ */
+
+
+float32_t arm_logsumexp_f32(const float32_t *in, uint32_t blockSize);
+
+/**
+ * @brief Dot product with log arithmetic
+ *
+ * Vectors are containing the log of the samples
+ *
+ * @param[in]       pSrcA points to the first input vector
+ * @param[in]       pSrcB points to the second input vector
+ * @param[in]       blockSize number of samples in each vector
+ * @param[in]       pTmpBuffer temporary buffer of length blockSize
+ * @return The log of the dot product .
+ *
+ */
+
+
+float32_t arm_logsumexp_dot_prod_f32(const float32_t * pSrcA,
+  const float32_t * pSrcB,
+  uint32_t blockSize,
+  float32_t *pTmpBuffer);
+
+/**
+ * @brief Entropy
+ *
+ * @param[in]  pSrcA        Array of input values.
+ * @param[in]  blockSize    Number of samples in the input array.
+ * @return     Entropy      -Sum(p ln p)
+ *
+ */
+
+
+float32_t arm_entropy_f32(const float32_t * pSrcA,uint32_t blockSize);
+
+
+/**
+ * @brief Entropy
+ *
+ * @param[in]  pSrcA        Array of input values.
+ * @param[in]  blockSize    Number of samples in the input array.
+ * @return     Entropy      -Sum(p ln p)
+ *
+ */
+
+
+float64_t arm_entropy_f64(const float64_t * pSrcA, uint32_t blockSize);
+
+
+/**
+ * @brief Kullback-Leibler
+ *
+ * @param[in]  pSrcA         Pointer to an array of input values for probability distribution A.
+ * @param[in]  pSrcB         Pointer to an array of input values for probability distribution B.
+ * @param[in]  blockSize     Number of samples in the input array.
+ * @return Kullback-Leibler  Divergence D(A || B)
+ *
+ */
+float32_t arm_kullback_leibler_f32(const float32_t * pSrcA
+  ,const float32_t * pSrcB
+  ,uint32_t blockSize);
+
+
+/**
+ * @brief Kullback-Leibler
+ *
+ * @param[in]  pSrcA         Pointer to an array of input values for probability distribution A.
+ * @param[in]  pSrcB         Pointer to an array of input values for probability distribution B.
+ * @param[in]  blockSize     Number of samples in the input array.
+ * @return Kullback-Leibler  Divergence D(A || B)
+ *
+ */
+float64_t arm_kullback_leibler_f64(const float64_t * pSrcA, 
+                const float64_t * pSrcB, 
+                uint32_t blockSize);
+
+
+/**
+ * @brief Weighted sum
+ *
+ *
+ * @param[in]    *in           Array of input values.
+ * @param[in]    *weigths      Weights
+ * @param[in]    blockSize     Number of samples in the input array.
+ * @return Weighted sum
+ *
+ */
+float32_t arm_weighted_sum_f32(const float32_t *in
+  , const float32_t *weigths
+  , uint32_t blockSize);
+
+
+/**
+ * @brief Barycenter
+ *
+ *
+ * @param[in]    in         List of vectors
+ * @param[in]    weights    Weights of the vectors
+ * @param[out]   out        Barycenter
+ * @param[in]    nbVectors  Number of vectors
+ * @param[in]    vecDim     Dimension of space (vector dimension)
+ * @return       None
+ *
+ */
+void arm_barycenter_f32(const float32_t *in
+  , const float32_t *weights
+  , float32_t *out
+  , uint32_t nbVectors
+  , uint32_t vecDim);
+
+/**
+ * @brief        Euclidean distance between two vectors
+ * @param[in]    pA         First vector
+ * @param[in]    pB         Second vector
+ * @param[in]    blockSize  vector length
+ * @return distance
+ *
+ */
+
+float32_t arm_euclidean_distance_f32(const float32_t *pA,const float32_t *pB, uint32_t blockSize);
+
+/**
+ * @brief        Bray-Curtis distance between two vectors
+ * @param[in]    pA         First vector
+ * @param[in]    pB         Second vector
+ * @param[in]    blockSize  vector length
+ * @return distance
+ *
+ */
+float32_t arm_braycurtis_distance_f32(const float32_t *pA,const float32_t *pB, uint32_t blockSize);
+
+/**
+ * @brief        Canberra distance between two vectors
+ *
+ * This function may divide by zero when samples pA[i] and pB[i] are both zero.
+ * The result of the computation will be correct. So the division per zero may be
+ * ignored.
+ *
+ * @param[in]    pA         First vector
+ * @param[in]    pB         Second vector
+ * @param[in]    blockSize  vector length
+ * @return distance
+ *
+ */
+float32_t arm_canberra_distance_f32(const float32_t *pA,const float32_t *pB, uint32_t blockSize);
+
+
+/**
+ * @brief        Chebyshev distance between two vectors
+ * @param[in]    pA         First vector
+ * @param[in]    pB         Second vector
+ * @param[in]    blockSize  vector length
+ * @return distance
+ *
+ */
+float32_t arm_chebyshev_distance_f32(const float32_t *pA,const float32_t *pB, uint32_t blockSize);
+
+
+/**
+ * @brief        Cityblock (Manhattan) distance between two vectors
+ * @param[in]    pA         First vector
+ * @param[in]    pB         Second vector
+ * @param[in]    blockSize  vector length
+ * @return distance
+ *
+ */
+float32_t arm_cityblock_distance_f32(const float32_t *pA,const float32_t *pB, uint32_t blockSize);
+
+/**
+ * @brief        Correlation distance between two vectors
+ *
+ * The input vectors are modified in place !
+ *
+ * @param[in]    pA         First vector
+ * @param[in]    pB         Second vector
+ * @param[in]    blockSize  vector length
+ * @return distance
+ *
+ */
+float32_t arm_correlation_distance_f32(float32_t *pA,float32_t *pB, uint32_t blockSize);
+
+/**
+ * @brief        Cosine distance between two vectors
+ *
+ * @param[in]    pA         First vector
+ * @param[in]    pB         Second vector
+ * @param[in]    blockSize  vector length
+ * @return distance
+ *
+ */
+
+float32_t arm_cosine_distance_f32(const float32_t *pA,const float32_t *pB, uint32_t blockSize);
+
+/**
+ * @brief        Jensen-Shannon distance between two vectors
+ *
+ * This function is assuming that elements of second vector are > 0
+ * and 0 only when the corresponding element of first vector is 0.
+ * Otherwise the result of the computation does not make sense
+ * and for speed reasons, the cases returning NaN or Infinity are not
+ * managed.
+ *
+ * When the function is computing x log (x / y) with x 0 and y 0,
+ * it will compute the right value (0) but a division per zero will occur
+ * and shoudl be ignored in client code.
+ *
+ * @param[in]    pA         First vector
+ * @param[in]    pB         Second vector
+ * @param[in]    blockSize  vector length
+ * @return distance
+ *
+ */
+
+float32_t arm_jensenshannon_distance_f32(const float32_t *pA,const float32_t *pB,uint32_t blockSize);
+
+/**
+ * @brief        Minkowski distance between two vectors
+ *
+ * @param[in]    pA         First vector
+ * @param[in]    pB         Second vector
+ * @param[in]    n          Norm order (>= 2)
+ * @param[in]    blockSize  vector length
+ * @return distance
+ *
+ */
+
+
+
+float32_t arm_minkowski_distance_f32(const float32_t *pA,const float32_t *pB, int32_t order, uint32_t blockSize);
+
+/**
+ * @brief        Dice distance between two vectors
+ *
+ * @param[in]    pA              First vector of packed booleans
+ * @param[in]    pB              Second vector of packed booleans
+ * @param[in]    order           Distance order
+ * @param[in]    blockSize       Number of samples
+ * @return distance
+ *
+ */
+
+
+float32_t arm_dice_distance(const uint32_t *pA, const uint32_t *pB, uint32_t numberOfBools);
+
+/**
+ * @brief        Hamming distance between two vectors
+ *
+ * @param[in]    pA              First vector of packed booleans
+ * @param[in]    pB              Second vector of packed booleans
+ * @param[in]    numberOfBools   Number of booleans
+ * @return distance
+ *
+ */
+
+float32_t arm_hamming_distance(const uint32_t *pA, const uint32_t *pB, uint32_t numberOfBools);
+
+/**
+ * @brief        Jaccard distance between two vectors
+ *
+ * @param[in]    pA              First vector of packed booleans
+ * @param[in]    pB              Second vector of packed booleans
+ * @param[in]    numberOfBools   Number of booleans
+ * @return distance
+ *
+ */
+
+float32_t arm_jaccard_distance(const uint32_t *pA, const uint32_t *pB, uint32_t numberOfBools);
+
+/**
+ * @brief        Kulsinski distance between two vectors
+ *
+ * @param[in]    pA              First vector of packed booleans
+ * @param[in]    pB              Second vector of packed booleans
+ * @param[in]    numberOfBools   Number of booleans
+ * @return distance
+ *
+ */
+
+float32_t arm_kulsinski_distance(const uint32_t *pA, const uint32_t *pB, uint32_t numberOfBools);
+
+/**
+ * @brief        Roger Stanimoto distance between two vectors
+ *
+ * @param[in]    pA              First vector of packed booleans
+ * @param[in]    pB              Second vector of packed booleans
+ * @param[in]    numberOfBools   Number of booleans
+ * @return distance
+ *
+ */
+
+float32_t arm_rogerstanimoto_distance(const uint32_t *pA, const uint32_t *pB, uint32_t numberOfBools);
+
+/**
+ * @brief        Russell-Rao distance between two vectors
+ *
+ * @param[in]    pA              First vector of packed booleans
+ * @param[in]    pB              Second vector of packed booleans
+ * @param[in]    numberOfBools   Number of booleans
+ * @return distance
+ *
+ */
+
+float32_t arm_russellrao_distance(const uint32_t *pA, const uint32_t *pB, uint32_t numberOfBools);
+
+/**
+ * @brief        Sokal-Michener distance between two vectors
+ *
+ * @param[in]    pA              First vector of packed booleans
+ * @param[in]    pB              Second vector of packed booleans
+ * @param[in]    numberOfBools   Number of booleans
+ * @return distance
+ *
+ */
+
+float32_t arm_sokalmichener_distance(const uint32_t *pA, const uint32_t *pB, uint32_t numberOfBools);
+
+/**
+ * @brief        Sokal-Sneath distance between two vectors
+ *
+ * @param[in]    pA              First vector of packed booleans
+ * @param[in]    pB              Second vector of packed booleans
+ * @param[in]    numberOfBools   Number of booleans
+ * @return distance
+ *
+ */
+
+float32_t arm_sokalsneath_distance(const uint32_t *pA, const uint32_t *pB, uint32_t numberOfBools);
+
+/**
+ * @brief        Yule distance between two vectors
+ *
+ * @param[in]    pA              First vector of packed booleans
+ * @param[in]    pB              Second vector of packed booleans
+ * @param[in]    numberOfBools   Number of booleans
+ * @return distance
+ *
+ */
+
+float32_t arm_yule_distance(const uint32_t *pA, const uint32_t *pB, uint32_t numberOfBools);
+
+
+  /**
+   * @ingroup groupInterpolation
+   */
+
+  /**
+   * @defgroup BilinearInterpolate Bilinear Interpolation
+   *
+   * Bilinear interpolation is an extension of linear interpolation applied to a two dimensional grid.
+   * The underlying function <code>f(x, y)</code> is sampled on a regular grid and the interpolation process
+   * determines values between the grid points.
+   * Bilinear interpolation is equivalent to two step linear interpolation, first in the x-dimension and then in the y-dimension.
+   * Bilinear interpolation is often used in image processing to rescale images.
+   * The CMSIS DSP library provides bilinear interpolation functions for Q7, Q15, Q31, and floating-point data types.
+   *
+   * <b>Algorithm</b>
+   * \par
+   * The instance structure used by the bilinear interpolation functions describes a two dimensional data table.
+   * For floating-point, the instance structure is defined as:
+   * <pre>
+   *   typedef struct
+   *   {
+   *     uint16_t numRows;
+   *     uint16_t numCols;
+   *     float32_t *pData;
+   * } arm_bilinear_interp_instance_f32;
+   * </pre>
+   *
+   * \par
+   * where <code>numRows</code> specifies the number of rows in the table;
+   * <code>numCols</code> specifies the number of columns in the table;
+   * and <code>pData</code> points to an array of size <code>numRows*numCols</code> values.
+   * The data table <code>pTable</code> is organized in row order and the supplied data values fall on integer indexes.
+   * That is, table element (x,y) is located at <code>pTable[x + y*numCols]</code> where x and y are integers.
+   *
+   * \par
+   * Let <code>(x, y)</code> specify the desired interpolation point.  Then define:
+   * <pre>
+   *     XF = floor(x)
+   *     YF = floor(y)
+   * </pre>
+   * \par
+   * The interpolated output point is computed as:
+   * <pre>
+   *  f(x, y) = f(XF, YF) * (1-(x-XF)) * (1-(y-YF))
+   *           + f(XF+1, YF) * (x-XF)*(1-(y-YF))
+   *           + f(XF, YF+1) * (1-(x-XF))*(y-YF)
+   *           + f(XF+1, YF+1) * (x-XF)*(y-YF)
+   * </pre>
+   * Note that the coordinates (x, y) contain integer and fractional components.
+   * The integer components specify which portion of the table to use while the
+   * fractional components control the interpolation processor.
+   *
+   * \par
+   * if (x,y) are outside of the table boundary, Bilinear interpolation returns zero output.
+   */
+
+
+  /**
+   * @addtogroup BilinearInterpolate
+   * @{
+   */
+
+  /**
+  * @brief  Floating-point bilinear interpolation.
+  * @param[in,out] S  points to an instance of the interpolation structure.
+  * @param[in]     X  interpolation coordinate.
+  * @param[in]     Y  interpolation coordinate.
+  * @return out interpolated value.
+  */
+  __STATIC_FORCEINLINE float32_t arm_bilinear_interp_f32(
+  const arm_bilinear_interp_instance_f32 * S,
+  float32_t X,
+  float32_t Y)
+  {
+    float32_t out;
+    float32_t f00, f01, f10, f11;
+    float32_t *pData = S->pData;
+    int32_t xIndex, yIndex, index;
+    float32_t xdiff, ydiff;
+    float32_t b1, b2, b3, b4;
+
+    xIndex = (int32_t) X;
+    yIndex = (int32_t) Y;
+
+    /* Care taken for table outside boundary */
+    /* Returns zero output when values are outside table boundary */
+    if (xIndex < 0 || xIndex > (S->numCols - 2) || yIndex < 0 || yIndex > (S->numRows - 2))
+    {
+      return (0);
+    }
+
+    /* Calculation of index for two nearest points in X-direction */
+    index = (xIndex ) + (yIndex ) * S->numCols;
+
+
+    /* Read two nearest points in X-direction */
+    f00 = pData[index];
+    f01 = pData[index + 1];
+
+    /* Calculation of index for two nearest points in Y-direction */
+    index = (xIndex ) + (yIndex+1) * S->numCols;
+
+
+    /* Read two nearest points in Y-direction */
+    f10 = pData[index];
+    f11 = pData[index + 1];
+
+    /* Calculation of intermediate values */
+    b1 = f00;
+    b2 = f01 - f00;
+    b3 = f10 - f00;
+    b4 = f00 - f01 - f10 + f11;
+
+    /* Calculation of fractional part in X */
+    xdiff = X - xIndex;
+
+    /* Calculation of fractional part in Y */
+    ydiff = Y - yIndex;
+
+    /* Calculation of bi-linear interpolated output */
+    out = b1 + b2 * xdiff + b3 * ydiff + b4 * xdiff * ydiff;
+
+    /* return to application */
+    return (out);
+  }
+
+
+  /**
+  * @brief  Q31 bilinear interpolation.
+  * @param[in,out] S  points to an instance of the interpolation structure.
+  * @param[in]     X  interpolation coordinate in 12.20 format.
+  * @param[in]     Y  interpolation coordinate in 12.20 format.
+  * @return out interpolated value.
+  */
+  __STATIC_FORCEINLINE q31_t arm_bilinear_interp_q31(
+  arm_bilinear_interp_instance_q31 * S,
+  q31_t X,
+  q31_t Y)
+  {
+    q31_t out;                                   /* Temporary output */
+    q31_t acc = 0;                               /* output */
+    q31_t xfract, yfract;                        /* X, Y fractional parts */
+    q31_t x1, x2, y1, y2;                        /* Nearest output values */
+    int32_t rI, cI;                              /* Row and column indices */
+    q31_t *pYData = S->pData;                    /* pointer to output table values */
+    uint32_t nCols = S->numCols;                 /* num of rows */
+
+    /* Input is in 12.20 format */
+    /* 12 bits for the table index */
+    /* Index value calculation */
+    rI = ((X & (q31_t)0xFFF00000) >> 20);
+
+    /* Input is in 12.20 format */
+    /* 12 bits for the table index */
+    /* Index value calculation */
+    cI = ((Y & (q31_t)0xFFF00000) >> 20);
+
+    /* Care taken for table outside boundary */
+    /* Returns zero output when values are outside table boundary */
+    if (rI < 0 || rI > (S->numCols - 2) || cI < 0 || cI > (S->numRows - 2))
+    {
+      return (0);
+    }
+
+    /* 20 bits for the fractional part */
+    /* shift left xfract by 11 to keep 1.31 format */
+    xfract = (X & 0x000FFFFF) << 11U;
+
+    /* Read two nearest output values from the index */
+    x1 = pYData[(rI) + (int32_t)nCols * (cI)    ];
+    x2 = pYData[(rI) + (int32_t)nCols * (cI) + 1];
+
+    /* 20 bits for the fractional part */
+    /* shift left yfract by 11 to keep 1.31 format */
+    yfract = (Y & 0x000FFFFF) << 11U;
+
+    /* Read two nearest output values from the index */
+    y1 = pYData[(rI) + (int32_t)nCols * (cI + 1)    ];
+    y2 = pYData[(rI) + (int32_t)nCols * (cI + 1) + 1];
+
+    /* Calculation of x1 * (1-xfract ) * (1-yfract) and acc is in 3.29(q29) format */
+    out = ((q31_t) (((q63_t) x1  * (0x7FFFFFFF - xfract)) >> 32));
+    acc = ((q31_t) (((q63_t) out * (0x7FFFFFFF - yfract)) >> 32));
+
+    /* x2 * (xfract) * (1-yfract)  in 3.29(q29) and adding to acc */
+    out = ((q31_t) ((q63_t) x2 * (0x7FFFFFFF - yfract) >> 32));
+    acc += ((q31_t) ((q63_t) out * (xfract) >> 32));
+
+    /* y1 * (1 - xfract) * (yfract)  in 3.29(q29) and adding to acc */
+    out = ((q31_t) ((q63_t) y1 * (0x7FFFFFFF - xfract) >> 32));
+    acc += ((q31_t) ((q63_t) out * (yfract) >> 32));
+
+    /* y2 * (xfract) * (yfract)  in 3.29(q29) and adding to acc */
+    out = ((q31_t) ((q63_t) y2 * (xfract) >> 32));
+    acc += ((q31_t) ((q63_t) out * (yfract) >> 32));
+
+    /* Convert acc to 1.31(q31) format */
+    return ((q31_t)(acc << 2));
+  }
+
+
+  /**
+  * @brief  Q15 bilinear interpolation.
+  * @param[in,out] S  points to an instance of the interpolation structure.
+  * @param[in]     X  interpolation coordinate in 12.20 format.
+  * @param[in]     Y  interpolation coordinate in 12.20 format.
+  * @return out interpolated value.
+  */
+  __STATIC_FORCEINLINE q15_t arm_bilinear_interp_q15(
+  arm_bilinear_interp_instance_q15 * S,
+  q31_t X,
+  q31_t Y)
+  {
+    q63_t acc = 0;                               /* output */
+    q31_t out;                                   /* Temporary output */
+    q15_t x1, x2, y1, y2;                        /* Nearest output values */
+    q31_t xfract, yfract;                        /* X, Y fractional parts */
+    int32_t rI, cI;                              /* Row and column indices */
+    q15_t *pYData = S->pData;                    /* pointer to output table values */
+    uint32_t nCols = S->numCols;                 /* num of rows */
+
+    /* Input is in 12.20 format */
+    /* 12 bits for the table index */
+    /* Index value calculation */
+    rI = ((X & (q31_t)0xFFF00000) >> 20);
+
+    /* Input is in 12.20 format */
+    /* 12 bits for the table index */
+    /* Index value calculation */
+    cI = ((Y & (q31_t)0xFFF00000) >> 20);
+
+    /* Care taken for table outside boundary */
+    /* Returns zero output when values are outside table boundary */
+    if (rI < 0 || rI > (S->numCols - 2) || cI < 0 || cI > (S->numRows - 2))
+    {
+      return (0);
+    }
+
+    /* 20 bits for the fractional part */
+    /* xfract should be in 12.20 format */
+    xfract = (X & 0x000FFFFF);
+
+    /* Read two nearest output values from the index */
+    x1 = pYData[((uint32_t)rI) + nCols * ((uint32_t)cI)    ];
+    x2 = pYData[((uint32_t)rI) + nCols * ((uint32_t)cI) + 1];
+
+    /* 20 bits for the fractional part */
+    /* yfract should be in 12.20 format */
+    yfract = (Y & 0x000FFFFF);
+
+    /* Read two nearest output values from the index */
+    y1 = pYData[((uint32_t)rI) + nCols * ((uint32_t)cI + 1)    ];
+    y2 = pYData[((uint32_t)rI) + nCols * ((uint32_t)cI + 1) + 1];
+
+    /* Calculation of x1 * (1-xfract ) * (1-yfract) and acc is in 13.51 format */
+
+    /* x1 is in 1.15(q15), xfract in 12.20 format and out is in 13.35 format */
+    /* convert 13.35 to 13.31 by right shifting  and out is in 1.31 */
+    out = (q31_t) (((q63_t) x1 * (0x0FFFFF - xfract)) >> 4U);
+    acc = ((q63_t) out * (0x0FFFFF - yfract));
+
+    /* x2 * (xfract) * (1-yfract)  in 1.51 and adding to acc */
+    out = (q31_t) (((q63_t) x2 * (0x0FFFFF - yfract)) >> 4U);
+    acc += ((q63_t) out * (xfract));
+
+    /* y1 * (1 - xfract) * (yfract)  in 1.51 and adding to acc */
+    out = (q31_t) (((q63_t) y1 * (0x0FFFFF - xfract)) >> 4U);
+    acc += ((q63_t) out * (yfract));
+
+    /* y2 * (xfract) * (yfract)  in 1.51 and adding to acc */
+    out = (q31_t) (((q63_t) y2 * (xfract)) >> 4U);
+    acc += ((q63_t) out * (yfract));
+
+    /* acc is in 13.51 format and down shift acc by 36 times */
+    /* Convert out to 1.15 format */
+    return ((q15_t)(acc >> 36));
+  }
+
+
+  /**
+  * @brief  Q7 bilinear interpolation.
+  * @param[in,out] S  points to an instance of the interpolation structure.
+  * @param[in]     X  interpolation coordinate in 12.20 format.
+  * @param[in]     Y  interpolation coordinate in 12.20 format.
+  * @return out interpolated value.
+  */
+  __STATIC_FORCEINLINE q7_t arm_bilinear_interp_q7(
+  arm_bilinear_interp_instance_q7 * S,
+  q31_t X,
+  q31_t Y)
+  {
+    q63_t acc = 0;                               /* output */
+    q31_t out;                                   /* Temporary output */
+    q31_t xfract, yfract;                        /* X, Y fractional parts */
+    q7_t x1, x2, y1, y2;                         /* Nearest output values */
+    int32_t rI, cI;                              /* Row and column indices */
+    q7_t *pYData = S->pData;                     /* pointer to output table values */
+    uint32_t nCols = S->numCols;                 /* num of rows */
+
+    /* Input is in 12.20 format */
+    /* 12 bits for the table index */
+    /* Index value calculation */
+    rI = ((X & (q31_t)0xFFF00000) >> 20);
+
+    /* Input is in 12.20 format */
+    /* 12 bits for the table index */
+    /* Index value calculation */
+    cI = ((Y & (q31_t)0xFFF00000) >> 20);
+
+    /* Care taken for table outside boundary */
+    /* Returns zero output when values are outside table boundary */
+    if (rI < 0 || rI > (S->numCols - 2) || cI < 0 || cI > (S->numRows - 2))
+    {
+      return (0);
+    }
+
+    /* 20 bits for the fractional part */
+    /* xfract should be in 12.20 format */
+    xfract = (X & (q31_t)0x000FFFFF);
+
+    /* Read two nearest output values from the index */
+    x1 = pYData[((uint32_t)rI) + nCols * ((uint32_t)cI)    ];
+    x2 = pYData[((uint32_t)rI) + nCols * ((uint32_t)cI) + 1];
+
+    /* 20 bits for the fractional part */
+    /* yfract should be in 12.20 format */
+    yfract = (Y & (q31_t)0x000FFFFF);
+
+    /* Read two nearest output values from the index */
+    y1 = pYData[((uint32_t)rI) + nCols * ((uint32_t)cI + 1)    ];
+    y2 = pYData[((uint32_t)rI) + nCols * ((uint32_t)cI + 1) + 1];
+
+    /* Calculation of x1 * (1-xfract ) * (1-yfract) and acc is in 16.47 format */
+    out = ((x1 * (0xFFFFF - xfract)));
+    acc = (((q63_t) out * (0xFFFFF - yfract)));
+
+    /* x2 * (xfract) * (1-yfract)  in 2.22 and adding to acc */
+    out = ((x2 * (0xFFFFF - yfract)));
+    acc += (((q63_t) out * (xfract)));
+
+    /* y1 * (1 - xfract) * (yfract)  in 2.22 and adding to acc */
+    out = ((y1 * (0xFFFFF - xfract)));
+    acc += (((q63_t) out * (yfract)));
+
+    /* y2 * (xfract) * (yfract)  in 2.22 and adding to acc */
+    out = ((y2 * (yfract)));
+    acc += (((q63_t) out * (xfract)));
+
+    /* acc in 16.47 format and down shift by 40 to convert to 1.7 format */
+    return ((q7_t)(acc >> 40));
+  }
+
+  /**
+   * @} end of BilinearInterpolate group
+   */
+
+
+/* SMMLAR */
+#define multAcc_32x32_keep32_R(a, x, y) \
+    a = (q31_t) (((((q63_t) a) << 32) + ((q63_t) x * y) + 0x80000000LL ) >> 32)
+
+/* SMMLSR */
+#define multSub_32x32_keep32_R(a, x, y) \
+    a = (q31_t) (((((q63_t) a) << 32) - ((q63_t) x * y) + 0x80000000LL ) >> 32)
+
+/* SMMULR */
+#define mult_32x32_keep32_R(a, x, y) \
+    a = (q31_t) (((q63_t) x * y + 0x80000000LL ) >> 32)
+
+/* SMMLA */
+#define multAcc_32x32_keep32(a, x, y) \
+    a += (q31_t) (((q63_t) x * y) >> 32)
+
+/* SMMLS */
+#define multSub_32x32_keep32(a, x, y) \
+    a -= (q31_t) (((q63_t) x * y) >> 32)
+
+/* SMMUL */
+#define mult_32x32_keep32(a, x, y) \
+    a = (q31_t) (((q63_t) x * y ) >> 32)
+
+
+#if   defined ( __CC_ARM )
+  /* Enter low optimization region - place directly above function definition */
+  #if defined( __ARM_ARCH_7EM__ )
+    #define LOW_OPTIMIZATION_ENTER \
+       _Pragma ("push")         \
+       _Pragma ("O1")
+  #else
+    #define LOW_OPTIMIZATION_ENTER
+  #endif
+
+  /* Exit low optimization region - place directly after end of function definition */
+  #if defined ( __ARM_ARCH_7EM__ )
+    #define LOW_OPTIMIZATION_EXIT \
+       _Pragma ("pop")
+  #else
+    #define LOW_OPTIMIZATION_EXIT
+  #endif
+
+  /* Enter low optimization region - place directly above function definition */
+  #define IAR_ONLY_LOW_OPTIMIZATION_ENTER
+
+  /* Exit low optimization region - place directly after end of function definition */
+  #define IAR_ONLY_LOW_OPTIMIZATION_EXIT
+
+#elif defined (__ARMCC_VERSION ) && ( __ARMCC_VERSION >= 6010050 )
+  #define LOW_OPTIMIZATION_ENTER
+  #define LOW_OPTIMIZATION_EXIT
+  #define IAR_ONLY_LOW_OPTIMIZATION_ENTER
+  #define IAR_ONLY_LOW_OPTIMIZATION_EXIT
+
+#elif defined ( __GNUC__ )
+  #define LOW_OPTIMIZATION_ENTER \
+       __attribute__(( optimize("-O1") ))
+  #define LOW_OPTIMIZATION_EXIT
+  #define IAR_ONLY_LOW_OPTIMIZATION_ENTER
+  #define IAR_ONLY_LOW_OPTIMIZATION_EXIT
+
+#elif defined ( __ICCARM__ )
+  /* Enter low optimization region - place directly above function definition */
+  #if defined ( __ARM_ARCH_7EM__ )
+    #define LOW_OPTIMIZATION_ENTER \
+       _Pragma ("optimize=low")
+  #else
+    #define LOW_OPTIMIZATION_ENTER
+  #endif
+
+  /* Exit low optimization region - place directly after end of function definition */
+  #define LOW_OPTIMIZATION_EXIT
+
+  /* Enter low optimization region - place directly above function definition */
+  #if defined ( __ARM_ARCH_7EM__ )
+    #define IAR_ONLY_LOW_OPTIMIZATION_ENTER \
+       _Pragma ("optimize=low")
+  #else
+    #define IAR_ONLY_LOW_OPTIMIZATION_ENTER
+  #endif
+
+  /* Exit low optimization region - place directly after end of function definition */
+  #define IAR_ONLY_LOW_OPTIMIZATION_EXIT
+
+#elif defined ( __TI_ARM__ )
+  #define LOW_OPTIMIZATION_ENTER
+  #define LOW_OPTIMIZATION_EXIT
+  #define IAR_ONLY_LOW_OPTIMIZATION_ENTER
+  #define IAR_ONLY_LOW_OPTIMIZATION_EXIT
+
+#elif defined ( __CSMC__ )
+  #define LOW_OPTIMIZATION_ENTER
+  #define LOW_OPTIMIZATION_EXIT
+  #define IAR_ONLY_LOW_OPTIMIZATION_ENTER
+  #define IAR_ONLY_LOW_OPTIMIZATION_EXIT
+
+#elif defined ( __TASKING__ )
+  #define LOW_OPTIMIZATION_ENTER
+  #define LOW_OPTIMIZATION_EXIT
+  #define IAR_ONLY_LOW_OPTIMIZATION_ENTER
+  #define IAR_ONLY_LOW_OPTIMIZATION_EXIT
+       
+#elif defined ( _MSC_VER ) || defined(__GNUC_PYTHON__)
+      #define LOW_OPTIMIZATION_ENTER
+      #define LOW_OPTIMIZATION_EXIT
+      #define IAR_ONLY_LOW_OPTIMIZATION_ENTER 
+      #define IAR_ONLY_LOW_OPTIMIZATION_EXIT
+#endif
+
+
+
+/* Compiler specific diagnostic adjustment */
+#if   defined ( __CC_ARM )
+
+#elif defined ( __ARMCC_VERSION ) && ( __ARMCC_VERSION >= 6010050 )
+
+#elif defined ( __GNUC__ )
+#pragma GCC diagnostic pop
+
+#elif defined ( __ICCARM__ )
+
+#elif defined ( __TI_ARM__ )
+
+#elif defined ( __CSMC__ )
+
+#elif defined ( __TASKING__ )
+
+#elif defined ( _MSC_VER )
+
+#else
+  #error Unknown compiler
+#endif
+
+#ifdef   __cplusplus
+}
+#endif
+
+
+#endif /* _ARM_MATH_H */
+
+/**
+ *
+ * End of file.
+ */
diff --git a/Firmware/Targets/F407VG/Middlewares/ST/ARM/DSP/Lib/libarm_cortexM4lf_math.a b/Firmware/Targets/F407VG/Middlewares/ST/ARM/DSP/Lib/libarm_cortexM4lf_math.a
new file mode 100644
index 000000000..101d668de
Binary files /dev/null and b/Firmware/Targets/F407VG/Middlewares/ST/ARM/DSP/Lib/libarm_cortexM4lf_math.a differ
diff --git a/Firmware/Targets/F407VG/Middlewares/Third_Party/ARM/DSP/LICENSE.txt b/Firmware/Targets/F407VG/Middlewares/Third_Party/ARM/DSP/LICENSE.txt
new file mode 100644
index 000000000..8dada3eda
--- /dev/null
+++ b/Firmware/Targets/F407VG/Middlewares/Third_Party/ARM/DSP/LICENSE.txt
@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "{}"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright {yyyy} {name of copyright owner}
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
diff --git a/Firmware/Targets/F407VG/OpenFFBoard_F407VG.ioc b/Firmware/Targets/F407VG/OpenFFBoard_F407VG.ioc
index d97d47989..103c28828 100644
--- a/Firmware/Targets/F407VG/OpenFFBoard_F407VG.ioc
+++ b/Firmware/Targets/F407VG/OpenFFBoard_F407VG.ioc
@@ -176,7 +176,7 @@ FREERTOS.IPParameters=Tasks01,configENABLE_FPU,configTOTAL_HEAP_SIZE,FootprintOK
 FREERTOS.Tasks01=defaultTask,16,512,StartDefaultTask,As weak,NULL,Dynamic,NULL,NULL
 FREERTOS.configCHECK_FOR_STACK_OVERFLOW=2
 FREERTOS.configENABLE_FPU=1
-FREERTOS.configGENERATE_RUN_TIME_STATS=0
+FREERTOS.configGENERATE_RUN_TIME_STATS=1
 FREERTOS.configMINIMAL_STACK_SIZE=64
 FREERTOS.configRECORD_STACK_HIGH_ADDRESS=1
 FREERTOS.configTIMER_TASK_STACK_DEPTH=128
@@ -184,7 +184,7 @@ FREERTOS.configTOTAL_HEAP_SIZE=0xffff
 FREERTOS.configUSE_IDLE_HOOK=1
 FREERTOS.configUSE_MALLOC_FAILED_HOOK=1
 FREERTOS.configUSE_NEWLIB_REENTRANT=1
-FREERTOS.configUSE_STATS_FORMATTING_FUNCTIONS=0
+FREERTOS.configUSE_STATS_FORMATTING_FUNCTIONS=1
 FREERTOS.configUSE_TRACE_FACILITY=1
 File.Version=6
 GPIO.groupedBy=Show All
@@ -308,9 +308,11 @@ Mcu.Pin84=VP_TIM8_VS_ClockSourceINT
 Mcu.Pin85=VP_TIM8_VS_no_output1
 Mcu.Pin86=VP_TIM9_VS_ClockSourceINT
 Mcu.Pin87=VP_TIM13_VS_ClockSourceINT
+Mcu.Pin88=VP_STMicroelectronics.X-CUBE-ALGOBUILD_VS_DSPOoLibraryJjLibrary_1.4.0_1.4.0
 Mcu.Pin9=PH1-OSC_OUT
-Mcu.PinsNb=88
-Mcu.ThirdPartyNb=0
+Mcu.PinsNb=89
+Mcu.ThirdParty0=STMicroelectronics.X-CUBE-ALGOBUILD.1.4.0
+Mcu.ThirdPartyNb=1
 Mcu.UserConstants=
 Mcu.UserName=STM32F407VGTx
 MxCube.Version=6.10.0
@@ -721,6 +723,7 @@ PH1-OSC_OUT.Signal=RCC_OSC_OUT
 PinOutPanel.RotationAngle=-180
 ProjectManager.AskForMigrate=true
 ProjectManager.BackupPrevious=false
+ProjectManager.CompilerLinker=GCC
 ProjectManager.CompilerOptimize=6
 ProjectManager.ComputerToolchain=false
 ProjectManager.CoupleFile=false
@@ -733,7 +736,7 @@ ProjectManager.FreePins=false
 ProjectManager.HalAssertFull=false
 ProjectManager.HeapSize=0x400
 ProjectManager.KeepUserCode=true
-ProjectManager.LastFirmware=false
+ProjectManager.LastFirmware=true
 ProjectManager.LibraryCopy=1
 ProjectManager.MainLocation=Core/Src
 ProjectManager.MultiThreaded=true
@@ -858,6 +861,10 @@ SPI3.Direction=SPI_DIRECTION_2LINES
 SPI3.IPParameters=VirtualType,Mode,Direction,CalculateBaudRate,BaudRatePrescaler
 SPI3.Mode=SPI_MODE_MASTER
 SPI3.VirtualType=VM_MASTER
+STMicroelectronics.X-CUBE-ALGOBUILD.1.4.0.DSPOoLibraryJjLibrary_Checked=true
+STMicroelectronics.X-CUBE-ALGOBUILD.1.4.0.IPParameters=LibraryCcDSPOoLibraryJjDSPOoLibrary
+STMicroelectronics.X-CUBE-ALGOBUILD.1.4.0.LibraryCcDSPOoLibraryJjDSPOoLibrary=true
+STMicroelectronics.X-CUBE-ALGOBUILD.1.4.0_SwParameter=LibraryCcDSPOoLibraryJjDSPOoLibrary\:true;
 TIM1.AutoReloadPreload=TIM_AUTORELOAD_PRELOAD_ENABLE
 TIM1.Channel-PWM\ Generation1\ CH1=TIM_CHANNEL_1
 TIM1.Channel-PWM\ Generation2\ CH2=TIM_CHANNEL_2
@@ -941,6 +948,8 @@ VP_FREERTOS_VS_CMSIS_V2.Mode=CMSIS_V2
 VP_FREERTOS_VS_CMSIS_V2.Signal=FREERTOS_VS_CMSIS_V2
 VP_IWDG_VS_IWDG.Mode=IWDG_Activate
 VP_IWDG_VS_IWDG.Signal=IWDG_VS_IWDG
+VP_STMicroelectronics.X-CUBE-ALGOBUILD_VS_DSPOoLibraryJjLibrary_1.4.0_1.4.0.Mode=DSPOoLibraryJjLibrary
+VP_STMicroelectronics.X-CUBE-ALGOBUILD_VS_DSPOoLibraryJjLibrary_1.4.0_1.4.0.Signal=STMicroelectronics.X-CUBE-ALGOBUILD_VS_DSPOoLibraryJjLibrary_1.4.0_1.4.0
 VP_SYS_VS_tim7.Mode=TIM7
 VP_SYS_VS_tim7.Signal=SYS_VS_tim7
 VP_TIM13_VS_ClockSourceINT.Mode=Enable_Timer
diff --git a/Firmware/scripts/generate_memory.py b/Firmware/scripts/generate_memory.py
index 5b31a90ff..9e3bd3eed 100644
--- a/Firmware/scripts/generate_memory.py
+++ b/Firmware/scripts/generate_memory.py
@@ -8,8 +8,8 @@
  *  Created on: 24.01.2020		
  *  Author: Yannick		
  *		
- *	/!\ Generated from the file memory_map.csv 
-   / ! \ DO NOT EDIT THIS DIRECTLY !!!	
+ *	/!\\ Generated from the file memory_map.csv 
+   / ! \\ DO NOT EDIT THIS DIRECTLY !!!	
  */		
 		
 #include "eeprom_addresses.h"		
@@ -22,8 +22,8 @@
  *  Created on: 24.01.2020		
  *  Author: Yannick		
  *		
- *	/!\ Generated from the file memory_map.csv 
-   / ! \ DO NOT EDIT THIS DIRECTLY !!!	
+ *	/!\\ Generated from the file memory_map.csv 
+   / ! \\ DO NOT EDIT THIS DIRECTLY !!!	
  */			
 		
 #ifndef EEPROM_ADDRESSES_H_
diff --git a/Firmware/scripts/memory_map.csv b/Firmware/scripts/memory_map.csv
index ccaca03f4..822ba9c93 100644
--- a/Firmware/scripts/memory_map.csv
+++ b/Firmware/scripts/memory_map.csv
@@ -52,6 +52,7 @@ Section comment,Name,Value,Comment on key,VirtAddVarTab,exportableFlashAddresses
 ,ADR_FFB_EFFECTS1,0x284,"// 0-7 inertia, 8-15 friction",1,1
 ,ADR_FFB_EFFECTS2,0x285,"// 0-7 spring, 8-15 damper",1,1
 ,ADR_FFB_EFFECTS3,0x286,"// 0-7 friction ramp up zone, 8-9 filterProfile",1,1
+,ADR_FFB_RECONSTRUCTION_FILTER,0x287,// 0-1 recon filter mode,1,1
 // Button Sources:,,,,,
 ,ADR_ADS111X_CONF1,0x290,,1,1
 // How many axis configured 1-3,,,,,
@@ -62,6 +63,7 @@ Section comment,Name,Value,Comment on key,VirtAddVarTab,exportableFlashAddresses
 ,ADR_AXIS1_DEGREES,0x303,,1,1
 ,ADR_AXIS1_MAX_SPEED,0x304,// Store the max speed,1,1
 ,ADR_AXIS1_MAX_ACCEL,0x305,// Store the max accel,1,1
+,ADR_AXIS1_MAX_SLEWRATE_DRV,0x306,// Max slew rate for drv,1,1
 ,ADR_AXIS1_ENDSTOP,0x307,"// 0-7 endstop margin, 8-15 endstop stiffness",1,1
 ,ADR_AXIS1_EFFECTS1,0x308,"// 0-7 idlespring, 8-15 damper",1,1
 ,ADR_AXIS1_SPEEDACCEL_FILTER,0x309,// Speed/Accel filter Lowpass profile,1,1
@@ -88,6 +90,7 @@ Section comment,Name,Value,Comment on key,VirtAddVarTab,exportableFlashAddresses
 ,ADR_AXIS2_DEGREES,0x343,,1,1
 ,ADR_AXIS2_MAX_SPEED,0x344,// Store the max speed,1,1
 ,ADR_AXIS2_MAX_ACCEL,0x345,// Store the max accel,1,1
+,ADR_AXIS2_MAX_SLEWRATE_DRV,0x346,// Max slew rate for drv,1,1
 ,ADR_AXIS2_ENDSTOP,0x347,"// 0-7 endstop margin, 8-15 endstop stiffness",1,1
 ,ADR_AXIS2_EFFECTS1,0x348,"// 0-7 idlespring, 8-15 damper",1,1
 ,ADR_AXIS2_SPEEDACCEL_FILTER,0x349,// Speed/Accel filter Lowpass profile,1,1
@@ -120,6 +123,7 @@ Section comment,Name,Value,Comment on key,VirtAddVarTab,exportableFlashAddresses
 ,ADR_AXIS3_DEGREES,0x383,,1,1
 ,ADR_AXIS3_MAX_SPEED,0x384,// Store the max speed,1,1
 ,ADR_AXIS3_MAX_ACCEL,0x385,// Store the max accel,1,1
+,ADR_AXIS3_MAX_SLEWRATE_DRV,0x386,// Max slew rate for drv,1,1
 ,ADR_AXIS3_ENDSTOP,0x387,"// 0-7 endstop margin, 8-15 endstop stiffness",1,1
 ,ADR_AXIS3_EFFECTS1,0x388,"// 0-7 idlespring, 8-15 damper",1,1
 ,ADR_AXIS3_SPEEDACCEL_FILTER,0x389,// Speed/Accel filter Lowpass profile,1,1