Documentation

• 1: Tanmatsu
• 1.1: Tanmatsu: hardware
• 1.1.1: Tanmatsu: connectors
• 1.1.1.1: Tanmatsu: internal add-on port
• 1.1.2: Tanmatsu: specifications
• 1.1.3: Tanmatsu: 3D printed case
• 1.2: Tanmatsu: getting started
• 1.3: Tanmatsu: software
• 1.3.1: AppFS
• 2: I2C VFD (NE-HCS12SS59T-R1)
• 3: OpenBMC
• 3.1: ASRock Rack
• 3.1.1: ASRock Rack X570D4U
• 3.1.1.1: ASRock Rack X570D4U mainboard: pinout
• 3.1.1.2: ASRock Rack X570D4U mainboard: I2C busses
• 3.1.1.3: ASRock Rack X570D4U mainboard: GPIO
• 3.1.1.4: Programming SPI flash with an FT2232 breakout board
• 3.1.1.5: ASRock Rack X570D4U mainboard: temperature sensors
• 3.1.1.6: ASRock Rack X570D4U mainboard: fans
• 3.1.2: ASRock Rack PAUL
• 3.1.2.1: ASRock Rack PAUL: GPIO
• 4: Contributors guide
• 4.1: CLA

1 - Tanmatsu

Tanmatsu is the dream terminal device for hackers, makers, and tech enthousiasts. Based around the powerful ESP32-P4 microcontroller, this device provides an accessible way to make, hack, and tinker on the go.

Tanmatsu lets you program on the go and communicate over long distances using LoRa whilst also providing advanced connectivity and extendability options for hardware hacking and development.

Features

Tanmatsu is based around the upcoming ESP32-P4 SoC by Espressif: their most powerful RISC-V microcontroller yet. With its 400MHz dual-core processor and 32MB of built-in PSRAM it makes the ideal platform for powerful processing on the go whilst still maintaining the ease of use one expects form a microcontroller platform.

In addition to the powerhouse ESP32-P4 application processor we have included an ESP32-C6 WiFi, Bluetooth Low Energy, and IEEE802.15.4 wireless radio module. This module enables wireless internet access, as well as access to local mesh networking like Thread and ZigBee in a hacker friendly way.

A LoRa radio module provides access to LoRa networks such as long distance mesh network services and (G)FSK modulated classic 433 or 868MHz communication, depending on the LoRa module installed.

The device has 16MB of built-in flash storage for firmware and applications, expandable using a micro SD card. The micro SD card socket supports SD cards at 3.3v and 1.8v voltage levels (SDIO 3) for extra fast transfer speeds.

A big MIPI DSI display and the QWERTY keyboard make for great ease of use both in the workshop and on the go.

In addition to all the built-in functionality the device allows for expansion modules using its two expansion ports. The back facing expansion port allows for expanding functionality using personality modules, while the side facing expansion port allows for easily connecting a wide variety of PMOD and SAO compatible accessories.

A QWIIC style expansion connector allows connecting the device to a wide range of sensors available from manufacturers such as Sparkfun and Adafruit, it supports both the I2C and the new I3C communication bus standards.

A 3D printed case is included with every Tanmatsu, this sturdy case will allow the device to be used everywhere whilst keeping the electronics safe and protected.

Software

The launcher firmware allows starting user made applications and in addition it provides access to a marketplace for applications where developers can publish their creations. Apps can be downloaded and installed directly on the device.

Hardware features - summary

• ESP32-P4 dual-core 400MHz RISC-V microcontroller with 32MB of built-in PSRAM
• ESP32-C6 radio module for WiFi, BLE and IEEE 802.15.4 mesh networking connectivity
• Ai-Thinker Ra-01S or Ra-01SH module for long range communication using LoRa modulation and generic (G)FSK modulation for short range classic wireless radio applications at 433MHz or 868MHz respectively
• 16MB of built-in flash storage for firmware and applications
• Fast and big 800x480 MIPI DSI display
• QWERTY keyboard
• Lithium polymer battery
• Audio output via headphone jack and speaker
• I2C and I3C connectivity via Qwiic compatible JST SH style connector
• SD card socket supporting SD cards at 3.3v and 1.8v voltage levels (SDIO 3)
• Side facing expansion port with both SAO and PMOD capabilities
• Back facing expansion port for expanding functionality using personality modules

Software features - summary

• Launcher menu for easy access to multiple applications and firmwares
• Access to user generated content and applications repository via the hub app

Open source

The hardware design will be made fully open source and available under a permissive license (CERN-OHL-P). The design can be edited using the open source PCB CAD application KiCAD, allowing everyone to edit the design without any roadblocks.

The board support package and launcher firmware will also be made open source under a permissive license (MIT), enabling modifications and improvements by the community and granting users and developers complete freedom and control.

Personality modules

Whilst the base Tanmatsu device already provides lots of functionality we plan on creating and making available multiple personality modules for extending the functioality in ways useful to you.
More information about the planned personality modules will be made available soon.

1.1 - Tanmatsu: hardware

WiFi, BLE and IEEE802.15.4 radio module

This ESP32-C6 based module provides the board with access to Wifi, BLE and IEEE802.15.4 (mesh network) connectivity while also controlling the LoRa radio module.

Camera connector

The camera connector is used to connect a CSI camera mdoule. It is pinout-compatible with the camera connector on the Raspberry Pi Zero and 5. Note that software support is limited to a subset of Raspberry Pi compatile camera module sensor chips such as OV5647.

QWIIC & Stemma QT compatible I2C & I3C connector

This connector can be used to connect external I2C or I3C based accessories. Both Adafruit and Sparkfun make a variety of modules and cables which could be connected to this port.

USB-C device port

This port is used to charge the battery, to program and debug the ESpP32-P4 and ESp32-C6 microcontrollers and to install apps and browse files from your computer.

USB-A host port

This port can be used to connect an USB device to the Tanmatsu.

SD card slot

Accepts micro SD memory cards including modern high speed SDIO 3.0 cards.

Battery connector

Allows for connecting a single cell Lithium Polymer or Lithium Ion battery cell. Using a protected cell is mandatory. Unprotected cells could potentially be drained below their lowest allowable voltage, which causes damage to the battery. Current control, over voltage protection and propper constant voltage/current charge control are is built-in into the Tanmatsu mainboard.

Sensor connector

Can be used to connect an I2C connected sensor PCB.

1.1.1 - Tanmatsu: connectors

1.1.1.1 - Tanmatsu: internal add-on port

