//----------------------------------------------
//
//         Sketch Generated by Visuino
//               www.visuino.com
//           Version 8.0.0.101
//
//------------------ Source --------------------
//
// test quad.visuino
//
//----------------------------------------------

#define VISUINO_ARDUINO_NANO
#define __VISUINO_SERVO_LIB__

#include <OpenWire.h>
#include <Mitov.h>
#include <Mitov_StandardSerial.h>
#include <Wire.h>
#include <Mitov_Basic_I2C.h>
#include <Mitov_MPU6050.h>
#include <Mitov_CompassHeading.h>
#include <Mitov_HMC5883_Compass.h>
#include <Mitov_BinaryGenerators.h>
#include <Mitov_LogicGates.h>
#include <Mitov_Math.h>
#include <Mitov_SetValueItems.h>
#include <Mitov_Timing.h>
#ifndef VISUINO_ESP32
#include <Servo.h>  // The 'Servo' Arduino library https://github.com/arduino-libraries/Servo needs to be installed trough the Arduino IDE for this Scetch to compile!
#endif // VISUINO_ESP32
#include <Mitov_Servo.h>
#include <Mitov_LogicFlipFlops.h>
#include <Mitov_GPS.h>
#include <Mitov_CommonMux.h>
#include <Mitov_Counter.h>
#include <Mitov_Button.h>
#include <Mitov_CommonDemux.h>


// Shared Component Member Variables

namespace ComponentVariables
{
class
{
public:
  uint32_t Value37 : 12;
  uint32_t Value43 : 12;
  uint32_t Value39 : 2;
  bool Value1 : 1;
  bool Value2 : 1;
  bool Value3 : 1;
  bool Value4 : 1;
  bool Value5 : 1;
  bool Value6 : 1;
  bool Value7 : 1;
  bool Value8 : 1;
  bool Value9 : 1;
  bool Value10 : 1;
  bool Value11 : 1;
  bool Value12 : 1;
  bool Value13 : 1;
  bool Value14 : 1;
  bool Value15 : 1;
  bool Value16 : 1;
  bool Value17 : 1;
  bool Value18 : 1;
  bool Value19 : 1;
  bool Value20 : 1;
  bool Value21 : 1;
  bool Value22 : 1;
  bool Value23 : 1;
  bool Value24 : 1;
  bool Value25 : 1;
  bool Value26 : 1;
  bool Value27 : 1;
  bool Value28 : 1;
  bool Value29 : 1;
  bool Value30 : 1;
  bool Value31 : 1;
  uint32_t Value32 : 1;
  bool Value33 : 1;
  bool Value34 : 1;
  bool Value35 : 1;
  bool Value36 : 1;
  bool Value38 : 1;
  bool Value40 : 1;
  bool Value41 : 1;
  bool Value42 : 1;
  bool Value44 : 1;
  uint32_t Value45 : 1;
  bool Value46 : 1;
  bool Value47 : 1;
  bool Value48 : 1;
  bool Value49 : 1;
  bool Value50 : 1;
  bool Value51 : 1;
  bool Value52 : 1;
  bool Value53 : 1;
  bool Value54 : 1;
  bool Value55 : 1;
  bool Value56 : 1;
  bool Value57 : 1;
  bool Value58 : 1;
  bool Value59 : 1;
  bool Value60 : 1;

} BitFields;

class Variable37
{
public:
  inline static uint32_t GetValue() { return BitFields.Value37; }
  inline static void SetValue( uint32_t AValue ) { BitFields.Value37 = AValue; }

};

class Variable43
{
public:
  inline static uint32_t GetValue() { return BitFields.Value43; }
  inline static void SetValue( uint32_t AValue ) { BitFields.Value43 = AValue; }

};

class Variable39
{
public:
  inline static uint32_t GetValue() { return BitFields.Value39; }
  inline static void SetValue( uint32_t AValue ) { BitFields.Value39 = AValue; }

};

class Variable1
{
public:
  inline static bool GetValue() { return BitFields.Value1; }
  inline static void SetValue( bool AValue ) { BitFields.Value1 = AValue; }

};

class Variable2
{
public:
  inline static bool GetValue() { return BitFields.Value2; }
  inline static void SetValue( bool AValue ) { BitFields.Value2 = AValue; }

};

class Variable3
{
public:
  inline static bool GetValue() { return BitFields.Value3; }
  inline static void SetValue( bool AValue ) { BitFields.Value3 = AValue; }

};

class Variable4
{
public:
  inline static bool GetValue() { return BitFields.Value4; }
  inline static void SetValue( bool AValue ) { BitFields.Value4 = AValue; }

};

class Variable5
{
public:
  inline static bool GetValue() { return BitFields.Value5; }
  inline static void SetValue( bool AValue ) { BitFields.Value5 = AValue; }

};

class Variable6
{
public:
  inline static bool GetValue() { return BitFields.Value6; }
  inline static void SetValue( bool AValue ) { BitFields.Value6 = AValue; }

};

class Variable7
{
public:
  inline static bool GetValue() { return BitFields.Value7; }
  inline static void SetValue( bool AValue ) { BitFields.Value7 = AValue; }

};

class Variable8
{
public:
  inline static bool GetValue() { return BitFields.Value8; }
  inline static void SetValue( bool AValue ) { BitFields.Value8 = AValue; }

};

class Variable9
{
public:
  inline static bool GetValue() { return BitFields.Value9; }
  inline static void SetValue( bool AValue ) { BitFields.Value9 = AValue; }

};

class Variable10
{
public:
  inline static bool GetValue() { return BitFields.Value10; }
  inline static void SetValue( bool AValue ) { BitFields.Value10 = AValue; }

};

class Variable11
{
public:
  inline static bool GetValue() { return BitFields.Value11; }
  inline static void SetValue( bool AValue ) { BitFields.Value11 = AValue; }

};

class Variable12
{
public:
  inline static bool GetValue() { return BitFields.Value12; }
  inline static void SetValue( bool AValue ) { BitFields.Value12 = AValue; }

};

class Variable13
{
public:
  inline static bool GetValue() { return BitFields.Value13; }
  inline static void SetValue( bool AValue ) { BitFields.Value13 = AValue; }

};

class Variable14
{
public:
  inline static bool GetValue() { return BitFields.Value14; }
  inline static void SetValue( bool AValue ) { BitFields.Value14 = AValue; }

};

class Variable15
{
public:
  inline static bool GetValue() { return BitFields.Value15; }
  inline static void SetValue( bool AValue ) { BitFields.Value15 = AValue; }

};

class Variable16
{
public:
  inline static bool GetValue() { return BitFields.Value16; }
  inline static void SetValue( bool AValue ) { BitFields.Value16 = AValue; }

};

class Variable17
{
public:
  inline static bool GetValue() { return BitFields.Value17; }
  inline static void SetValue( bool AValue ) { BitFields.Value17 = AValue; }

};

class Variable18
{
public:
  inline static bool GetValue() { return BitFields.Value18; }
  inline static void SetValue( bool AValue ) { BitFields.Value18 = AValue; }

};

class Variable19
{
public:
  inline static bool GetValue() { return BitFields.Value19; }
  inline static void SetValue( bool AValue ) { BitFields.Value19 = AValue; }

};

class Variable20
{
public:
  inline static bool GetValue() { return BitFields.Value20; }
  inline static void SetValue( bool AValue ) { BitFields.Value20 = AValue; }

};

class Variable21
{
public:
  inline static bool GetValue() { return BitFields.Value21; }
  inline static void SetValue( bool AValue ) { BitFields.Value21 = AValue; }

};

class Variable22
{
public:
  inline static bool GetValue() { return BitFields.Value22; }
  inline static void SetValue( bool AValue ) { BitFields.Value22 = AValue; }

};

class Variable23
{
public:
  inline static bool GetValue() { return BitFields.Value23; }
  inline static void SetValue( bool AValue ) { BitFields.Value23 = AValue; }

};

class Variable24
{
public:
  inline static bool GetValue() { return BitFields.Value24; }
  inline static void SetValue( bool AValue ) { BitFields.Value24 = AValue; }

};

class Variable25
{
public:
  inline static bool GetValue() { return BitFields.Value25; }
  inline static void SetValue( bool AValue ) { BitFields.Value25 = AValue; }

};

class Variable26
{
public:
  inline static bool GetValue() { return BitFields.Value26; }
  inline static void SetValue( bool AValue ) { BitFields.Value26 = AValue; }

};

class Variable27
{
public:
  inline static bool GetValue() { return BitFields.Value27; }
  inline static void SetValue( bool AValue ) { BitFields.Value27 = AValue; }

};

class Variable28
{
public:
  inline static bool GetValue() { return BitFields.Value28; }
  inline static void SetValue( bool AValue ) { BitFields.Value28 = AValue; }

};

class Variable29
{
public:
  inline static bool GetValue() { return BitFields.Value29; }
  inline static void SetValue( bool AValue ) { BitFields.Value29 = AValue; }

};

class Variable30
{
public:
  inline static bool GetValue() { return BitFields.Value30; }
  inline static void SetValue( bool AValue ) { BitFields.Value30 = AValue; }

};

class Variable31
{
public:
  inline static bool GetValue() { return BitFields.Value31; }
  inline static void SetValue( bool AValue ) { BitFields.Value31 = AValue; }

};

class Variable32
{
public:
  inline static uint32_t GetValue() { return BitFields.Value32; }
  inline static void SetValue( uint32_t AValue ) { BitFields.Value32 = AValue; }

};

class Variable33
{
public:
  inline static bool GetValue() { return BitFields.Value33; }
  inline static void SetValue( bool AValue ) { BitFields.Value33 = AValue; }

};

class Variable34
{
public:
  inline static bool GetValue() { return BitFields.Value34; }
  inline static void SetValue( bool AValue ) { BitFields.Value34 = AValue; }

};

class Variable35
{
public:
  inline static bool GetValue() { return BitFields.Value35; }
  inline static void SetValue( bool AValue ) { BitFields.Value35 = AValue; }

};

class Variable36
{
public:
  inline static bool GetValue() { return BitFields.Value36; }
  inline static void SetValue( bool AValue ) { BitFields.Value36 = AValue; }

};

class Variable38
{
public:
  inline static bool GetValue() { return BitFields.Value38; }
  inline static void SetValue( bool AValue ) { BitFields.Value38 = AValue; }

};

class Variable40
{
public:
  inline static bool GetValue() { return BitFields.Value40; }
  inline static void SetValue( bool AValue ) { BitFields.Value40 = AValue; }

};

class Variable41
{
public:
  inline static bool GetValue() { return BitFields.Value41; }
  inline static void SetValue( bool AValue ) { BitFields.Value41 = AValue; }

};

class Variable42
{
public:
  inline static bool GetValue() { return BitFields.Value42; }
  inline static void SetValue( bool AValue ) { BitFields.Value42 = AValue; }

};

class Variable44
{
public:
  inline static bool GetValue() { return BitFields.Value44; }
  inline static void SetValue( bool AValue ) { BitFields.Value44 = AValue; }

};

class Variable45
{
public:
  inline static uint32_t GetValue() { return BitFields.Value45; }
  inline static void SetValue( uint32_t AValue ) { BitFields.Value45 = AValue; }

};

class Variable46
{
public:
  inline static bool GetValue() { return BitFields.Value46; }
  inline static void SetValue( bool AValue ) { BitFields.Value46 = AValue; }

};

class Variable47
{
public:
  inline static bool GetValue() { return BitFields.Value47; }
  inline static void SetValue( bool AValue ) { BitFields.Value47 = AValue; }

};

class Variable48
{
public:
  inline static bool GetValue() { return BitFields.Value48; }
  inline static void SetValue( bool AValue ) { BitFields.Value48 = AValue; }

};

class Variable49
{
public:
  inline static bool GetValue() { return BitFields.Value49; }
  inline static void SetValue( bool AValue ) { BitFields.Value49 = AValue; }

};

class Variable50
{
public:
  inline static bool GetValue() { return BitFields.Value50; }
  inline static void SetValue( bool AValue ) { BitFields.Value50 = AValue; }

};

class Variable51
{
public:
  inline static bool GetValue() { return BitFields.Value51; }
  inline static void SetValue( bool AValue ) { BitFields.Value51 = AValue; }

};

class Variable52
{
public:
  inline static bool GetValue() { return BitFields.Value52; }
  inline static void SetValue( bool AValue ) { BitFields.Value52 = AValue; }

};

class Variable53
{
public:
  inline static bool GetValue() { return BitFields.Value53; }
  inline static void SetValue( bool AValue ) { BitFields.Value53 = AValue; }

};

class Variable54
{
public:
  inline static bool GetValue() { return BitFields.Value54; }
  inline static void SetValue( bool AValue ) { BitFields.Value54 = AValue; }

};

class Variable55
{
public:
  inline static bool GetValue() { return BitFields.Value55; }
  inline static void SetValue( bool AValue ) { BitFields.Value55 = AValue; }

};

class Variable56
{
public:
  inline static bool GetValue() { return BitFields.Value56; }
  inline static void SetValue( bool AValue ) { BitFields.Value56 = AValue; }

};

class Variable57
{
public:
  inline static bool GetValue() { return BitFields.Value57; }
  inline static void SetValue( bool AValue ) { BitFields.Value57 = AValue; }

};

class Variable58
{
public:
  inline static bool GetValue() { return BitFields.Value58; }
  inline static void SetValue( bool AValue ) { BitFields.Value58 = AValue; }

};

class Variable59
{
public:
  inline static bool GetValue() { return BitFields.Value59; }
  inline static void SetValue( bool AValue ) { BitFields.Value59 = AValue; }

};

class Variable60
{
public:
  inline static bool GetValue() { return BitFields.Value60; }
  inline static void SetValue( bool AValue ) { BitFields.Value60 = AValue; }

};

} // ComponentVariables

