Calculate specificity score for this matcher type.

Split this range into `n` non-overlapping sub-ranges. Each sub-range will have approximately the same size, with any remainder distributed among the

Route a board connection's parts to where they belong.

Cancel the current animation and return the LED.

Compute the difficulty needed to achieve this share rate at the given hashrate. Convenience for `Difficulty::from_target(self.to_target(..))`.

Compute the target needed to achieve this share rate at the given hashrate. A hash is valid if hash < target. With hashes uniform over [0, 2^256), ex

Expected work per nonce at this difficulty. A nonce that passes the ASIC's difficulty filter represents this many hashes of work on average.

Get the register address for this register

Expected hashrate allocated to one source. Degenerate today: the source gets the full aggregate. The signature takes a source so a proportional split

Apply general purpose bits with validation. # Errors Returns `GpBitsExceedMask` if GP bits have any bits set outside the allowed mask.

Get the raw bytes for testing

Get value as megahashes per second

Get the rate as shares per minute.

Assign each source's cached job to a newly-eligible thread. Called from the thread's first ExpectedHashRate report. The thread takes the full EN2 ran

Authorize with the pool. Sends `mining.authorize` with username and password. Uses the message router to handle interleaved notifications.

Wait for the given duration, draining commands in the meantime. Returns `true` if shutdown was requested during the wait.

Internal actor task for BM13xxThread. This runs as an independent Tokio task and handles: - Commands from scheduler (update/replace work, go idle, sh

Build a `UsbDeviceInfo` from an nusb `DeviceInfo`.

Check and report status

Make a raw API call and pretty-print the JSON response.

Print a summary of the current miner state.

Pairs every source's command sender with its current hashrate allocation. Collected up front so the caller can send without holding `&self` across aw

Compute merkle root for a specific extranonce2 value. Builds the complete coinbase transaction by concatenating parts with the given extranonce2, com

Configure version rolling support. Sends `mining.configure` to request version rolling capability. Must be called before subscribe. Returns the mask

Run a single connection attempt through its full lifecycle. Creates channels, spawns the client task, runs the event loop until disconnect or shutdow

Validates data integrity using the CRC-5-USB algorithm. This function checks if the data passes CRC validation by calculating the CRC-5 and verifying

Get the current data bits configuration.

Get the current parity configuration.

Get the current stop bits configuration.

Dump the complete TPS546 configuration for debugging

Threads eligible for work: those that have reported an expected hashrate.

When the ASIC was last taken out of reset, or `None` if it is currently in reset. Safe to call from another task.

Encode the register data (not the address)

Get error details if this is an error response

The log2 of the difficulty (e.g., 8 for difficulty 256).

Extend a vector with the serialized bytes of this extranonce2.

Find the best matching board descriptor for this USB device. Uses pattern matching with specificity scoring to select the most appropriate board hand

Find a connected emberOne/00 board via udev and return its control serial port path and bcdDevice, or None if no board is connected.

Firmware minor version (`M` field).

Read external temperature in Celsius This is typically connected to the ASIC's temperature diode

Get fan speed

GET a v0 API endpoint and deserialize the JSON response.

Fetch the current miner state snapshot.

Calculate power in milliwatts

GET a v0 API endpoint and return the raw response body.

Get fan RPM Uses the simplified formula from esp-miner: RPM = 5400000 / TACH_count

Read a string property from an IORegistry entry.

Read TACH count (fan speed measurement) Returns raw TACH count - convert to RPM based on fan specs

Handle CPU miner transport events.

Handle mining.notify notification.

Detect and handle thread disconnections.

Handle USB transport events.

Expected number of hashes in the given duration. Returns a fractional count because this is a statistical expectation (e.g., 0.5 hashes in 100 ms at

Whether the suggest cooldown is still active at `now`.

Initialize logging. If running under systemd, use journald; otherwise fall back to stdout.

Check whether job difficulty is unreasonably high for our hashrate.

Whether this error is unrecoverable and should not be retried. Authorization failures and invalid URLs are fatal---wrong credentials and malformed ad

Whether the estimate has settled enough to trust. Returns true once at least `min_samples` have been recorded in the current window. Before this poin

Check if this is TPS546D24A format (REL bit + restricted mode)

Number of leading zero bits.

Enumerate existing devices, then watch for hotplug events. The `hotplug` watch is created before enumeration begins so that devices connected during

Get next message ID and increment counter.

Calculate this percentage of a value

Check whether any parent of `entry` has the given IOKit location ID. Uses IORegistryEntrySearchCFProperty to find the nearest ancestor with a locatio

Parse a merkle node from Stratum hex string.

Read the local (on-die) temperature.

Read the remote (external diode) temperature. Returns `Error::RemoteDiodeOpen` if the diode is disconnected or faulted.

Reboot the board. Sends a reboot command and returns immediately without waiting for a response; the firmware resets before it can reply. The host ca

Reset to the beginning of the range.

Reset the statistics counters to zero.

Select response format based on firmware version. Firmware minor >= 1 uses v1 response format with explicit status byte. Older firmware uses v0.

Build the v0 API routes with OpenAPI metadata.

Main scheduler loop.

Connect to the pool and run the client. Establishes a TCP connection then delegates to [`run_with_transport`](Self::run_with_transport).

Run the CPU mining loop. This function runs in a dedicated `std::thread`. It receives commands via an `mpsc` channel and hashes using the current tas