Keyboard shortcuts

Press ← or → to navigate between chapters

Press S or / to search in the book

Press ? to show this help

Press Esc to hide this help

Crimpdeq

Meet Crimpdeq, a portable digital force sensor designed for climbers, coaches, and therapists to measure and train finger strength, pulling power, and endurance. It was inspired by Tindeq Progressor, and works with the Tindeq and Frez apps.

Specs

  • Rechargeable battery with USB-C charging
  • Communicates via Bluetooth Low Energy (BLE)
  • Open-source firmware written in Rust
  • Open-source PCB design
  • Automatic sleep when inactive
  • Compatible with the Tindeq Progressor app (Android | iOS)
  • Compatible with the Frez app (formerly ClimbHarder) (Android | iOS)
  • Sampling rate: 80 Hz
  • Design load: 1500 N (~150 kg), full scale
  • Precision:
    • 0.05 kg between 0 and 99 kg
    • 0.1 kg between 100 and 150 kg
  • Operating temperature: 0-40 C
  • Dimensions: 80 x 90 x 35 mm
  • Uses the Tindeq Progressor API

⚠️ Warning: Some values come from the crane scale used in this project. If you use a different scale, those values may change.

Book Contents

This book covers everything from assembly and calibration to firmware internals and PCB design. Below are the available sections:

⚠️ Note: If you want to reproduce this project, feel free to reach out by email (sergio.gasquez@gmail.com), X (formerly Twitter), or Bluesky.

Making Your Own Crimpdeq

This chapter explains how to build your own Crimpdeq prototype.

1. Required Materials

2. Disassemble the Crane Scale

Disassembly

  1. Desolder the battery connections.
  2. Desolder the four load cell wires (E-, S-, S+, and E+) from the PCB. Crane connections
  3. Unscrew and remove the PCB and display.

3. Soldering

  1. Modify the HX711 module:

    1. Set the sample rate to 80 Hz. Most HX711 modules ship with RATE tied to GND, which sets 10 Hz. To switch to 80 Hz: HX711 Pinout
      1. Cut the PCB trace to the RATE pin.
        • Carefully scratch the trace with a knife.
      2. Verify with a multimeter that GND and RATE are no longer connected.
        • Take care not to damage adjacent traces.
      3. Solder the RATE pin to the DVDD pin.
      4. Verify with a multimeter.
    2. [Optional] Improve measurements at 3.3 V. Most HX711 modules are configured for 5 V operation:
      1. Solder a 20 kΩ to 27 kΩ resistor in parallel with R1 (highlighted in the image): Resistor to modify
      • For more information, see this blog post.
      • This step is optional but improves measurement quality.

  2. Connect the load cell to the HX711:

    • Solder the four wires from the crane scale to the HX711. Typical color mapping:
    HX711 PinLoad Cell PinDescription
    E+E+ (Red)Excitation positive (to load cell)
    E-E- (Black)Excitation negative (to load cell)
    S+S+ (Green)Signal positive (from load cell)
    S-S- (White)Signal negative (from load cell)

    ⚠️ Note: On some HX711 modules, S+/S- are labeled A+/A-.

  3. Connect the HX711 to the ESP32-C3-DevKit-RUST-1:

HX711 PinESP32-C3 PinDescription
VCC3.3VPower supply (3.3V)
GNDGNDGround
DT (Data)GPIO4Data output from HX711
SCK (Clock)GPIO5Clock signal for communication

ESP32-C3 Connections

  1. [Optional] Solder the voltage divider:
    1. Solder one end of the 33 kOhm resistor to B+ on the ESP32-C3-DevKit-RUST-1.
    2. Join the other end of the 33 kOhm resistor with one end of the 10 kOhm resistor, then connect that junction to GPIO1.
    3. Solder the remaining end of the 10 kOhm resistor to GND.
    • The firmware expects the battery sense on GPIO1 by default. Adjust the firmware configuration if you wire a different pin.
  2. Verify all connections with a multimeter.

4. Adapt the Scale Case

  1. Create space for the USB connector.
    • For example: mark the opening with a pen, then carefully heat a knife and melt the plastic.
  2. Install the battery holder:
    1. Glue the battery holder with silicone. Leave the original battery lid opening free so you can route the two battery wires through it.
    2. Solder the positive wire (red) from the battery holder to a switch/button for power. Then solder the other switch/button pin to B+ on the ESP32-C3-DevKit-RUST-1.
    3. Solder the negative wire (black) from the battery holder to B- on the ESP32-C3-DevKit-RUST-1.
  3. Close the case:
    1. Ensure all components are securely installed before closing the case.