// Arduino Constant Declarations

namespace VisuinoConstants
{
class FloatValue5
{
public:
    inline static constexpr float GetValue() { return 358; }
};

class FloatValue21
{
public:
    inline static constexpr float GetValue() { return 89; }
};

class FloatValue13
{
public:
    inline static constexpr float GetValue() { return 270; }
};

class FloatValue11
{
public:
    inline static constexpr float GetValue() { return 220; }
};

class FloatValue6
{
public:
    inline static constexpr float GetValue() { return 1; }
};

class FloatValue7
{
public:
    inline static constexpr float GetValue() { return 3; }
};

class FloatValue12
{
public:
    inline static constexpr float GetValue() { return 90; }
};

class FloatValue10
{
public:
    inline static constexpr float GetValue() { return 140; }
};

class FloatValue15
{
public:
    inline static constexpr float GetValue() { return 300; }
};

class FloatValue16
{
public:
    inline static constexpr float GetValue() { return 15; }
};

class FloatValue17
{
public:
    inline static constexpr float GetValue() { return 345; }
};

class FloatValue18
{
public:
    inline static constexpr float GetValue() { return 179; }
};

class FloatValue14
{
public:
    inline static constexpr float GetValue() { return 60; }
};

class FloatValue1
{
public:
    inline static constexpr float GetValue() { return 0; }
};

class FloatValue4
{
public:
    inline static constexpr float GetValue() { return 0.0599999986588955; }
};

class FloatValue19
{
public:
    inline static constexpr float GetValue() { return 181; }
};

class FloatValue0
{
public:
    inline static constexpr float GetValue() { return 1.25; }
};

class FloatValue20
{
public:
    inline static constexpr float GetValue() { return 0.5; }
};

class FloatValue8
{
public:
    inline static constexpr float GetValue() { return 4; }
};

class FloatValue9
{
public:
    inline static constexpr float GetValue() { return 5; }
};

class FloatValue3
{
public:
    inline static constexpr float GetValue() { return -0.0599999986588955; }
};

class FloatValue2
{
public:
    inline static constexpr float GetValue() { return 2; }
};

} // VisuinoConstants

// Pin Call Declarations

namespace PinCalls
{
class PinCallerReceive0
{
public:
  void Notify( void *_Data );

};
class PinCallerReceive1
{
public:
  void Notify( void *_Data );

};
class PinCallerReceive2
{
public:
  void Notify( void *_Data );

};
class PinCallerReceive3
{
public:
  void Notify( void *_Data );

};
class PinCallerReceive4
{
public:
  void Notify( void *_Data );

};
class PinCallerReceive5
{
public:
  void Notify( void *_Data );

};
class PinCallerReceive6
{
public:
  void Notify( void *_Data );

};
class PinCallerReceive7
{
public:
  void Notify( void *_Data );

};
class PinCallerReceive8
{
public:
  void Notify( void *_Data );

};
class PinCallerReceive9
{
public:
  void Notify( void *_Data );

};
class PinCallerReceive10
{
public:
  void Notify( void *_Data );

};
class PinCallerReceive11
{
public:
  void Notify( void *_Data );

};
class PinCallerReceive12
{
public:
  void Notify( void *_Data );

};
class PinCallerReceive13
{
public:
  void Notify( void *_Data );

};
class PinCallerReceive14
{
public:
  void Notify( void *_Data );

};
class PinCallerReceive15
{
public:
  void Notify( void *_Data );

};
class PinCallerReceive16
{
public:
  void Notify( void *_Data );

};
class PinCallerReceive17
{
public:
  void Notify( void *_Data );

};
class PinCallerReceive18
{
public:
  void Notify( void *_Data );

};
class PinCallerReceive19
{
public:
  void Notify( void *_Data );

};
class PinCallerReceive20
{
public:
  void Notify( void *_Data );

};
class PinCallerReceive21
{
public:
  void Notify( void *_Data );

};
class PinCallerReceive22
{
public:
  void Notify( void *_Data );

};
class PinCallerReceive23
{
public:
  void Notify( void *_Data );

};
class PinCallerReceive24
{
public:
  void Notify( void *_Data );

};
class PinCallerReceive25
{
public:
  void Notify( void *_Data );

};
class PinCallerReceive26
{
public:
  void Notify( void *_Data );

};
class PinCallerReceive27
{
public:
  void Notify( void *_Data );

};
class PinCallerReceive28
{
public:
  void Notify( void *_Data );

};
class PinCallerReceive29
{
public:
  void Notify( void *_Data );

};
class PinCallerReceive30
{
public:
  void Notify( void *_Data );

};
class PinCallerReceive31
{
public:
  void Notify( void *_Data );

};
class PinCallerReceive32
{
public:
  void Notify( void *_Data );

};
class PinCallerReceive33
{
public:
  void Notify( void *_Data );

};
class PinCallerReceive34
{
public:
  void Notify( void *_Data );

};
class PinCallerReceive35
{
public:
  void Notify( void *_Data );

};
class PinCallerReceive36
{
public:
  void Notify( void *_Data );

};
class PinCallerReceive37
{
public:
  void Notify( void *_Data );

};
class PinCallerReceive38
{
public:
  void Notify( void *_Data );

};
class PinCallerReceive39
{
public:
  void Notify( void *_Data );

};
class PinCallerReceive40
{
public:
  void Notify( void *_Data );

};
class PinCallerReceive41
{
public:
  void Notify( void *_Data );

};
class PinCallerReceive42
{
public:
  void Notify( void *_Data );

};
class PinCallerReceive43
{
public:
  void Notify( void *_Data );

};
class PinCallerReceive44
{
public:
  void Notify( void *_Data );

};
class PinCallerReceive45
{
public:
  void Notify( void *_Data );

};
class PinCallerReceive46
{
public:
  void Notify( void *_Data );

};
class PinCallerReceive47
{
public:
  void Notify( void *_Data );

};
class PinCallerReceive48
{
public:
  void Notify( void *_Data );

};
} // PinCalls

// Call Chains

namespace CallChains
{
class SendByte1
{
public:
  inline static constexpr uint32_t Count() { return 1; }
  static void Call( uint8_t AValue );

};
class RequestData1
{
public:
  inline static constexpr uint32_t Count() { return 1; }
  static void Call();

};
class TryActive1
{
public:
  inline static constexpr uint32_t Count() { return 5; }
  static void Call( bool & AResult );

};
class TryActive2
{
public:
  inline static constexpr uint32_t Count() { return 0; }
  static void Call( bool & AResult );

};
class SetPinValue1
{
public:
  inline static constexpr uint32_t Count() { return 0; }
  static void Call( uint32_t AIndex );

};
class PeriodicCall1
{
public:
  inline static constexpr uint32_t Count() { return 0; }
  static void Call();

};
} // CallChains

// System Objects Declarations

namespace BoardDeclarations
{
Mitov::TPeriodMicros<1000000, ::CallChains::PeriodicCall1> SystemPeriodMicros_1000000;
} // BoardDeclarations

// Arduino Board Declarations

namespace BoardDeclarations
{
namespace Types
{
typedef Mitov::ArduinoDigitalInputChannel<
  Mitov::ConstantProperty<51, bool, false >, // InitialValue = 0
  Mitov::ConstantProperty<25, bool, false >, // IsOpenDrain = 0
  Mitov::ConstantProperty<25, bool, true >, // IsOutput = -1
  Mitov::ConstantProperty<20, bool, false >, // IsPullDown = 0
  Mitov::ConstantProperty<5, bool, false >, // IsPullUp = False (Default)
  Mitov::DigitalPin_NoImplementation<6 >, // OutputPin
  6 // PIN_DIGITAL
  > ArduinoDigitalChannel_6;
} // Types

namespace Instances
{
Types::ArduinoDigitalChannel_6 ArduinoDigitalChannel_6;
} // Instances

namespace Types
{
typedef Mitov::ArduinoDigitalOutputChannel<
  Mitov::ConstantProperty<22, bool, false >, // IsAnalog = 0
  Mitov::ConstantProperty<24, bool, false >, // IsCombinedInOut = 0
  Mitov::ConstantProperty<21, bool, false >, // IsOpenDrain = 0
  Mitov::ConstantProperty<26, bool, false >, // IsOutput = 0
  Mitov::ConstantProperty<20, bool, false >, // IsPullDown = 0
  Mitov::ConstantProperty<5, bool, true >, // IsPullUp = True
  Mitov::ConstantProperty<23, bool, false >, // IsRawInput = 0
  Mitov::DigitalPin_EmbeddedPinImplementation<6, ::PinCalls::PinCallerReceive0 >, // OutputPin
  8 // PIN_DIGITAL
  > ArduinoDigitalChannel_8;
} // Types

namespace Instances
{
Types::ArduinoDigitalChannel_8 ArduinoDigitalChannel_8;
} // Instances

namespace Types
{
typedef Mitov::ArduinoDigitalInputChannel<
  Mitov::ConstantProperty<51, bool, false >, // InitialValue = 0
  Mitov::ConstantProperty<25, bool, false >, // IsOpenDrain = 0
  Mitov::ConstantProperty<25, bool, true >, // IsOutput = -1
  Mitov::ConstantProperty<20, bool, false >, // IsPullDown = 0
  Mitov::ConstantProperty<5, bool, false >, // IsPullUp = False (Default)
  Mitov::DigitalPin_NoImplementation<6 >, // OutputPin
  13 // PIN_DIGITAL
  > ArduinoDigitalChannel_13;
} // Types

namespace Instances
{
Types::ArduinoDigitalChannel_13 ArduinoDigitalChannel_13;
} // Instances

namespace Types
{
typedef Mitov::SerialPort<
  SERIAL_TYPE, // 0_T_TYPE
  Serial, // 1_C_OBJECT
  Mitov::ConstantProperty<4, uint32_t, 0 >, // AfterSendingDelay = 0 (Default)
  Mitov::ConstantProperty<7, uint32_t, 8 >, // DataBits = 8 (Default)
  Mitov::ConstantProperty<2, bool, true >, // Enabled = True (Default)
  Mitov::ConstantProperty<12, uint32_t, 0 >, // FEndTime = 0
  Mitov::ConstantProperty<10, bool, false >, // FSending = False
  Mitov::GenericPin_EmbeddedPinImplementation<5, ::PinCalls::PinCallerReceive1 >, // OutputPin
  Mitov::ConstantProperty<9, Mitov::TArduinoStandardSerialParity, Mitov::spNone >, // Parity = spNone (Default)
  Mitov::DigitalPin_NoImplementation<3 >, // SendingOutputPin
  Mitov::ConstantProperty<6, uint32_t, 9600 >, // Speed = 9600 (Default)
  Mitov::ConstantProperty<8, uint32_t, 1 > // StopBits = 1 (Default)
   > SerialPort0;
} // Types

namespace Instances
{
Types::SerialPort0 SerialPort0;
} // Instances

namespace Types
{
typedef ::Mitov::ArduinoI2C<
  Wire, // 1_I2C
  Mitov::ConstantProperty<6, uint32_t, 0 >, // Address = 0 (Default)
  Mitov::EmbeddedCallChain<CallChains::RequestData1 >, // INSTANCE_RequestData
  Mitov::EmbeddedCallChain<CallChains::SendByte1 >, // INSTANCE_SendByte
  Mitov::ConstantProperty<5, bool, false >, // IsSlave = False (Default)
  Mitov::GenericPin_NoImplementation<2 >, // OutputPin
  Mitov::ClockPin_NoImplementation<4 > // RequestOutputPin
   > TArduinoI2C1;
} // Types

namespace Instances
{
Types::TArduinoI2C1 TArduinoI2C1;
} // Instances

} // BoardDeclarations

