Breadboarding the interface from Arduinos to the 1130's 2501 reader controller logic

TWO ARDUINOS PROGRAMMED TO EMULATE 2501 READER BEHAVIOR

I wrote a program for an Arduino Uno that will respond to the requests from the 1130 controller to start the motor and to feed cards, producing the timing CB (circuit breaker) pulses. It also models the timer in the 2501 card reader which would turn off the motor 15 seconds after the last access by the 1130 controller. 

IBM uses the term circuit breaker to mean a microswitch that is activated by a cam. In the 2501, it is actually magnetic pickups that sense a permanent magnet on a rotating wheel, but the terminology remains. In the 2501, pulses are emitted by CB1, CB2 and CB3 to indicate points during the feed cycle of card movement. 

I programmed an Arduino Mega 2560 to model the photocells and read emitter pulses of a 2501 reading cards. It watches the CB1 and CB3 timing pulses from the other Arduino and receives control signals from the 1130 controller logic. When the controller energizes the Feed Solenoid, to move a card through the machine one position, the Arduino program will produce the outputs that would occur. 

The 2501 has three positions where a card can sit - the hopper, the pre-read station, and the stacker. Each feed cycle moves cards from one to the next position. Initially there are cards in the hopper but not elsewhere. Pushing the Start button on the reader triggers the controller logic to issue a Feed Solenoid and move one card into the pre-read station. 

After this first card situation, each Feed Solenoid moves a card from pre-read through the read photocells to the stacker, simultaneously moving one card from the hopper into the pre-read station. This continues until the Hopper Empty microswitch tells the controller that there are no cards left in the hopper.

A photocell at the left side of the pre-read station, the right side of a punched card, will be blocked as a card is moved into the station. It stays dark until a next feed cycle when the card is moved through the read photocells to the stacker. 

As the card moves away from the left side of the pre-read station, the photocell sees light. This is the trigger to the controller logic to set up for a card read as this occurrence defines the point where the left edge of the card is entering the reading photocell area.

The 2501 records timing pulses on a read emitter wheel that will produce a pulse for each of the card columns as they pass under the photocell. These 55 microsecond pulses are the Read Emitter output of the card read. My Arduino sees the signal to record the timing pulses which starts my production of Read Emitter signals, emulating what the 2501 would have done. 

The first pulse is column 0, so it is ignored by the controller logic. The next 80 cause the controller logic to sample the state of twelve photocells, one for each row of the punched card. The logic samples the photocells twice - at the start of the read emitter pulse and at the end. If the sampled values differ, a read check error is flagged. 

My Arduino presents the signal that would come from the pre-read station photocell as cards physically move into it and out of it. I set them up in advance of the Read Emitter pulse and hold them steady until a safe time after the end of the Read Emitter pulse. 

I set up the values for the 80 columns, with the state of the twelve row photocells for each, using Hollerith encoding. It is a card that has // XEQ CARL at the left side and C0001209 in columns 73 to 80. The end characters allow me to be sure that the emulated 2501 doesn't get out of sync with the 1130's controller logic and misalign the results. 

INTERFACING ARDUINOS TO THE 1130 LOGIC

The 1130 logic uses different voltage levels than the TTL levels of the two Arduinos. In some cases, 12V and -3 are present on input signals. 

To protect the inputs of the Arduinos, I have these signals feed an open collector buffer gate with the Arduino's internal pullup resistor reading a logic HIGH if the gate is not on and a logic LOW when it is active. This is true for all of the inputs into the Arduinos.

To drive the 1130 logic from the Arduino, I also used open collector buffer gates, since the 1130 logic doesn't care about a logic HIGH voltage, only reacting to a LOW level on the input. This is true for many of the outputs of the Arduino, but not all. 

Some of the signals going into the 1130 see a voltage of -3V and expect to be pulled up to +12V for a logic high. Those signals use a transistor to connect the +12V to the input when activated by the Arduino output. These are -Motor Hold, +Card Lever 1 (pre-read photocell), +Row 12, +Row 11, +Row 0, +Row 1 . . . +Row9 photocells. 

SIGNALS NOT HANDLED BY THE ARDUINO DONE ON INTERFACE CIRCUITRY

There are microswitches in the 2501 that detect jams in the stacker, the hopper empty condition, and open covers on the machine. These lines into the 1130 see -3V and expect to be fed +12V when active, controlled by switches in the interface circuitry and not by an Arduino.  

Some inputs to the 2501 will drive indicator lamps on the front of the machine. These are Ready, Feed Check, Read Check and Combined Attention. These can be fed to LEDs in the interface circuitry. 

The Start, Stop and NPRO pushbuttons on the 2501 go the the 1130 logic where they see -3V, but present +12V when the button is pressed. Again I use switches in the interface circuits. 

BREADBOARDING INTERFACE CIRCUITRY

I needed ten open collector buffer gates for the signals passing between Arduinos and the 1130 logic, six switches, four LEDs, 14 transistors for the circuits that swing between +12 and -3, plus the various pullup and current limiting resistors.