DIY E-TUBE Tap

Chapter 02What it can and can't do

Shimano's own tools do two jobs: they report data, and they let E-TUBE Project change settings and update firmware. This build does the first job well. The second job needs Shimano's private protocol and signed firmware, so leave it to Shimano's tools.

Chapter 03How the E-TUBE bus works

Chapter 04System design

Your board sits on a branch of the motor-to-display cable, never in the middle of it. If your board fails or comes unplugged, the bike keeps working.

Chapter 05Bill of materials

Prices are typical Australian retail in AUD, including GST. They're estimates, so check before you order. Where to buy in Australia:

• Shimano parts: your Merida dealer, 99 Bikes, or online bike stores. Bike shops can order E-TUBE parts through Shimano's Australian distributor.
• Electronics: Core Electronics (XIAO, Pololu); Altronics or Jaycar (passives, enclosures, heat-shrink); DigiKey AU, element14 or Mouser AU (TLV3501, inductors; free shipping above about A$60).

A · Bike interface (Shimano parts)

Cheaper alternative: skip JC200 #2 and the EW-SD50 by cutting leg L1 of the JC130 and soldering it straight to your board. That saves about A$45–65, but the JC130 can't be reused afterwards.

B · Electronics

C · Tools

D · Software (free)

ESP-IDF v5.x (RMT RX driver, NimBLE), LVGL 9 + esp_lvgl_port, Python 3 with pyserial, PulseView, and nRF Connect on your phone.

Chapter 06Circuit design

The board is two independent circuits that share only ground: a power path that feeds the ESP32 from the bus, and a signal path that listens to it. Build and test the signal path first. The power path stays disconnected (JP1 open) until Stage B.

Power path

Signal path

The numbers behind the parts

PCB layout

A 60 × 40 mm two-layer board. The layout follows the schematic: power runs along the top, the listening circuit sits in the bottom-left corner, and the XIAO is in the bottom-right corner. The top-layer drawing is to scale (10 px = 1 mm). Use it as the placement guide when you lay out the board in KiCad, or as a map when you build it on perfboard.

Footprints and ordering

From KiCad to a board: draw the schematic, assign the footprints above, place parts as in the drawing, route, add the GND pours (B.Cu and F.Cu), run the design rules check (DRC), then File → Plot Gerbers plus a drill file. At JLCPCB, choose 2 layers, 1.6 mm, lead-free HASL or ENIG, 5 pieces. That's about A$8 for the boards plus A$15–25 shipping to Australia.

Chapter 07ESP32-S3 wiring

The pin plan is for the XIAO ESP32-S3 with an SPI display and I²C touch controller, the most common touchscreen setup. Check your screen's pin names against the table and adjust. If your screen is an all-in-one ESP32-S3 board, connect the comparator to any free GPIO that isn't a strapping pin and change TAP_GPIO in the firmware.

Chapter 08Build, step by step

Chapter 09Decoding the protocol

Laptop decoder

This turns the logger's pulse widths into bits. Each width is rounded to whole 500 ns half-cycles, so timing errors can't build up across a long frame. In a test with ±150 ns of random jitter on every pulse, it decoded 20,000 out of 20,000 simulated frames correctly.

Copy#!/usr/bin/env python3
"""etube_decode.py: read 'F n w0 w1 ...' lines from the ESP32 and print bits.
Usage: python3 etube_decode.py /dev/cu.usbmodem1101 [label]"""
import sys, collections, serial

HALF_NS = 500          # one carrier half-cycle (1 MHz carrier)