// Declarations

namespace Declarations
{
namespace Types
{
typedef Mitov::MPU6050I2C<
  TwoWire, // 0_I2C_TYPE_PIN
  Wire, // 1_I2C_NAME_PIN
  Mitov::NestedProperty<28, Mitov::MPUAccelerometer<
    Mitov::ConstantProperty<15, Mitov::TArduinoMPU9250AccelerometerRange, Mitov::ar2g >, // FullScaleRange = 0 (Default)
    Mitov::AnalogPin_EmbeddedPinImplementation<12, ::PinCalls::PinCallerReceive2 >, // OutputPins_0
    Mitov::AnalogPin_EmbeddedPinImplementation<13, ::PinCalls::PinCallerReceive3 >, // OutputPins_1
    Mitov::AnalogPin_NoImplementation<14 >, // OutputPins_2
    Mitov::NestedProperty<19, Mitov::MPUOptionalSelfTestSensor<
      Mitov::ConstantProperty<17, bool, true >, // Enabled = True (Default)
      Mitov::ConstantProperty<18, bool, false > // SelfTest = False (Default)
       > >, // X
    Mitov::NestedProperty<23, Mitov::MPUOptionalSelfTestSensor<
      Mitov::ConstantProperty<21, bool, true >, // Enabled = True (Default)
      Mitov::ConstantProperty<22, bool, false > // SelfTest = False (Default)
       > >, // Y
    Mitov::NestedProperty<27, Mitov::MPUOptionalSelfTestSensor<
      Mitov::ConstantProperty<25, bool, true >, // Enabled = True (Default)
      Mitov::ConstantProperty<26, bool, false > // SelfTest = False (Default)
       > > // Z
     > >, // Accelerometer
  Mitov::ConstantProperty<9, uint8_t, 104 >, // Address = 104 (Default)
  Mitov::ConstantProperty<5, bool, false >, // ClockInputPin_o_IsConnected = False
  Mitov::ConstantProperty<8, Mitov::TArduinoMPUClockSource, Mitov::mcsAutoSelect >, // ClockSource = 0 (Default)
  Mitov::ConstantProperty<3, bool, true >, // Enabled = True (Default)
  Mitov::ConstantProperty<71, Mitov::TArduinoMPU6050Filter, Mitov::f_AB_260Hz_GB_256Hz_F_8KHz >, // Filter = 0 (Default)
  Mitov::NestedProperty<66, Mitov::MPUFrameSynchronization<
    Mitov::ConstantProperty<64, bool, false >, // EnableInterrupt = False (Default)
    Mitov::ConstantProperty<65, bool, false >, // InterruptOnLowLevel = False (Default)
    Mitov::ConstantProperty<63, Mitov::TArduinoMPU9250FrameSynchronizationLocation, Mitov::fslDisabled >, // Location = 0 (Default)
    Mitov::ClockPin_NoImplementation<62 > // OutputPin
     > >, // FrameSynchronization
  Mitov::NestedProperty<48, Mitov::MPUGyroscope<
    Mitov::ConstantProperty<34, Mitov::TArduinoMPU9250GyroscopeRange, Mitov::gr250dps >, // FullScaleRange = 0 (Default)
    Mitov::AnalogPin_NoImplementation<31 >, // OutputPins_0
    Mitov::AnalogPin_NoImplementation<32 >, // OutputPins_1
    Mitov::AnalogPin_NoImplementation<33 >, // OutputPins_2
    Mitov::ConstantProperty<35, Mitov::TArduinoAngleUnits, Mitov::auDegree >, // Units = auDegree (Default)
    Mitov::NestedProperty<39, Mitov::MPUOptionalSelfTestSensor<
      Mitov::ConstantProperty<37, bool, true >, // Enabled = True (Default)
      Mitov::ConstantProperty<38, bool, false > // SelfTest = False (Default)
       > >, // X
    Mitov::NestedProperty<43, Mitov::MPUOptionalSelfTestSensor<
      Mitov::ConstantProperty<41, bool, true >, // Enabled = True (Default)
      Mitov::ConstantProperty<42, bool, false > // SelfTest = False (Default)
       > >, // Y
    Mitov::NestedProperty<47, Mitov::MPUOptionalSelfTestSensor<
      Mitov::ConstantProperty<45, bool, true >, // Enabled = True (Default)
      Mitov::ConstantProperty<46, bool, false > // SelfTest = False (Default)
       > > // Z
     > >, // Gyroscope
  Mitov::NestedProperty<60, Mitov::MPUInterrupt<
    Mitov::ConstantProperty<55, bool, false >, // Inverted = False (Default)
    Mitov::ConstantProperty<57, bool, true >, // Latch = True (Default)
    Mitov::ConstantProperty<58, bool, false >, // OnFrameSync = False (Default)
    Mitov::ConstantProperty<59, bool, false >, // OnRawReady = False (Default)
    Mitov::ConstantProperty<56, bool, false > // OpenDrain = False (Default)
     > >, // Interrupt
  Mitov::NestedProperty<70, Mitov::MPU6050LowPowerMode<
    Mitov::ConstantProperty<68, bool, false >, // Enabled = False (Default)
    Mitov::ConstantPropertyFloat<69, float, ::VisuinoConstants::FloatValue0 > // SampleFrequency = 1.25 (Default)
     > >, // LowPowerMode
  Mitov::ConstantProperty<72, uint32_t, 1 >, // SampleRateDivider = 1 (Default)
  Mitov::NestedProperty<53, Mitov::TArduinoBasicEnabledThermometer<
    Mitov::ConstantProperty<50, bool, true >, // Enabled = True (Default)
    Mitov::ConstantProperty<52, bool, false >, // InFahrenheit = False (Default)
    Mitov::AnalogPin_NoImplementation<51 > // OutputPin
     > > // Thermometer
   > AccelerometerGyroscope1; // TArduinoMPU6050I2C
} // Types

namespace Instances
{
Types::AccelerometerGyroscope1 AccelerometerGyroscope1; // TArduinoMPU6050I2C
} // Instances

namespace Types
{
typedef Mitov::CompassHeading<
  Mitov::ConstantPropertyFloat<7, float, ::VisuinoConstants::FloatValue1 >, // DeclinationAngle = 0 (Default)
  Mitov::TypedVariable<9, bool, ::ComponentVariables::Variable1 >, // FChangeOnly = 0
  Mitov::TypedVariable<11, bool, ::ComponentVariables::Variable2 >, // FModified = 0
  Mitov::AnalogPin_EmbeddedPinImplementation_ChangeOnly<3, ::PinCalls::PinCallerReceive4 >, // OutputPin
  Mitov::ConstantProperty<8, Mitov::TArduinoAngleUnits, Mitov::auDegree > // Units = auDegree (Default)
   > CompassHeading1; // TArduinoCompassHeading
} // Types

namespace Instances
{
Types::CompassHeading1 CompassHeading1; // TArduinoCompassHeading
} // Instances

namespace Types
{
typedef Mitov::HMC5883L_Compass<
  TwoWire, // 0_I2C_TYPE_PIN
  Wire, // 1_I2C_NAME_PIN
  Mitov::ConstantProperty<9, uint8_t, 30 >, // Address = 30 (Default)
  Mitov::ConstantProperty<10, Mitov::TCompassHMC5883LAveragedSamples, Mitov::cas1 >, // AveragedSamples = 0 (Default)
  Mitov::ConstantProperty<11, Mitov::TCompassHMC5883LBias, Mitov::cbNone >, // Bias = 0 (Default)
  Mitov::ConstantProperty<3, bool, true >, // Enabled = True (Default)
  Mitov::ConstantProperty<14, bool, true >, // FClocked = True
  Mitov::ConstantProperty<12, Mitov::TCompassHMC5883LGain, Mitov::cg1090 >, // Gain = 1 (Default)
  Mitov::ConstantProperty<13, bool, false >, // Idle = False (Default)
  Mitov::AnalogPin_EmbeddedPinImplementation<6, ::PinCalls::PinCallerReceive5 >, // XOutputPin
  Mitov::AnalogPin_EmbeddedPinImplementation<7, ::PinCalls::PinCallerReceive6 >, // YOutputPin
  Mitov::AnalogPin_NoImplementation<8 > // ZOutputPin
   > Compass1; // TCompassHMC5883L
} // Types

namespace Instances
{
Types::Compass1 Compass1; // TCompassHMC5883L
} // Instances

namespace Types
{
typedef Mitov::PulseGenerator<
  Mitov::ConstantPropertyFloat<8, float, ::VisuinoConstants::FloatValue1 >, // Asymmetry = 0 (Default)
  Mitov::TypedVariableValue<4, bool, ::ComponentVariables::Variable3, true >, // Enabled = True (Default)
  Mitov::ConstantPropertyFloat<17, float, ::VisuinoConstants::FloatValue1>, // FPhase = 0
  Mitov::TypedVariable<15, bool, ::ComponentVariables::Variable4 >, // FValue = 0
  Mitov::ConstantPropertyFloat<7, float, ::VisuinoConstants::FloatValue2 >, // Frequency = 2
  Mitov::ConstantProperty<5, bool, false >, // InitialValue = False (Default)
  Mitov::DigitalPin_EmbeddedPinImplementation<3, ::PinCalls::PinCallerReceive7 >, // OutputPin
  Mitov::ConstantPropertyFloat<9, float, ::VisuinoConstants::FloatValue1 >, // Phase = 0 (Default)
  Mitov::NestedProperty<14, Mitov::TArduinoGeneratorWhenDisabled<
    Mitov::ConstantProperty<13, bool, false >, // CompleteCycle = False (Default)
    Mitov::ConstantProperty<12, bool, true >, // FCycleCompleted = True
    Mitov::ConstantProperty<11, bool, true > // Reset = True
     > > // WhenDisabled
   > PulseGenerator1; // TArduinoPulseGenerator
} // Types

namespace Instances
{
Types::PulseGenerator1 PulseGenerator1; // TArduinoPulseGenerator
} // Instances

namespace Types
{
typedef Mitov::BooleanOperation<
  Mitov::BooleanOr, // BASE
  2, // COUNT_InputPins
  Mitov::TypedVariable<7, bool, ::ComponentVariables::Variable5 >, // FModified = 0
  Mitov::DigitalPin_DirectBoardPinImplementation<4 > // OutputPin
   > Or1; // TArduinoBooleanOr
} // Types

namespace Instances
{
Types::Or1 Or1; // TArduinoBooleanOr
} // Instances

namespace Types
{
typedef Mitov::CompareRange<
  Mitov::ConstantProperty<4, bool, true >, // Enabled = True (Default)
  Mitov::TypedVariable<13, bool, ::ComponentVariables::Variable6 >, // FStarted = 0
  Mitov::ConstantProperty<11, bool, true >, // IncludeLimits = True
  Mitov::ConstantProperty<10, bool, false >, // IsOutsideRange = False (Default)
  Mitov::ConstantProperty<12, bool, true >, // OnlyChanged = True (Default)
  Mitov::DigitalPin_EmbeddedPinImplementation<5, ::PinCalls::PinCallerReceive8 >, // OutputPin
  Mitov::NestedProperty<9, Mitov::ValueRange<
    Mitov::ConstantPropertyFloat<8, float, ::VisuinoConstants::FloatValue4 >, // Value_Max = 0.0599999986588955
    Mitov::ConstantPropertyFloat<7, float, ::VisuinoConstants::FloatValue3 > // Value_Min = -0.0599999986588955
     > >, // Range
  float // TYPE
   > CompareRange1; // TArduinoAnalogCompareRange
} // Types

namespace Instances
{
Types::CompareRange1 CompareRange1; // TArduinoAnalogCompareRange
} // Instances

namespace Types
{
typedef Mitov::CompareRange<
  Mitov::ConstantProperty<4, bool, true >, // Enabled = True (Default)
  Mitov::TypedVariable<13, bool, ::ComponentVariables::Variable7 >, // FStarted = 0
  Mitov::ConstantProperty<11, bool, true >, // IncludeLimits = True
  Mitov::ConstantProperty<10, bool, false >, // IsOutsideRange = False (Default)
  Mitov::ConstantProperty<12, bool, true >, // OnlyChanged = True (Default)
  Mitov::DigitalPin_EmbeddedPinImplementation<5, ::PinCalls::PinCallerReceive9 >, // OutputPin
  Mitov::NestedProperty<9, Mitov::ValueRange<
    Mitov::ConstantPropertyFloat<8, float, ::VisuinoConstants::FloatValue4 >, // Value_Max = 0.0599999986588955
    Mitov::ConstantPropertyFloat<7, float, ::VisuinoConstants::FloatValue3 > // Value_Min = -0.0599999986588955
     > >, // Range
  float // TYPE
   > CompareRange2; // TArduinoAnalogCompareRange
} // Types

namespace Instances
{
Types::CompareRange2 CompareRange2; // TArduinoAnalogCompareRange
} // Instances

namespace Types
{
typedef Mitov::BooleanOperation<
  Mitov::BooleanAnd, // BASE
  3, // COUNT_InputPins
  Mitov::TypedVariable<8, bool, ::ComponentVariables::Variable9 >, // FModified = 0
  Mitov::DigitalPin_EmbeddedPinImplementation_ChangeOnly<3, ::PinCalls::PinCallerReceive10, Mitov::TypedVariable<0, bool, ::ComponentVariables::Variable8 > > // OutputPin
   > And1; // TArduinoBooleanAnd
} // Types

namespace Instances
{
Types::And1 And1; // TArduinoBooleanAnd
} // Instances

namespace Types
{
typedef Mitov::CompareRange<
  Mitov::ConstantProperty<4, bool, true >, // Enabled = True (Default)
  Mitov::TypedVariable<13, bool, ::ComponentVariables::Variable10 >, // FStarted = 0
  Mitov::ConstantProperty<11, bool, true >, // IncludeLimits = True
  Mitov::ConstantProperty<10, bool, false >, // IsOutsideRange = False (Default)
  Mitov::ConstantProperty<12, bool, true >, // OnlyChanged = True (Default)
  Mitov::DigitalPin_EmbeddedPinImplementation<5, ::PinCalls::PinCallerReceive11 >, // OutputPin
  Mitov::NestedProperty<9, Mitov::ValueRange<
    Mitov::ConstantPropertyFloat<8, float, ::VisuinoConstants::FloatValue5 >, // Value_Max = 358
    Mitov::ConstantPropertyFloat<7, float, ::VisuinoConstants::FloatValue2 > // Value_Min = 2
     > >, // Range
  float // TYPE
   > CompareRange3; // TArduinoAnalogCompareRange
} // Types

namespace Instances
{
Types::CompareRange3 CompareRange3; // TArduinoAnalogCompareRange
} // Instances

namespace Types
{
typedef Mitov::BooleanOperation<
  Mitov::BooleanOr, // BASE
  2, // COUNT_InputPins
  Mitov::TypedVariable<7, bool, ::ComponentVariables::Variable12 >, // FModified = 0
  Mitov::DigitalPin_EmbeddedPinImplementation_ChangeOnly<3, ::PinCalls::PinCallerReceive12, Mitov::TypedVariable<0, bool, ::ComponentVariables::Variable11 > > // OutputPin
   > Or2; // TArduinoBooleanOr
} // Types

namespace Instances
{
Types::Or2 Or2; // TArduinoBooleanOr
} // Instances

namespace Types
{
typedef Mitov::BooleanInverter<
  Mitov::ConstantProperty<4, bool, true >, // Enabled = True (Default)
  Mitov::DigitalPin_EmbeddedPinImplementation<3, ::PinCalls::PinCallerReceive13 > // OutputPin
   > Inverter1; // TArduinoBooleanInverter
} // Types

namespace Instances
{
Types::Inverter1 Inverter1; // TArduinoBooleanInverter
} // Instances

namespace Types
{
typedef Mitov::PulseGenerator<
  Mitov::ConstantPropertyFloat<8, float, ::VisuinoConstants::FloatValue1 >, // Asymmetry = 0 (Default)
  Mitov::TypedVariableValue<4, bool, ::ComponentVariables::Variable13, true >, // Enabled = True (Default)
  Mitov::ConstantPropertyFloat<17, float, ::VisuinoConstants::FloatValue1>, // FPhase = 0
  Mitov::TypedVariable<15, bool, ::ComponentVariables::Variable14 >, // FValue = 0
  Mitov::VariableMinPropertyFloat<7, float, ::VisuinoConstants::FloatValue2, ::VisuinoConstants::FloatValue1 >, // Frequency = 2
  Mitov::ConstantProperty<5, bool, false >, // InitialValue = False (Default)
  Mitov::DigitalPin_EmbeddedPinImplementation<3, ::PinCalls::PinCallerReceive14 >, // OutputPin
  Mitov::ConstantPropertyFloat<9, float, ::VisuinoConstants::FloatValue1 >, // Phase = 0 (Default)
  Mitov::NestedProperty<14, Mitov::TArduinoGeneratorWhenDisabled<
    Mitov::ConstantProperty<13, bool, false >, // CompleteCycle = False (Default)
    Mitov::ConstantProperty<12, bool, true >, // FCycleCompleted = True
    Mitov::ConstantProperty<11, bool, true > // Reset = True
     > > // WhenDisabled
   > PulseGenerator2; // TArduinoPulseGenerator
} // Types

namespace Instances
{
Types::PulseGenerator2 PulseGenerator2; // TArduinoPulseGenerator
} // Instances

namespace Types
{
typedef Mitov::ValueSourceState<
  0, // COUNT_Ramp_Elements = 0
  Mitov::EmbeddedCallChain<CallChains::TryActive1 >, // Elements_TryActive
  Mitov::TypedVariable<10, bool, ::ComponentVariables::Variable16 >, // FStarted = False
  Mitov::TypedVariable<7, bool, ::ComponentVariables::Variable15 >, // FStateActive = False
  Mitov::AnalogPin_EmbeddedPinImplementation<3, ::PinCalls::PinCallerReceive15 >, // OutputPin
  float, // TYPE
  Mitov::VariablePropertyFloat<5, float, ::VisuinoConstants::FloatValue1 > // Value = 0 (Default)
   > AnalogValue1; // TArduinoFloatValue
} // Types

namespace Instances
{
Types::AnalogValue1 AnalogValue1; // TArduinoFloatValue
} // Instances

namespace Types
{
typedef Mitov::ArduinoStateSetValueElement<
  Declarations::Types::AnalogValue1, // 0_TYPE_OWNER
  Declarations::Instances::AnalogValue1, // 1_NAME_OWNER
  Mitov::TypedVariable<4, bool, ::ComponentVariables::Variable17 >, // FInputValue = 0
  Mitov::ConstantPropertyFloat<3, float, ::VisuinoConstants::FloatValue6 > // Value = 1
   > TArduinoAnalogStateSetValueElement1;
} // Types

namespace Instances
{
Types::TArduinoAnalogStateSetValueElement1 TArduinoAnalogStateSetValueElement1;
} // Instances

namespace Types
{
typedef Mitov::ArduinoStateSetValueElement<
  Declarations::Types::AnalogValue1, // 0_TYPE_OWNER
  Declarations::Instances::AnalogValue1, // 1_NAME_OWNER
  Mitov::TypedVariable<4, bool, ::ComponentVariables::Variable18 >, // FInputValue = 0
  Mitov::ConstantPropertyFloat<3, float, ::VisuinoConstants::FloatValue2 > // Value = 2
   > TArduinoAnalogStateSetValueElement2;
} // Types

namespace Instances
{
Types::TArduinoAnalogStateSetValueElement2 TArduinoAnalogStateSetValueElement2;
} // Instances

namespace Types
{
typedef Mitov::ArduinoStateSetValueElement<
  Declarations::Types::AnalogValue1, // 0_TYPE_OWNER
  Declarations::Instances::AnalogValue1, // 1_NAME_OWNER
  Mitov::TypedVariable<4, bool, ::ComponentVariables::Variable19 >, // FInputValue = 0
  Mitov::ConstantPropertyFloat<3, float, ::VisuinoConstants::FloatValue7 > // Value = 3
   > TArduinoAnalogStateSetValueElement3;
} // Types

namespace Instances
{
Types::TArduinoAnalogStateSetValueElement3 TArduinoAnalogStateSetValueElement3;
} // Instances

namespace Types
{
typedef Mitov::ArduinoStateSetValueElement<
  Declarations::Types::AnalogValue1, // 0_TYPE_OWNER
  Declarations::Instances::AnalogValue1, // 1_NAME_OWNER
  Mitov::TypedVariable<4, bool, ::ComponentVariables::Variable20 >, // FInputValue = 0
  Mitov::ConstantPropertyFloat<3, float, ::VisuinoConstants::FloatValue8 > // Value = 4
   > TArduinoAnalogStateSetValueElement4;
} // Types

namespace Instances
{
Types::TArduinoAnalogStateSetValueElement4 TArduinoAnalogStateSetValueElement4;
} // Instances

namespace Types
{
typedef Mitov::ArduinoStateSetValueElement<
  Declarations::Types::AnalogValue1, // 0_TYPE_OWNER
  Declarations::Instances::AnalogValue1, // 1_NAME_OWNER
  Mitov::TypedVariable<4, bool, ::ComponentVariables::Variable21 >, // FInputValue = 0
  Mitov::ConstantPropertyFloat<3, float, ::VisuinoConstants::FloatValue9 > // Value = 5
   > TArduinoAnalogStateSetValueElement5;
} // Types

namespace Instances
{
Types::TArduinoAnalogStateSetValueElement5 TArduinoAnalogStateSetValueElement5;
} // Instances

namespace Types
{
typedef Mitov::CompareRange<
  Mitov::ConstantProperty<4, bool, true >, // Enabled = True (Default)
  Mitov::TypedVariable<13, bool, ::ComponentVariables::Variable22 >, // FStarted = 0
  Mitov::ConstantProperty<11, bool, false >, // IncludeLimits = False (Default)
  Mitov::ConstantProperty<10, bool, false >, // IsOutsideRange = False (Default)
  Mitov::ConstantProperty<12, bool, true >, // OnlyChanged = True (Default)
  Mitov::DigitalPin_EmbeddedPinImplementation<5, ::PinCalls::PinCallerReceive16 >, // OutputPin
  Mitov::NestedProperty<9, Mitov::ValueRange<
    Mitov::ConstantPropertyFloat<8, float, ::VisuinoConstants::FloatValue11 >, // Value_Max = 220
    Mitov::ConstantPropertyFloat<7, float, ::VisuinoConstants::FloatValue10 > // Value_Min = 140
     > >, // Range
  float // TYPE
   > CompareRange4; // TArduinoAnalogCompareRange
} // Types

namespace Instances
{
Types::CompareRange4 CompareRange4; // TArduinoAnalogCompareRange
} // Instances

namespace Types
{
typedef Mitov::CompareRange<
  Mitov::ConstantProperty<4, bool, true >, // Enabled = True (Default)
  Mitov::TypedVariable<13, bool, ::ComponentVariables::Variable23 >, // FStarted = 0
  Mitov::ConstantProperty<11, bool, false >, // IncludeLimits = False (Default)
  Mitov::ConstantProperty<10, bool, false >, // IsOutsideRange = False (Default)
  Mitov::ConstantProperty<12, bool, true >, // OnlyChanged = True (Default)
  Mitov::DigitalPin_EmbeddedPinImplementation<5, ::PinCalls::PinCallerReceive17 >, // OutputPin
  Mitov::NestedProperty<9, Mitov::ValueRange<
    Mitov::ConstantPropertyFloat<8, float, ::VisuinoConstants::FloatValue13 >, // Value_Max = 270
    Mitov::ConstantPropertyFloat<7, float, ::VisuinoConstants::FloatValue12 > // Value_Min = 90
     > >, // Range
  float // TYPE
   > CompareRange5; // TArduinoAnalogCompareRange
} // Types

namespace Instances
{
Types::CompareRange5 CompareRange5; // TArduinoAnalogCompareRange
} // Instances

namespace Types
{
typedef Mitov::CompareRange<
  Mitov::ConstantProperty<4, bool, true >, // Enabled = True (Default)
  Mitov::TypedVariable<13, bool, ::ComponentVariables::Variable24 >, // FStarted = 0
  Mitov::ConstantProperty<11, bool, false >, // IncludeLimits = False (Default)
  Mitov::ConstantProperty<10, bool, false >, // IsOutsideRange = False (Default)
  Mitov::ConstantProperty<12, bool, true >, // OnlyChanged = True (Default)
  Mitov::DigitalPin_EmbeddedPinImplementation<5, ::PinCalls::PinCallerReceive18 >, // OutputPin
  Mitov::NestedProperty<9, Mitov::ValueRange<
    Mitov::ConstantPropertyFloat<8, float, ::VisuinoConstants::FloatValue15 >, // Value_Max = 300
    Mitov::ConstantPropertyFloat<7, float, ::VisuinoConstants::FloatValue14 > // Value_Min = 60
     > >, // Range
  float // TYPE
   > CompareRange6; // TArduinoAnalogCompareRange
} // Types

namespace Instances
{
Types::CompareRange6 CompareRange6; // TArduinoAnalogCompareRange
} // Instances

namespace Types
{
typedef Mitov::CompareRange<
  Mitov::ConstantProperty<4, bool, true >, // Enabled = True (Default)
  Mitov::TypedVariable<13, bool, ::ComponentVariables::Variable25 >, // FStarted = 0
  Mitov::ConstantProperty<11, bool, false >, // IncludeLimits = False (Default)
  Mitov::ConstantProperty<10, bool, false >, // IsOutsideRange = False (Default)
  Mitov::ConstantProperty<12, bool, true >, // OnlyChanged = True (Default)
  Mitov::DigitalPin_EmbeddedPinImplementation<5, ::PinCalls::PinCallerReceive19 >, // OutputPin
  Mitov::NestedProperty<9, Mitov::ValueRange<
    Mitov::ConstantPropertyFloat<8, float, ::VisuinoConstants::FloatValue17 >, // Value_Max = 345
    Mitov::ConstantPropertyFloat<7, float, ::VisuinoConstants::FloatValue16 > // Value_Min = 15
     > >, // Range
  float // TYPE
   > CompareRange7; // TArduinoAnalogCompareRange
} // Types

namespace Instances
{
Types::CompareRange7 CompareRange7; // TArduinoAnalogCompareRange
} // Instances

namespace Types
{
typedef Mitov::BooleanInverter<
  Mitov::ConstantProperty<4, bool, true >, // Enabled = True (Default)
  Mitov::DigitalPin_EmbeddedPinImplementation<3, ::PinCalls::PinCallerReceive20 > // OutputPin
   > Inverter2; // TArduinoBooleanInverter
} // Types

namespace Instances
{
Types::Inverter2 Inverter2; // TArduinoBooleanInverter
} // Instances

namespace Types
{
typedef Mitov::BooleanInverter<
  Mitov::ConstantProperty<4, bool, true >, // Enabled = True (Default)
  Mitov::DigitalPin_EmbeddedPinImplementation<3, ::PinCalls::PinCallerReceive21 > // OutputPin
   > Inverter3; // TArduinoBooleanInverter
} // Types

namespace Instances
{
Types::Inverter3 Inverter3; // TArduinoBooleanInverter
} // Instances

namespace Types
{
typedef Mitov::BooleanInverter<
  Mitov::ConstantProperty<4, bool, true >, // Enabled = True (Default)
  Mitov::DigitalPin_EmbeddedPinImplementation<3, ::PinCalls::PinCallerReceive22 > // OutputPin
   > Inverter4; // TArduinoBooleanInverter
} // Types

namespace Instances
{
Types::Inverter4 Inverter4; // TArduinoBooleanInverter
} // Instances

namespace Types
{
typedef Mitov::BooleanInverter<
  Mitov::ConstantProperty<4, bool, true >, // Enabled = True (Default)
  Mitov::DigitalPin_EmbeddedPinImplementation<3, ::PinCalls::PinCallerReceive23 > // OutputPin
   > Inverter5; // TArduinoBooleanInverter
} // Types

namespace Instances
{
Types::Inverter5 Inverter5; // TArduinoBooleanInverter
} // Instances

namespace Types
{
typedef Mitov::BooleanInverter<
  Mitov::ConstantProperty<4, bool, true >, // Enabled = True (Default)
  Mitov::DigitalPin_EmbeddedPinImplementation<3, ::PinCalls::PinCallerReceive24 > // OutputPin
   > Inverter6; // TArduinoBooleanInverter
} // Types

namespace Instances
{
Types::Inverter6 Inverter6; // TArduinoBooleanInverter
} // Instances

namespace Types
{
typedef Mitov::CompareRange<
  Mitov::ConstantProperty<4, bool, true >, // Enabled = True (Default)
  Mitov::TypedVariable<13, bool, ::ComponentVariables::Variable26 >, // FStarted = 0
  Mitov::ConstantProperty<11, bool, false >, // IncludeLimits = False (Default)
  Mitov::ConstantProperty<10, bool, false >, // IsOutsideRange = False (Default)
  Mitov::ConstantProperty<12, bool, true >, // OnlyChanged = True (Default)
  Mitov::DigitalPin_EmbeddedPinImplementation<5, ::PinCalls::PinCallerReceive25 >, // OutputPin
  Mitov::NestedProperty<9, Mitov::ValueRange<
    Mitov::ConstantPropertyFloat<8, float, ::VisuinoConstants::FloatValue19 >, // Value_Max = 181
    Mitov::ConstantPropertyFloat<7, float, ::VisuinoConstants::FloatValue18 > // Value_Min = 179
     > >, // Range
  float // TYPE
   > CompareRange8; // TArduinoAnalogCompareRange
} // Types

namespace Instances
{
Types::CompareRange8 CompareRange8; // TArduinoAnalogCompareRange
} // Instances

namespace Types
{
typedef Mitov::Delay<
  Mitov::ConstantProperty<8, bool, true >, // CanRestart = True (Default)
  Mitov::ConstantProperty<4, bool, true >, // Enabled = True (Default)
  Mitov::TypedVariable<9, bool, ::ComponentVariables::Variable27 >, // FValue = 0
  Mitov::ConstantProperty<7, uint32_t, 5000000 >, // Interval = 5000000
  Mitov::ClockPin_EmbeddedPinImplementation<3, ::PinCalls::PinCallerReceive26 > // OutputPin
   > Delay1; // TArduinoDelay
} // Types

namespace Instances
{
Types::Delay1 Delay1; // TArduinoDelay
} // Instances

namespace Types
{
typedef Mitov::MitovServo<
  Mitov::TypedVariableValue<4, bool, ::ComponentVariables::Variable28, true >, // Enabled = True (Default)
  Mitov::VariableMinMaxPropertyFloat<5, float, ::VisuinoConstants::FloatValue20, ::VisuinoConstants::FloatValue1, ::VisuinoConstants::FloatValue6 >, // InitialValue = 0.5 (Default)
  Mitov::ConstantProperty<8, uint32_t, 2400 >, // MaxPulse = 2400 (Default)
  Mitov::ConstantProperty<7, uint32_t, 544 >, // MinPulse = 544 (Default)
  5, // OutputPin
  Mitov::ConstantProperty<6, bool, false > // Reversed = False (Default)
   > Servo1; // TArduinoServo
} // Types

namespace Instances
{
Types::Servo1 Servo1; // TArduinoServo
} // Instances

namespace Types
{
typedef Mitov::SRFlipFlop<
  Mitov::TypedVariableValue<5, bool, ::ComponentVariables::Variable29, false >, // InitialValue = False (Default)
  Mitov::DigitalPin_NoImplementation<4 >, // InvertedOutputPin
  Mitov::DigitalPin_EmbeddedPinImplementation<3, ::PinCalls::PinCallerReceive27 > // OutputPin
   > SRFlipFlop1; // TArduinoSRFlipFlop
} // Types

namespace Instances
{
Types::SRFlipFlop1 SRFlipFlop1; // TArduinoSRFlipFlop
} // Instances

namespace Types
{
typedef Mitov::CompareValue<
  Mitov::CompareType_Implementation_ctBigger, // CompareType = 2
  Mitov::ConstantProperty<4, bool, true >, // Enabled = True (Default)
  Mitov::TypedVariable<9, bool, ::ComponentVariables::Variable30 >, // FStarted = 0
  Mitov::ConstantProperty<8, bool, true >, // OnlyChanged = True (Default)
  Mitov::DigitalPin_EmbeddedPinImplementation<5, ::PinCalls::PinCallerReceive28 >, // OutputPin
  float, // TYPE
  Mitov::ConstantPropertyFloat<6, float, ::VisuinoConstants::FloatValue20 > // Value = 0.5
   > CompareValue1; // TArduinoCompareValue
} // Types

namespace Instances
{
Types::CompareValue1 CompareValue1 = Types::CompareValue1( 0.0f ); // TArduinoCompareValue
} // Instances

namespace Types
{
typedef Mitov::BooleanInverter<
  Mitov::ConstantProperty<4, bool, true >, // Enabled = True (Default)
  Mitov::DigitalPin_EmbeddedPinImplementation<3, ::PinCalls::PinCallerReceive29 > // OutputPin
   > Inverter7; // TArduinoBooleanInverter
} // Types

namespace Instances
{
Types::Inverter7 Inverter7; // TArduinoBooleanInverter
} // Instances

namespace Types
{
typedef Mitov::MitovSerialGPS<
  Mitov::ConstantProperty<10, uint32_t, 2000 >, // BaseYear = 2000 (Default)
  Mitov::AnalogPin_NoImplementation<5 >, // CourseOutputPins_0
  Mitov::AnalogPin_NoImplementation<6 >, // CourseOutputPins_1
  Mitov::TypedPin_NoImplementation<7, Mitov::TDateTime >, // DateTimeOutputPin
  Mitov::ConstantProperty<3, bool, true >, // Enabled = True (Default)
  Mitov::ConstantProperty<34, uint32_t, 0 >, // FHour = 0
  Mitov::ConstantProperty<40, uint32_t, 0 >, // FMilliSeconds = 0
  Mitov::ConstantProperty<36, uint32_t, 0 >, // FMinutes = 0
  Mitov::ConstantProperty<38, uint32_t, 0 >, // FSeconds = 0
  Mitov::TypedVariable<32, uint32_t, ::ComponentVariables::Variable32 >, // FState = 1
  Mitov::TypedVariable<30, bool, ::ComponentVariables::Variable31 >, // FValuePopulated = 0
  Mitov::AnalogPin_NoImplementation<29 >, // HorizontalPrecisionOutputPin
  Mitov::DigitalPin_NoImplementation<8 >, // InvalidOutputPin
  Mitov::AnalogPin_EmbeddedPinImplementation<14, ::PinCalls::PinCallerReceive30 >, // LocationOutputPins_0
  Mitov::AnalogPin_NoImplementation<15 >, // LocationOutputPins_1
  Mitov::AnalogPin_NoImplementation<16 >, // LocationOutputPins_2
  Mitov::AnalogPin_NoImplementation<17 >, // LocationOutputPins_3
  Mitov::AnalogPin_NoImplementation<18 >, // LocationOutputPins_4
  Mitov::DigitalPin_NoImplementation<9 >, // MessageErrorOutputPin
  Mitov::TypedPin_NoImplementation<27, uint32_t >, // ModeOutputPin
  Mitov::TypedPin_NoImplementation<28, uint32_t >, // NavigationStatusOutputPin
  Mitov::TypedPin_EmbeddedPinImplementation<20, ::PinCalls::PinCallerReceive31, uint32_t >, // SatellitesOutputPins_0
  Mitov::ClockPin_NoImplementation<21 >, // SatellitesOutputPins_1
  Mitov::TypedPin_NoImplementation<22, uint32_t >, // SatellitesOutputPins_2
  Mitov::TypedPin_NoImplementation<23, uint32_t >, // SatellitesOutputPins_3
  Mitov::TypedPin_NoImplementation<24, uint32_t >, // SatellitesOutputPins_4
  Mitov::TypedPin_NoImplementation<25, uint32_t >, // SatellitesOutputPins_5
  Mitov::ClockPin_NoImplementation<26 > // SatellitesOutputPins_6
   > GPS1; // TArduinoSerialGPS
} // Types

namespace Instances
{
Types::GPS1 GPS1; // TArduinoSerialGPS
} // Instances

namespace Types
{
typedef Mitov::MapRange<
  Mitov::ConstantProperty<5, bool, true >, // Enabled = True (Default)
  Mitov::NestedProperty<9, Mitov::ValueRange<
    Mitov::ConstantPropertyFloat<8, float, ::VisuinoConstants::FloatValue21 >, // Value_Max = 89
    Mitov::ConstantPropertyFloat<7, float, ::VisuinoConstants::FloatValue1 > // Value_Min = 0 (Default)
     > >, // InputRange
  Mitov::AnalogPin_EmbeddedPinImplementation<3, ::PinCalls::PinCallerReceive32 >, // OutputPin
  Mitov::NestedProperty<13, Mitov::ValueRange<
    Mitov::ConstantPropertyFloat<12, float, ::VisuinoConstants::FloatValue6 >, // Value_Max = 1 (Default)
    Mitov::ConstantPropertyFloat<11, float, ::VisuinoConstants::FloatValue20 > // Value_Min = 0.5
     > > // OutputRange
   > MapRange1; // TArduinoMapRange
} // Types

namespace Instances
{
Types::MapRange1 MapRange1; // TArduinoMapRange
} // Instances

namespace Types
{
typedef Mitov::CompareValue<
  Mitov::CompareType_Implementation_ctBiggerOrEqual, // CompareType = 4
  Mitov::ConstantProperty<4, bool, true >, // Enabled = True (Default)
  Mitov::TypedVariable<9, bool, ::ComponentVariables::Variable33 >, // FStarted = 0
  Mitov::ConstantProperty<8, bool, true >, // OnlyChanged = True (Default)
  Mitov::DigitalPin_EmbeddedPinImplementation<5, ::PinCalls::PinCallerReceive33 >, // OutputPin
  uint32_t, // TYPE
  Mitov::ConstantProperty<6, uint32_t, 3 > // Value = 3
   > CompareValue2; // TArduinoUnsignedCompareValue
} // Types

namespace Instances
{
Types::CompareValue2 CompareValue2 = Types::CompareValue2( 0 ); // TArduinoUnsignedCompareValue
} // Instances

namespace Types
{
typedef Mitov::BooleanOperation<
  Mitov::BooleanAnd, // BASE
  2, // COUNT_InputPins
  Mitov::TypedVariable<7, bool, ::ComponentVariables::Variable35 >, // FModified = 0
  Mitov::DigitalPin_EmbeddedPinImplementation_ChangeOnly<3, ::PinCalls::PinCallerReceive34, Mitov::TypedVariable<0, bool, ::ComponentVariables::Variable34 > > // OutputPin
   > And2; // TArduinoBooleanAnd
} // Types

namespace Instances
{
Types::And2 And2; // TArduinoBooleanAnd
} // Instances

namespace Types
{
typedef Mitov::Timer<
  Mitov::ConstantProperty<6, bool, false >, // AutoRepeat = False (Default)
  Mitov::ConstantProperty<7, bool, false >, // CanRestart = False
  Mitov::ConstantProperty<4, bool, true >, // Enabled = True (Default)
  Mitov::TypedVariable<10, bool, ::ComponentVariables::Variable36 >, // FValue = 0
  Mitov::ConstantProperty<5, uint32_t, 250000 >, // Interval = 250000
  Mitov::DigitalPin_DirectBoardPinImplementation<7 > // OutputPin
   > Timer1; // TArduinoTimer
} // Types

namespace Instances
{
Types::Timer1 Timer1; // TArduinoTimer
} // Instances

namespace Types
{
typedef Mitov::CommonMux<
  2, // COUNT_InputPins
  Mitov::VariableMinMaxPropertySharedBits<8, uint32_t, 0, ::ComponentVariables::Variable37, 0, 4000 >, // InitialChannel = 0 (Default)
  Mitov::AnalogPin_EmbeddedPinImplementation<3, ::PinCalls::PinCallerReceive35 >, // OutputPin
  float // TYPE
   > AnalogMux1; // TArduinoAnalogMux
} // Types

namespace Instances
{
Types::AnalogMux1 AnalogMux1; // TArduinoAnalogMux
} // Instances

namespace Types
{
typedef Mitov::Counter<
  Mitov::ConstantProperty<4, bool, true >, // Enabled = True (Default)
  Mitov::TypedVariableMinMax<22, int32_t, ::ComponentVariables::Variable39, 0, 2 >, // FCount = 0
  Mitov::ConstantProperty<6, int32_t, 0 >, // InitialValue = 0 (Default)
  Mitov::NestedProperty<11, Mitov::GenericValueLimit<
    Mitov::DigitalPin_NoImplementation<8 >, // ReachedOutputPin
    Mitov::ConstantProperty<10, bool, true >, // RollOver = True (Default)
    Mitov::ConstantProperty<9, int32_t, 2 > // Value = 2
     > >, // Value_Max
  Mitov::NestedProperty<16, Mitov::GenericValueLimit<
    Mitov::DigitalPin_NoImplementation<13 >, // ReachedOutputPin
    Mitov::ConstantProperty<15, bool, true >, // RollOver = True (Default)
    Mitov::ConstantProperty<14, int32_t, 0 > // Value = 0
     > >, // Value_Min
  Mitov::TypedVariable<20, bool, ::ComponentVariables::Variable38 >, // NeedsUpdate = 0
  Mitov::TypedPin_EmbeddedPinImplementation<3, ::PinCalls::PinCallerReceive36, int32_t >, // OutputPin
  Mitov::ConstantProperty<19, bool, false > // Reversed = False (Default)
   > Counter1; // TArduinoCounter
} // Types

namespace Instances
{
Types::Counter1 Counter1; // TArduinoCounter
} // Instances

namespace Types
{
typedef Mitov::Button<
  Mitov::ConstantProperty<5, uint32_t, 50 >, // DebounceInterval = 50 (Default)
  Mitov::TypedVariable<6, bool, ::ComponentVariables::Variable40 >, // FLastValue = 0
  Mitov::TypedVariable<8, bool, ::ComponentVariables::Variable41 >, // FValue = 0
  Mitov::DigitalPin_EmbeddedPinImplementation<3, ::PinCalls::PinCallerReceive37 > // OutputPin
   > Button1; // TArduinoButton
} // Types

namespace Instances
{
Types::Button1 Button1; // TArduinoButton
} // Instances

namespace Types
{
typedef Mitov::BooleanInverter<
  Mitov::ConstantProperty<4, bool, true >, // Enabled = True (Default)
  Mitov::DigitalPin_EmbeddedPinImplementation<3, ::PinCalls::PinCallerReceive38 > // OutputPin
   > Inverter8; // TArduinoBooleanInverter
} // Types

namespace Instances
{
Types::Inverter8 Inverter8; // TArduinoBooleanInverter
} // Instances

namespace Types
{
typedef Mitov::ValueSource<
  0, // COUNT_Ramp_Elements = 0
  Mitov::EmbeddedCallChain<CallChains::TryActive2 >, // Elements_TryActive
  Mitov::TypedVariable<9, bool, ::ComponentVariables::Variable42 >, // FStarted = False
  Mitov::AnalogPin_EmbeddedPinImplementation<3, ::PinCalls::PinCallerReceive39 >, // OutputPin
  float, // TYPE
  Mitov::VariablePropertyFloat<5, float, ::VisuinoConstants::FloatValue1 > // Value = 0 (Default)
   > AnalogValue2; // TArduinoFloatValue
} // Types

namespace Instances
{
Types::AnalogValue2 AnalogValue2; // TArduinoFloatValue
} // Instances

namespace Types
{
typedef Mitov::ArduinoSetValueElement<
  Declarations::Types::AnalogValue2, // 0_TYPE_OWNER
  Declarations::Instances::AnalogValue2, // 1_NAME_OWNER
  Mitov::ConstantPropertyFloat<2, float, ::VisuinoConstants::FloatValue1 > // Value = 0 (Default)
   > TArduinoAnalogSetValueElement1;
} // Types

namespace Instances
{
Types::TArduinoAnalogSetValueElement1 TArduinoAnalogSetValueElement1;
} // Instances

namespace Types
{
typedef Mitov::ArduinoSetValueElement<
  Declarations::Types::AnalogValue2, // 0_TYPE_OWNER
  Declarations::Instances::AnalogValue2, // 1_NAME_OWNER
  Mitov::ConstantPropertyFloat<2, float, ::VisuinoConstants::FloatValue12 > // Value = 90
   > TArduinoAnalogSetValueElement2;
} // Types

namespace Instances
{
Types::TArduinoAnalogSetValueElement2 TArduinoAnalogSetValueElement2;
} // Instances