This port is not exposed by default, and a modified back cover needs to be used to make it accessible. For this reason the port is also named the “internal expansion port”.

Pinout

Limitations & warnings

• Total for all 3.3v outputs must not exceed 1A of current. It is generally adviced to stay well below this figure.
• Do not exceed a current of 1.5A from the battery when the battery is connected to the internal battery connector
• Do not charge the battery via the internal add-on port

1.1.2 - Tanmatsu: specifications

This section lists the technical specifications of the Tanmatsu hardware.

Note: information on this page is actively being worked on and might contain accidental errors and inaccuracies.

Physical dimensions

Size of the device including the 3D printed case:

• Width: 12 cm (4.72 in)
• Length: 13.5 cm (5.31 in)
• Height: 1.8 cm (0.71 in)

Weight: 215 g (0.47 pounds) including case and battery

Case

See case.

Peripherals

Display

• Model: SWI LH397K-IC01
• Size: 3.97 in diagonally, 51.84 x 86.40 mm
• Resolution: 480x800
• Colors: 65536 colors (16-bit / RGB565)
• Controller: ST7701S
• Interface: MIPI DSI (2 lanes)
• Brightness: 330cd/m2

Note: display supports 16M colors (24-bit / RGB888) but current software can not make use of this mode.

Nicolai Electronics developed an ESP-IDF component for configuring the MIPI DSI peripheral in the ESP32-P4 for use with this display.
The component also allows for easy switching between the display on the Tanmatsu and the display included with the official ESP32-P4 development kit.

The display will be available as a spare part from our webshop once Tanmatsu is shipped.

Keyboard

• Full 69-key alphanumeric keyboard with colored 6 function keys
• Metal dome sheet for tactile feeling
• LED backlight (white)

The keyboard has been developed by our awesome friends at Solder Party.

The keyboard and corresponding metal dome sheet will be available as a spare part in our webshop once Tanmatsu starts shipping.

Battery

Single cell protected Lithium Polymer battery with PH-2.0 style connector.
The connector and pinout are compatible with the battery connector on Adafruit boards.

The battery will be available as a spare part in our webshop once Tanmatsu starts shipping.

Connectors and interfaces

On the outside of the case:

• USB-C device port connected to an USB hub. Allows access to:
  • The ESP32-P4 USB interface (PHY 1, defaults to USB-serial/JTAG debug interface but can be remapped to custom USB functions by software)
  • ESP32-C6 USB-serial/JTAG debug interface
  • Personality module expansion port (provides access to an optionally connected USB device on a personality module)
• USB-A host port (480 Mbit superspeed USB 2.0), provides 1A of current with automatic current limiting
• Qwiic and Stemma-QT compatible 4-pin SH connector for connecting I2C and I3C accessories
• 3.5 mm headphone jack
• CATT (Connect All The Things) connector: combined PMOD and SAO compatible 2.54 mm pinsocket optionally also usable as JTAG interface for debugging the ESP32-P4 application processor
• Three push buttons (Power, up and down). Holding down the down button when applying power puts the ESP32-P4 into USB download mode for easy firmware recovery
• Micro SD card slot compatible with SDIO 2 and SDIO 3 cards at 3.3v and 1.8v voltage levels
• (optional) SMA antenna connector for LoRa antenna

On the inside of the case:

• PH-2.0 2-pin battery connector
• PicoBlade 2-pin speaker connector for 8 Ohm speaker
• Raspberry Pi camera compatible 22-pin MIPI CSI camera interface
• IPEX-1 antenna connector for LoRa antenna
• Personality module connector: 36-pin 2.54 mm pinsocket with:
  • Access to power rails (5V, Vbatt, Vsys and 3.3v)
  • USB hub downstream port connected to the USB-C port via an USB hub
  • Internal I2C bus (can be used for sensors and for an identification EEPROM)
  • 14 GPIO pins
  • ESP32-P4 USB interface (PHY 2) or 2 extra GPIO pins
  • UART interface or 2 extra GPIO pins
  • I2S interface or 4 extra GPIO pins (shared with audio codec, when used as GPIO audio functionality is unavailable)
  • I3C bus (shared with 4-pin SH connector) or 2 extra GPIO pins

Chips and modules

WiFi, BLE and IEEE 802.15.4 radio

Module: Espressif Systems ESP32-C6-WROOM-1-N8

• CPU: 32-bit RISC-V single core microprocessor, up to 160 MHz
• RAM: 512 KB
• WiFi: WiFi 6 on 2.4GHz
• BLE: 5.3
• Mesh networking: IEEE 802.15.4-2015 protocol, supports Thread 1.3 and Zigbee 3.0
• Flash: 8 MB

More information can be found in the Datasheet.

Application processor

Chip: Espressif Systems ESP32-P4NRW32

• CPU: 32-bit RISC-V dual core microprocessor, up to 400 MHz
• RAM: 32 MB
• Flash: 16 MB

The datasheet for this chip is not yet publicly available

Management coprocessor

Chip: WCH CH32V203C8T6

• CPU: 32-bit RISC-V single core microprocessor, up to 144 MHz
• RAM: 20KB
• Flash: 64 KB

More information can be found in the Datasheet.

The management coprocessor is responsible for reading the keyboard matrix and power management. It presents itself as an I2C peripheral on the internal I2C bus of the Tanmatsu and provides the following services:

• Keyboard events
• PWM control for the display backlight
• PWM control for the keyboard backlight
• Real Time Clock (RTC) backed by watch crystal
• Alarm wakeup
• PMIC control
• Power switching for USB-A port
• Power and boot-mode control for the ESP32-C6 radio module
• Power switching for audio amplifier
• Headphone detection
• Addressable LED control for the 6 built-in addressable LEDs

The firmware for this chip will be made available under terms of the MIT license after the product starts shipping to customers. Modifying the firmware is of course possible but is not recommended.

The firmware of the coprocessor can be updated from the ESP32-P4 application processor, for this Nicolai Electronics developed an ESP-IDF component capable of reprogramming CH32V20x and CH32V30x microcontrollers from the ESP32-P4 application processor.

LoRa radio

The PCB footprint supports a range of radio modules from Ai-Thinker. Software support will initially be provided for the RA-01SH 868 MHz band SX1262 based and the RA-01S 433 MHz band SX1268 based modules.

All Tanmatsu boards will be delivered with a module which has the IPEX-1 antenna connector installed. Optionally an SMA antenna connector can be installed to allow connecting standard external LoRa antennas. Tanmatsu will be provided with either an internal IPEX-1 antenna or a basic SMA antenna depending on the option chosen.