def decode(widths_ns):
    # Returns (bpsk_bits, dbpsk_bits). Time is counted in whole half-cycles.
    units, flips = 0, set()
    for w in widths_ns:
        n = round(w / HALF_NS)
        if n == 2:                         # 1 us pulse = phase flip at its centre
            flips.add((units + 1) // 4)    # 4 half-cycles per bit
        units += n
    nbits = units // 4
    bpsk, cur = [], 1                      # first bit is unknown; assume 1
    for k in range(nbits):
        if k in flips:
            cur ^= 1
        bpsk.append(cur)
    dbpsk = [1 if k in flips else 0 for k in range(nbits)]
    return bpsk, dbpsk

def main():
    port = serial.Serial(sys.argv[1], 115200, timeout=1)
    label = sys.argv[2] if len(sys.argv) > 2 else "capture"
    seen = collections.Counter()
    with open(f"{label}.log", "a") as log:
        for raw in port:
            parts = raw.decode(errors="ignore").split()
            if len(parts) < 3 or parts[0] != "F":
                continue
            widths = [int(x) for x in parts[2:] if x != "0"]
            bpsk, dbpsk = decode(widths)
            a = "".join(map(str, bpsk))
            b = "".join(map(str, dbpsk))
            seen[a] += 1
            line = f"{len(bpsk):4d}  BPSK {a}\n      DBPSK {b}"
            print(line + ("" if seen[a] > 1 else "   <-- new"))
            log.write(f"{label}\t{a}\t{b}\n")

if __name__ == "__main__":
    main()

Run it once per experiment with a label (baseline, eco, high, …), then compare the logs side by side. Messages marked <-- new are the first time a bit pattern was seen, which helps a lot when you press a button.

Chapter 10Firmware

Capture + logger (ESP-IDF v5)

This is the whole Stage A firmware: it receives frames on GPIO4 and prints pulse widths in nanoseconds. While a line is printing, the next frame can be missed. That's fine for exploration; once you need every frame, use a double buffer.

Copy// main/tap_main.c: E-TUBE tap, Stage A capture firmware
#include <stdio.h>
#include "freertos/FreeRTOS.h"
#include "freertos/queue.h"
#include "driver/rmt_rx.h"
#include "driver/ledc.h"
#include "esp_err.h"

#define TAP_GPIO       4            // XIAO D3, comparator output
#define TEST_GPIO      2            // XIAO D1, 1 MHz self-test output (Phase 4 only)
#define RMT_RES_HZ     80000000     // 12.5 ns per tick
#define RX_SYMBOLS     2048

static rmt_channel_handle_t rx_chan;
static rmt_symbol_word_t rx_buf[RX_SYMBOLS];
static QueueHandle_t rx_queue;

static const rmt_receive_config_t rx_cfg = {
    .signal_range_min_ns = 100,     // drop glitches shorter than 100 ns
    .signal_range_max_ns = 20000,   // 20 us without an edge ends the frame
};

static bool IRAM_ATTR on_rx_done(rmt_channel_handle_t ch,
                                 const rmt_rx_done_event_data_t *ev, void *ctx)
{
    BaseType_t woken = pdFALSE;
    xQueueSendFromISR(rx_queue, ev, &woken);
    return woken == pdTRUE;
}

static void tap_init(void)
{
    rmt_rx_channel_config_t cfg = {
        .gpio_num = TAP_GPIO,
        .clk_src = RMT_CLK_SRC_DEFAULT,
        .resolution_hz = RMT_RES_HZ,
        .mem_block_symbols = RX_SYMBOLS,
        .flags.with_dma = true,     // ESP32-S3 supports DMA on RMT RX
    };
    ESP_ERROR_CHECK(rmt_new_rx_channel(&cfg, &rx_chan));
    rx_queue = xQueueCreate(4, sizeof(rmt_rx_done_event_data_t));
    rmt_rx_event_callbacks_t cbs = { .on_recv_done = on_rx_done };
    ESP_ERROR_CHECK(rmt_rx_register_event_callbacks(rx_chan, &cbs, NULL));
    ESP_ERROR_CHECK(rmt_enable(rx_chan));
}

// Phase 4 self-test: 1 MHz, 50 % square wave on TEST_GPIO
static void test_signal_start(void)
{
    ledc_timer_config_t t = {
        .speed_mode = LEDC_LOW_SPEED_MODE, .timer_num = LEDC_TIMER_0,
        .duty_resolution = LEDC_TIMER_4_BIT, .freq_hz = 1000000,
        .clk_cfg = LEDC_AUTO_CLK,
    };
    ESP_ERROR_CHECK(ledc_timer_config(&t));
    ledc_channel_config_t c = {
        .gpio_num = TEST_GPIO, .speed_mode = LEDC_LOW_SPEED_MODE,
        .channel = LEDC_CHANNEL_0, .timer_sel = LEDC_TIMER_0, .duty = 8,
    };
    ESP_ERROR_CHECK(ledc_channel_config(&c));
}

static void tap_task(void *arg)
{
    rmt_rx_done_event_data_t ev;
    for (;;) {
        ESP_ERROR_CHECK(rmt_receive(rx_chan, rx_buf, sizeof(rx_buf), &rx_cfg));
        xQueueReceive(rx_queue, &ev, portMAX_DELAY);
        printf("F %u", (unsigned)ev.num_symbols);
        for (size_t i = 0; i < ev.num_symbols; i++) {
            const rmt_symbol_word_t *s = &ev.received_symbols[i];
            // ticks * 12.5 ns; the last symbol's duration1 may be 0
            printf(" %u %u", s->duration0 * 25 / 2, s->duration1 * 25 / 2);
        }
        printf("\n");
    }
}

void app_main(void)
{
    tap_init();
#ifdef CONFIG_TAP_SELFTEST
    test_signal_start();
#endif
    xTaskCreatePinnedToCore(tap_task, "tap", 4096, NULL, 10, NULL, 1);
}

Bluetooth LE layout

Chapter 11Touchscreen dashboard

Chapter 12Controlling assist and lights

* Lights work with option A if the light toggle is a button you can reach, on the switch or on the display. Wire that button the same way.

Can my touchscreen fully replace the display?

Can I take the signals from the display's chips instead of the motor wire?

Option A: the button add-on

Inside the assist switch, each button is a small tactile switch on a circuit board. A PhotoMOS relay is a tiny solid-state switch controlled by an internal LED. Solder its output across a tactile switch, and when the ESP32 lights the LED, the relay closes that switch exactly like a finger press. The relay's two sides are electrically isolated, and its output works in either direction, so you don't need to know which pad is which.

1. Battery out. Open the assist switch (normally the left-hand bar unit). Note every screw and the gasket, and photograph the circuit board.
2. Find the pads. Each tactile switch has 4 legs in 2 connected pairs. With the multimeter on continuity, find the pair that only beeps while the button is held down.
3. Prove it. Battery in. Briefly bridge those two pads with insulated tweezers: the assist mode should change. Battery out again.
4. Solder 30 AWG Kynar wire to each pad pair. Many switch boards share one common pad, which gets you down to 4 wires for 3 buttons. Hot-glue the wires near the joints for strain relief.
5. Route and seal. Take the wires out through a small hole in the housing and seal it with neutral-cure silicone (acid-cure types corrode copper). Refit the gasket.
6. Connect to the relay outputs on your board through a small locking connector (JST-PH), so the switch can be disconnected.
7. Close the loop in firmware: press for 150 ms, then watch the bus tap. If the decoded assist mode didn't change within 300 ms, show a warning instead of pressing again and again.

Copy// main/buttons.c: press the switch's buttons through MCP23008 + PhotoMOS
#include "driver/i2c_master.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"

#define MCP23008_ADDR  0x20
#define REG_IODIR      0x00
#define REG_OLAT       0x0A

enum { BTN_UP = 0, BTN_DOWN = 1, BTN_LIGHT = 2 };

static i2c_master_dev_handle_t mcp;

static void mcp_write(uint8_t reg, uint8_t val)
{
    uint8_t buf[2] = { reg, val };
    ESP_ERROR_CHECK(i2c_master_transmit(mcp, buf, sizeof(buf), 50));
}

// bus: the I2C bus handle your touch driver already created
void buttons_init(i2c_master_bus_handle_t bus)
{
    i2c_device_config_t dev = {
        .dev_addr_length = I2C_ADDR_BIT_LEN_7,
        .device_address = MCP23008_ADDR,
        .scl_speed_hz = 400000,
    };
    ESP_ERROR_CHECK(i2c_master_bus_add_device(bus, &dev, &mcp));
    mcp_write(REG_OLAT, 0x00);      // all relays open before enabling outputs
    mcp_write(REG_IODIR, 0xF8);     // GP0..GP2 outputs, rest inputs
}

// 150 ms = short press. Use about 1500 ms only where Shimano's manual
// says a long press is needed (lights on some layouts). Never walk mode.
void button_press(int btn, int ms)
{
    mcp_write(REG_OLAT, (uint8_t)(1u << btn));
    vTaskDelay(pdMS_TO_TICKS(ms));
    mcp_write(REG_OLAT, 0x00);
}

Add-on parts (AUD)

Chapter 133D-printed case

Measure your screen first

Drawings

Garmin mount adapter

1. Fit test: set PART = "garmin_test", render, and print it (about 10 minutes). Push it into your Garmin mount turned 90°, then twist a quarter turn.
2. Won't go in: lower g_tab_w by 0.2 mm. Goes in but won't twist: raise g_neck_h by 0.2 mm, or lower g_tab_t. Rattles when locked: lower g_neck_h by 0.2 mm. Reprint the test after each change.
3. Check the locked direction: mark "up" on the test disc. If "up" points sideways when locked, set g_angle = 90.
4. Print the adapter: PART = "garmin", plate down, 6 walls and 50 % infill so the tabs are solid. The tabs overhang the neck by about 4 mm, which most printers handle without supports. If yours sags, enable supports for this part only.
5. Fit it: remove the bar mount and screw the adapter on with the same two M3 × 10 screws.

Print settings

Case hardware (AUD)

Assembly

1. Inserts: with a soldering iron at about 230 °C, press the 4 inserts into the bezel bosses (from the back face) and the 2 inserts into the shell's mount bosses (from the inside). Let them cool before handling.
2. Window: put a frame of VHB tape around the inside pocket, press the polycarbonate sheet in, and hold it for 30 s.
3. Screen: lay the touchscreen module glass-down onto the sheet, centred on the window. Stick a foam pad on each press post.
4. Tap board: screw it onto the 4 standoffs. Fit the PG7 gland in the left wall, feed the pigtail through it, and solder the pigtail to J1. Connect the screen wires to the XIAO.
5. Close: lay the TPU gasket on the shell rim, bring the bezel down, and tighten the 4 M3 × 30 screws a little at a time in a cross pattern until the gasket is evenly squeezed.
6. Mount: screw the mount onto the back (2 × M3 × 10), wrap the shim around the bar, and strap the unit on. Plug the USB-C port.

The OpenSCAD file

Install OpenSCAD 2021.01 or newer and download hardware/case/etube_case.scad from the project repository. Set PART to each part name in turn (bezel, shell, mount or garmin, gasket), press F6 to render, and export each one as an STL for your slicer. MOUNT = "garmin" shows the Garmin adapter in the assembly view.

Chapter 14Troubleshooting

Chapter 15Glossary

E-TUBE

Shimano's wired system for Di2 shifting and STEPS e-bikes. Two wires carry both power and data.

EW-SD50

The E-TUBE cable with the small round plugs used on your bike. The newer EW-SD300 has different plugs and doesn't fit.

Junction A / B

Shimano's names for junction units. A has a button and LED (active). B is a passive split or join.

Carrier

The steady 1 MHz wave the data rides on.

BPSK

Binary phase-shift keying: data is sent by flipping the carrier upside down (180°).

DBPSK

Differential BPSK: a flip means 1 and no flip means 0, so you don't need to know the starting phase.

AC coupling

Passing a signal through a capacitor so changes get through but steady DC doesn't.

Bias

A steady voltage (here 1.65 V) that the AC signal is centred on so it fits inside 0–3.3 V.

Comparator

A chip that outputs high when + is above −, and low otherwise. It turns a wave into clean digital edges.

Hysteresis

A small gap between the switch-on and switch-off thresholds, so noise near the threshold can't make the output flicker.

Choke

An inductor that passes DC but resists fast changes, used here to keep the power supply from absorbing the data.

TVS diode

Transient-voltage suppressor. Conducts hard above its rated voltage to absorb spikes.

PTC fuse

A fuse that heats up and cuts current on overload, then resets when it cools.

RMT

The ESP32's "remote control" peripheral, which measures pulse lengths in hardware with 12.5 ns resolution.

DMA

Direct memory access: hardware copies data into RAM without the CPU's involvement.

Strapping pin

A GPIO whose level at power-up sets how the chip boots. Don't connect anything that drives it.

GATT

How Bluetooth LE organises data into services and characteristics that a phone can read or subscribe to.

LVGL

An open-source graphics library for small screens, with buttons, labels, charts and touch input.

CRC

A checksum at the end of a frame that lets the receiver detect corrupted data.

Chapter 16Sources

1. EEVblog forum: Shimano Di2 modulation. Two-wire bus, BPSK, ~1 MHz carrier, ~500 kbit/s.
2. Hackaday: reverse engineering Shimano bike electronics (kwakeham's Di2 wireless work).
3. PyPI: ngorke. E-Tube related tools.
4. Shimano: EW-EN100. Supported motors E5000/E6100/E7000/E8000.
5. bike-components: EW-JC200. 2-port EW-SD50 junction.
6. Rose: EW-JC304. EW-SD300 plugs, not compatible with this bike's cables.
7. 99 Bikes: Merida eSpresso 400 S EQ. E6100 drive, SC-E5000 display, 504 Wh battery.