  Mitov::ClockPin_EmbeddedPinImplementation<6, ::PinCalls::PinCallerReceive40 > SourcePin1;
  Mitov::ClockPin_EmbeddedPinImplementation<7, ::PinCalls::PinCallerReceive41 > SourcePin2;
namespace Types
{
typedef Mitov::ClockDemux<
  2, // COUNT_OutputPins
  Mitov::VariableMinMaxPropertySharedBits<8, uint32_t, 0, ::ComponentVariables::Variable43, 0, 4000 >, // InitialChannel = 0 (Default)
  Mitov::EmbeddedCallChain<CallChains::SetPinValue1 > // OutputPins_SetPinValue
   > ClockDemmux1; // TArduinoClockDemux
} // Types

namespace Instances
{
Types::ClockDemmux1 ClockDemmux1; // TArduinoClockDemux
} // Instances

namespace Types
{
typedef Mitov::Counter<
  Mitov::ConstantProperty<4, bool, true >, // Enabled = True (Default)
  Mitov::TypedVariableMinMax<22, int32_t, ::ComponentVariables::Variable45, 0, 1 >, // FCount = 0
  Mitov::ConstantProperty<6, int32_t, 0 >, // InitialValue = 0 (Default)
  Mitov::NestedProperty<11, Mitov::GenericValueLimit<
    Mitov::DigitalPin_NoImplementation<8 >, // ReachedOutputPin
    Mitov::ConstantProperty<10, bool, true >, // RollOver = True (Default)
    Mitov::ConstantProperty<9, int32_t, 1 > // Value = 1
     > >, // Value_Max
  Mitov::NestedProperty<16, Mitov::GenericValueLimit<
    Mitov::DigitalPin_NoImplementation<13 >, // ReachedOutputPin
    Mitov::ConstantProperty<15, bool, true >, // RollOver = True (Default)
    Mitov::ConstantProperty<14, int32_t, 0 > // Value = 0
     > >, // Value_Min
  Mitov::TypedVariable<20, bool, ::ComponentVariables::Variable44 >, // NeedsUpdate = 0
  Mitov::TypedPin_EmbeddedPinImplementation<3, ::PinCalls::PinCallerReceive42, int32_t >, // OutputPin
  Mitov::ConstantProperty<19, bool, false > // Reversed = False (Default)
   > Counter2; // TArduinoCounter
} // Types

namespace Instances
{
Types::Counter2 Counter2; // TArduinoCounter
} // Instances

namespace Types
{
typedef Mitov::PulseGenerator_Shared<
  Mitov::ConstantPropertyFloat<8, float, ::VisuinoConstants::FloatValue1 >, // Asymmetry = 0 (Default)
  Mitov::ConstantProperty<4, bool, true >, // Enabled = True (Default)
  Mitov::ConstantPropertyFloat<17, float, ::VisuinoConstants::FloatValue1>, // FPhase = 0
  Mitov::TypedVariable<15, bool, ::ComponentVariables::Variable46 >, // FValue = 0
  Mitov::ConstantPropertyFloat<7, float, ::VisuinoConstants::FloatValue20 >, // Frequency = 0.5
  Mitov::ConstantProperty<5, bool, false >, // InitialValue = False (Default)
  Mitov::DigitalPin_EmbeddedPinImplementation<3, ::PinCalls::PinCallerReceive43 >, // OutputPin
  Mitov::ConstantPropertyFloat<9, float, ::VisuinoConstants::FloatValue1 >, // Phase = 0 (Default)
  Mitov::NestedProperty<14, Mitov::TArduinoGeneratorWhenDisabled<
    Mitov::ConstantProperty<13, bool, false >, // CompleteCycle = False (Default)
    Mitov::ConstantProperty<12, bool, true >, // FCycleCompleted = True
    Mitov::ConstantProperty<11, bool, false > // Reset = False (Default)
     > > // WhenDisabled
   > PulseGenerator3; // TArduinoPulseGenerator
} // Types

namespace Instances
{
Types::PulseGenerator3 PulseGenerator3; // TArduinoPulseGenerator
} // Instances

namespace Types
{
typedef Mitov::BooleanOperation<
  Mitov::BooleanOr, // BASE
  2, // COUNT_InputPins
  Mitov::TypedVariable<7, bool, ::ComponentVariables::Variable48 >, // FModified = 0
  Mitov::DigitalPin_EmbeddedPinImplementation_ChangeOnly<3, ::PinCalls::PinCallerReceive44, Mitov::TypedVariable<0, bool, ::ComponentVariables::Variable47 > > // OutputPin
   > Or3; // TArduinoBooleanOr
} // Types

namespace Instances
{
Types::Or3 Or3; // TArduinoBooleanOr
} // Instances

namespace Types
{
typedef Mitov::CompareValue<
  Mitov::CompareType_Implementation_ctEqual, // CompareType = 0 (Default)
  Mitov::ConstantProperty<4, bool, true >, // Enabled = True (Default)
  Mitov::TypedVariable<9, bool, ::ComponentVariables::Variable49 >, // FStarted = 0
  Mitov::ConstantProperty<8, bool, true >, // OnlyChanged = True (Default)
  Mitov::DigitalPin_EmbeddedPinImplementation<5, ::PinCalls::PinCallerReceive45 >, // OutputPin
  int32_t, // TYPE
  Mitov::ConstantProperty<6, int32_t, 1 > // Value = 1
   > CompareValue3; // TArduinoIntegerCompareValue
} // Types

namespace Instances
{
Types::CompareValue3 CompareValue3 = Types::CompareValue3( 0 ); // TArduinoIntegerCompareValue
} // Instances

namespace Types
{
typedef Mitov::CompareValue<
  Mitov::CompareType_Implementation_ctEqual, // CompareType = 0 (Default)
  Mitov::ConstantProperty<4, bool, true >, // Enabled = True (Default)
  Mitov::TypedVariable<9, bool, ::ComponentVariables::Variable50 >, // FStarted = 0
  Mitov::ConstantProperty<8, bool, true >, // OnlyChanged = True (Default)
  Mitov::DigitalPin_EmbeddedPinImplementation<5, ::PinCalls::PinCallerReceive46 >, // OutputPin
  int32_t, // TYPE
  Mitov::ConstantProperty<6, int32_t, 2 > // Value = 2
   > CompareValue4; // TArduinoIntegerCompareValue
} // Types

namespace Instances
{
Types::CompareValue4 CompareValue4 = Types::CompareValue4( 0 ); // TArduinoIntegerCompareValue
} // Instances

namespace Types
{
typedef Mitov::BooleanOperation<
  Mitov::BooleanOr, // BASE
  2, // COUNT_InputPins
  Mitov::TypedVariable<7, bool, ::ComponentVariables::Variable52 >, // FModified = 0
  Mitov::DigitalPin_EmbeddedPinImplementation_ChangeOnly<3, ::PinCalls::PinCallerReceive47, Mitov::TypedVariable<0, bool, ::ComponentVariables::Variable51 > > // OutputPin
   > Or4; // TArduinoBooleanOr
} // Types

namespace Instances
{
Types::Or4 Or4; // TArduinoBooleanOr
} // Instances

namespace Types
{
typedef Mitov::BooleanOperation<
  Mitov::BooleanOr, // BASE
  2, // COUNT_InputPins
  Mitov::TypedVariable<7, bool, ::ComponentVariables::Variable54 >, // FModified = 0
  Mitov::DigitalPin_EmbeddedPinImplementation_ChangeOnly<3, ::PinCalls::PinCallerReceive48, Mitov::TypedVariable<0, bool, ::ComponentVariables::Variable53 > > // OutputPin
   > Or5; // TArduinoBooleanOr
} // Types

namespace Instances
{
Types::Or5 Or5; // TArduinoBooleanOr
} // Instances

} // Declarations

