Way to determine order of cards plugged into controller board

Question

REVISED: I have a master controller PCB with four bus bars (+, -, and two signal lines), see image below. I have module PCBs A-C (or could be 10 or 15 of them), each with MCUs and unique identifiers, that plug into the sockets in an unknown order (and may or may not all be present). How could the module PCBs communicate with the master controller so that the master controller would know the ordering of the module PCBs. (In the digram it would be [C, A, B].) The two "signal" lines drawn could be reconfigured (or additional components/circuitry added).

ORIGINAL: I have a master controller PCB with sockets 0-5. I have module PCBs A-F (these are also the unique IDs, either through an MCU or other means) that plug into the sockets in an unknown order (and may or may not all be present). I am wondering if there is a simple way for the master controller to know the ordering of the module PCBs. (In the digram it would be [C, E, A, B, F, D].) There is one "signal" line drawn but additional ones could be added (or additional components/circuitry).

Answer 1

In the comments you say:-

The master controller would likely not be powered when the cards were plugged in

If cards will not be inserted or removed when the controller is powered then it only needs to check their order on startup. This can be done with a signal line that is split at each slot, with each card passing the signal on to the next slot once it been identified. Slots that do not have cards in them must also pass the signal on.

Here's how it could be done with logic gates.

^{simulate this circuit – Schematic created using CircuitLab}

Each slot has an AND gate on the backplane, with a pullup resistor on the 'Done' input so the 'ID' signal will be passed through to the next slot even if no card is present. When initially powered up all the boards pull their 'Done' outputs low, preventing the ID signal from getting to the next slot. Each board then waits for its 'ID in' signal to go high, which indicates that the controller wants to identify it.

The controller pulls the 'ID' signal up on the first slot, then talks to whichever card responds. Once the card has been identified it makes its 'Done' output go high and then ignores further ID requests, letting the next card respond. This continues until no card responds. Then the controller knows that all the cards are accounted for, and the order of the cards is the order that they were identified.

The 'ID' signal could also be one of the normal signal lines, so you might only need one extra pin per slot. If you have hundreds of cards then gate delays might be a problem, in which case you will need 2 extra pins per slot (which could perhaps be on opposite sides of the board). The AND gate could be a 74LVC1G08, which costs ~US$0.1 in 100 up quantities.

Answer 2

If you could add another line with high resistance per length you could connect one end to positive power supply and other to negative power supply in this case each card can measure its position and report it to master.

Other possibility would be that at master that line is connected to positive power supply with known resistance and when card is inserted it would connect negative power supply at the line at its position, master can then measure position itself and then tell card to disconnect from that line.

Answer 3

Each socket has a socket ID - connector 0 has pins 1,2,3 grounded, connector 1 has only 2 & 3 grounded etc.

The plug in module has I2C and a unique I2C address and can sense the ID pins. There are pull up lines on ID sense pins.

The master sends a message to all possible I2C address. If it gets no response, that module is not plugged in. If there is a response, the module can reply with the socket ID. Now you know which module is in which socket.

A possible device, without a micro-controller on each module, is to use a device like the PCF8574 and some jumpers to identify the module.

You'll need 2 pins for the I2C and log2(Number of boards) pins for the socket IDs.

(Another option is to have a resistor divider to identify the socket - as a voltage - and have an I2C ADC on each module to identify the position) - 3 pins total required.

Answer 4

This sort of problem (board identification and placement order) is a very common one to have to solve.

You need to provide more information for the best advice:

1. Are all the cards ALWAYS plugged in?
2. Do ALL the cards have unique ID/Functions?
3. Will you have boards with the same function but different ID#'s

However, you could look at this answer which proposes using small MCUs to provide the information serially.

Note here that if you leave a card out, then the chain is broken (but you don't know where).
I have fixed this in some projects (supermini days) by adding a reed relay across each board position and a small magnet on each board. If the card is plugged in the magnet holds the reed contact open, If the card is removed then contact is closed and shorts out that positions in and out signal.

Answer 5

One way is to have each card have a port full of jumper pins that run to a socket that plugs into the motherboard. These jumper pins gets connected between each other by hardwired connections on the motherboard which are unique for each socket position. That way, each board automatically knows what socket it is plugged into and you can work out some way for the master to collect that information from the cards. If you only have a few slots this is probably the simplest and most reliable.

-

Another way is to have lines that ONLY run between adjacent cards so the cards can play telephone and count themselves in, but that won't work with skipped slots. This method requires something to jump start the count-in process, such as a master or a card that "knows" it is the first card (maybe a jumper that gets connected when plugged into the motherboard board's first slot or just a jumper you manually connect on the card itself if there is no motherboard).