Audio

Everest Semiconductor ES8156 audio codec:

• Hardware volume control via I2C interface
• Stereo audio DAC

FM8002A mono speaker amplifier:

• Can be switched on and off using the coprocessor
• Connected to built-in 8 Ohm speaker

Power management

PMIC

Texas Instruments BQ25895RTW PMIC for battery charging and monitoring as well as DC/DC boost converter for 5 volt rail (to power USB-A port, addressable LEDs and 5 volt pin on the personality module expansion header).

Provides soft power on/off functionality when the device is battery powered and allows seamless transition between battery and USB-C power source.

3.3v rail DC/DC converter

Texas Instruments TPS63020DSJR DC/DC buck and boost converter providing a stable 3.3v rail even when the battery voltage drops below 3.3 volt.

Backlight drivers

Two AP3032KTR backlight driver chips, one for the display and one for the keyboard backlight LEDs.
Brightness controlled using PWM via the CH32V203 coprocessor.

Standby power rail

A small LDO provides 2.5v to the Vbatt rail of the CH32V203 coprocessor even when the device is off. This uses almost no power (theoretically the battery would last over 10 years on a single charge if the device is never turned on, ignoring LiPo battery self-discharge) and allows the Real Time Clock in the CH32V203 coprocessor to keep track of time even when the device is off. A special latch circuit circuit allows the CH32V203 to power on the Tanmatsu using its alarm pulse output by emulating a press of the power button.

Addressable LEDs

Six SK6805-EC20 addressable LEDs controlled by the coprocessor.

Sensors

• Bosch BMI270 IMU combined accelerometer and gyroscope
• Header for optional SCD40 or SCD41 CO2, temperature and humidity sensor (not populated, modules are available on AliExpress) or other I2C controlled sensor

Questions?

If you have questions please contact us by joining one of our community chatgroups (Telegram and Discord) or by emailing us.

1.1.3 - Tanmatsu: 3D printed case

Information about the 3D printed case for Tanmatsu.

Note: information on this page is actively being worked on and might contain accidental errors and inaccuracies.

Filament

The 3D printed case and spacer are printed using Extrudr PLA NX2 on Prusa Mini and Prusa XL printers.

Design files

Once Tanmatsu is available the spacer and case designs will be published as STEP and STL files.

The 3D printed case and spacer will both be available as a spare part from our webshop once Tanmatsu is shipped.

Photos

These photos show some of the prototype 3D printed cases, final design will differ slightly because we are still actively working on improving the design for easier manufacturing and better dust protection.

Special thanks

We want to thank our friends over at YTec 3D for developing the Tanmatsu case and designs. Check out their amazing projects.

Questions?

If you have questions please contact us by joining one of our community chatgroups (Telegram and Discord) or by emailing us.

1.2 - Tanmatsu: getting started

Introduction

Congratulations! You just got your hands on your Tanmatsu, we bet you’re excited to get started so let’s not delay and get right to it!

Turning Tanmatsu on and off

The top most button on the right side of the device is the power button.

Tanmatsu has multiple power states, some are defined by software, others by hardware. Depending on the state your device is in you will need to hold down the power button for a different duration to reach the desired state.

• If your Tanmatsu is completely turned off it is in a mode where only the clock is running. This mode requires so little power that you should not notice any battery drain in years if the device is left alone. Pressing the power button for 2.5 seconds turns the device on if it is in this state.
• If your Tanmatsu is turned on you can turn it off completely by holding down the power button for more than half a second.
• If you keep holding down the power button after the device has powered off then the device will restart 2.5 seconds after it powered off. This allows for easily rebooting your tanmatsu by holding down the power button for 3 seconds.
• Depending on the app currently running on your Tanmatsu there might be more power states available. We recommend trying a short press of the power button to enter and leave the sleep state.

Charging your Tanmatsu

You can charge your Tanmatsu by plugging in a power source (phone charger or computer) into the USB-C port. Tanmatsu will automatically power on when a power source is detected and battery charging will start automatically.

Tanmatsu will only charge when on or in sleep mode. If Tanmatsu is powered off the battery will not be charged even with a power source connected to the USB-C port. The default firmware for Tanmatsu will include a mode which turns off the radio and display and keyboard backlight before putting the ESP32-P4 application processor into deep sleep mode. You can enter this mode by pressing the power button for less than half a second. You can check if your Tanmatsu is charging by looking at the color of the power LED.

Power LED

The color of the power LED indicates the state of the power management system.

If the power LED displays a solid single color:

• Blue: running on battery, no charger detected
• Yellow: charger detected, battery is being charged
• Green: charger detected, battery is fully charged
• Red: charger detected, no battery detected

If the power LED displays a blinking color:

• Slowly blinking red: the battery is almost empty, connect a charger to avoid losing work
• Rapidly blinking red: a fault occured in the power management circuit

In case you encounter a fault condition please exit the currently running app and return to the launcher menu. The launcher menu will provide more detailed information about the active fault flags.

PMIC status LED

There is a small red LED on the back of the mainboard. This LED provides additional status information about the state of the power management system of Tanmatsu.

• Off: the battery is not being charged
• Slow blinking: a PMIC fault has occured
• Rapid bliniing: Tanmatsu is trying to charge the battery but no battery is being detected

PMIC stands for “Power Management Integrated Circuit”. Tanmatsu uses a BQ25895 PMIC from Texas Instruments to manage battery charging.

Fault conditions

A fault doesn’t immediately mean there is anything wrong with your Tanmatsu and using a Lithium Polymer battery is not dangerous if the battery is handled correctly. Tanmatsu contains a multiple layers of protection to prevent any damage to your device, the battery or it’s surroundings. If charging is stopped due to a fault then most likely there is something wrong with your battery, though this doesn’t immediately have to be a problem.

The protection functions built into the Tanmatsu mainboard will, in addition to the battery protection circuit built into the battery itself, stop charging if it detects that the battery voltage is below the minimum safe threshold for a Lithium Polymer battery or above the maximum voltage threshold of a Lithium Polymer battery. In both cases the power LED will rapidly blink in red and the small red LED on the back of the mainboard will

A situation that can trigger the under-voltage protection is a situation where the battery has drained below it’s rated minimum voltage due to degradation when left completely empty for a long period of time. In this situation is is also possible that the battery simply is not detected, in which case the power LED will turn red when an external power source is connected. If the battery has accidently reached a voltage near 2.5 volt then the battery will be disconnected to protect it. Normally the battery voltage recovers a bit automatically after leaving the battery alone for a few minutes. In this situation you can safely restart start charging the battery again after the voltage has reached it’s normal level.