// Type Converters

namespace TypeConverters
{
Mitov::Convert_BinaryToClock<Mitov::TypedVariable<0, bool, ::ComponentVariables::Variable55 > > Converter0;
Mitov::Convert_BinaryToClock<Mitov::TypedVariable<0, bool, ::ComponentVariables::Variable56 > > Converter1;
Mitov::Convert_BinaryToClock<Mitov::TypedVariable<0, bool, ::ComponentVariables::Variable57 > > Converter2;
Mitov::Convert_BinaryToClock<Mitov::TypedVariable<0, bool, ::ComponentVariables::Variable58 > > Converter3;
Mitov::Convert_BinaryToClock<Mitov::TypedVariable<0, bool, ::ComponentVariables::Variable59 > > Converter4;
Mitov::Convert_BinaryToClock<Mitov::TypedVariable<0, bool, ::ComponentVariables::Variable60 > > Converter5;
} // TypeConverters

// Bindings

namespace Bindings
{
inline void PulseGenerator1_EnabledInputPin_o_Receive( void * ___PTR___, bool __AOriginalValue__ )
{
  bool ___A_VALUE___ = *(bool *)___PTR___;
  if( __AOriginalValue__ == ___A_VALUE___ )
    return;

  Declarations::Instances::PulseGenerator1.Enabled() = ___A_VALUE___;
  Declarations::Instances::PulseGenerator1.UpdateEnabled();
}

inline void PulseGenerator2_EnabledInputPin_o_Receive( void * ___PTR___, bool __AOriginalValue__ )
{
  bool ___A_VALUE___ = *(bool *)___PTR___;
  if( __AOriginalValue__ == ___A_VALUE___ )
    return;

  Declarations::Instances::PulseGenerator2.Enabled() = ___A_VALUE___;
  Declarations::Instances::PulseGenerator2.UpdateEnabled();
}

inline void Servo1_EnabledInputPin_o_Receive( void * ___PTR___, bool __AOriginalValue__ )
{
  bool ___A_VALUE___ = *(bool *)___PTR___;
  if( __AOriginalValue__ == ___A_VALUE___ )
    return;

  Declarations::Instances::Servo1.Enabled() = ___A_VALUE___;
  Declarations::Instances::Servo1.UpdateEnabled();
}

} // Bindings

