Tinkerforge

https://www.tinkerforge.com/en/doc/
Admin
Tinkerforge is an open-source hardware building block system of stackable Bricks and sensor/actuator...
Tokens:8,951,314
Snippets:92,015
Trust Score:9.4
Update:2 months ago
Show doc for...
Tokens:
Raw
### Execute Example with Installed Bindings

Source: https://www.tinkerforge.com/en/doc/Software/API_Bindings_Ruby.html

Command to run the configuration example when bindings are installed.

```bash
ruby example_configuration.rb
```

--------------------------------

### Install Bindings from Source

Source: https://www.tinkerforge.com/en/doc/Software/API_Bindings_Python.html

Use the setup script or pip to install the bindings from the source directory.

```bash
python setup.py install
```

```bash
pip install .
```

--------------------------------

### Execute PHP Example

Source: https://www.tinkerforge.com/en/doc/Software/API_Bindings_PHP.html

Command to run the configuration example script.

```bash
php ExampleConfiguration.php
```

--------------------------------

### Execute Node.js Example

Source: https://www.tinkerforge.com/en/doc/Software/API_Bindings_JavaScript.html

Command to run the configuration example script.

```bash
node ExampleConfiguration.js
```

--------------------------------

### Install Brick Daemon

Source: https://www.tinkerforge.com/en/doc/Tutorials/Tutorial_Build_Environment/Tutorial.html

Installation command for the compiled Brick Daemon.

```bash
sudo make install
```

--------------------------------

### Hello World Example

Source: https://www.tinkerforge.com/en/doc/Software/Bricklets/OLED64x48_Bricklet_Mathematica.html

Demonstrates how to initialize the connection, clear the display, and write text to the OLED 64x48 Bricklet.

```Mathematica
 1Needs["NETLink`"]
 2LoadNETAssembly["Tinkerforge",NotebookDirectory[]<>"../../.."]
 3
 4host="localhost"
 5port=4223
 6uid="XYZ"(*Change XYZ to the UID of your OLED 64x48 Bricklet*)
 7
 8(*Create IPConnection and device object*)
 9ipcon=NETNew["Tinkerforge.IPConnection"]
10oled=NETNew["Tinkerforge.BrickletOLED64x48",uid,ipcon]
11ipcon@Connect[host,port]
12
13(*Clear display*)
14oled@ClearDisplay[]
15
16(*Write "Hello World" starting from upper left corner of the screen*)
17oled@WriteLine[0,0,"Hello World"]
18
19(*Clean up*)
20ipcon@Disconnect[]
21ReleaseNETObject[oled]
22ReleaseNETObject[ipcon]
```

--------------------------------

### Hello World Example

Source: https://www.tinkerforge.com/en/doc/Software/Bricklets/LCD20x4_Bricklet_Mathematica.html

Demonstrates how to initialize the connection, turn on the backlight, and write text to the LCD 20x4 Bricklet.

```Mathematica
 1Needs["NETLink`"]
 2LoadNETAssembly["Tinkerforge",NotebookDirectory[]<>"../../.."]
 3
 4host="localhost"
 5port=4223
 6uid="XYZ"(*Change XYZ to the UID of your LCD 20x4 Bricklet*)
 7
 8(*Create IPConnection and device object*)
 9ipcon=NETNew["Tinkerforge.IPConnection"]
10lcd=NETNew["Tinkerforge.BrickletLCD20x4",uid,ipcon]
11ipcon@Connect[host,port]
12
13(*Turn backlight on*)
14lcd@BacklightOn[]
15
16(*Write "Hello World"*)
17lcd@WriteLine[0,0,"Hello World"]
18
19(*Clean up*)
20ipcon@Disconnect[]
21ReleaseNETObject[lcd]
22ReleaseNETObject[ipcon]
```

--------------------------------

### Get Frame Started Callback Receiver

Source: https://www.tinkerforge.com/en/doc/Software/Bricklets/RGBLEDMatrix_Bricklet_Rust.html

Registers a receiver to handle frame started events, which trigger when a new frame write begins.

```rust
pub fn RgbLedMatrixBricklet::get_frame_started_callback_receiver(&self) -> ConvertingCallbackReceiver<u32>
```

--------------------------------

### Hello World Example

Source: https://www.tinkerforge.com/en/doc/Software/Bricklets/LCD16x2_Bricklet_PHP.html

Demonstrates how to initialize the Bricklet, turn on the backlight, and write text to the display.

```php
 1<?php
 2
 3require_once('Tinkerforge/IPConnection.php');
 4require_once('Tinkerforge/BrickletLCD16x2.php');
 5
 6use Tinkerforge\
IPConnection;
 7use Tinkerforge\BrickletLCD16x2;
 8
 9const HOST = 'localhost';
10const PORT = 4223;
11const UID = 'XYZ'; // Change XYZ to the UID of your LCD 16x2 Bricklet
12
13$ipcon = new IPConnection(); // Create IP connection
14$lcd = new BrickletLCD16x2(UID, $ipcon); // Create device object
15
16$ipcon->connect(HOST, PORT); // Connect to brickd
17// Don't use device before ipcon is connected
18
19// Turn backlight on
20$lcd->backlightOn();
21
22// Write "Hello World"
23$lcd->writeLine(0, 0, 'Hello World');
24
25echo "Press key to exit\n";
26fgetc(fopen('php://stdin', 'r'));
27$ipcon->disconnect();
28
29?>
```

--------------------------------

### Dispatch Callback Example

Source: https://www.tinkerforge.com/en/doc/Software/Bricklets/Color_Bricklet_Shell.html

General command to start receiving callbacks from the device.

```shell
tinkerforge dispatch color-bricklet <uid> example
```

--------------------------------

### Hello World Example in HTML

Source: https://www.tinkerforge.com/en/doc/Software/Bricklets/LCD16x2_Bricklet_JavaScript.html

Demonstrates how to initialize an IPConnection, create a device object, and write text to the LCD 16x2 Bricklet.

```html
 1<!DOCTYPE html>
 2<html>
 3    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
 4    <head>
 5        <title>Tinkerforge | JavaScript Example</title>
 6    </head>
 7    <body>
 8        <div style="text-align:center;">
 9            <h1>LCD 16x2 Bricklet Hello World Example</h1>
