Grua 02

////////////////////////////////////////////////////////////////////////////////
// //
// This software is supplied under the terms of a license agreement or //
// nondisclosure agreement with Mitov Software and may not be copied //
// or disclosed except in accordance with the terms of that agreement. //
// //
////////////////////////////////////////////////////////////////////////////////
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
template<typename T> class AddValue
{
public:
inline static T CalculateOutput( T AInValue, T AParamValue )
{
return AInValue + AParamValue;
}
};
//---------------------------------------------------------------------------
template<typename T> class SubtractValue
{
public:
{
return AInValue - AParamValue;
}
};
//---------------------------------------------------------------------------
template<typename T> class SubtractFromValue
{
public:
{
return AParamValue - AInValue;
}
};
//---------------------------------------------------------------------------
template<typename T> class MultiplyByValue
{
public:
{
return AInValue * AParamValue;
}
};
//---------------------------------------------------------------------------
template<typename T> class DivideByValue
{
public:
OpenWire::SourcePin OutputPin;
public:
T Value;
public:
void SetValue( T AValue )
{
if( AValue == 0 )
Value = 1;
else
Value = AValue;
}
public:
void InputPin_o_Receive( void *_Data )
{
T AOutValue = ( *(T*)_Data ) / Value;
OutputPin.Notify( &AOutValue );
}
public:
DivideByValue( T AValue = 1 ) :
Value( AValue )
{
}
};
//---------------------------------------------------------------------------
template<typename T> class DivideByValue_Enable
{
public:
public:
bool Enabled = true;
public:
T Value;
public:
{
if( AValue == 0 )
Value = 1;
else
Value = AValue;
}
public:
{
if( ! Enabled )
{
OutputPin.Notify( _Data );
return;
}
T AOutValue = ( *(T*)_Data ) / Value;

}
public:
DivideByValue_Enable( T AValue = 1 ) :
Value( AValue )
{
}
};
//---------------------------------------------------------------------------
template<typename T> class DivideValue
{
public:
{
if( AInValue == 0 )
AInValue = 0.0000000001;
return AParamValue / AInValue;

}
};
//---------------------------------------------------------------------------
template<typename T> class Inverse
{
public:
inline static T CalculateOutput( T AInValue )
{
return -AInValue;
}
};
//---------------------------------------------------------------------------
template<typename T> class Abs
{
public:
{
return abs( AInValue );
}
};
//---------------------------------------------------------------------------
template<typename T> class MinLimit
{
public:
{
return ( AInValue < AParamValue ) ? AParamValue : AInValue;
}
};
//---------------------------------------------------------------------------
template<typename T> class MaxLimit
{
public:
{
return ( AInValue > AParamValue ) ? AParamValue : AInValue;
}
};
//---------------------------------------------------------------------------
template<typename T> class Limit
{
public:
public:
T Min = 0.0;
T Max = 1.0;
public:
{
float AInValue = *(float*)_Data;
float AOutValue = ( AInValue > Max ) ?

Max :
( AInValue < Min ) ? Min : AInValue;
}
public:
Limit( T AMin, T AMax ) :
Min( AMin ),
Max( AMax )
{
}
};
//---------------------------------------------------------------------------
template<typename T> class Limit_Enable
{
public:
public:
T Min = 0.0;
T Max = 1.0;
public:
{
if( ! Enabled )
{
return;
}
float AInValue = *(float*)_Data;
float AOutValue = ( AInValue > Max ) ?

Max :
( AInValue < Min ) ? Min : AInValue;
}
public:
Limit_Enable( T AMin, T AMax ) :
Min( AMin ),
Max( AMax )
{
}
};
//---------------------------------------------------------------------------
enum CompareValueType { ctEqual, ctNotEqual, ctBigger, ctSmaller,
ctBiggerOrEqual, ctSmallerOrEqual };
//---------------------------------------------------------------------------
template<typename T> class CompareValue
{
public:
public:
T Value;
protected:
T FCurrentValue;
public:
CompareValueType CompareType : 3;
bool Enabled : 1;
bool OnlyChanged : 1;
bool IgnoreCase : 1; // Added in root to save space!
protected:
bool FOutputValue : 1;
bool FStarted : 1;
bool FProcessedOnce : 1;
public:
{
if( OnlyChanged )
if( Value == AValue )
return;
Value = AValue;
ProcessOutput();
}
protected:
bool PerformCompare( T ACurrentValue, T AValue )
{
switch( CompareType )
{
default:
case ctEqual:
return ( ACurrentValue == AValue );
case ctNotEqual:
return ( ACurrentValue != AValue );
case ctBigger:
return ( ACurrentValue > AValue );
case ctSmaller:
return ( ACurrentValue < AValue );
case ctBiggerOrEqual:
return ( ACurrentValue >= AValue );
case ctSmallerOrEqual:
return ( ACurrentValue <= AValue );
}
}
protected:
void ProcessOutput()
{
if( ! Enabled )
return;
// Serial.print( FCurrentValue ); Serial.print( " ? " );

Serial.println( Value );
bool ABoolValue = PerformCompare( FCurrentValue, Value );
if( ! OnlyChanged )
if( FOutputValue )
{
FOutputValue = false;
OutputPin.SendValue( false );
}
if( ( !FStarted ) || ( FOutputValue != ABoolValue ) )

{
OutputPin.Notify( &ABoolValue );
FOutputValue = ABoolValue;
FStarted = true;
}
}
public:
{
T AValue = *(T*)_Data;
if( OnlyChanged )
if( FProcessedOnce )
if( AValue == FCurrentValue )
return;
FCurrentValue = AValue;
FProcessedOnce = true;
ProcessOutput();
}
public:
inline void SystemStart()
{
if( ! FStarted )
OutputPin.SendValue<bool>( false );
public:
CompareValue( T AInitialValue ) :
Value( AInitialValue ),
FCurrentValue( AInitialValue ),
CompareType( ctEqual ),
Enabled( true ),
OnlyChanged( true ),
IgnoreCase( false ),
FOutputValue( false ),
FStarted( false ),
FProcessedOnce( false )
{
}
};
//---------------------------------------------------------------------------
template<> bool CompareValue<char>::PerformCompare( char ACurrentValue, char
AValue )
{
if( IgnoreCase )
{
ACurrentValue = toupper( ACurrentValue );
AValue = toupper( AValue );
}
{
default:
case ctEqual:
case ctNotEqual:
case ctBigger:
case ctSmaller:
}
}
//---------------------------------------------------------------------------
template<> bool CompareValue<Mitov::String>::PerformCompare( Mitov::String
ACurrentValue, Mitov::String AValue )
{
if( IgnoreCase )
{
ACurrentValue.toUpperCase();
AValue.toUpperCase();
}
{
default:
case ctEqual:
case ctNotEqual:
case ctBigger:
case ctSmaller:
}
}
//---------------------------------------------------------------------------
template<> void CompareValue<Mitov::String>::InputPin_o_Receive( void
*_Data )
{
Mitov::String AValue = Mitov::String( (char*)_Data );
if( OnlyChanged )
return;
ProcessOutput();
}
//---------------------------------------------------------------------------
class CompareDateTimeValue
{
public:
public:
Mitov::TDateTime Value;
protected:
Mitov::TDateTime FCurrentValue;
public:
TDateTimeCompareItems Items;
public:
CompareValueType CompareType : 3;
bool Enabled : 1;
protected:
bool FStarted : 1;
public:
void SetValue( Mitov::TDateTime AValue )
{
if( OnlyChanged )
if( Value == AValue )
return;
Value = AValue;
ProcessOutput();
}
protected:
bool PerformCompare( Mitov::TDateTime ACurrentValue, Mitov::TDateTime
AValue )
{
{
default:
case ctEqual:
return ( ACurrentValue.IsEqual( AValue, Items ) );
case ctNotEqual:
return ( ! ACurrentValue.IsEqual( AValue, Items ) );
case ctBigger:
return ( ACurrentValue.IsBigger( AValue, Items ) );
case ctSmaller:
return ( AValue.IsBigger( ACurrentValue, Items ) );
return ( ACurrentValue.IsBiggerOrEqual( AValue, Items ) );
return ( AValue.IsBiggerOrEqual( ACurrentValue, Items ) );
}
}
protected:
{
if( ! Enabled )
return;
// Serial.print( FCurrentValue ); Serial.print( " ? " );

Serial.println( Value );
bool ABoolValue = PerformCompare( FCurrentValue, Value );
if( ! OnlyChanged )
if( FOutputValue )
{
}

{
FStarted = true;
}
}
public:
{
Mitov::TDateTime AValue = *(Mitov::TDateTime*)_Data;
if( OnlyChanged )
return;
ProcessOutput();
}
public:
{
if( ! FStarted )
public:
CompareDateTimeValue() :
CompareType( ctEqual ),
Enabled( true ),
FStarted( false ),
{
}
};
//---------------------------------------------------------------------------
template<typename T> class CompareRange
{
public:
public:
class TValueRange
{
public:
T Min;
T Max;
public:
TValueRange( T AMin, T AMax ) :
Min( AMin ),
Max( AMax )
{
}
};
public:
TValueRange Range;
protected:
T FCurrentValue;
public:
bool Enabled : 1;
bool IsOutsideRange : 1;
bool IncludeLimits : 1;
protected:
bool FStarted : 1;
public:
{
if( ! Enabled )
return;
bool ABoolValue = PerformCompare( FCurrentValue );
if( ! OnlyChanged )
if( FOutputValue )
{
}

{
FStarted = true;
}
}
protected:
bool PerformCompare( T ACurrentValue )
{
if( IsOutsideRange )
{
if( IncludeLimits )
{
if( ACurrentValue >= Range.Max )
return true;
return ( ACurrentValue <= Range.Min );

}
if( ACurrentValue > Range.Max )

return true;
return ( ACurrentValue < Range.Min );

}
if( IncludeLimits )
{
if( ACurrentValue >= Range.Max )
return false;
return ! ( ACurrentValue <= Range.Min );

}
if( ACurrentValue > Range.Max )

return false;
return ! ( ACurrentValue < Range.Min );

}
public:
{
T AValue = *(T*)_Data;
if( OnlyChanged )
return;
ProcessOutput();
}
public:
{
if( ! FStarted )
public:
CompareRange( T AMin, T AMax ) :
Range( AMin, AMax ),
FCurrentValue( 0 ),
Enabled( true ),
IsOutsideRange( false ),
IncludeLimits( false ),
FStarted( false ),
{
}
};
//---------------------------------------------------------------------------
template<> bool CompareRange<char>::PerformCompare( char ACurrentValue )
{
char AMinValue = Range.Min;
char AMaxValue = Range.Max;
if( IgnoreCase )
{
ACurrentValue = toupper( ACurrentValue );
AMinValue = toupper( AMinValue );
AMaxValue = toupper( AMaxValue );
}
{
if( IncludeLimits )
{
if( ACurrentValue >= AMaxValue )
return true;
return ( ACurrentValue <= AMinValue );

}
if( ACurrentValue > AMaxValue )

return true;
return ( ACurrentValue < AMinValue );

}
if( IncludeLimits )
{
if( ACurrentValue >= AMaxValue )
return false;
return ! ( ACurrentValue <= AMinValue );

}
if( ACurrentValue > AMaxValue )

return false;
return ! ( ACurrentValue < AMinValue );

}
//---------------------------------------------------------------------------
class CompareDateTimeRange
{
public:
public:
class TValueRange
{
public:
Mitov::TDateTime Min;
Mitov::TDateTime Max = 100.0;
};
public:
TValueRange Range;
public:
TDateTimeCompareItems Items;
protected:
Mitov::TDateTime FCurrentValue;
public:
bool Enabled : 1;
bool IsOutsideRange : 1;
bool IncludeLimits : 1;
protected:
bool FStarted : 1;
public:
{
if( ! Enabled )
return;
bool ABoolValue = PerformCompare( FCurrentValue );
if( ! OnlyChanged )
if( FOutputValue )
{
}

{
FStarted = true;
}
}
protected:
bool PerformCompare( Mitov::TDateTime ACurrentValue )
{
{
if( IncludeLimits )
{
if( ACurrentValue.IsBiggerOrEqual( Range.Max, Items )
)
return true;
return ( Range.Min.IsBigger( ACurrentValue,

Items ) );
}
if( ACurrentValue.IsBigger( Range.Max, Items ) )

return true;
return ( Range.Min.IsBiggerOrEqual( ACurrentValue, Items )

);
}
if( IncludeLimits )
{
if( ACurrentValue.IsBiggerOrEqual( Range.Max, Items ) )
return false;
return ! ( Range.Min.IsBigger( ACurrentValue, Items ) );

}
if( ACurrentValue.IsBigger( Range.Max, Items ) )

return false;
return ! ( Range.Min.IsBiggerOrEqual( ACurrentValue, Items ) );

}
public:
{
Mitov::TDateTime AValue = *(Mitov::TDateTime*)_Data;
if( OnlyChanged )
return;
ProcessOutput();
}
public:
{
if( ! FStarted )
public:
CompareDateTimeRange() :
Enabled( true ),
IsOutsideRange( false ),
IncludeLimits( false ),
FStarted( false ),
{
}
};
//---------------------------------------------------------------------------
class AveragePeriod
{
public:
public:
unsigned long Period = 1000;
protected:
float FSum = 0.0f;
unsigned long FCount = 0;
unsigned long FLastTime = 0;
public:
{
FSum += *(float *)_Data;
++FCount;
}
public:
inline void SystemLoopBegin( unsigned long currentMicros )
{
if( currentMicros - FLastTime < Period )
return;
if( ! FCount )
return;
float AValue = FSum / FCount;
FSum = 0.0;
FCount = 0;
FLastTime = currentMicros;
OutputPin.Notify( &AValue );
}
};
//---------------------------------------------------------------------------
template<typename T_IMPLEMENTATION_CLASS, typename T, int C_NUM_INPUTS> class
MultiInputMathOperation
{
public:
public:
bool Enabled : 1;
protected:
bool FModified : 1;
bool FPopulated : 1;
T FLastOutput;
T FValues[ C_NUM_INPUTS ] = { 0 };
public:
void InputPins_o_Receive( int AIndex, void *_Data )
{
FValues[ AIndex ] = *(T *)_Data;
FModified = true;
}
public:
{
CalculateSendOutput();
}
inline void SystemLoopEnd( unsigned long currentMicros )

{
CalculateSendOutput();
}
protected:
void CalculateSendOutput()
{
// Serial.println( "CalculateSendOutput+++" );
T AValue = T_IMPLEMENTATION_CLASS::CalculateOutput( FValues,
C_NUM_INPUTS );
// Serial.println( AValue );
if( FModified )
if( FLastOutput == AValue )
return;
FLastOutput = AValue;
FPopulated = true;
FModified = false;
OutputPin.SendValue( AValue ); // Use Send Value for String

Compatibility!
/*
T_OUT AValue = CalculateOutput();
// Serial.println( AValue );
if( ! AFromStart )
if( FLastOutput == AValue )
return;

Compatibility!
FModified = false;
*/
}
public:
void ClockInputPin_o_Receive( void *_Data )
{
T AValue = T_IMPLEMENTATION_CLASS::CalculateOutput( FValues,
C_NUM_INPUTS );
// if( FLastOutput == AValue )
// return;

Compatibility!
FModified = false;
}
public:
MultiInputMathOperation() :
Enabled( true ),
FModified( false ),
FPopulated( false )
{
}
};
//---------------------------------------------------------------------------
template<typename T> class Add
{
public:
static T CalculateOutput( T *AInputValues, uint16_t ANumInputs )
{
T AValue = 0;
for( int i = 0; i < ANumInputs; ++i )
AValue += AInputValues[ i ];
return AValue;
}
};
//---------------------------------------------------------------------------
template<typename T> class Multiply
{
public:
static T CalculateOutput( T *AInputValues, uint16_t ANumInputs )
{
T AValue = 1;
for( int i = 0; i < ANumInputs; ++i )
AValue *= AInputValues[ i ];
return AValue;
}
};
//---------------------------------------------------------------------------
class ValueRange
{
public:
float Min = 0.0f;
float Max = 1.0f;
};
//---------------------------------------------------------------------------
class MapRange
{
public:
public:
ValueRange InputRange;
ValueRange OutputRange;
public:
{
float AValue = *(float*)_Data;
float AOutValue = Func::MapRange( AValue, InputRange.Min,

InputRange.Max, OutputRange.Min, OutputRange.Max );
}
};
//---------------------------------------------------------------------------
class MapRange_Enable
{
public:
public:
public:
{
if( ! Enabled )
{
return;
}
float AOutValue = Func::MapRange( AValue, InputRange.Min,

InputRange.Max, OutputRange.Min, OutputRange.Max );
}
};
//---------------------------------------------------------------------------
class AnalogDeadZone
{
public:
public:
float Value = 0.5f;
float Span = 0.1f;
public:
{
float AFalfSpan = Span / 2;
if( AValue > Value + AFalfSpan )

AValue -= AFalfSpan;
else if( AValue < Value - AFalfSpan )

AValue += AFalfSpan;
else
AValue = Value;
}
public:
{
OutputPin.Notify( &Value );
}
};
//---------------------------------------------------------------------------
class AnalogDeadZone_Enable
{
public:
public:
float Value = 0.5f;

float Span = 0.1f;
public:
{
if( ! Enabled )
{
return;
}


else
AValue = Value;
}
public:
{
OutputPin.Notify( &Value );
}
};
//---------------------------------------------------------------------------
class AnalogDeadZoneScaled
{
public:
public:
float Value = 0.5f;
float Span = 0.1f;
public:
{


else
AValue = Value;
float AOutValue = Func::MapRange( AValue, InputRange.Min +

AFalfSpan, InputRange.Max - AFalfSpan, OutputRange.Min, OutputRange.Max );
}
public:
{
float AOutValue = Func::MapRange( Value, InputRange.Min +

}
};
//---------------------------------------------------------------------------
class AnalogDeadZoneScaled_Enable
{
public:
public:
float Value = 0.5f;
float Span = 0.1f;
public:
{
if( ! Enabled )
{
return;
}


else
AValue = Value;
float AOutValue = Func::MapRange( AValue, InputRange.Min +

}
public:
{
float AOutValue = Func::MapRange( Value, InputRange.Min +

}
};
//---------------------------------------------------------------------------
template<typename T> class RaiseToPower
{
public:
{
return pow( AInValue, AParamValue );
}
};
//---------------------------------------------------------------------------
class Sine
{
public:
inline static float CalculateOutput( float AInValue )
{
return sin( AInValue );
}
};
//---------------------------------------------------------------------------
class Cosine
{
public:
{
return cos( AInValue );
}
};
//---------------------------------------------------------------------------
class RadToDegrees
{
public:
{
return AInValue * 180 / MITOV_PI;
}
};
//---------------------------------------------------------------------------
class DegreesToRad
{
public:
{
return AInValue * MITOV_PI / 180;
}
};
//---------------------------------------------------------------------------
template<typename T> class AndValue
{
public:
{
return AInValue & AParamValue;
}
};
//---------------------------------------------------------------------------
template<typename T> class OrValue
{
public:
{
return AInValue | AParamValue;
}
};
//---------------------------------------------------------------------------
template<typename T> class XorValue
{
public:
{
return AInValue ^ AParamValue;
}
};
//---------------------------------------------------------------------------
template<typename T> class NotValue
{
public:
{
return ~ AInValue;
}
};
//---------------------------------------------------------------------------
template<typename T> class Accumulate
{
public:
public:
bool Enabled : 1;
protected:
bool FHasTime : 1;
public:
T InitialValue = 0;
public:
void SetInitialValue( float AValue )
{
if( InitialValue == AValue )
return;
InitialValue = AValue;
OutputPin.Notify( &InitialValue );
}
protected:
T FilterValue( T AValue )
{
unsigned long ATime = micros();
if( ! FHasTime )
{
FHasTime = true;
return InitialValue;
}
float dT = ( ATime - FLastTime ) / 1000000.0f;
InitialValue += AValue * dT;
}
public:
{
if( ! Enabled )
{
return;
}
T AOutValue = FilterValue( *(T*)_Data );
}
public:
Accumulate() :
Enabled( true ),
FHasTime( false )
{
}
};
//---------------------------------------------------------------------------
class AccumulateAngle
{
public:
TAngleUnits Units = auDegree;
public:
public:
bool Enabled : 1;
protected:
bool FHasTime : 1;
public:
float InitialValue = 0.0;
public:
void SetInitialValue( float AValue )
{
if( InitialValue == AValue )
return;
InitialValue = AValue;
OutputPin.Notify( &InitialValue );
}
protected:
float FilterValue( float AValue )
{
if( ! FHasTime )
{
FHasTime = true;
}
unsigned long ATime = micros();

float dT = ( ATime - FLastTime ) / 1000000.0f;
InitialValue += AValue * dT;
switch( Units )
{
case auDegree:
InitialValue = posmod( InitialValue, 360.0f );
break;
case auRadians:
InitialValue = posmod( InitialValue, 2 * PI );
break;
case auNormalized:
InitialValue = posmod( InitialValue, 1.0f );
break;
}
public:
{
if( ! Enabled )
{
return;
}
float AOutValue = FilterValue( *(float*)_Data );
}
public:
AccumulateAngle() :
Enabled( true ),
FHasTime( false )
{
}
};
//---------------------------------------------------------------------------
#undef Abs
#undef Min
#undef Max
}
#endif
// This software is supplied under the terms of a license agreement or //

// Copyright(c) 2002-2018 Mitov Software. All Rights Reserved. ///
/ This software is supplied under the terms of a license agreement or //

// Copyright(c) 2002-2018 Mitov Software. All Rights Reserved. //

Grua 02

Загружено:

Сведения о документе

Оригинальное название

Авторское право

Доступные форматы

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Доступные форматы

Grua 02

Загружено:

Авторское право:

Доступные форматы

////////////////////////////////////////////////////////////////////////////////

T AOutValue = ( *(T*)_Data ) / Value;

return AParamValue / AInValue;

float AOutValue = ( AInValue > Max ) ?

float AInValue = *(float*)_Data;

float AOutValue = ( AInValue > Max ) ?

// Serial.print( FCurrentValue ); Serial.print( " ? " );

bool ABoolValue = PerformCompare( FCurrentValue, Value );

if( ( !FStarted ) || ( FOutputValue != ABoolValue ) )

// Serial.print( FCurrentValue ); Serial.print( " ? " );

bool ABoolValue = PerformCompare( FCurrentValue, Value );

if( ( !FStarted ) || ( FOutputValue != ABoolValue ) )

bool ABoolValue = PerformCompare( FCurrentValue );

if( ( !FStarted ) || ( FOutputValue != ABoolValue ) )

return ( ACurrentValue <= Range.Min );

if( ACurrentValue > Range.Max )

return ( ACurrentValue < Range.Min );

return ! ( ACurrentValue <= Range.Min );

if( ACurrentValue > Range.Max )

return ! ( ACurrentValue < Range.Min );

return ( ACurrentValue <= AMinValue );

if( ACurrentValue > AMaxValue )

return ( ACurrentValue < AMinValue );

return ! ( ACurrentValue <= AMinValue );

if( ACurrentValue > AMaxValue )

return ! ( ACurrentValue < AMinValue );

bool ABoolValue = PerformCompare( FCurrentValue );

if( ( !FStarted ) || ( FOutputValue != ABoolValue ) )

return ( Range.Min.IsBigger( ACurrentValue,

if( ACurrentValue.IsBigger( Range.Max, Items ) )

return ( Range.Min.IsBiggerOrEqual( ACurrentValue, Items )

return ! ( Range.Min.IsBigger( ACurrentValue, Items ) );

if( ACurrentValue.IsBigger( Range.Max, Items ) )

return ! ( Range.Min.IsBiggerOrEqual( ACurrentValue, Items ) );

float AValue = FSum / FCount;

inline void SystemLoopEnd( unsigned long currentMicros )

OutputPin.SendValue( AValue ); // Use Send Value for String

OutputPin.SendValue( AValue ); // Use Send Value for String

OutputPin.SendValue( AValue ); // Use Send Value for String

float AOutValue = Func::MapRange( AValue, InputRange.Min,

float AValue = *(float*)_Data;

float AOutValue = Func::MapRange( AValue, InputRange.Min,

float AFalfSpan = Span / 2;

if( AValue > Value + AFalfSpan )

else if( AValue < Value - AFalfSpan )

float Value = 0.5f;

float AValue = *(float*)_Data;

float AFalfSpan = Span / 2;

if( AValue > Value + AFalfSpan )

else if( AValue < Value - AFalfSpan )

float AFalfSpan = Span / 2;

if( AValue > Value + AFalfSpan )

else if( AValue < Value - AFalfSpan )

float AOutValue = Func::MapRange( AValue, InputRange.Min +

float AOutValue = Func::MapRange( Value, InputRange.Min +

float AValue = *(float*)_Data;

float AFalfSpan = Span / 2;

if( AValue > Value + AFalfSpan )

else if( AValue < Value - AFalfSpan )

float AOutValue = Func::MapRange( AValue, InputRange.Min +

float AOutValue = Func::MapRange( Value, InputRange.Min +

T AOutValue = FilterValue( *(T*)_Data );

unsigned long ATime = micros();

T AOutValue = ( (T)_Data ) / Value;

float AInValue = (float)_Data;

float AValue = (float)_Data;

float AValue = (float)_Data;

float AValue = (float)_Data;

T AOutValue = FilterValue( (T)_Data );

float AOutValue = FilterValue( (float)_Data );