The battery supplied with your Tanmatsu has a built-in protection circuit preventing the battery from draining below it’s minimum rated voltage during normal use.

A Lithium Polymer battery that has reached a voltage below 2.5 volt for a prolonged period of time can become chemically unstable, we recommend replacing the battery if your battery has drained below 2.5 volt. Recharging a Lithium Polymer battery that has been subjected to a situation where it reached a voltage of less than 2.5 volt can be dangerous, the battery may for example swell up and could potentially damage the device or it’s surroundings.

1.3 - Tanmatsu: software

Work in progress

The software for Tanmatsu is currently under active development. On this page we will regulary post updates on our progress. Don’t want to miss out on any updates? Join our Discord or Telegram groups.

Device drivers

The invisible though crucial part of all software running on Tanmatsu. These ESP-IDF components provide the building blocks for interfacing with the hardware on the Tanmatsu mainboard.

MIPI DSI display

The Tanmatsu has a MIPI DSI display with a ST7701 controller. Espressif provides a driver for this controller, we added the correct initialization commands and configuration for the display on the Tanmatsu and packaged these in a component. In addition to the configuration of the Tanmatsu display the display included with the Espressif ESP32-P4 devkit is also supported by this component, allowing for easy switching between Tanmatsu hardware and the ESP32-P4 devkit.

Coprocessor

This driver component manages communication with the coprocessor firmware via I2C and exposes functions for accessing all coprocessor functionality.

ES8156 audio DAC

This driver component allows for configuring the ES8156 audio DAC via I2C.

BMI270 IMU

This driver component wraps the Bosch SDK for the BMI270 IMU, implementing communication via I2C for the ESP32-P4.

In circuit programming

These components are as invisible during normal use as they are useful when you need them. To do initial hardware bringup and to update the firmware of the coprocessor and the radio Tanmatsu needs a way to reprogram these chips from the ESP32-P4 application processor.

Tools

The BSP (Board Support Package) wraps the driver components to provide an easy way to integrate board support for Tanmatsu (and other devices) into ESP-IDF projects.

AppFS allows for dynamically installing and running ESP32 firmware from a special flash partition. This mechanism allows for installing and running apps directly from the Tanmatsu launcher.

The LVGL BSP interface is a component providing the glue needed to use the LVGL graphics stack component provided by Espressif with the BSP component, mapping the keyboard buttons and correctly configuring the display and display rotation.

1.3.1 - AppFS

AppFS is an ESP-IDF component that implements a method for dynamically installing and loading firmware binaries. It implements a pseudo filesystem interface for storing firmwares and a bootloader modification which allows for starting firmwares from the AppFS partition.

Originally AppFS was created by Jeroen Domburg (sprite_tm) for the PocketSprite keychain gameconsole. Since it’s creation Badge.Team has succesfully deployed, updated and extended AppFS to make it the ready to use component it is today.

The current version of AppFS supports ESP-IDF 5.3 and later and has bootloader modifications for the ESP32, ESP32-C6 and ESP32-P4 included. Other ESP32 variants are not supported yet.

Using the AppFS component in your projects

Apps do not require any changes to be started using AppFS, you only need the AppFS component to build a launcher menu.

To include the AppFS component in your launcher menu project first add the component as a requirement using idf.py:

idf.py add-dependency "badgeteam/appfs^1.0.0"

This makes the AppFS APIs available, but does not apply the required bootloader changes.

To apply the bootloader changes either create two symlinks or copy the contents of the folders.

mkdir bootloader_components
ln -s managed_components/badgeteam__appfs bootloader_components/appfs
ln -s managed_components/badgeteam__appfs/bootloader_main bootloader_components/main

The component is now ready for use.

#include "esp_err.h"
#include "esp_log.h"
#include "appfs.h"

void initialize_appfs(void) {
    esp_err_t res = appfsInit(APPFS_PART_TYPE, APPFS_PART_SUBTYPE);
    if (res != ESP_OK) {
        ESP_LOGE(TAG, "Failed to initialize AppFS: %s", esp_err_to_name(res));
        return;
    }
}

See the functions defined in appfs.h for more information on how to use the library.

Partition table

The appfs.h header defines a type and subtype for the AppFS partition:

#define APPFS_PART_TYPE    0x43 /*<! Default partition type of an appfs partition */
#define APPFS_PART_SUBTYPE 0x3  /*<! Default partition subtype of an appfs partition */

To create an AppFS partition add an entry to the partitions CSV file for your project:

# ESP-IDF Partition Table
# Name, Type, SubType, Offset,   Size,
appfs,  0x43, 3,       0x330000, 8000K,

AppFS partition tools

After ESP-IDF has downloaded the component a tools folder can be found at managed_components/badgeteam__appfs/tools. In this folder a set of Python scripts can be found for creating and managing AppFS partition data.

Creating an AppFS partition image

In the partition table above the partition is 8000 KB in size. Converted to bytes 8000 KB becomes 8000 x 1024 = 8192000 bytes.

A partition can be created using the following command:

python appfs_generate.py 8192000 example.bin

To add firmware binaries to the AppFS partition file the appfs_add_file.py tool can be used:

python appfs_add_file.py example.bin myapp.bin "myapp" "My app" 1

The name and title fields are strings. The filename (name field) of the file can be a maximum of 48 bytes long and the title of the file can be 64 bytes long. The version field is an 16 bits unsigned integer with a range of 0 - 65535.

The filename (name field) of the file is used in the AppFS API to identify files in the filesystem, filenames have to be unique. The title field is optional and may be used to include a human readable alternative to the filename. If unused the title field can be set to a blank string "". The version field is also optional and may be used to identify the installed version of an application, allowing for easier implementation of update mechanisms. If unused the version field can be set to 0.

2 - I2C VFD (NE-HCS12SS59T-R1)

What is it?

A Samsung HCS-12SS59T 12 character vacuum fluorescent display connected to a custom driver board which takes away all the difficulties of using such a display. The driver board does everything for you, from step-up voltage generation to having a microcontroller that translates between the display and an easy to use I2C interface.

Why did you make it?

I like weird and wonderful displays and this display deserves a spot in cool DIY projects. Unfortunately it is not exactly plug-and-play for use in Arduino, MicroPython or Raspberry pi projects.

What makes it special?