10            <p>
11                <input value="localhost" id="host" type="text" size="20">:
12                <input value="4280" id="port" type="text" size="5">,
13                <input value="uid" id="uid" type="text" size="5">
14                <input value="Start Example" id="start" type="button" onclick="startExample();">
15            </p>
16            <p>
17                <textarea readonly id="text" cols="80" rows="24" style="resize:none;"
18                          >Press "Start Example" to begin ...</textarea>
19            </p>
20        </div>
21        <script src="./Tinkerforge.js" type='text/javascript'></script>
22        <script type='text/javascript'>
23            var ipcon;
24            var textArea = document.getElementById("text");
25            function startExample() {
26                textArea.value = "";
27                var HOST = document.getElementById("host").value;
28                var PORT = parseInt(document.getElementById("port").value);
29                var UID = document.getElementById("uid").value;
30                if(ipcon !== undefined) {
31                    ipcon.disconnect();
32                }
33                ipcon = new Tinkerforge.IPConnection(); // Create IP connection
34                var lcd = new Tinkerforge.BrickletLCD16x2(UID, ipcon); // Create device object
35                ipcon.connect(HOST, PORT,
36                    function(error) {
37                        textArea.value += 'Error: ' + error + '\n';
38                    }
39                ); // Connect to brickd
40                // Don't use device before ipcon is connected
41
42                ipcon.on(Tinkerforge.IPConnection.CALLBACK_CONNECTED,
43                    function (connectReason) {
44                        // Turn backlight on
45                        lcd.backlightOn();
46
47                        // Write "Hello World"
48                        lcd.writeLine(0, 0, 'Hello World');
49                    }
50                );
51            }
52        </script>
53    </body>
54</html>
```

--------------------------------

### Hello World Example

Source: https://www.tinkerforge.com/en/doc/Software/Bricklets/OLED128x64_Bricklet_Mathematica.html

Demonstrates how to initialize the OLED 128x64 Bricklet and write a simple text string to the display.

```Mathematica
 1Needs["NETLink`"]
 2LoadNETAssembly["Tinkerforge",NotebookDirectory[]<>"../../.."]
 3
 4host="localhost"
 5port=4223
 6uid="XYZ"(*Change XYZ to the UID of your OLED 128x64 Bricklet*)
 7
 8(*Create IPConnection and device object*)
 9ipcon=NETNew["Tinkerforge.IPConnection"]
10oled=NETNew["Tinkerforge.BrickletOLED128x64",uid,ipcon]
11ipcon@Connect[host,port]
12
13(*Clear display*)
14oled@ClearDisplay[]
15
16(*Write "Hello World" starting from upper left corner of the screen*)
17oled@WriteLine[0,0,"Hello World"]
18
19(*Clean up*)
20ipcon@Disconnect[]
21ReleaseNETObject[oled]
22ReleaseNETObject[ipcon]
```

--------------------------------

### Dispatch Callback Example

Source: https://www.tinkerforge.com/en/doc/Software/Bricklets/AmbientLightV3_Bricklet_Shell.html

Starts the dispatching process to receive callbacks from the Bricklet.

```shell
tinkerforge dispatch ambient-light-v3-bricklet <uid> example
```

--------------------------------

### Dispatch Callback Example

Source: https://www.tinkerforge.com/en/doc/Software/Bricklets/AmbientLightV2_Bricklet_Shell.html

General command to start dispatching callbacks from the Bricklet.

```shell
tinkerforge dispatch ambient-light-v2-bricklet <uid> example
```

--------------------------------

### Hello World Example

Source: https://www.tinkerforge.com/en/doc/Software/Bricklets/OLED64x48_Bricklet_Go.html

Demonstrates how to initialize the Bricklet and write text to the display.

```go
package main

import (
    "fmt"
    "github.com/Tinkerforge/go-api-bindings/ipconnection"
    "github.com/Tinkerforge/go-api-bindings/oled_64x48_bricklet"
)

const ADDR string = "localhost:4223"
const UID string = "XYZ" // Change XYZ to the UID of your OLED 64x48 Bricklet.

func main() {
    ipcon := ipconnection.New()
    defer ipcon.Close()
    oled, _ := oled_64x48_bricklet.New(UID, &ipcon) // Create device object.

    ipcon.Connect(ADDR) // Connect to brickd.
    defer ipcon.Disconnect()
    // Don't use device before ipcon is connected.

    // Clear display
    oled.ClearDisplay()

    // Write "Hello World" starting from upper left corner of the screen
    oled.WriteLine(0, 0, "Hello World")

    fmt.Print("Press enter to exit.")
    fmt.Scanln()
}
```

--------------------------------

### LED Strip Bricklet 2.0 Callback Example

Source: https://www.tinkerforge.com/en/doc/Software/Bricklets/LEDStripV2_Bricklet_JavaScript.html

This HTML example demonstrates how to connect to the Bricklet and register a frame started callback to monitor LED strip activity.

```html
 1<!DOCTYPE html>
 2
 3<!-- FIXME: This example is incomplete -->
 4
 5<html>
 6    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
 7    <head>
 8        <title>Tinkerforge | JavaScript Example</title>
 9    </head>
