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 Tindeq Progressor app (Android | iOS)
  • Compatible with Frez app (formerly ClimbHarder) (Android | iOS)
  • Sampling frequency: 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 × 90 × 35 mm
  • Uses the Tindeq Progressor API

⚠️ Warning: Some of these specs come from the crane scale, if you use a different one, those values might change.

Content of the Book

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

⚠️ Note: If you’re interested in reproducing this project or giving it a try, please, reach out! You can contact me via 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 wires of the load cell (E-, S-, S+ and E+) from the PCB. Crane connections
  3. Unscrew and remove the PCB along with the display.

3. Soldering

  1. Modify the HX711 module:

    1. Set the sample rate to 80 Hz: Most HX711 modules ship with the RATE pin tied to GND, which sets a 10 Hz sample rate. To switch to 80 Hz: HX711 Pinout
      1. Cut the PCB trace to the RATE pin.
        • This can be done by carefully scratching 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] Optimize measurements for 3.3 V: Most HX711 modules are configured for 5 V operation. To improve measurements at 3.3 V:
      1. Solder, in parallel, a resistor between 20 kΩ and 27 kΩ across R1. R1 is the highlighted resistor in the image: Resistor to modify
      • For more information, see this blog post.
      • This step is optional, but it improves measurement quality.

  2. Connect the Load Cell to the HX711:

    • Solder the 4 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 the S+/S- pins 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 33kΩ resistor to the B+ pin on the ESP32-C3-DevKit-RUST-1.
    2. Join the other end of the 33kΩ resistor and one end of the 10kΩ resistor together, and connect that junction to GPIO1 on the ESP32-C3-DevKit-RUST-1.
    3. Solder the remaining end of the 10kΩ 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: place the board to mark the opening with a pen, then carefully heat a knife and melt the plastic to create space.
  2. Install the battery holder:
    1. Glue the battery holder with silicone. Leave the lid for the scale’s original batteries open, you will route the two battery holder wires through that opening.
    2. Solder the positive wire (red) of the battery holder to a switch or button to turn the device on/off, then solder the other pin of the switch/button to the B+ pin of ESP32-C3-DevKit-RUST-1.
    3. Solder the negative wire (black) of the battery holder to the B- pin of 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 your device with a USB‑C cable.

  2. Pull the crimpdeq-firmware repository:

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

    If you don’t have git installed, you can click the green “Code” button on the repository and use the “Download ZIP” option.

  3. Upload the firmware to your device:

    1. Download the binary from the desired GitHub releases.
    2. Flash your device
    • Using esp.huhn.me.
      1. Click “Connect” and select the serial port of your ESP board.
      2. Upload your .bin file.
      3. Click “Program”.
    • Using Adafruit ESPTool
      1. Click Connect and select the serial port of your ESP board (should be named USB/JTAG serial debug unit...)
      2. Upload your .bin file at offset 0x10000
      3. Click Program Flashing with ESPTool

    ⚠️ Note: If this uploading method doesn’t work for you, refer to the Firmware chapter. You may need to install the prerequisites, build, and flash the firmware.

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

    1. Connect your device with the Frez or Tindeq apps.
    2. Use the “Live View” option.
    3. Measure a known weight and verify that Crimpdeq measures the right value.

Calibration

This guide will help you calibrate your Crimpdeq device to ensure accurate weight measurements. The calibration process involves using a known weight to establish a reference point for the device’s measurements.

Prerequisites

  • nRF Connect installed for 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 the device named “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 the “Unknown Service” section.
    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).
  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 your device, follow these steps:

  1. Connect a USB‑C cable:
    • Plug the device into a power source using a USB‑C cable.
    • Turn on the device as you normally would.
    • A red LED will turn on, indicating that the device is charging.
  2. Wait for the charge to complete:
    • When the red LED turns off, the battery is fully charged.
    • You can now unplug the device and use it.

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 to your device, ensure you have the following installed:

  • Rust
  • The stable toolchain with the ESP32-C3 target architecture installed: 
    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 via 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, enabling BLE (Bluetooth Low Energy) 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

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 variant removes unused sensors from the original design and adds only the components required for this project.

⚠️ Status: The PCB has not been fabricated yet and is therefore untested.

Advanced Version

The crimpdeq-board repository contains an advanced version 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. There is no estimated timeline for availability.