private static string UID = "XXYYZZ"; // Change XXYYZZ to the UID of your Servo Brick

    #endregion Fields

    #region Methods

    static void Main()
    {
        IPConnection ipcon = new IPConnection(); // Create IP connection
        BrickServo servo = new BrickServo(UID, ipcon); // Create device object

        ipcon.Connect(HOST, PORT); // Connect to brickd
        // Don't use device before ipcon is connected

        // Register position reached callback to function PositionReachedCB
        servo.PositionReached += PositionReachedCB;

        // Enable position reached callback
        servo.EnablePositionReachedCallback();

        // Set velocity to 100°/s. This has to be smaller or equal to the
        // maximum velocity of the servo you are using, otherwise the position
        // reached callback will be called too early
        servo.SetVelocity(0, 10000);
        servo.SetPosition(0, 9000);
        servo.Enable(0);

        Console.WriteLine("Press enter to exit");
        Console.ReadLine();
        servo.Disable(0);
        ipcon.Disconnect();
    }

    // Print incoming enumeration
    static void EnumerateCB(IPConnection sender,
	                        string uid, string connectedUid, char position,
	                        short[] hardwareVersion, short[] firmwareVersion,
	                        int deviceIdentifier, short enumerationType)
    {
        System.Console.WriteLine("UID:               " + uid);
        System.Console.WriteLine("Enumeration Type:  " + enumerationType);

        if(enumerationType == IPConnection.ENUMERATION_TYPE_DISCONNECTED)
        {
            System.Console.WriteLine("");
            return;
        }

        System.Console.WriteLine("Connected UID:     " + connectedUid);
        System.Console.WriteLine("Position:          " + position);
        System.Console.WriteLine("Hardware Version:  " + hardwareVersion[0] + "." +
                                                         hardwareVersion[1] + "." +
                                                         hardwareVersion[2]);
        System.Console.WriteLine("Firmware Version:  " + firmwareVersion[0] + "." +
                                                         firmwareVersion[1] + "." +
                                                         firmwareVersion[2]);
        System.Console.WriteLine("Device Identifier: " + deviceIdentifier);
        System.Console.WriteLine("");
    }

    private static string UID = "XYZ"; // Change XYZ to the UID of your Multi Touch Bricklet

    #endregion Fields

    #region Methods

    static void Main()
    {
        IPConnection ipcon = new IPConnection(); // Create IP connection
        BrickletMultiTouch mt = new BrickletMultiTouch(UID, ipcon); // Create device object

        ipcon.Connect(HOST, PORT); // Connect to brickd
        // Don't use device before ipcon is connected

        // Get current touch state
        int state = mt.GetTouchState();
        string str = "";

        if((state & (1 << 12)) == (1 << 12)) {
            str += "In proximity, ";
        }

        if((state & 0xfff) == 0) {
            str += "No electrodes touched";
        } else {
            str += "Electrodes ";
            for(int i = 0; i < 12; i++) {
                if((state & (1 << i)) == (1 << i)) {
                    str += i + " ";
                }
            }
            str += "touched";
        }

        Console.WriteLine(str);

        Console.WriteLine("Press enter to exit");
        Console.ReadLine();
        ipcon.Disconnect();
    }

    private static string UID = "XYZ"; // Change XYZ to the UID of your Industrial Digital Out 4 Bricklet

    #endregion Fields

    #region Methods

    static void Main()
    {
        IPConnection ipcon = new IPConnection(); // Create IP connection
        BrickletIndustrialDigitalOut4 ido4 =
          new BrickletIndustrialDigitalOut4(UID, ipcon); // Create device object

        ipcon.Connect(HOST, PORT); // Connect to brickd
        // Don't use device before ipcon is connected

        // Turn pins alternating high/low 10 times with 100ms delay
        for(int i = 0; i < 10; i++)
        {
            Thread.Sleep(100);
            ido4.SetValue(1 << 0);
            Thread.Sleep(100);
            ido4.SetValue(1 << 1);
            Thread.Sleep(100);
            ido4.SetValue(1 << 2);
            Thread.Sleep(100);
            ido4.SetValue(1 << 3);
        }

        Console.WriteLine("Press enter to exit");
        Console.ReadLine();
        ipcon.Disconnect();
    }

    // Callback handles device connections and configures possibly lost
    // configuration of lcd and temperature callbacks, backlight etc.
    static void EnumerateCB(IPConnection sender, string UID, string connectedUID, 
	                        char position, short[] hardwareVersion, 
	                        short[] firmwareVersion, int deviceIdentifier, 
	                        short enumerationType)
    {
        if(enumerationType == IPConnection.ENUMERATION_TYPE_CONNECTED ||
           enumerationType == IPConnection.ENUMERATION_TYPE_AVAILABLE)
        {
            // Enumeration is for LCD Bricklet
            if(deviceIdentifier == BrickletLCD20x4.DEVICE_IDENTIFIER)
            {
                // Create lcd device object
                lcd = new BrickletLCD20x4(UID, ipcon);
                lcd.ButtonPressed += ButtonPressedCB;

                lcd.ClearDisplay();
                lcd.BacklightOn();
            }
            // Enumeration is for Temperature Bricklet
            if(deviceIdentifier == BrickletTemperature.DEVICE_IDENTIFIER)
            {
                // Create temperature device object
                temp = new BrickletTemperature(UID, ipcon);
                temp.Temperature += TemperatureCB;

                temp.SetTemperatureCallbackPeriod(50);
            }
        }
    }

    private static string UID = "XYZ"; // Change XYZ to the UID of your Tilt Bricklet

    #endregion Fields

    #region Methods

    static void Main()
    {
        IPConnection ipcon = new IPConnection(); // Create IP connection
        BrickletTilt t = new BrickletTilt(UID, ipcon); // Create device object

        ipcon.Connect(HOST, PORT); // Connect to brickd
        // Don't use device before ipcon is connected

        // Get current tilt state
        byte state = t.GetTiltState();

        switch(state)
        {
        case BrickletTilt.TILT_STATE_CLOSED:
            Console.WriteLine("Tilt State: Closed");
            break;
        case BrickletTilt.TILT_STATE_OPEN:
            Console.WriteLine("Tilt State: Open");
            break;
        case BrickletTilt.TILT_STATE_CLOSED_VIBRATING:
            Console.WriteLine("Tilt State: Closed Vibrating");
            break;
        }

        Console.WriteLine("Press enter to exit");
        Console.ReadLine();
        ipcon.Disconnect();
    }

    static void Main()
    {
        IPConnection ipcon = new IPConnection(); // Create IP connection
        BrickletCAN can = new BrickletCAN(UID, ipcon); // Create device object

        ipcon.Connect(HOST, PORT); // Connect to brickd
        // Don't use device before ipcon is connected

        // Configure transceiver for loopback mode
        can.SetConfiguration(BrickletCAN.BAUD_RATE_1000KBPS,
                             BrickletCAN.TRANSCEIVER_MODE_LOOPBACK, 0);

        // Register frame read callback to function FrameReadCB
        can.FrameRead += FrameReadCB;

        // Enable frame read callback
        can.EnableFrameReadCallback();

        // Write standard data frame with identifier 1742 and 3 bytes of data
        byte[] data = new byte[8]{42, 23, 17, 0, 0, 0, 0, 0};
        can.WriteFrame(BrickletCAN.FRAME_TYPE_STANDARD_DATA, 1742, data, 3);

        Console.WriteLine("Press enter to exit");
        Console.ReadLine();
        can.DisableFrameReadCallback();
        ipcon.Disconnect();
    }

 // Callback handles reconnection of IP Connection
 static void ConnectedCB(IPConnection sender, short connectReason)
 {
     // Enumerate devices again. If we reconnected, the Bricks/Bricklets
     // may have been offline and the configuration may be lost.
     // In this case we don't care for the reason of the connection
     ipcon.Enumerate();
 }

    // Authenticate each time the connection got (re-)established
    static void ConnectedCB(IPConnection sender, short connectReason)
    {
        switch(connectReason)
        {
            case IPConnection.CONNECT_REASON_REQUEST:
                System.Console.WriteLine("Connected by request");
                break;

            case IPConnection.CONNECT_REASON_AUTO_RECONNECT:
                System.Console.WriteLine("Auto-Reconnected");
                break;
        }

        // Authenticate first...
        try
        {
            sender.Authenticate(SECRET);
            System.Console.WriteLine("Authentication succeeded");
        }
        catch(TinkerforgeException)
        {
            System.Console.WriteLine("Could not authenticate");
            return;
        }

        // ...then trigger enumerate
        sender.Enumerate();
    }

    // Print incoming enumeration
    static void EnumerateCB(IPConnection sender,
	                        string uid, string connectedUid, char position,
	                        short[] hardwareVersion, short[] firmwareVersion,
	                        int deviceIdentifier, short enumerationType)
    {
        System.Console.WriteLine("UID: " + uid + ", Enumeration Type: " + enumerationType);
    }

    static void EnumerateCB(IPConnection sender, string UID, string connectedUID, char position,
	                        short[] hardwareVersion, short[] firmwareVersion,
	                        int deviceIdentifier, short enumerationType)
    {
        if(enumerationType == IPConnection.ENUMERATION_TYPE_CONNECTED ||
           enumerationType == IPConnection.ENUMERATION_TYPE_AVAILABLE)
        {
            if(deviceIdentifier == BrickletIndustrialDigitalIn4.DEVICE_IDENTIFIER)
            {
                try
                {
                    brickletIndustrialDigitalIn4 = new BrickletIndustrialDigitalIn4(UID, ipcon);
                    brickletIndustrialDigitalIn4.SetDebouncePeriod(10000);
                    brickletIndustrialDigitalIn4.SetInterrupt(15);
                    brickletIndustrialDigitalIn4.Interrupt += InterruptCB;
                    System.Console.WriteLine("Industrial Digital In 4 initialized");
                }
                catch(TinkerforgeException e)
                {
                    System.Console.WriteLine("Industrial Digital In 4 init failed: " + e.Message);
                    brickletIndustrialDigitalIn4 = null;
                }
            }
        }
    }

    private static string UID = "XYZ"; // Change XYZ to the UID of your Real-Time Clock Bricklet

    #endregion Fields

    #region Methods

    static void Main()
    {
        IPConnection ipcon = new IPConnection(); // Create IP connection
        BrickletRealTimeClock rtc = new BrickletRealTimeClock(UID, ipcon); // Create device object

        ipcon.Connect(HOST, PORT); // Connect to brickd
        // Don't use device before ipcon is connected

        // Get current date and time
        int year; byte month, day, hour, minute, second, centisecond, weekday;
        rtc.GetDateTime(out year, out month, out day, out hour, out minute, out second,
                        out centisecond, out weekday);

        Console.WriteLine("Year: " + year);
        Console.WriteLine("Month: " + month);
        Console.WriteLine("Day: " + day);
        Console.WriteLine("Hour: " + hour);
        Console.WriteLine("Minute: " + minute);
        Console.WriteLine("Second: " + second);
        Console.WriteLine("Centisecond: " + centisecond);
        Console.WriteLine("Weekday: " + weekday);

        // Get current timestamp (unit is ms)
        long timestamp = rtc.GetTimestamp();
        Console.WriteLine("Timestamp: " + timestamp + " ms");

        Console.WriteLine("Press enter to exit");
        Console.ReadLine();
        ipcon.Disconnect();
    }

    public DualButtonInput(IPConnection ipcon, BlockingQueue<char> keyQueue)
    {
        this.keyQueue = keyQueue;

        byte buttonL;
        byte buttonR;

        if (Config.UID_DUAL_BUTTON_BRICKLET[0] == null)
        {
            System.Console.WriteLine("Not Configured: Dual Button 1");
        }
        else
        {
            dualButton1 = new BrickletDualButton(Config.UID_DUAL_BUTTON_BRICKLET[0], ipcon);

            try
            {
                dualButton1.GetButtonState(out buttonL, out buttonR);
                System.Console.WriteLine("Found: Dual Button 1 ({0})",
                                         Config.UID_DUAL_BUTTON_BRICKLET[0]);
            }
            catch (TinkerforgeException)
            {
                System.Console.WriteLine("Not Found: Dual Button 1 ({0})",
                                         Config.UID_DUAL_BUTTON_BRICKLET[0]);
            }

            dualButton1.StateChanged += StateChanged1CB;
        }

        if (Config.UID_DUAL_BUTTON_BRICKLET[1] == null)
        {
            System.Console.WriteLine("Not Configured: Dual Button 2");
        }
        else
        {
            dualButton2 = new BrickletDualButton(Config.UID_DUAL_BUTTON_BRICKLET[1], ipcon);

            try
            {
                dualButton2.GetButtonState(out buttonL, out buttonR);
                System.Console.WriteLine("Found: Dual Button 2 ({0})",
                                         Config.UID_DUAL_BUTTON_BRICKLET[0]);
            }
            catch (TinkerforgeException)
            {
                System.Console.WriteLine("Not Found: Dual Button 2 ({0})",
                                         Config.UID_DUAL_BUTTON_BRICKLET[0]);
            }

            dualButton2.StateChanged += StateChanged2CB;
        }

        pressTimer = new Timer(delegate(object state) { PressTick(); }, null, 100, 100);
    }

    private static int VALUE_B_ON = (1 << 1) | (1 << 2); // Pin 1 and 2 high

    #endregion Fields

    #region Methods

    static void Main()
    {
        IPConnection ipcon = new IPConnection(); // Create IP connection
        BrickletIndustrialQuadRelay iqr = new BrickletIndustrialQuadRelay(UID, ipcon); // Create device object

        ipcon.Connect(HOST, PORT); // Connect to brickd
        // Don't use device before ipcon is connected

        iqr.SetMonoflop(VALUE_A_ON, 15, 1500); // Set pins to high for 1.5 seconds

        ipcon.Disconnect();
    }

    private static string UID = "XYZ"; // Change XYZ to the UID of your Piezo Buzzer Bricklet

    #endregion Fields

    #region Methods

    static void Main()
    {
        IPConnection ipcon = new IPConnection(); // Create IP connection
        BrickletPiezoBuzzer pb = new BrickletPiezoBuzzer(UID, ipcon); // Create device object

        ipcon.Connect(HOST, PORT); // Connect to brickd
        // Don't use device before ipcon is connected

        // Make 2 second beep
        pb.Beep(2000);

        Console.WriteLine("Press enter to exit");
        Console.ReadLine();
        ipcon.Disconnect();
    }

    private static string UID = "XYZ"; // Change XYZ to the UID of your Analog Out Bricklet

    #endregion Fields

    #region Methods

    static void Main()
    {
        IPConnection ipcon = new IPConnection(); // Create IP connection
        BrickletAnalogOut ao = new BrickletAnalogOut(UID, ipcon); // Create device object

        ipcon.Connect(HOST, PORT); // Connect to brickd
        // Don't use device before ipcon is connected

        // Set output voltage to 3.3V
        ao.SetVoltage(3300);

        Console.WriteLine("Press enter to exit");
        Console.ReadLine();
        ipcon.Disconnect();
    }

    private static string UID = "XYZ"; // Change XYZ to the UID of your Piezo Speaker Bricklet

    #endregion Fields

    #region Methods

    static void Main()
    {
        IPConnection ipcon = new IPConnection(); // Create IP connection
        BrickletPiezoSpeaker ps = new BrickletPiezoSpeaker(UID, ipcon); // Create device object

        ipcon.Connect(HOST, PORT); // Connect to brickd
        // Don't use device before ipcon is connected

        // Morse SOS with a frequency of 2kHz
        ps.MorseCode("... --- ...", 2000);

        Console.WriteLine("Press enter to exit");
        Console.ReadLine();
        ipcon.Disconnect();
    }

    private static string UID = "XYZ"; // Change XYZ to the UID of your RGB LED Bricklet

    #endregion Fields

    #region Methods

    static void Main()
    {
        IPConnection ipcon = new IPConnection(); // Create IP connection
        BrickletRGBLED rl = new BrickletRGBLED(UID, ipcon); // Create device object

        ipcon.Connect(HOST, PORT); // Connect to brickd
        // Don't use device before ipcon is connected

        // Set light blue color
        rl.SetRGBValue(0, 170, 234);

        Console.WriteLine("Press enter to exit");
        Console.ReadLine();
        ipcon.Disconnect();
    }

    private static string UID = "XYZ"; // Change XYZ to the UID of your Multi Touch Bricklet

    #endregion Fields

    #region Methods

    static void Main()
    {
        IPConnection ipcon = new IPConnection(); // Create IP connection
        BrickletMultiTouch mt = new BrickletMultiTouch(UID, ipcon); // Create device object

        ipcon.Connect(HOST, PORT); // Connect to brickd
        // Don't use device before ipcon is connected

        // Register touch state callback to function TouchStateCB
        mt.TouchState += TouchStateCB;

        Console.WriteLine("Press enter to exit");
        Console.ReadLine();
        ipcon.Disconnect();
    }

    private static string UID = "XYZ"; // Change XYZ to the UID of your Dual Button Bricklet

    #endregion Fields

    #region Methods

    static void Main()
    {
        IPConnection ipcon = new IPConnection(); // Create IP connection
        BrickletDualButton db = new BrickletDualButton(UID, ipcon); // Create device object

        ipcon.Connect(HOST, PORT); // Connect to brickd
        // Don't use device before ipcon is connected

        // Register state changed callback to function StateChangedCB
        db.StateChanged += StateChangedCB;

        Console.WriteLine("Press enter to exit");
        Console.ReadLine();
        ipcon.Disconnect();
    }