Everything is handled on-board, from generating the required voltages to handling the display control signals. All you have to do is hook up this module via I2C using the QWIIC / Stemma QT connectors on this board. There is two of them allowing for easy daisy chaining with more displays or other QWIIC/Stemma QT boards.

Sources

The hardware design files can be found in the hardware repository and the firmware can be found in the firmware repository.

How to use the device

The device can be connected to a microcontroller via the standardized QWIIC interface.

The device is compatible with a supply voltage of 3.3 volt. The I2C interface requires a working voltage of 3.3 volt as well.

I2C interface

The default I2C address is 0x10. The address can be changed by bridging the address jumpers on the board. This allows for modifying the I2C address in the range 0x10 up to 0x2F. Jumper 0 increases the address by 1, jumper 1 increases the address by 2, jumper 3 increases the address by 4 and jumper 4 increases the address by 8.

Register map

Scrolling modes

0 = Scrolling disable
1 = Scroll left (increment display offset)
2 = Scroll right (decrement display offset)

Usage

Basic usage

At power on the display is automatically enabled. Writing ASCII text to registers 10 through 255 will make the text appear on the display.

To move the position in the buffer which is shown on the display you can write an offset to register 1 (display offset).

System control

To turn off the display write 0 to bit 0 of register 0, to turn on the display write a 1 to bit 0 of register 0. The LED can be controlled using bit 2 of register 0.

Scrolling

The automatic scrolling feature automatically updates the value of register 2 (display offset) to make the text shown on the display scroll without interaction by the bus master.

To enable automatic scrolling first write the maximum value the offset register should reach by setting the value of register 2 (scroll length). To stop scrolling once the last character of a string of text is shown on the rightmost position of the display set the value of this register to the length of the string minus 12 (the amount of characters the VFD can display).

Then write the speed at which you wish the characters to scroll into registers 4 and 5. This value is a 16-bit number representing the amount of milliseconds to wait before moving to the next character.

If scrolling was used before then resetting the current display offset to 0 makes sure the display starts scrolling from the beginning of the text.

To start scrolling write 1 to register 3. This will cause the text to scroll to the left automatically. Scrolling will stop once the scroll length value is reached. To automatically reset to the start of the string the loop function can be enabled by writing 17 (16, loop enable + 1, scroll left) to register 3.

For better readability adding 12 spaces to the front of the string to be scrolled is adviced, this makes the scrolling text start by scrolling in from the right into a blank screen.

Example Arduino sketch

The following Arduino sketch shows basic usage and how to use the built-in automatic scrolling features of the product.

// This example sketch may be freely used and considered in the public domain
// in countries where releasing code into the public domain is not possible
// this code may be used under the terms specified in the CC0 license
// https://creativecommons.org/public-domain/cc0/

#include <Wire.h>

#define VFD_REG_CTRL         0
#define VFD_REG_OFFSET       1
#define VFD_REG_SCROLL_LEN   2
#define VFD_REG_SCROLL_MODE  3
#define VFD_REG_SCROLL_SPEED 4
#define VFD_REG_DATA         10

#define VFD_SCROLL_DISABLE   0
#define VFD_SCROLL_LEFT      1
#define VFD_SCROLL_RIGHT     2

const int16_t I2C_ADDR = 0x10;

// Functions for reading and writing

void vfd_read_regs(uint8_t reg, uint8_t* val, uint8_t len) {
  Wire.beginTransmission(I2C_ADDR);
  Wire.write(reg);
  Wire.endTransmission(false);
  Wire.requestFrom((uint8_t) I2C_ADDR, (uint8_t) len);
  for (uint8_t index = 0; index < len; index++) {
    val[index] = Wire.read();
  }
  Wire.endTransmission();
}

void vfd_read_reg(uint8_t reg, uint8_t* val) {
  vfd_read_regs(reg, val, 1);
}

void vfd_write_regs(uint8_t reg, uint8_t* val, uint8_t len) {
  Serial.print("I2C write to register " + String(reg) + ": ");
  Wire.beginTransmission(I2C_ADDR);
  Wire.write(reg);
  for (uint8_t index = 0; index < len; index++) {
    Serial.print(String(val[index], HEX) + ", ");
    Wire.write(val[index]);
  }
  Serial.println();
  Wire.endTransmission();
}

void vfd_write_reg(uint8_t reg, uint8_t val) {
  vfd_write_regs(reg, &val, 1);
}

// Functions for using the control register

void vfd_control_led(bool state) {
  uint8_t val = 0;
  vfd_read_reg(VFD_REG_CTRL, &val);
  Serial.println("LED, READ  " + String(val, HEX));
  val &= ~(1 << 2); // Turn off the LED
  if (state) {
    val |= (1 << 2); // Turn on the LED
  }
  Serial.println("LED, WRITE " + String(val, HEX));
  vfd_write_reg(VFD_REG_CTRL, val);
}

void vfd_control_test(bool state) {
  uint8_t val = 0;
  vfd_read_reg(VFD_REG_CTRL, &val);
  val &= ~(1 << 1); // Turn off the test mode
  if (state) {
    val |= (1 << 1); // Turn on the test mode
  }
  vfd_write_reg(VFD_REG_CTRL, val);
}

void vfd_control_enable(bool state) {
  uint8_t val = 0;
  vfd_read_reg(VFD_REG_CTRL, &val);
  val &= ~(1 << 0); // Turn off the VFD
  if (state) {
    val |= (1 << 0); // Turn on the VFD
  }
  vfd_write_reg(VFD_REG_CTRL, val);
}

void vfd_control(bool enable, bool test, bool led) {
  uint8_t val = 0;
  if (enable) {
    val |= (1 << 0);
  }
  if (test) {
    val |= (1 << 1);
  }
  if (led) {
    val |= (1 << 2);
  }
  vfd_write_reg(VFD_REG_CTRL, val);
}

// Functions for using the scroll features

void vfd_set_offset(uint8_t offset) {
  vfd_write_reg(VFD_REG_OFFSET, offset);
}

void vfd_set_scroll_length(uint8_t len) {
  vfd_write_reg(VFD_REG_SCROLL_LEN, len);
}

void vfd_set_scroll_mode(uint8_t scroll_mode, bool scroll_loop) {
  uint8_t val = scroll_mode & 0x0F;
  if (scroll_loop) {
    val |= (1 << 4);
  }
  vfd_write_reg(VFD_REG_SCROLL_MODE, val);
}