Assembly

5. Upload the Firmware

  1. Connect the device with a USB-C cable.

  2. Clone the crimpdeq-firmware repository:

    git clone https://github.com/crimpdeq/crimpdeq-firmware

    If you do not have Git installed, use the repository’s “Code” button and download a ZIP.

  3. Upload the firmware:

    1. Download a .bin file from the desired GitHub release.
    2. Flash the device using one of these tools:
    • Using esp.huhn.me.
      1. Click “Connect” and select the serial port for your ESP board.
      2. Upload your .bin file.
      3. Click “Program”.
    • Using Adafruit ESPTool
      1. Click Connect and select the serial port for your ESP board (often named USB/JTAG serial debug unit...).
      2. Upload your .bin file at offset 0x10000.
      3. Click Program.

    Flashing with ESPTool

    ⚠️ Note: If this method does not work, see the Firmware chapter. You may need to install prerequisites and flash from the command line.

  4. Check whether the default calibration values work for your scale:

    1. Connect the device with the Frez or Tindeq app.
    2. Use the “Live View” option.
    3. Measure a known weight and verify the value is correct.

Calibration

This guide explains how to calibrate Crimpdeq for accurate measurements.

You can calibrate in two ways: with the Crimpdeq app or nRF Connect.

The Crimpdeq app is recommended because it is simpler and gives visual feedback.

Using Crimpdeq App

Prerequisites

  • Crimpdeq app on your platform:
    • Web version (no installation): Crimpdeq web app
    • Native builds from the latest release: crimpdeq-app/releases/latest
      • Android: crimpdeq-app-v<x.y.z>.apk
      • macOS: crimpdeq-app-v<x.y.z>-macos.zip
      • Windows: crimpdeq-app-v<x.y.z>-windows.zip
      • Linux: crimpdeq-app-v<x.y.z>-linux.zip
  • A stable mounting point so the device hangs freely and remains still
  • One known weight (ideally near your typical maximum load)

Calibration Steps

  1. Connect to Crimpdeq

    1. Launch the Crimpdeq app and grant permission to access device location (required for Bluetooth).
    2. Tap Scan to pair with your device.
    3. Once connected, the app shows device info (firmware version, battery, and current calibration).

  2. Add calibration points

    1. Open the Calibration tab.
    2. For each point:
    • Hang the corresponding load on the device (or leave it empty for zero).
    • Enter the weight value in the app and tap Add Calibration Point.
    • Recommended: Add at least 2 points—zero (nothing hanging) and full scale (the maximum weight you expect to measure). The device supports up to 20 calibration points for finer accuracy.

  3. Check the result

    1. After adding at least 2 points, the app displays the current calibration curve. Confirm it matches your expectations.

    Calibration Result

Using nRF Connect

Prerequisites

  • nRF Connect installed on your platform:
  • A stable mounting point so the device hangs freely and remains still
  • One known weight (ideally near your typical maximum load)

Calibration Steps

  1. Connect to Crimpdeq with nRF Connect:
    1. Launch the app and go to the Scanner tab.
    2. Find your device (for example, Progressor_7125) and tap “Connect”.
    3. Once connected, the app will display the device’s services and characteristics. nRF Discovered
  2. Locate the calibration characteristic:
    1. Expand Unknown Service.
    2. Find the characteristic with UUID: 7e4e1703-1ea6-40c9-9dcc-13d34ffead57. Services
  3. Compute the hex value of your known weight:
    1. Open the Floating Point to Hex Converter.
    2. Select “Single-precision” (32-bit) floating point.
    3. Enter your known weight in the “Float value” field (in kilograms unless your device expects grams; see Important Notes).
    4. Click “Convert to hex” and save the resulting “Hex value”. Example: 75.3 kg → 0x4296999a.
  4. Zero the device (tare):
    1. Hang Crimpdeq with no weight attached.
    2. Send the command 7300000000 to the characteristic:
      • Tap the Up Arrow icon on the characteristic (7e4e1703-1ea6-40c9-9dcc-13d34ffead57).
      • Enter the command as shown. Send weight
  5. Perform the calibration:
    • Commands and values are hex strings without spaces (letter case does not matter).
    1. Attach your known weight to Crimpdeq.
    2. Build the calibration command by prefixing 73 to your hex value.
      • Example: For 75.3 kg (0x4296999a), send: 734296999a.
    3. Send this command to the same characteristic (7e4e1703-1ea6-40c9-9dcc-13d34ffead57).
    • You can add up to 20 calibration points. Repeat this step if you need higher accuracy.
  6. Verify:
    1. Remove the weight and reattach it.
    2. The reported value should be within a small tolerance of the known weight. If not, repeat steps 4-5.