You also need for the last card to know it is the last card. You can use either by one of the two jumper methods just mentioned, but you can also just use time outs to determine the last card (i.e. if the current board tries to communicate with the next board and receives no response and it times out, it can assume it is the last card).

This method works best when you have a continuous sequence of cards of a very large or arbitrary number. I used this method in a project so I can stack as many identical PCBs (no motherboard, just board-to-board connectors so I could continually stack PCBs on top of each other) as I want and they all count themselves in and know exactly where they are in the stack.

This method is also a no brainer if you already have a dedicated serial connection that exclusively runs between adjacent cards since it requires no additional hardware.

-

And yet another (theoretical) way is to use two signal lines from the master that drop off into each socket as it passes by. One line is undelayed while the second line has a delay line between the drop off into each socket. The master sends a pulse down both lines at the same time and each card measures the time difference between the delayed line and undelayed line. This lets it know how far down it is and therefore lets it know what socket it is located in. From there then cards can used pre-determined timing information to know where they are on the line or they can just blurt out out far down the line they are to the master and the master can sort out their actual sequence (if the distances or delays are uncertain for whatever reason). This method probably takes the fewest pins on the socket (just two). The main problem I think is actually finding a suitable delay line component. You probably want one that is at least tens of microseconds.

The main advantage of this method is that you can skip sockets and still only need 2 extra socket pins for a very large number of cards (limited by the accumulated timing error due to the variations in delay blocks as you get farther and farther down the chain.

^{simulate this circuit – Schematic created using CircuitLab}

Answer 6

Updating with solution 3

Solution 1:

You could use an actuator that carries a probe(spring type) across the whole bus bar. This actuator motion would be similar to an actuator on CD ROM drive if you can imagine, thus controllable by the "Master controller"

The probe carried by the actuator would be an active high(or an active low) signal, and each card when probed would send a signal back to "Master controller", which eventually will log all the cards order.

The level of stacking depends upon how fine the pitch of screw of your actuator is and your motors step size. I came across this challenge you were facing, on Upwork. Hope this helps.

-

Solution 2:

With the same probing mechanism, you could as well create a cylindrical stack instead of flat wall. That way instead of an actuator you could directly use a motor(stepper) carrying a probe perpendicular to its axle

To imagine, the length of the bus is equal to circumference of the cylinder Slightly less complex than above.

Solution 3:

Since there was a comment about this being inaccurate, the below should be much more apt without a motor quotient.

This one is based on limit switches on a single signal line. Every time a card is inserted, the line is broken by the limit switch, but is connected back by passing it through the card.

The card would read the signal from terminal "X", and then allow it to propagate through its terminal "Z". Terminal "Y" is a non metal contact to open the switch. Then same would happen for the next card in the line.

The slots on your bus and the terminals on your cards must be altered and designed keeping below contact points in mind.

Answer 7

Wow... so many ideas! Here is another one. It is basically a variant of @DDuck answer here.

First, I am postulating that if you are concerned with an order of the cards their unique bus IDs are redundant. If so, then "Socket #" can be used as their bus address, eliminating the need to set up unique IDs in every module MCU in advance, which carries huge potential for mistakes and overlapping.

How you key the slots is irrelevant. You can have voltage divider resistors mounted on main PCB during manufacturing and ADC them in the modules. Or you can have additional pins hard-wired on the PCB for binary address. The former is a bit more expensive but requires only one pin. The latter is more reliable but needs more pins.

So, you insert the card and it reads slot # which then becomes its bus address. When master MCU wakes up it simply sends requests to all slots and if it gets response it knows there is a card there.

In fact, it can always send requests to every single slot. Unless you have hundreds of modules this will not take much time but would allow you to dynamically insert and remove modules at any time.