void vfd_set_scroll_speed(uint16_t scroll_speed) {
  uint8_t values[2];
  values[0] = (scroll_speed) & 0xFF;
  values[1] = (scroll_speed >> 8) & 0xFF;
  vfd_write_regs(VFD_REG_SCROLL_SPEED, values, sizeof(uint16_t));
}

// Functions for using the text buffer

void vfd_write_text(String text) {
  // This function writes an ASCII string into
  // register 10 to 255

  const size_t max_len = 245; // can store text in registers 10 to 255
  size_t len = text.length();

  if (len > max_len) {
    // Silently limit the length of the string
    len = max_len;
  }

  Wire.beginTransmission(I2C_ADDR);
  Wire.write(VFD_REG_DATA);
  for (size_t index = 0; index < len; index++) {
    Wire.write(text[index]);
  }
  Wire.endTransmission();
}

// Functions for Arduino program

void setup() {
  Serial.begin(115200);

  Serial.println("Initialize I2C bus");
  Wire.begin(); // Initialize the I2C bus

  // Configure the display and show a message
  Serial.println("Configure the display and show a message");
  vfd_set_scroll_mode(VFD_SCROLL_DISABLE, false); // Disable scrolling
  vfd_set_offset(0); // Move to beginning of text buffer
  vfd_write_text("Hello world ");
  vfd_control(true, false, true); // Turn on VFD and LED
  delay(1000); // Wait a bit

  Serial.println("Demonstrate scrolling");
  String text = "            The quick brown fox jumps over the lazy dog 0123456789 !@$%^&*()-_=+";
  vfd_write_text(text);
  vfd_set_scroll_length(text.length() - 12); // Scroll until the last character of the string is on the most right character of the display
  vfd_set_scroll_speed(100); // Scroll one character every 100ms
  vfd_set_scroll_mode(VFD_SCROLL_LEFT, false); // Scroll left then stop
  vfd_control_led(false);
  delay(10000);

  vfd_set_scroll_mode(VFD_SCROLL_RIGHT, false); // Scroll right then stop
  vfd_control_led(true); // Turn on LED
  delay(10000);

  vfd_set_scroll_mode(VFD_SCROLL_LEFT, true); // Scroll left then loop
  vfd_control_led(false); // Turn off LED
  delay(20000);

  vfd_set_scroll_mode(VFD_SCROLL_DISABLE, false); // Disable scrolling
  vfd_write_text("            "); // Clear screen
  vfd_set_offset(0); // Move to beginning of text buffer
  vfd_control_led(true); // Turn on LED

  Serial.println("Starting counter loop");
}

uint32_t counter = 0;
void loop() {
  // Count as fast as we can
  vfd_write_text(String(counter));
  counter++;
}

What does it look like?

3 - OpenBMC

OpenBMC is an open source Linux distribution for Baseboard Management Controllers. Nicolai Electronics works on enabling more boards to run this open source firmware instead of manufacturer provided proprietary solutions. More information can be found on the board specific pages.

3.1 - ASRock Rack

ASRock Rack is a hardware manufacturer which has produced multiple mainboards and devices which should be capable of running OpenBMC. More information on the boards Nicolai Electronics is working can be found on the board specific pages.

3.1.1 - ASRock Rack X570D4U

Project status: in progress

The ASRock Rack X570D4U series of mainboards consists of three mainboards with an AMD X570 chipset and AM4 socket. ASRock Rack sells the board in three versions: a cost reduced version without a 10Gbit NIC (X570D4U), a version with an Intel 10Gbit NIC (X570D4U-2L2T) and a version with a Broadcom 10Gbit NIC (X570D4U-2L2T/BCM). These boards contain an Aspeed AST2500 BMC chip. A Baseboard Management Controller (BMC) is a small computer built into the motherboard that allows for out-of-band management. It allows for remote power control, KVM (remote keyboard, video and mouse) control, virtual media insertion and much more.

These parts make for quite a powerful system, unfortunately the operating system shipped by ASRock Rack is proprietary and dos not allow for easy modification. To allow for a more secure, transparent and customizable experience we are working on adding support for this mainboard to the mainline Linux kernel and the OpenBMC Linux distribution for BMCs.

Official documentation is provided in ASRock Racks manual for these mainboards. Not a all headers and connectors are described in this manual. The pinout of the undocumented connectors and headers can be found on the pinout page.
The BMC has a programming header, a debug serial port, I2C busses and GPIOs.

Project status

Enabling the use of the mainline Linux kernel and OpenBMC on this hardware is an ongoing effort. An initial port of OpenBMC missing most board specific features can be found here.

3.1.1.1 - ASRock Rack X570D4U mainboard: pinout

This page describes the undocumented headers and connectors on the ASRock X570D4U mainboard. The official manual for this mainboard describes most other connectors and headers.

BMC debug header

This header labeled BMC_DEBUG1 provides access to the debug serial port of the AST2500 SoC (UART 5). The UART works with 3.3v level signals and provides a 3.3v output and can be found on the bottom left of the mainboard.

Using this port you can access the U-Boot command prompt, the Linux bootlog and a shell.

BMC programming header

This header labeled BMC_PH1 provides access to the MX25L51245G 64MB flash chip containing the BMC firmware. Using an exernal SPI flash programmer this port allows for unbricking and easy reflashing of the BMC firmware during development.

This interface uses 3.3v level signals. Connecting the BMC RESET# pin to GND disables the AST2500, allowing an exernal programmer to reprogram the flash chip without interference from the SoC.

Manufacturing mode header

This header labeled MFG1 is connected to GPIO H4 of the AST2500 SoC. With the official firmware installed shorting this jumper makes the BMC boot into a special debug mode, dropping to a root shell on the BMC_DEBUG1 port. When running OpenBMC this GPIO is available for custom applications.

Chassis identification

These three headers labeled CHASSIS_ID1, CHASSIS_ID2 and CHASSIS_ID3 are connected to GPIO G1, G2 and G3 of the AST2500 SoC for ID1, ID2 and ID3 respectively. On production boards these headers appear to not have been installed, but they are functional. When running OpenBMC these GPIOs are available for custom applications.

3.1.1.2 - ASRock Rack X570D4U mainboard: I2C busses

This page describes the I2C busses and connected on-board devices on the ASRock X570D4U mainboard.

I2C bus 0

This bus is connected to the AUX_PANEL1 connector. SMBus alert for this bus is connected to GPIO 52 (G4) named input-aux-smb-alert-n.

I2C bus 1

This bus is used for controlling on-board devices that are used when the host is on.