10    <body>
11        <div style="text-align:center;">
12            <h1>LED Strip Bricklet 2.0 Callback Example</h1>
13            <p>
14                <input value="localhost" id="host" type="text" size="20">:
15                <input value="4280" id="port" type="text" size="5">,
16                <input value="uid" id="uid" type="text" size="5">
17                <input value="Start Example" id="start" type="button" onclick="startExample();">
18            </p>
19            <p>
20                <textarea readonly id="text" cols="80" rows="24" style="resize:none;"
21                          >Press "Start Example" to begin ...</textarea>
22            </p>
23        </div>
24        <script src="./Tinkerforge.js" type='text/javascript'></script>
25        <script type='text/javascript'>
26            var ipcon;
27            var textArea = document.getElementById("text");
28            function startExample() {
29                textArea.value = "";
30                var HOST = document.getElementById("host").value;
31                var PORT = parseInt(document.getElementById("port").value);
32                var UID = document.getElementById("uid").value;
33                if(ipcon !== undefined) {
34                    ipcon.disconnect();
35                }
36                ipcon = new Tinkerforge.IPConnection(); // Create IP connection
37                var ls = new Tinkerforge.BrickletLEDStripV2(UID, ipcon); // Create device object
38                ipcon.connect(HOST, PORT,
39                    function(error) {
40                        textArea.value += 'Error: ' + error + '\n';
41                    }
42                ); // Connect to brickd
43                // Don't use device before ipcon is connected
44
45                ipcon.on(Tinkerforge.IPConnection.CALLBACK_CONNECTED,
46                    function (connectReason) {
47                        // Set frame duration to 50ms (20 frames per second)
48                        ls.setFrameDuration(50);
49                    }
50                );
51
52                // Register frame started callback
53                ls.on(Tinkerforge.BrickletLEDStripV2.CALLBACK_FRAME_STARTED,
54                    // Use frame started callback to move the active LED every frame
55                    function (length) {
56                        textArea.value += 'Length: ' + length + '\n';
57                        textArea.scrollTop = textArea.scrollHeight;
58                    }
59                );
60            }
61        </script>
62    </body>
63</html>
```

--------------------------------

### Hello World Example

Source: https://www.tinkerforge.com/en/doc/Software/Bricklets/LCD16x2_Bricklet_C.html

Demonstrates how to initialize the Bricklet, turn on the backlight, and write text to the display.

```c
 1#include <stdio.h>
 2
 3#include "ip_connection.h"
 4#include "bricklet_lcd_16x2.h"
 5
 6#define HOST "localhost"
 7#define PORT 4223
 8#define UID "XYZ" // Change XYZ to the UID of your LCD 16x2 Bricklet
 9
10int main(void) {
11    // Create IP connection
12    IPConnection ipcon;
13    ipcon_create(&ipcon);
14
15    // Create device object
16    LCD16x2 lcd;
17    lcd_16x2_create(&lcd, UID, &ipcon);
18
19    // Connect to brickd
20    if(ipcon_connect(&ipcon, HOST, PORT) < 0) {
21        fprintf(stderr, "Could not connect\n");
22        return 1;
23    }
24    // Don't use device before ipcon is connected
25
26    // Turn backlight on
27    lcd_16x2_backlight_on(&lcd);
28
29    // Write "Hello World"
30    lcd_16x2_write_line(&lcd, 0, 0, "Hello World");
31
32    printf("Press key to exit\n");
33    getchar();
34    lcd_16x2_destroy(&lcd);
35    ipcon_destroy(&ipcon); // Calls ipcon_disconnect internally
36    return 0;
37}
```

--------------------------------

### Dispatch Callback Example

Source: https://www.tinkerforge.com/en/doc/Software/Bricklets/PiezoBuzzer_Bricklet_Shell.html

Use this command to start receiving callbacks from the Piezo Buzzer Bricklet.

```shell
tinkerforge dispatch piezo-buzzer-bricklet <uid> example
```

--------------------------------

### Hello World Example

Source: https://www.tinkerforge.com/en/doc/Software/Bricklets/OLED128x64V2_Bricklet_Mathematica.html

Demonstrates how to connect to the Bricklet and write text to the display. Ensure the UID is updated to match the specific device.

```Mathematica
 1Needs["NETLink`"]
 2LoadNETAssembly["Tinkerforge",NotebookDirectory[]<>"../../.."]
 3
 4host="localhost"
 5port=4223
 6uid="XYZ"(*Change XYZ to the UID of your OLED 128x64 Bricklet 2.0*)
 7
 8(*Create IPConnection and device object*)
 9ipcon=NETNew["Tinkerforge.IPConnection"]
10oled=NETNew["Tinkerforge.BrickletOLED128x64V2",uid,ipcon]
11ipcon@Connect[host,port]
12
13(*Clear display*)
14oled@ClearDisplay[]
15
16(*Write "Hello World" starting from upper left corner of the screen*)
17oled@WriteLine[0,0,"Hello World"]
18
19(*Clean up*)
20ipcon@Disconnect[]
21ReleaseNETObject[oled]
22ReleaseNETObject[ipcon]
```

--------------------------------

### IMU Bricklet 3.0 All Data Example

Source: https://www.tinkerforge.com/en/doc/Software/Bricklets/IMUV3_Bricklet_JavaScript.html

Shows the initial setup for connecting to the Bricklet and establishing an IP connection.

```html
 1<!DOCTYPE html>
 2<html>
 3    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
 4    <head>
 5        <title>Tinkerforge | JavaScript Example</title>
 6    </head>
 7    <body>
 8        <div style="text-align:center;">
 9            <h1>IMU Bricklet 3.0 All Data Example</h1>