// Call Chains

namespace CallChains
{
void SendByte1::Call( uint8_t AValue )
{
  BoardDeclarations::Instances::TArduinoI2C1.SendByte( AValue );
}

void RequestData1::Call()
{
  BoardDeclarations::Instances::TArduinoI2C1.RequestData();
}

void TryActive1::Call( bool & AResult )
{
  Declarations::Instances::TArduinoAnalogStateSetValueElement5.TryActive( AResult );
  Declarations::Instances::TArduinoAnalogStateSetValueElement4.TryActive( AResult );
  Declarations::Instances::TArduinoAnalogStateSetValueElement3.TryActive( AResult );
  Declarations::Instances::TArduinoAnalogStateSetValueElement2.TryActive( AResult );
  Declarations::Instances::TArduinoAnalogStateSetValueElement1.TryActive( AResult );
}

void TryActive2::Call( bool & AResult )
{
}

void SetPinValue1::Call( uint32_t AIndex )
{
  switch( AIndex )
  {
    case 0: ::Declarations::SourcePin1.ClockPin(); break;
    case 1: ::Declarations::SourcePin2.ClockPin(); break;
  }
}

void PeriodicCall1::Call()
{
  Declarations::Instances::PulseGenerator3.PeriodicCall();
}

} // CallChains