PCA9557 IO expander

Nuvoton NCT6796D-R SuperIO

This chip can read the CPU and chipset temperatures. It should be possible to use the newly added nct6775-i2c driver to use this device.

Using the NCT6775-I2C driver

The OpenBMC port for the X570D4U already includes the nct6775-i2c driver in it’s kernel, but as the SuperIO device only appears on the bus when the host system is powered on the driver needs to be loaded in and unloaded based on power state changes. This has not been implemented yet.

The driver can be manually loaded in using the following command:

echo "nct6775 0x2d" > /sys/bus/i2c/devices/i2c-1/new_device

If the driver was loaded correctly then you should now be able to find a folder called hwmon in the device folder /sys/bus/i2c/devices/i2c-1/1-002d. This folder will contain a symlink to the hwmon interface for the SuperIO chip. If the folder is missing then your kernel does not include the nct6775-i2c driver.

Directly accessing and reading the temperature registers

Alternatively the temperatures can be read using this shell script, for which no kernel driver is required:

#!/bin/bash
i2cset -y 1 0x2d 0x4e 0x04
while :
do
    TSI0INT=$((16#$(i2cget -y 1 0x2d 0x09 | cut -f2 -dx)))
    TSI0FRC=$(($((16#$(i2cget -y 1 0x2d 0x0a | cut -f2 -dx)))>>5))
    TSI1INT=$((16#$(i2cget -y 1 0x2d 0x0b | cut -f2 -dx)))
    TSI1FRC=$(($((16#$(i2cget -y 1 0x2d 0x0c | cut -f2 -dx)))>>5))
    echo "TSI0_TEMP: $TSI0INT.$TSI0FRC °C / TSI1_TEMP: $TSI1INT.$TSI1FRC °C"
    sleep 0.5
done

Nuvoton W83773G

This device is available on the versions of the X570D4U which include a 10Gbit network adapter. It monitors the temperature of the 10Gbit NIC.

cat /sys/class/hwmon/hwmon0/temp2_input

I2C bus 2

This bus is used for connecting to exernal power supplies with SMBus monitoring support using the PSU_SMB1 connector. SMBus alert for this bus is connected to GPIO 54 (G6) named input-psu-smb-alert-n.

I2C bus 3

This bus has an unknown purpose.

I2C bus 4

This bus is used to connect to expansion cards inserted into the PCI-Express slots of the mainboard.

NXP PCA9545A I2C bus switch

I2C bus 5

This bus is connected to the BMC_SMB_1 connector. The BMC_PRESENT_1_N signal on the BMC_SMB_1 connector is connected to GPIO 132 (Q4) named input-bmc-smb-present-n.

I2C bus 7

This bus is used for connecting to the FRU EEPROM and the RAM DIMMs.

I2C bus 8

This bus is connected to the IPMB_1 connector.

3.1.1.3 - ASRock Rack X570D4U mainboard: GPIO

This page describes the GPIOs of the ASPEED AST2500 BMC on the ASRock X570D4U mainboard.

3.1.1.4 - Programming SPI flash with an FT2232 breakout board

Connection diagram

3.1.1.5 - ASRock Rack X570D4U mainboard: temperature sensors

This page describes the temperature sensors on the X570D4U.

Nuvoton NCT6796D-R SuperIO

This device can be accessed via I2C bus 1 at address 0x2D.

Nuvoton W83773G

This device can be accessed via I2C bus 1 at address 0x4C.

3.1.1.6 - ASRock Rack X570D4U mainboard: fans

This page describes the fan connectors on the X570D4U.

Fan connectors

Fan 1-3 connector pinout

Fan 4-6 connector pinout

3.1.2 - ASRock Rack PAUL

Project status: in progress

The ASRock Rack PAUL is a PCI-express add-in card for servers and workstations containing an Aspeed AST2500 BMC chip. A Baseboard Management Controller (BMC) is a small computer that allows for out-of-band management. It allows for remote power control, KVM (remote keyboard, video and mouse) control, virtual media insertion and much more.

These parts make for quite a powerful system, unfortunately the operating system shipped by ASRock Rack is proprietary and dos not allow for easy modification. To allow for a more secure, transparent and customizable experience we are working on adding support for this mainboard to the mainline Linux kernel and the OpenBMC Linux distribution for BMCs.

Official documentation is provided in ASRock Racks manual.

3.1.2.1 - ASRock Rack PAUL: GPIO

This page describes the GPIOs of the ASPEED AST2500 BMC on the ASRock Rack Paul card.

4 - Contributors guide

We love open source and welcome contributions to our projects!

How to contribute

You can submit your contributions to our projects using Github pull requests.

Before contributing

Open source is great, but there are a lot of things to keep in mind. Please read through these bullet points before submitting your pull request to one of our projects.

• Contributions must be either entirely your own work or already MIT or CERN-OHL-P licensed. We believe in true freedom and we thus do not accept contributions licensed with restrictive open source licenses such as GPL variants.
• If your employer has included a clause in your employment contract transferring rights to your IP to the company you work for then you need to have your employer sign the CLA if you wish to contribute as technically you do not have the rights to your own work.
• We require you to sign a contributors license agreement (CLA) before we can accept your contribution.

The CLA

Just like most makers and hackers we know our main goal is to create cool things for others to enjoy. Legal problems are something we definitely want to avoid. Because of this we have to ask you to sign a contributors license agreement (CLA) before we can accept your contribution.

This CLA serves to let us avoid creating any restrictions as to how we use our projects now or in the future, to avoid any potential conflict.

We do of course respect your status as a contributor and we encourage you to add your name in the header of the source code files of any significant part of your contribution and we will respect this attribution when using your contribution.

At the same time, by signing the CLA you you do grant to us a worldwide, royalty-free, non-exclusive, perpetual and irrevocable license, with the right to transfer an unlimited number of non-exclusive licenses or to grant sublicenses to third parties, under the copyright covering the contribution to use the contribution by all means.

Or in less legalese terms: by contributing you give your work to us.

Notice

This document only highlights some of the key features and terms of the CLA. It is not a license and has no legal value. Please make sure to review the terms and conditions of the actual license before contributing.

You can read the CLA here.

4.1 - CLA

Contributor Agreement

Individual Contributor Non-Exclusive License Agreement including the Traditional Patent License OPTION

Thank you for your interest in contributing to this Nicolai Electronics project hosted on GitHub (“We” or “Us”).

The purpose of this contributor agreement (“Agreement”) is to clarify and document the rights granted by contributors to Us. To make this document effective, please follow the instructions in the contributors guide.

How to use this Contributor Agreement

If You are an employee and have created the Contribution as part of your employment, You need to have Your employer approve this Agreement or sign the Entity version of this document. If You do not own the Copyright in the entire work of authorship, any other author of the Contribution should also sign this.

1. Definitions

“You” means the individual Copyright owner who Submits a Contribution to Us. If You are an employee and submit the Contribution as part of your employment, You have had Your employer approve this Agreement or sign the Entity version of this document.

“Contribution” means any original work of authorship, including any original modifications or additions to an existing work of authorship, Submitted by You to Us, in which You own the Copyright. If You do not own the Copyright in the entire work of authorship, please contact Us by submitting a comment on GitHub.

“Copyright” means all rights protecting works of authorship owned or controlled by You, including copyright, moral and neighboring rights, as appropriate, for the full term of their existence including any extensions by You.

“Material” means the software or documentation made available by Us to third parties. When this Agreement covers more than one software project, the Material means the software or documentation to which the Contribution was Submitted. After You Submit the Contribution, it may be included in the Material.

“Submit” means any form of physical, electronic, or written communication sent to Us, including but not limited to electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, Us, but excluding communication that is conspicuously marked or otherwise designated in writing by You as “Not a Contribution.”

“Submission Date” means the date You Submit a Contribution to Us.

“Documentation” means any non-software portion of a Contribution.

2. License grant

2.1 Copyright license to Us

Subject to the terms and conditions of this Agreement, You hereby grant to Us a worldwide, royalty-free, NON-exclusive, perpetual and irrevocable license, with the right to transfer an unlimited number of non-exclusive licenses or to grant sublicenses to third parties, under the Copyright covering the Contribution to use the Contribution by all means, including, but not limited to:

• publish the Contribution,
• modify the Contribution,
• prepare derivative works based upon or containing the Contribution and/or to combine the Contribution with other Materials,
• reproduce the Contribution in original or modified form,
• distribute, to make the Contribution available to the public, display and publicly perform the Contribution in original or modified form.

2.2 Moral rights

Moral Rights remain unaffected to the extent they are recognized and not waivable by applicable law. Notwithstanding, You may add your name in the header of the source code files of Your Contribution and We will respect this attribution when using Your Contribution.

3. Patents

3.1 Patent license

Subject to the terms and conditions of this Agreement You hereby grant to us a worldwide, royalty-free, non-exclusive, perpetual and irrevocable (except as stated in Section 3.2) patent license, with the right to transfer an unlimited number of non-exclusive licenses or to grant sublicenses to third parties, to make, have made, use, sell, offer for sale, import and otherwise transfer the Contribution and the Contribution in combination with the Material (and portions of such combination). This license applies to all patents owned or controlled by You, whether already acquired or hereafter acquired, that would be infringed by making, having made, using, selling, offering for sale, importing or otherwise transferring of Your Contribution(s) alone or by combination of Your Contribution(s) with the Material.

3.2 Revocation of patent license

You reserve the right to revoke the patent license stated in section 3.1 if we make any infringement claim that is targeted at your Contribution and not asserted for a Defensive Purpose. An assertion of claims of the Patents shall be considered for a “Defensive Purpose” if the claims are asserted against an entity that has filed, maintained, threatened, or voluntarily participated in a patent infringement lawsuit against Us or any of Our licensees.

4. Disclaimer

THE CONTRIBUTION IS PROVIDED “AS IS”. MORE PARTICULARLY, ALL EXPRESS OR IMPLIED WARRANTIES INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT ARE EXPRESSLY DISCLAIMED BY YOU TO US AND BY US TO YOU. TO THE EXTENT THAT ANY SUCH WARRANTIES CANNOT BE DISCLAIMED, SUCH WARRANTY IS LIMITED IN DURATION TO THE MINIMUM PERIOD PERMITTED BY LAW.

5. Consequential damage waiver

TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, IN NO EVENT WILL YOU OR US BE LIABLE FOR ANY LOSS OF PROFITS, LOSS OF ANTICIPATED SAVINGS, LOSS OF DATA, INDIRECT, SPECIAL, INCIDENTAL, CONSEQUENTIAL AND EXEMPLARY DAMAGES ARISING OUT OF THIS AGREEMENT REGARDLESS OF THE LEGAL OR EQUITABLE THEORY (CONTRACT, TORT OR OTHERWISE) UPON WHICH THE CLAIM IS BASED.

6. Approximation of disclaimer and damage waiver

IF THE DISCLAIMER AND DAMAGE WAIVER MENTIONED IN SECTION 4. AND SECTION 5. CANNOT BE GIVEN LEGAL EFFECT UNDER APPLICABLE LOCAL LAW, REVIEWING COURTS SHALL APPLY LOCAL LAW THAT MOST CLOSELY APPROXIMATES AN ABSOLUTE WAIVER OF ALL CIVIL OR CONTRACTUAL LIABILITY IN CONNECTION WITH THE CONTRIBUTION.

7. Term

7.1 This Agreement shall come into effect upon Your acceptance of the terms and conditions.

7.3 In the event of a termination of this Agreement Sections 4, 5, 6, 7 and 8 shall survive such termination and shall remain in full force thereafter. For the avoidance of doubt, Free and Open Source Software (sub)licenses that have already been granted for Contributions at the date of the termination shall remain in full force after the termination of this Agreement.

8. Miscellaneous

8.1 This Agreement and all disputes, claims, actions, suits or other proceedings arising out of this agreement or relating in any way to it shall be governed by the laws of The Netherlands excluding its private international law provisions.

8.2 This Agreement sets out the entire agreement between You and Us for Your Contributions to Us and overrides all other agreements or understandings.

8.3 In case of Your death, this agreement shall continue with Your heirs. In case of more than one heir, all heirs must exercise their rights through a commonly authorized person.

8.4 If any provision of this Agreement is found void and unenforceable, such provision will be replaced to the extent possible with a provision that comes closest to the meaning of the original provision and that is enforceable. The terms and conditions set forth in this Agreement shall apply notwithstanding any failure of essential purpose of this Agreement or any limited remedy to the maximum extent possible under law.

8.5 You agree to notify Us of any facts or circumstances of which you become aware that would make this Agreement inaccurate in any respect.

This document is a modified version of a license generated with https://contributoragreements.org/ca-cla-chooser/ and licensed by Nicolai Electronics and Contributoragreements under terms of the CC BY-SA license.