10            <p>
11                <input value="localhost" id="host" type="text" size="20">:
12                <input value="4280" id="port" type="text" size="5">,
13                <input value="uid" id="uid" type="text" size="5">
14                <input value="Start Example" id="start" type="button" onclick="startExample();">
15            </p>
16            <p>
17                <textarea readonly id="text" cols="80" rows="24" style="resize:none;"
18                          >Press "Start Example" to begin ...</textarea>
19            </p>
20        </div>
21        <script src="./Tinkerforge.js" type='text/javascript'></script>
22        <script type='text/javascript'>
23            var ipcon;
24            var textArea = document.getElementById("text");
25            function startExample() {
26                textArea.value = "";
27                var HOST = document.getElementById("host").value;
28                var PORT = parseInt(document.getElementById("port").value);
29                var UID = document.getElementById("uid").value;
30                if(ipcon !== undefined) {
31                    ipcon.disconnect();
32                }
33                ipcon = new Tinkerforge.IPConnection(); // Create IP connection
34                var imu = new Tinkerforge.BrickletIMUV3(UID, ipcon); // Create device object
35                ipcon.connect(HOST, PORT,
36                    function(error) {
```

--------------------------------

### Complete WeatherStation setup

Source: https://www.tinkerforge.com/en/doc/Kits/WeatherStation/JavaToLCD.html

Combines the listener implementation and main method to establish the connection and start the enumeration process.

```java
class WeatherListener implements IPConnection.EnumerateListener,
                                 IPConnection.ConnectedListener {
    private IPConnection ipcon = null;

    public WeatherListener(IPConnection ipcon) {
        this.ipcon = ipcon;
    }

    public void connected(short connectedReason) {
        if(connectedReason == IPConnection.CONNECT_REASON_AUTO_RECONNECT) {
            ipcon.enumerate();
        }
    }
}

public class WeatherStation {
    private static final String host = "localhost";
    private static final int port = 4223;
    private static IPConnection ipcon = null;
    private static WeatherListener weatherListener = null;

    public static void main(String args[]) {
        ipcon = new IPConnection();
        ipcon.connect(host, port);

        weatherListener = new WeatherListener(ipcon);
        ipcon.addEnumerateListener(weatherListener);
        ipcon.addConnectedListener(weatherListener);

        ipcon.enumerate();
    }
}
```

--------------------------------

### Hello World Example

Source: https://www.tinkerforge.com/en/doc/Software/Bricklets/EPaper296x128_Bricklet_Go.html

Demonstrates how to initialize the Bricklet, clear the display, and draw text.

```go
 1package main
 2
 3import (
 4    "fmt"
 5    "github.com/Tinkerforge/go-api-bindings/e_paper_296x128_bricklet"
 6    "github.com/Tinkerforge/go-api-bindings/ipconnection"
 7)
 8
 9const ADDR string = "localhost:4223"
10const UID string = "XYZ" // Change XYZ to the UID of your E-Paper 296x128 Bricklet.
11
12func main() {
13    ipcon := ipconnection.New()
14    defer ipcon.Close()
15    ep, _ := e_paper_296x128_bricklet.New(UID, &ipcon) // Create device object.
16
17    ipcon.Connect(ADDR) // Connect to brickd.
18    defer ipcon.Disconnect()
19    // Don't use device before ipcon is connected.
20
21    // Use black background
22    ep.FillDisplay(e_paper_296x128_bricklet.ColorBlack)
23
24    // Write big white "Hello World" in the middle of the screen
25    ep.DrawText(16, 48, e_paper_296x128_bricklet.Font24x32,
26        e_paper_296x128_bricklet.ColorWhite,
27        e_paper_296x128_bricklet.OrientationHorizontal, "Hello World")
28    ep.Draw()
29
30    fmt.Print("Press enter to exit.")
31    fmt.Scanln()
32}
```

--------------------------------

### Hello World Example

Source: https://www.tinkerforge.com/en/doc/Software/Bricklets/LCD20x4_Bricklet_Python.html

Demonstrates how to initialize the Bricklet, turn on the backlight, and write text to the display.

```python
#!/usr/bin/env python
# -*- coding: utf-8 -*-

HOST = "localhost"
PORT = 4223
UID = "XYZ" # Change XYZ to the UID of your LCD 20x4 Bricklet

from tinkerforge.ip_connection import IPConnection
from tinkerforge.bricklet_lcd_20x4 import BrickletLCD20x4

if __name__ == "__main__":
    ipcon = IPConnection() # Create IP connection
    lcd = BrickletLCD20x4(UID, ipcon) # Create device object

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

    # Turn backlight on
    lcd.backlight_on()

    # Write "Hello World"
    lcd.write_line(0, 0, "Hello World")

    input("Press key to exit\n") # Use raw_input() in Python 2
    ipcon.disconnect()
```

--------------------------------

### Callback Usage in PHP

Source: https://www.tinkerforge.com/en/doc/Software/Bricklets/LEDStripV2_Bricklet_PHP.html

Registers a frame started callback to monitor frame duration. Note that this example is marked as incomplete in the source.

```php
<?php

// FIXME: This example is incomplete

require_once('Tinkerforge/IPConnection.php');
require_once('Tinkerforge/BrickletLEDStripV2.php');

use Tinkerforge\IPConnection;
use Tinkerforge\BrickletLEDStripV2;

const HOST = 'localhost';
const PORT = 4223;
const UID = 'XYZ'; // Change XYZ to the UID of your LED Strip Bricklet 2.0

// Use frame started callback to move the active LED every frame
function cb_frameStarted($length)
{
    echo "Length: $length\n";
}

$ipcon = new IPConnection(); // Create IP connection
$ls = new BrickletLEDStripV2(UID, $ipcon); // Create device object

$ipcon->connect(HOST, PORT); // Connect to brickd
// Don't use device before ipcon is connected

// Set frame duration to 50ms (20 frames per second)
$ls->setFrameDuration(50);

// Register frame started callback to function cb_frameStarted
$ls->registerCallback(BrickletLEDStripV2::CALLBACK_FRAME_STARTED, 'cb_frameStarted');

echo "Press ctrl+c to exit\n";
$ipcon->dispatchCallbacks(-1); // Dispatch callbacks forever

?>
```

--------------------------------

### Install Go Bindings via GitHub

Source: https://www.tinkerforge.com/en/doc/Software/API_Bindings_Go.html

Use the go get tool to fetch the latest version of the Tinkerforge API bindings.

```bash
go get -u github.com/Tinkerforge/go-api-bindings
```

--------------------------------

### Hello World Example

Source: https://www.tinkerforge.com/en/doc/Software/Bricklets/EPaper296x128_Bricklet_CSharp.html

Demonstrates how to initialize the Bricklet, fill the display with a black background, and draw text.

```csharp
 1using System;
 2using Tinkerforge;
 3
 4class Example
 5{
 6    private static string HOST = "localhost";
 7    private static int PORT = 4223;
 8    private static string UID = "XYZ"; // Change XYZ to the UID of your E-Paper 296x128 Bricklet
 9
10    static void Main()
11    {
12        IPConnection ipcon = new IPConnection(); // Create IP connection
13        BrickletEPaper296x128 ep = new BrickletEPaper296x128(UID, ipcon); // Create device object
14
15        ipcon.Connect(HOST, PORT); // Connect to brickd
16        // Don't use device before ipcon is connected
17
18        // Use black background
19        ep.FillDisplay(BrickletEPaper296x128.COLOR_BLACK);
20
21        // Write big white "Hello World" in the middle of the screen
22        ep.DrawText(16, 48, BrickletEPaper296x128.FONT_24X32,
23                    BrickletEPaper296x128.COLOR_WHITE,
24                    BrickletEPaper296x128.ORIENTATION_HORIZONTAL, "Hello World");
25        ep.Draw();
26
27        Console.WriteLine("Press enter to exit");
28        Console.ReadLine();
29        ipcon.Disconnect();
30    }
31}
```

--------------------------------

### Hello World Example

Source: https://www.tinkerforge.com/en/doc/Software/Bricklets/LCD20x4_Bricklet_Ruby.html

Demonstrates how to initialize the LCD 20x4 Bricklet, turn on the backlight, and write text to the display.

```ruby
#!/usr/bin/env ruby
# -*- ruby encoding: utf-8 -*-

require 'tinkerforge/ip_connection'
require 'tinkerforge/bricklet_lcd_20x4'

include Tinkerforge

HOST = 'localhost'
PORT = 4223
UID = 'XYZ' # Change XYZ to the UID of your LCD 20x4 Bricklet

ipcon = IPConnection.new # Create IP connection
lcd = BrickletLCD20x4.new UID, ipcon # Create device object

ipcon.connect HOST, PORT # Connect to brickd
# Don't use device before ipcon is connected

# Turn backlight on
lcd.backlight_on

# Write "Hello World"
lcd.write_line 0, 0, 'Hello World'

puts 'Press key to exit'
$stdin.gets
ipcon.disconnect
```

--------------------------------

### Scribble Example in C

Source: https://www.tinkerforge.com/en/doc/Software/Bricklets/OLED128x64_Bricklet_C.html

Requires the libgd library to be installed. The code converts pixel data into the page-based format expected by the OLED display.

```c
 1#include <stdio.h>
 2#include <math.h>
 3#include <gd.h> // https://libgd.github.io/
 4
 5#define IPCON_EXPOSE_MILLISLEEP
 6
 7#include "ip_connection.h"
 8#include "bricklet_oled_128x64.h"
 9
10#define HOST "localhost"
11#define PORT 4223
12#define UID "XYZ" // Change XYZ to the UID of your OLED 128x64 Bricklet
13#define WIDTH 128
14#define HEIGHT 64
15
16void draw_image(OLED128x64 *oled, gdImagePtr image) {
17    uint8_t pages[HEIGHT / 8][WIDTH];
18    int row, column, bit, index;
19
20    // Convert pixels into pages
21    for (row = 0; row < HEIGHT / 8; row++) {
22        for (column = 0; column < WIDTH; column++) {
23            pages[row][column] = 0;
24
25            for (bit = 0; bit < 8; bit++) {
26                index = gdImageGetPixel(image, column, (row * 8) + bit);
27
28                if (gdImageRed(image, index) > 0) {
29                    pages[row][column] |= 1 << bit;
30                }
31            }
32        }
33    }
34
35    // Write all pages
36    oled_128x64_new_window(oled, 0, WIDTH - 1, 0, HEIGHT / 8 - 1);
37
38    for (row = 0; row < HEIGHT / 8; row++) {
39        for (column = 0; column < WIDTH; column += 64) {
40            oled_128x64_write(oled, &pages[row][column]);
41        }
42    }
43}
44
45int main(void) {
46    // Create IP connection
47    IPConnection ipcon;
48    ipcon_create(&ipcon);
49
50    // Create device object
51    OLED128x64 oled;
52    oled_128x64_create(&oled, UID, &ipcon);
53
54    // Connect to brickd
55    if(ipcon_connect(&ipcon, HOST, PORT) < 0) {
56        fprintf(stderr, "Could not connect\n");
57        return 1;
58    }
59    // Don't use device before ipcon is connected
60
61    // Clear display
62    oled_128x64_clear_display(&oled);
63
64    // Draw rotating line
65    gdImagePtr image = gdImageCreate(WIDTH, HEIGHT);
66    int black = gdImageColorAllocate(image, 0, 0, 0);
67    int white = gdImageColorAllocate(image, 255, 255, 255);
68    int origin_x = WIDTH / 2;
69    int origin_y = HEIGHT / 2;
70    int length = HEIGHT / 2 - 2;
71    int angle = 0;
72
73    printf("Press ctrl+c exit\n");
74
75    while (true) {
76        double radians = M_PI * angle / 180.0;
77        int x = (int)(origin_x + length * cos(radians));
78        int y = (int)(origin_y + length * sin(radians));
79
80        gdImageFilledRectangle(image, 0, 0, WIDTH, HEIGHT, black);
81        gdImageLine(image, origin_x, origin_y, x, y, white);
82
83        draw_image(&oled, image);
84        millisleep(25);
85
86        angle++;
87    }
88
89    gdImageDestroy(image);
90    ipcon_destroy(&ipcon); // Calls ipcon_disconnect internally
91    return 0;
92}
```

--------------------------------

### BrickRED.start_program

Source: https://www.tinkerforge.com/en/doc/Software/Bricks/RED_Brick_Modbus.html

Starts a program.

```APIDOC
## BrickRED.start_program

### Description
Initiates the execution of a program identified by program_id.

### Parameters
- **program_id** (uint16) - Required - Range: [0 to 2^16 - 1]

### Response
- **error_code** (uint8) - Status code
```

--------------------------------

### Install Brick Viewer via APT

Source: https://www.tinkerforge.com/en/doc/Software/Brickv_Install_Linux.html

Installs the brickv package from the configured Tinkerforge APT repository.

```bash
sudo apt install brickv
```

--------------------------------

### Simple Analog Out Usage

Source: https://www.tinkerforge.com/en/doc/Software/Bricklets/AnalogOutV3_Bricklet_uC.html

Demonstrates basic setup and voltage configuration for the Analog Out Bricklet 3.0. This example requires a platform-specific HAL driver.

```c
 1// This example is not self-contained.
 2// It requires usage of the example driver specific to your platform.
 3// See the HAL documentation.
 4
 5#include "src/bindings/hal_common.h"
 6#include "src/bindings/bricklet_analog_out_v3.h"
 7
 8void check(int rc, const char *msg);
 9void example_setup(TF_HAL *hal);
10void example_loop(TF_HAL *hal);
11
12static TF_AnalogOutV3 ao;
13
14void example_setup(TF_HAL *hal) {
15    // Create device object
16    check(tf_analog_out_v3_create(&ao, NULL, hal), "create device object");
17
18    // Set output voltage to 3.3V
19    check(tf_analog_out_v3_set_output_voltage(&ao, 3300), "call set_output_voltage");
20}
21
22void example_loop(TF_HAL *hal) {
23    // Poll for callbacks
24    tf_hal_callback_tick(hal, 0);
25}
```

--------------------------------

### Hello World Example

Source: https://www.tinkerforge.com/en/doc/Software/Bricklets/OLED64x48_Bricklet_Perl.html

Demonstrates how to initialize the OLED 64x48 Bricklet and write a simple text string to the display.

```perl
 1#!/usr/bin/perl
 2
 3use strict;
 4use Tinkerforge::IPConnection;
 5use Tinkerforge::BrickletOLED64x48;
 6
 7use constant HOST => 'localhost';
 8use constant PORT => 4223;
 9use constant UID => 'XYZ'; # Change XYZ to the UID of your OLED 64x48 Bricklet
10
11my $ipcon = Tinkerforge::IPConnection->new(); # Create IP connection
12my $oled = Tinkerforge::BrickletOLED64x48->new(&UID, $ipcon); # Create device object
13
14$ipcon->connect(&HOST, &PORT); # Connect to brickd
15# Don't use device before ipcon is connected
16
17# Clear display
18$oled->clear_display();
19
20# Write "Hello World" starting from upper left corner of the screen
21$oled->write_line(0, 0, "Hello World");
22
23print "Press key to exit\n";
24<STDIN>;
25$ipcon->disconnect();
```

--------------------------------

### Temperature Bricklet 2.0 Web Interface Examples

Source: https://www.tinkerforge.com/en/doc/Tutorials/Tutorial_RED_Brick/Tutorial.html

Examples showing how to read temperature data and display it in a web browser using Python (Flask) or PHP.

```python
 1#!/usr/bin/env python
 2# -*- coding: utf-8 -*-
 3
 4HOST = "localhost"
 5PORT = 4223
 6UID = "XYZ" # Change XYZ to the UID of your Temperature Bricklet 2.0
 7
 8from flask import Flask       # Use Flask framework
 9application = Flask(__name__) # Function "application" is used by Apache/wsgi
10app = application             # Use shortcut for routing
11
12from tinkerforge.ip_connection import IPConnection
13from tinkerforge.bricklet_temperature_v2 import BrickletTemperatureV2
14
15PAGE = u"""
16<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
17<html>
18 <head>
19  <title>Temperature</title>
20 </head>
21 <body>
22  <p>Temperature: {0} °C<p>
23 </body>
24</html>
25"""
26
27@app.route('/')
28def index():
29    ipcon = IPConnection() # Create IP connection
30    t = BrickletTemperatureV2(UID, ipcon) # Create device object
31
32    ipcon.connect(HOST, PORT) # Connect to brickd
33    # Don't use device before ipcon is connected
34
35    # Get current temperature (unit is °C/100)
36    temperature = t.get_temperature() / 100.0
37
38    ipcon.disconnect()
39
40    return PAGE.format(temperature)
```

```php
 1<?php
 2
 3require_once('Tinkerforge/IPConnection.php');
 4require_once('Tinkerforge/BrickletTemperatureV2.php');
 5
 6use Tinkerforge\IPConnection;
 7use Tinkerforge\BrickletTemperatureV2;
 8
 9const HOST = 'localhost';
10const PORT = 4223;
11const UID = 'XYZ'; // Change XYZ to the UID of your Temperature Bricklet 2.0
12
13$ipcon = new IPConnection(); // Create IP connection
14$t = new BrickletTemperatureV2(UID, $ipcon); // Create device object
15
16$ipcon->connect(HOST, PORT); // Connect to brickd
17// Don't use device before ipcon is connected
18
19// Get current temperature (unit is °C/100)
20$temperature = $t->getTemperature() / 100.0;
21
22$ipcon->disconnect();
23
24header('content-type: text/html; charset=utf-8');
25
26?>
27
28<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
29<html>
30 <head>
31  <title>Temperature</title>
32 </head>
33 <body>
34  <p>Temperature: <?php echo $temperature; ?> °C<p>
35 </body>
36</html>
```

--------------------------------

### Use frame started callback via Shell

Source: https://www.tinkerforge.com/en/doc/Software/Bricklets/LEDStripV2_Bricklet_Shell.html

Configures the frame duration and dispatches the frame-started callback. Note that this example is marked as incomplete in the source.

```shell
 1#!/bin/sh
 2# Connects to localhost:4223 by default, use --host and --port to change this
 3
 4# FIXME: This example is incomplete
 5
 6uid=XYZ # Change XYZ to the UID of your LED Strip Bricklet 2.0
 7
 8# Set frame duration to 50ms (20 frames per second)
tinkerforge call led-strip-v2-bricklet $uid set-frame-duration 50
10
11# Use frame started callback to move the active LED every frame
tinkerforge dispatch led-strip-v2-bricklet $uid frame-started &
13
14echo "Press key to exit"; read dummy
15
16kill -- -$$ # Stop callback dispatch in background
```

--------------------------------

### Hello World Example

Source: https://www.tinkerforge.com/en/doc/Software/Bricklets/LCD16x2_Bricklet_Perl.html

Demonstrates how to initialize the connection, turn on the backlight, and write text to the LCD display.

```perl
 1#!/usr/bin/perl
 2
 3use strict;
 4use Tinkerforge::IPConnection;
 5use Tinkerforge::BrickletLCD16x2;
 6
 7use constant HOST => 'localhost';
 8use constant PORT => 4223;
 9use constant UID => 'XYZ'; # Change XYZ to the UID of your LCD 16x2 Bricklet
10
11my $ipcon = Tinkerforge::IPConnection->new(); # Create IP connection
12my $lcd = Tinkerforge::BrickletLCD16x2->new(&UID, $ipcon); # Create device object
13
14$ipcon->connect(&HOST, &PORT); # Connect to brickd
15# Don't use device before ipcon is connected
16
17# Turn backlight on
18$lcd->backlight_on();
19
20# Write "Hello World"
21$lcd->write_line(0, 0, "Hello World");
22
23print "Press key to exit\n";
24<STDIN>;
25$ipcon->disconnect();
```

--------------------------------

### Start Brick Viewer from Source

Source: https://www.tinkerforge.com/en/doc/Software/Brickv_Install_Linux.html

Launches the application from the source directory.

```bash
python main.py
```

--------------------------------

### Hello World Example

Source: https://www.tinkerforge.com/en/doc/Software/Bricklets/EPaper296x128_Bricklet_VBNET.html

Demonstrates how to initialize the Bricklet, fill the display with a black background, and draw text.

```vbnet
 1Imports System
 2Imports Tinkerforge
 3
 4Module ExampleHelloWorld
 5    Const HOST As String = "localhost"
 6    Const PORT As Integer = 4223
 7    Const UID As String = "XYZ" ' Change XYZ to the UID of your E-Paper 296x128 Bricklet
 8
 9    Sub Main()
10        Dim ipcon As New IPConnection() ' Create IP connection
11        Dim ep As New BrickletEPaper296x128(UID, ipcon) ' Create device object
12
13        ipcon.Connect(HOST, PORT) ' Connect to brickd
14        ' Don't use device before ipcon is connected
15
16        ' Use black background
17        ep.FillDisplay(BrickletEPaper296x128.COLOR_BLACK)
18
19        ' Write big white "Hello World" in the middle of the screen
20        ep.DrawText(16, 48, BrickletEPaper296x128.FONT_24X32, _
21                    BrickletEPaper296x128.COLOR_WHITE, _
22                    BrickletEPaper296x128.ORIENTATION_HORIZONTAL, "Hello World")
23        ep.Draw()
24
25        Console.WriteLine("Press key to exit")
26        Console.ReadLine()
27        ipcon.Disconnect()
28    End Sub
29End Module
```

--------------------------------

### Counter Example for E-Paper 296x128 Bricklet

Source: https://www.tinkerforge.com/en/doc/Software/Bricklets/EPaper296x128_Bricklet_openHAB.html

This rule increments a counter and displays it on the E-Paper display when the system starts or the draw status changes. Ensure the item name and Bricklet UID are updated to match your specific configuration.

```openHAB Rules
 1// For this example create an item linked to the Draw Status channel of your E-Paper 296x128 Bricklet.
 2
 3var counter = 0
 4
 5val DRAW_STATUS_IDLE = 0
 6val FONT_24X32 = 9
 7val COLOR_BLACK = 0
 8val COLOR_WHITE = 1
 9val ORIENTATION_HORIZONTAL = 0
10
11rule "draw"
12when
13    System started or Item XYZ_DrawStatus changed // Change XYZ_DrawStatus to the created item name
14then
15    // Only draw if the current draw status is idle
16    if ((XYZ_DrawStatus.state as Number).intValue != DRAW_STATUS_IDLE) {
17        return
18    }
19    
20    // Change XYZ to the UID of your E-Paper 296x128 Bricklet
21    val epaperActions = getActions("tinkerforge", "tinkerforge:brickletepaper296x128:XYZ")
22    
23    // Remove last image from buffer
24    epaperActions.brickletEPaper296x128FillDisplay(COLOR_WHITE)
25    
26    // Add current counter to buffer
27    epaperActions.brickletEPaper296x128DrawText(140, 50, FONT_24X32, COLOR_BLACK, ORIENTATION_HORIZONTAL, String.valueOf(counter))
28    
29    // Draw buffer
30    epaperActions.brickletEPaper296x128Draw()
31    
32    counter = counter + 1
33end
```

--------------------------------

### BrickMaster.startWifi2Bootloader()

Source: https://www.tinkerforge.com/en/doc/Software/Bricks/Master_Brick_Java.html

Starts the bootloader of the WIFI Extension 2.0.

```APIDOC
## BrickMaster.startWifi2Bootloader()

### Description
Starts the bootloader of the WIFI Extension 2.0. Should only be started over a USB connection.

### Returns
- **result** (byte) - 0 on success.
```

--------------------------------

### Hello World Example

Source: https://www.tinkerforge.com/en/doc/Software/Bricklets/LCD16x2_Bricklet_Delphi.html

Demonstrates how to initialize the Bricklet, turn on the backlight, and write text to the display.

```pascal
 1program ExampleHelloWorld;
 2
 3{$ifdef MSWINDOWS}{$apptype CONSOLE}{$endif}
 4{$ifdef FPC}{$mode OBJFPC}{$H+}{$endif}
 5
 6uses
 7  SysUtils, IPConnection, BrickletLCD16x2;
 8
 9type
10  TExample = class
11  private
12    ipcon: TIPConnection;
13    lcd: TBrickletLCD16x2;
14  public
15    procedure Execute;
16  end;
17
18const
19  HOST = 'localhost';
20  PORT = 4223;
21  UID = 'XYZ'; { Change XYZ to the UID of your LCD 16x2 Bricklet }
22
23var
24  e: TExample;
25
26procedure TExample.Execute;
27begin
28  { Create IP connection }
29  ipcon := TIPConnection.Create;
30
31  { Create device object }
32  lcd := TBrickletLCD16x2.Create(UID, ipcon);
33
34  { Connect to brickd }
35  ipcon.Connect(HOST, PORT);
36  { Don't use device before ipcon is connected }
37
38  { Turn backlight on }
39  lcd.BacklightOn;
40
41  { Write "Hello World" }
42  lcd.WriteLine(0, 0, 'Hello World');
43
44  WriteLn('Press key to exit');
45  ReadLn;
46  ipcon.Destroy; { Calls ipcon.Disconnect internally }
47end;
48
49begin
50  e := TExample.Create;
51  e.Execute;
52  e.Destroy;
53end.
```

--------------------------------

### Install Brick Daemon Dependencies

Source: https://www.tinkerforge.com/en/doc/Software/Brickd_Install_Linux.html

Installs the required system dependencies before manual package installation.

```bash
sudo apt-get install libusb-1.0-0 libgpiod2 procps
```

--------------------------------

### Install Docker Build Environment

Source: https://www.tinkerforge.com/en/doc/Tutorials/Tutorial_Build_Environment/Tutorial.html

Commands to install Docker and pull the necessary Tinkerforge build environment images.

```bash
apt-get install docker.io        # For Debian based distributions
sudo usermod -aG docker <USER>   # Replace <USER> by the user that should be able to compile
                                 # through docker. You have to log in/out once after this
docker pull tinkerforge/build_environment_c     # For Bricks and old Bricklets
docker pull tinkerforge/build_environment_comcu # For Co-Processor Bricklets
```

--------------------------------

### Hello World Example

Source: https://www.tinkerforge.com/en/doc/Software/Bricklets/LCD20x4_Bricklet_Java.html

Demonstrates how to connect to the Bricklet, turn on the backlight, and write text to the display.

```java
 1import com.tinkerforge.IPConnection;
 2import com.tinkerforge.BrickletLCD20x4;
 3
 4public class ExampleHelloWorld {
 5    private static final String HOST = "localhost";
 6    private static final int PORT = 4223;
 7
 8    // Change XYZ to the UID of your LCD 20x4 Bricklet
 9    private static final String UID = "XYZ";
10
11    // Note: To make the example code cleaner we do not handle exceptions. Exceptions
12    //       you might normally want to catch are described in the documentation
13    public static void main(String args[]) throws Exception {
14        IPConnection ipcon = new IPConnection(); // Create IP connection
15        BrickletLCD20x4 lcd = new BrickletLCD20x4(UID, ipcon); // Create device object
16
17        ipcon.connect(HOST, PORT); // Connect to brickd
18        // Don't use device before ipcon is connected
19
20        // Turn backlight on
21        lcd.backlightOn();
22
23        // Write "Hello World"
24        lcd.writeLine((short)0, (short)0, "Hello World");
25
26        System.out.println("Press key to exit"); System.in.read();
27        ipcon.disconnect();
28    }
29}
```

--------------------------------

### Install Dependencies for Source Installation

Source: https://www.tinkerforge.com/en/doc/Software/Brickv_Install_Linux.html

Installs the required Python packages for running Brick Viewer from source on Debian-based systems.

```bash
sudo apt-get install python3 python3-pyqt5 python3-pyqt5.qtopengl python3-serial python3-tz python3-tzlocal
```

--------------------------------

### BrickMaster.start_wifi2_bootloader

Source: https://www.tinkerforge.com/en/doc/Software/Bricks/Master_Brick_Modbus.html

Starts the bootloader of the WIFI Extension 2.0.

```APIDOC
## BrickMaster.start_wifi2_bootloader

### Description
Starts the bootloader of the WIFI Extension 2.0. Returns 0 on success.

### Response
- **result** (int8) - Result code.
```
Tokens:
Raw