// Pin Call Declarations

namespace PinCalls
{
void PinCallerConverterReceive1( void *_Data );
void PinCallerConverterReceive2( void *_Data );
void PinCallerConverterReceive3( void *_Data );
void PinCallerConverterReceive4( void *_Data );
void PinCallerConverterReceive5( void *_Data );
void PinCallerConverterReceive6( void *_Data );
} // PinCalls

// Pin Call Implementations

namespace PinCalls
{
void PinCallerReceive1::Notify( void *_Data )
{
  Declarations::Instances::GPS1._DirectPinReceive( _Data );
}

void PinCallerReceive0::Notify( void *_Data )
{
  Declarations::Instances::Button1.InputPin_o_Receive( _Data );
}

void PinCallerReceive2::Notify( void *_Data )
{
  Declarations::Instances::CompareRange2.InputPin_o_Receive( _Data );
}

void PinCallerReceive3::Notify( void *_Data )
{
  Declarations::Instances::CompareRange1.InputPin_o_Receive( _Data );
  Declarations::Instances::CompareValue1.InputPin_o_Receive( _Data );
}

void PinCallerReceive4::Notify( void *_Data )
{
  Declarations::Instances::CompareRange3.InputPin_o_Receive( _Data );
  Declarations::Instances::CompareRange4.InputPin_o_Receive( _Data );
  Declarations::Instances::CompareRange5.InputPin_o_Receive( _Data );
  Declarations::Instances::CompareRange6.InputPin_o_Receive( _Data );
  Declarations::Instances::CompareRange7.InputPin_o_Receive( _Data );
  Declarations::Instances::CompareRange8.InputPin_o_Receive( _Data );
}

void PinCallerReceive5::Notify( void *_Data )
{
  Declarations::Instances::CompassHeading1.InputPins_o_Receive( 0, _Data );
}

void PinCallerReceive6::Notify( void *_Data )
{
  Declarations::Instances::CompassHeading1.InputPins_o_Receive( 1, _Data );
}

void PinCallerReceive7::Notify( void *_Data )
{
  Declarations::Instances::Or1.InputPins_o_Receive( 1, _Data );
}

void PinCallerReceive8::Notify( void *_Data )
{
  Declarations::Instances::And1.InputPins_o_Receive( 0, _Data );
}

void PinCallerReceive9::Notify( void *_Data )
{
  Declarations::Instances::And1.InputPins_o_Receive( 1, _Data );
}

void PinCallerReceive10::Notify( void *_Data )
{
  Declarations::Instances::Or1.InputPins_o_Receive( 0, _Data );
}

void PinCallerReceive11::Notify( void *_Data )
{
  Declarations::Instances::Inverter1.InputPin_o_Receive( _Data );
}

void PinCallerReceive12::Notify( void *_Data )
{
  Declarations::Instances::And2.InputPins_o_Receive( 0, _Data );
}

void PinCallerReceive13::Notify( void *_Data )
{
  Declarations::Instances::Or2.InputPins_o_Receive( 0, _Data );
  TypeConverters::Converter0.Convert( _Data, PinCallerConverterReceive1 );
  Declarations::Instances::Inverter7.InputPin_o_Receive( _Data );
  Declarations::Instances::Or5.InputPins_o_Receive( 0, _Data );
}

void PinCallerConverterReceive1( void *_Data )
{
  Declarations::Instances::Delay1.StartInputPin_o_Receive( _Data );
}
void PinCallerReceive14::Notify( void *_Data )
{
  Declarations::Instances::Or2.InputPins_o_Receive( 1, _Data );
  TypeConverters::Converter1.Convert( _Data, PinCallerConverterReceive2 );
}

void PinCallerConverterReceive2( void *_Data )
{
  Declarations::Instances::Delay1.ResetInputPin_o_Receive( _Data );
}
void PinCallerReceive15::Notify( void *_Data )
{
  Declarations::Instances::PulseGenerator2.Frequency().InputPin_o_Receive( _Data );
}

void PinCallerReceive16::Notify( void *_Data )
{
  Declarations::Instances::Inverter5.InputPin_o_Receive( _Data );
}

void PinCallerReceive17::Notify( void *_Data )
{
  Declarations::Instances::Inverter4.InputPin_o_Receive( _Data );
}

void PinCallerReceive18::Notify( void *_Data )
{
  Declarations::Instances::Inverter3.InputPin_o_Receive( _Data );
}

void PinCallerReceive19::Notify( void *_Data )
{
  Declarations::Instances::Inverter2.InputPin_o_Receive( _Data );
}

void PinCallerReceive20::Notify( void *_Data )
{
  Declarations::Instances::TArduinoAnalogStateSetValueElement5.InputPin_o_Receive( _Data );
}

void PinCallerReceive21::Notify( void *_Data )
{
  Declarations::Instances::TArduinoAnalogStateSetValueElement4.InputPin_o_Receive( _Data );
}

void PinCallerReceive22::Notify( void *_Data )
{
  Declarations::Instances::TArduinoAnalogStateSetValueElement3.InputPin_o_Receive( _Data );
}

void PinCallerReceive23::Notify( void *_Data )
{
  Declarations::Instances::TArduinoAnalogStateSetValueElement2.InputPin_o_Receive( _Data );
}

void PinCallerReceive24::Notify( void *_Data )
{
  Declarations::Instances::TArduinoAnalogStateSetValueElement1.InputPin_o_Receive( _Data );
}

void PinCallerReceive25::Notify( void *_Data )
{
  Declarations::Instances::Inverter6.InputPin_o_Receive( _Data );
}

void PinCallerReceive26::Notify( void *_Data )
{
  Declarations::Instances::SRFlipFlop1.SetInputPin_o_Receive( _Data );
}

void PinCallerReceive27::Notify( void *_Data )
{
  TypeConverters::Converter2.Convert( _Data, PinCallerConverterReceive3 );
  Declarations::Instances::Or3.InputPins_o_Receive( 0, _Data );
}

void PinCallerConverterReceive3( void *_Data )
{
  Declarations::Instances::Timer1.StartInputPin_o_Receive( _Data );
}
void PinCallerReceive28::Notify( void *_Data )
{
  TypeConverters::Converter3.Convert( _Data, PinCallerConverterReceive4 );
}

void PinCallerConverterReceive4( void *_Data )
{
  Declarations::Instances::SRFlipFlop1.ResetInputPin_o_Receive( _Data );
  Declarations::Instances::Timer1.ResetInputPin_o_Receive( _Data );
}
void PinCallerReceive29::Notify( void *_Data )
{
  bool __Value_PulseGenerator2_EnabledInputPin__ = Declarations::Instances::PulseGenerator2.Enabled().GetValue();
  ::Bindings::PulseGenerator2_EnabledInputPin_o_Receive( _Data, __Value_PulseGenerator2_EnabledInputPin__ );
}

void PinCallerReceive30::Notify( void *_Data )
{
  Declarations::Instances::AnalogMux1.InputPins_o_Receive( 0, _Data );
}

void PinCallerReceive31::Notify( void *_Data )
{
  Declarations::Instances::CompareValue2.InputPin_o_Receive( _Data );
}

void PinCallerReceive32::Notify( void *_Data )
{
  Declarations::Instances::Servo1.InputPin_o_Receive( _Data );
}

void PinCallerReceive33::Notify( void *_Data )
{
  Declarations::Instances::And2.InputPins_o_Receive( 1, _Data );
}

void PinCallerReceive34::Notify( void *_Data )
{
  BoardDeclarations::Instances::ArduinoDigitalChannel_6.DigitalInputPin_o_Receive( _Data );
  Declarations::Instances::Or4.InputPins_o_Receive( 0, _Data );
}

void PinCallerReceive35::Notify( void *_Data )
{
  Declarations::Instances::MapRange1.InputPin_o_Receive( _Data );
}

void PinCallerReceive36::Notify( void *_Data )
{
  Declarations::Instances::AnalogMux1.SelectInputPin_o_Receive( _Data );
  Declarations::Instances::CompareValue3.InputPin_o_Receive( _Data );
  Declarations::Instances::CompareValue4.InputPin_o_Receive( _Data );
}

void PinCallerReceive37::Notify( void *_Data )
{
  Declarations::Instances::Inverter8.InputPin_o_Receive( _Data );
}

void PinCallerReceive38::Notify( void *_Data )
{
  TypeConverters::Converter4.Convert( _Data, PinCallerConverterReceive5 );
}

void PinCallerConverterReceive5( void *_Data )
{
  Declarations::Instances::Counter1.InputPin_o_Receive( _Data );
}
void PinCallerReceive39::Notify( void *_Data )
{
  Declarations::Instances::AnalogMux1.InputPins_o_Receive( 1, _Data );
}

void PinCallerReceive40::Notify( void *_Data )
{
  Declarations::Instances::TArduinoAnalogSetValueElement1.InputPin_o_Receive( _Data );
}

void PinCallerReceive41::Notify( void *_Data )
{
  Declarations::Instances::TArduinoAnalogSetValueElement2.InputPin_o_Receive( _Data );
}

void PinCallerReceive42::Notify( void *_Data )
{
  Declarations::Instances::ClockDemmux1.SelectInputPin_o_Receive( _Data );
  Declarations::Instances::ClockDemmux1.InputPin_o_Receive( _Data );
}

void PinCallerReceive43::Notify( void *_Data )
{
  TypeConverters::Converter5.Convert( _Data, PinCallerConverterReceive6 );
}

void PinCallerConverterReceive6( void *_Data )
{
  Declarations::Instances::Counter2.InputPin_o_Receive( _Data );
}
void PinCallerReceive44::Notify( void *_Data )
{
  bool __Value_Servo1_EnabledInputPin__ = Declarations::Instances::Servo1.Enabled().GetValue();
  ::Bindings::Servo1_EnabledInputPin_o_Receive( _Data, __Value_Servo1_EnabledInputPin__ );
  BoardDeclarations::Instances::ArduinoDigitalChannel_13.DigitalInputPin_o_Receive( _Data );
}

void PinCallerReceive45::Notify( void *_Data )
{
  Declarations::Instances::Or3.InputPins_o_Receive( 1, _Data );
}

void PinCallerReceive46::Notify( void *_Data )
{
  Declarations::Instances::Or4.InputPins_o_Receive( 1, _Data );
  Declarations::Instances::Or5.InputPins_o_Receive( 1, _Data );
}

void PinCallerReceive47::Notify( void *_Data )
{
  bool __Value_PulseGenerator1_EnabledInputPin__ = Declarations::Instances::PulseGenerator1.Enabled().GetValue();
  ::Bindings::PulseGenerator1_EnabledInputPin_o_Receive( _Data, __Value_PulseGenerator1_EnabledInputPin__ );
}

void PinCallerReceive48::Notify( void *_Data )
{
  Declarations::Instances::And1.InputPins_o_Receive( 2, _Data );
}

} // PinCalls

