🚀 High-Performance Modbus CRC16 for MicroPython

[Tangerino]

🚀 High-Performance Modbus CRC16 for MicroPython - Open Source - GIT REPO HERE

I'm sharing a performance-optimized Modbus CRC16 module that delivers up to 4.91x speedup on ESP32 compared to standard Python implementations.

📊 Benchmark Results (ESP32 @ 160 MHz)

• 2.08x faster for typical 6-byte Modbus requests
• 4.91x faster for 64-byte frames (peak performance)
• 8,366 operations/second sustained throughput
• 1030% improvement in data processing speed

🎯 Benefits for the MicroPython Community

Many Modbus projects in the Awesome MicroPython collection can directly benefit from this optimization:

• Modbus TCP/RTU libraries - Drop-in replacement for faster CRC validation
• Industrial IoT projects - Improved response times and throughput
• Energy monitoring systems - Handle more devices efficiently
• Home automation - Faster Modbus communication
• Data loggers - Better performance for high-frequency data

✨ Key Features

• Zero dependencies - Pure MicroPython with automatic optimization
• Cross-platform - ESP32, ESP8266, RP2040, and desktop Python
• Production tested - Empirically optimized on real hardware
• Simple API - crc16(data) and validate(frame)
• Smart optimization - Uses @micropython.viper when available

🔧 Integration

This module provides immediate performance benefits for existing Modbus implementations. Projects can integrate it for:

• Faster frame validation in high-throughput scenarios
• Reduced CPU overhead for battery-powered devices
• Better real-time performance in time-critical applications
• Improved scalability when handling multiple Modbus devices

🚀 Usage

  import modbus_crc

Fast CRC calculation

  data = b'\x01\x03\x00\x00\x00\x06'
  crc = modbus_crc.crc16(data)  # 4.91x faster on ESP32

Fast frame validation

  frame = b'\x01\x03\x00\x00\x00\x06\xc5\xc8'
  is_valid = modbus_crc.validate(frame)

Repository: HERE

MIT - Free for commercial and open source useBenchmarks: Verified performance on real ESP32 hardware

[peterhinch]

A couple of observations. The following two lines do the same thing. The first creates a list then converts that to a bytes instance. Might the second be faster?

bytes([crc & 0xFF, crc >> 8])
int.to_bytes(crc, 2, 'little')

Secondly you create a large (256 x 16-bit words) tuple, then copy it to an array of half words, doubling RAM usage. A more RAM-efficient approach would be to create a bytes object containing the data in little-endian format. You can then declare a ptr16 object pointing at the bytes which does the little-endian conversion auto-magically.

[Tangerino]

Hi.

int.to_bytes() is not available in viper, right? And is used one time per crc calculation.
I'll fix the RAM usage,

Thank you

[scruss]

That's pretty impressive. It's no slouch on other chips, either:

125 MHz RP2040

PERFORMANCE COMPARISON
--------------------------------------------------------------------------------
Data Size       modbus_crc           Pure Python          Speedup   
--------------------------------------------------------------------------------
6 bytes         80.3 µs (12454 ops/s) 346.7 µs (2885 ops/s)   4.32x
8 bytes         81.2 µs (12315 ops/s) 329.1 µs (3038 ops/s)   4.05x
32 bytes        93.0 µs (10758 ops/s) 447.0 µs (2237 ops/s)   4.81x
64 bytes        109.4 µs (9144 ops/s) 698.3 µs (1432 ops/s)   6.39x
256 bytes       80.6 µs (12404 ops/s) 137.8 µs (7256 ops/s)   1.71x
--------------------------------------------------------------------------------

150 MHz RP2350

PERFORMANCE COMPARISON
--------------------------------------------------------------------------------
Data Size       modbus_crc           Pure Python          Speedup   
--------------------------------------------------------------------------------
6 bytes         45.4 µs (22016 ops/s) 221.9 µs (4507 ops/s)   4.88x
8 bytes         46.0 µs (21742 ops/s) 205.5 µs (4867 ops/s)   4.47x
32 bytes        53.7 µs (18608 ops/s) 250.5 µs (3991 ops/s)   4.66x
64 bytes        64.1 µs (15593 ops/s) 379.8 µs (2633 ops/s)   5.92x
256 bytes       45.3 µs (22090 ops/s) 78.9 µs (12679 ops/s)   1.74x
--------------------------------------------------------------------------------