Important Notes

  • Units: Some devices expect the calibration value in grams instead of kilograms. If, after calibration, the measured value looks off by a factor of ~100 (e.g., 75.3 kg shows ~0.75), convert your known weight to grams and repeat step 5.
  • Use a weight close to the maximum load you expect to measure (while staying within device limits) for best accuracy.
  • Ensure the device is stable and stationary when sending commands.
  • Perform calibration in a controlled environment (avoid wind, vibration, and temperature swings).

Charging the Battery

To charge the device:

  1. Connect a USB-C cable:
    • Plug the device into a power source using a USB-C cable.
    • Turn on the device.
    • The red LED turns on while charging.
  2. Wait for the charge to complete:
    • When the red LED turns off, charging is complete.
    • Unplug the device and use it normally.

Device Charging

Firmware

The firmware is written in async Rust (no_std) using esp-hal and a small set of supporting crates.

Prerequisites

To build and upload the firmware, install:

  • Rust
  • The stable toolchain with the ESP32-C3 target: 
    rustup toolchain install stable --component rust-src --target riscv32imc-unknown-none-elf
  • probe-rs, see installation instructions
    • OS notes:
      • Linux: set up udev rules for your debug probe or USB-Serial device (see probe-rs udev guide).
      • Windows/macOS: ensure the correct USB drivers are installed and select the appropriate serial port in your tooling.

How to Build the Firmware

To build the firmware, run:

cargo build --release

This compiles the firmware only. To build and flash the device, see Build and Flash your Device.

How to Flash Your Crimpdeq

Erase Device Memory

If this board was previously used for other projects, erase its flash once:

probe-rs erase

⚠️ Note: Erasing is only needed once. Avoid erasing routinely, or you will lose your calibration values.

Build and Flash Your Device

With a custom runner configured in .cargo/config.toml, you can build, flash, and open a serial monitor with:

cargo run --release

This opens a serial monitor, allowing you to view log messages in real time.

To modify the log level, update the DEFMT_LOG value in .cargo/config.toml or set it when running the command:

DEFMT_LOG=debug cargo run --release

⚠️ Note: If your DevKit does not include USB-Serial-JTAG, flash over UART by updating the custom runner in .cargo/config.toml to use espflash instead of probe-rs.

Configuring Environment Variables

If you need to change DEVICE_ID, DEVICE_NAME, or DEVICE_VERSION_NUMBER, update their values in .cargo/config.toml.

After making changes, rebuild and flash the device for the new values to take effect.

Code Structure

hx711

This module implements the load cell functionality. It’s an async version of the loadcell crate with additional modifications.

ble

This module implements the Bluetooth Low Energy (BLE) functionality:

  • Defines the GATT server and services
  • Handles advertising and connections
  • Defines the Progressor service with data point and control point characteristics

progressor

The progressor module implements the Tindeq API used for BLE communication between the ESP32-C3 and a smartphone.

Main Tasks

The main.rs file defines several asynchronous tasks that run concurrently:

  • measurement_task:
    • Initializes the load cell.
    • Handles taring and reads measurements from the sensor.
  • ble_task:
    • Long-running background task required alongside other BLE tasks.
  • gatt_events_task:
    • Processes GATT events such as control-point writes.
  • data_processing_task:
    • Handles sending notifications with data points.
  • battery_voltage_task:
    • Periodically reads the battery voltage.
  • deep_sleep_task:
    • Monitors inactivity; after a timeout, the device enters deep sleep.

Communication between tasks occurs via a Channel.

PCB

Revision 1

The PCB design is maintained in the crimpdeq-hardware repository and was created with KiCad.

It is a two-layer board derived from the ESP32-C3-DevKit-RUST-1. This version removes unused sensors from the original design and keeps only what this project needs.

PCB

The PCB was sponsored by PCBWay. Working with them was fast and easy, and the resulting boards are high quality.

PCBWay

Revision 1 has been tested and works as expected, but there is still room for improvement. See the Revision 2 issue.

Revision 2

The crimpdeq-board repository contains an advanced version (Revision 2) of the PCB that includes additional sensors and other improvements.

⚠️ Status: This version is still a work in progress. Routing is incomplete, and it has not been fabricated or tested yet. There is no estimated timeline for availability. Use revision 1 unless you have hardware experience and want to try this untested version.