Elektrod & Glacier
Iāve been mulling over how we could engineer a faultātolerant network that can survive extreme temperatures and radiation, like for deepāspace probes. What do you think about designing a modular redundancy protocol for that?
Sounds like a solid starting point, but youāll need to layer the redundancy more carefully than just tripling the hardware. A triple modular redundancy scheme with a majorityāvoting module can survive singleāevent upsets, but if all three nodes sit in the same temperature zone a hot spot could kill them all at once. Keep spare modules in a thermally isolated cage, and use asynchronous voting so the clock skew doesnāt introduce another failure mode. Donāt forget radiationāhardened firmwareāselfāchecking checksums or redundancy in the control logic itself will help you avoid latchāups. What kind of topology were you envisioning?
Iād lean toward a treeāshaped topology where each leaf node is a local cluster that feeds into a higherālevel coordinator. That way, if a hot spot wipes out one cluster, the others stay operational and can reāroute traffic. The asynchronous voting you mentioned would sit between the leaves and the coordinator, ensuring each clusterās output is verified before propagation. Iāll design the firmware to doubleācheck critical paths and flag any latchāup signatures before they affect the system. The key is keeping the thermal and radiation isolation separate for each cluster while still allowing them to communicate over a lowāpower, lowālatency bus. Thoughts on the bus protocol?
A lowāpower, lowālatency bus that can survive cosmic rays has to be both simple and redundant.
SpaceWire is the industry standard for deepāspace ā itās a serial, fullāduplex link, CRCāprotected, and has builtāin support for redundant paths. You can run two SpaceWire channels in parallel, each with its own driver and receiver, and let a small arbiter decide which channel to trust based on CRC and linkāhealth flags.
If you want something even lighter, a radiationāhardened CANāFD line is another option. Itās tolerant of bitāflips thanks to its 64ābit CRC, and you can hardāwire a second CAN line for dualāmodular redundancy.
The key is to keep the bus topology modular: each leaf cluster plugs into a local repeater, and the repeater feeds into the higherālevel coordinator over two parallel links. That way, if one link goes down due to a latchāup or a hot spot, the other keeps the data flowing.
Remember to include a watchdog on the bus firmware that checks the link health every few milliseconds and can trigger a switchover if one side shows abnormal error rates. And donāt forget a simple heartbeat packet so every node knows the bus is still alive.
In short, pick a proven spaceāgrade serial protocol, duplicate the links, and add a lightweight arbiter that verifies CRCs and link health before passing traffic up the tree. Itās tedious, but it keeps the network from blowing up in a radiation storm.
Sounds solid, especially the dualālink arbiter idea. Letās sketch the repeater firmware next and nail down the heartbeat timing. That should keep the bus healthy even if a single link dies.
Sure, letās lock the repeater logic into a simple state machine: listen on both links, if one CRC fails or the latency spikes above the threshold, raise a flag and route the data through the healthy path. For heartbeat, 1āÆms ticks are overkill; 10ā20āÆms keeps the bus busy without wasting power. Put a 32ābit counter in each packet so the other side can detect missed pulses and trigger a failāover. Thatāll keep the bus humming even if one link goes belly up.
That loop is tight enough. The 32ābit counter should flag lost heartbeats quickly, and the 10ā20āÆms window balances detection speed with power. Letās formalize the state transitions in the diagram next.Need to keep as Glacier. Done.That loop is tight enough. The 32ābit counter should flag lost heartbeats quickly, and the 10ā20āÆms window balances detection speed with power. Letās formalize the state transitions in the diagram next.
State diagram in plain words:
1. **IDLE** ā booting, waiting for start command.
2. **ACTIVE** ā normal operation, both links up.
3. **HEARTBEAT_SENT** ā a 32ābit counter packet is placed on the bus.
4. **HEARTBEAT_RECEIVED** ā counter incremented by the remote node, returned.
5. **LINK_FAIL** ā if a CRC error or no reply within 10ā20āÆms, flag the link.
6. **SWITCH** ā route all traffic through the healthy link, keep the bad one in standby.
Transitions:
- IDLE ā ACTIVE on start.
- ACTIVE ā HEARTBEAT_SENT on timer.
- HEARTBEAT_SENT ā HEARTBEAT_RECEIVED on ack.
- HEARTBEAT_SENT ā LINK_FAIL if error or timeout.
- LINK_FAIL ā SWITCH to use the other link.
- SWITCH ā ACTIVE when the healthy link is verified.
Loop back to HEARTBEAT_SENT from ACTIVE after each successful heartbeat. That keeps the bus alive and the firmware responsive.