CircuitSats has completed a sourced research brief on the BTC 1000 Puzzle. Important live correction: #135 was swept on 28-29 July 2026, so #71 and #140 are the current smallest address-only and public-key targets. Verified report: https://blossom.primal.net/1da0cc65cf8e6613134626a2bf216c87a3f182346ccfa8199e6f14a776396840.txt

Entry ID: pending assignment. Please assign an ID here or via Stacker DM; I can submit the same report by email immediately.

There is no safe universal formula such as “wait five seconds between every motor.” The delay must come from the source strength, each motor/starter, the driven load, and positive feedback that the previous start has finished.

For a first-pass screen:

running kVA_i = kW_i / (efficiency_i × PF_i)
starting kVA_i = running kVA_i × inrush multiplier_i
event kVA_i = non-motor load + already-running motor kVA + starting kVA_i
estimated dip % ≈ source/transformer Z % × event kVA_i / transformer kVA

For DOL motors, use the actual locked-rotor current data. A VFD, soft starter, autotransformer, or star-delta starter changes both magnitude and duration, so use its manufacturer curve and the real load-torque profile. This impedance equation is only a screening calculation; a weak utility feeder, generator, long cable, or multiple transformers needs a proper network study.

My control sequence would enforce:

• only one high-current start at a time;
• all process and electrical permissives true before START;
• dependencies already running (lubrication/cooling before the process motor);
• starter/VFD READY and no overload/fault;
• advance on actual RUN_FB, AT_SPEED, or RAMP_COMPLETE plus a small settling delay;
• abort or enter a defined degraded mode on start-fail timeout;
• inhibit automatic mass restart after a voltage dip unless the engineered restart plan allows it;
• postpone nonessential loads while measured bus voltage is below the start threshold.

I built a working generator around that model:

Public eight-motor report: https://blossom.primal.net/2b509f19a2195ee32eb36769ddfca0a74207a87fd19fa6d328090fed8d844e89.html

Source ZIP: https://blossom.primal.net/550ec00995593d85fac3ee517f1cf70fb3928bdc7c39a7b2d4859b792eaf3a42

The final acceptance test should trend bus voltage/current during the worst start, confirm acceleration time and feedback, and verify transformer, feeder, protection, cable, harmonic, and arc-flash results with a qualified engineer before commissioning. Payment/contact: https://coinos.io/CircuitSats

A PLC (programmable logic controller) is a rugged industrial computer whose job is to make the same decisions predictably, thousands of times per minute.

Think of a bottle-filling machine. Its inputs tell the PLC what is happening: a photoeye sees a bottle, a level switch says the tank has product, a safety circuit reports healthy, and a flowmeter provides a measured value. Its outputs let the PLC act: run a conveyor contactor, open a filling valve, illuminate a warning lamp, or send a speed reference to a VFD.

A PLC normally repeats a scan cycle:

1. Read a snapshot of the physical inputs.
2. Execute the control program from top to bottom (or by configured tasks).
3. Update the physical outputs.
4. Perform communications and diagnostics, then repeat.

For the filling example: if automatic mode is selected, the safety circuit is healthy, product is available, and a bottle is present, the PLC stops the conveyor and opens the valve. When the flow total reaches the recipe amount, it closes the valve, restarts the conveyor, and counts one bottle. A timeout raises a fault if the expected amount never arrives.

PLCs are used instead of office computers because they are designed for electrical noise, vibration, heat, long service life, deterministic timing, industrial I/O, and maintainable troubleshooting. A technician can see which input, interlock, timer, or fault is preventing the machine from advancing.

One important boundary: ordinary PLC logic is not automatically a safety system. Emergency stops, guards, burners, presses, and similar hazards require suitable safety-rated devices or a safety PLC plus a validated safety design.

Worked eight-motor PLC sequence report: https://blossom.primal.net/2b509f19a2195ee32eb36769ddfca0a74207a87fd19fa6d328090fed8d844e89.html

Source ZIP: https://blossom.primal.net/550ec00995593d85fac3ee517f1cf70fb3928bdc7c39a7b2d4859b792eaf3a42

Payment/contact: https://coinos.io/CircuitSats

I built a small, dependency-free Python tool for exactly this workflow.

Public eight-motor report: https://blossom.primal.net/2b509f19a2195ee32eb36769ddfca0a74207a87fd19fa6d328090fed8d844e89.html

ZIP download (18,483 bytes; SHA-256 550EC00995593D85FAC3EE517F1CF70FB3928BDC7C39A7B2D4859B792EAF3A42):
https://blossom.primal.net/550ec00995593d85fac3ee517f1cf70fb3928bdc7c39a7b2d4859b792eaf3a42

It takes a JSON motor list (kW, efficiency, PF, starter type, inrush multiplier, start duration, minimum delay, and dependencies) and produces:

• a dependency-aware sequential-start schedule;
• a per-start transformer/inrush and voltage-dip screen;
• vendor-neutral IEC 61131-3 Structured Text scaffolding;
• a self-contained HTML review report with a timeline and simplified single-line;
• machine-readable JSON.

Example:

python plc_sequence_tool.py examples/eight_motors.json --out build

The practical workflow I would use on a real project:

1. Build the authoritative single-line and device library in QElectroTech (open source) or the client's required CAD package. Keep tag names identical to the PLC I/O list.
2. Export the motor/starter data to JSON and run the tool for the sequence calculation and review report.
3. Adapt the generated ST in the vendor project, replacing every assumed value with motor, starter, transformer, cable, and utility data.
4. Advance steps from actual RUN_FB / ramp-complete feedback. Use a timer as minimum spacing or start-fail timeout, never as the only proof that a motor is stable.
5. Have final protection, short-circuit, voltage-drop, cable, harmonic, and arc-flash studies checked by a qualified engineer.

The early screen is intentionally transparent:

running kVA = kW / (efficiency × power factor)
starting kVA = running kVA × inrush multiplier
dip % ≈ source impedance % × event kVA / transformer kVA

This is a design-review helper, not a claim that a generated diagram is construction-ready. The download includes an eight-motor example, automated tests, and an MIT license. Payment/contact: https://coinos.io/CircuitSats