namespace ComponentsHardware
{
void SystemUpdateHardware()
{
}
} // ComponentsHardware

//The setup function is called once at startup of the sketch
void setup()
{
  BoardDeclarations::SystemPeriodMicros_1000000.SystemStarted();
  BoardDeclarations::Instances::SerialPort0.SystemInit();
  BoardDeclarations::Instances::TArduinoI2C1.SystemInit();
  BoardDeclarations::Instances::ArduinoDigitalChannel_6.SystemInit();
  BoardDeclarations::Instances::ArduinoDigitalChannel_8.SystemInit();
  BoardDeclarations::Instances::ArduinoDigitalChannel_13.SystemInit();
  Declarations::Instances::AccelerometerGyroscope1.SystemInit();
  Declarations::Instances::Counter1.SystemInit();
  Declarations::Instances::Counter2.SystemInit();
  BoardDeclarations::Instances::ArduinoDigitalChannel_6.SystemStart();
  BoardDeclarations::Instances::ArduinoDigitalChannel_8.SystemStart();
  BoardDeclarations::Instances::ArduinoDigitalChannel_13.SystemStart();
  Declarations::Instances::AccelerometerGyroscope1.SystemStart();
  Declarations::Instances::Compass1.SystemStart();
  Declarations::Instances::PulseGenerator1.SystemStart();
  Declarations::Instances::Or1.SystemStart();
  Declarations::Instances::CompareRange1.SystemStart();
  Declarations::Instances::CompareRange2.SystemStart();
  Declarations::Instances::And1.SystemStart();
  Declarations::Instances::CompareRange3.SystemStart();
  Declarations::Instances::Or2.SystemStart();
  Declarations::Instances::PulseGenerator2.SystemStart();
  Declarations::Instances::AnalogValue1.SystemStart();
  Declarations::Instances::CompareRange4.SystemStart();
  Declarations::Instances::CompareRange5.SystemStart();
  Declarations::Instances::CompareRange6.SystemStart();
  Declarations::Instances::CompareRange7.SystemStart();
  Declarations::Instances::CompareRange8.SystemStart();
  Declarations::Instances::Servo1.SystemStart();
  Declarations::Instances::SRFlipFlop1.SystemStart();
  Declarations::Instances::CompareValue1.SystemStart();
  Declarations::Instances::CompareValue2.SystemStart();
  Declarations::Instances::And2.SystemStart();
  Declarations::Instances::Timer1.SystemStart();
  Declarations::Instances::AnalogMux1.SystemStart();
  Declarations::Instances::Counter1.SystemStart();
  Declarations::Instances::Button1.SystemStart();
  Declarations::Instances::AnalogValue2.SystemStart();
  Declarations::Instances::Counter2.SystemStart();
  Declarations::Instances::PulseGenerator3.SystemStart();
  Declarations::Instances::Or3.SystemStart();
  Declarations::Instances::CompareValue3.SystemStart();
  Declarations::Instances::CompareValue4.SystemStart();
  Declarations::Instances::Or4.SystemStart();
  Declarations::Instances::Or5.SystemStart();
}

// The loop function is called in an endless loop
void loop()
{
  BoardDeclarations::SystemPeriodMicros_1000000.SystemLoopBegin();
  BoardDeclarations::Instances::ArduinoDigitalChannel_6.SystemLoopBegin();
  BoardDeclarations::Instances::ArduinoDigitalChannel_8.SystemLoopBegin();
  BoardDeclarations::Instances::ArduinoDigitalChannel_13.SystemLoopBegin();
  BoardDeclarations::Instances::SerialPort0.SystemLoopBeginOutput();
  Declarations::Instances::AccelerometerGyroscope1.SystemLoopBegin();
  Declarations::Instances::Compass1.SystemLoopBegin();
  Declarations::Instances::PulseGenerator1.SystemLoopBegin();
  Declarations::Instances::PulseGenerator2.SystemLoopBegin();
  Declarations::Instances::Delay1.SystemLoopBegin();
  Declarations::Instances::Timer1.SystemLoopBegin();
  Declarations::Instances::Button1.SystemLoopBegin();
  Declarations::Instances::PulseGenerator3.SystemLoopBegin();
  Declarations::Instances::CompassHeading1.SystemLoopEnd();
  Declarations::Instances::Or1.SystemLoopEnd();
  Declarations::Instances::And1.SystemLoopEnd();
  Declarations::Instances::Or2.SystemLoopEnd();
  Declarations::Instances::And2.SystemLoopEnd();
  Declarations::Instances::AnalogMux1.SystemLoopEnd();
  Declarations::Instances::Or3.SystemLoopEnd();
  Declarations::Instances::Or4.SystemLoopEnd();
  Declarations::Instances::Or5.SystemLoopEnd();
}