AFT

I have on occasion required a tool for identifying fiber optic lines at work. While it isn't often enough to justify the expense of a proper fiber test device, it might be within my capabilities to construct a basic fiber “toner” set.

The project's working title is AFT (Arduino Fiber Tracer or Adequate Fiber Tracer).

SFPs (small form-factor pluggable) are compact IR transceivers designed for fiber optic networking. There are two major advantages to using an SFP in this device. First, it puts the tester on equal footing with the devices in the live environment. We don't have to worry about propagation distances; if the tester can't transmit over the entire fiber run, then neither will a switch be able to. Second, it allows the tester to check the SFP itself using DDM/DOM [1] or I2C [2]. In the future, we may also be able to program the tester to talk to live network devices to help determine where the other end of the cable goes¹⁾.

The electrical pinout is shown in Table 1.

For the prototypes, we will be using the Osmocom SFP Experimenter board. This breakout contains all support circuitry required to send single-ended signals through an SFP. No restriction is made on the input data, so we need not send valid Ethernet frames. That opens up the question of how we are to encode the data for transmission [3]. Of course, instead of sending arbitrary bits, we could instead transmit a clock.

For whatever reason, the SFP Experimenter board is designed to accept I/O connections through SMA connectors (one per stream). The units ship without the connectors soldered to the board, so we can add whatever kind of interface we want—simple wires will do.

SFP modules expose a great deal of data detailing their internal status, all accessible through I2C at one of two addresses (0xA0, 0xA2).

The idea is to have a pair of Arduino-based devices. For a given test session, one (designated the sender) is connected the the line under test and begins transmitting a particular signal. The other (designated the receiver) watches for this signal. Once it finds the signal, it can send a reply back to confirm that the sender is indeed on the other end. Each device should be equipped with a display and a handful of buttons for communicating with the user.

User I/O can be provided over I2C with an Adafruit RGB LCD shield. The LCD color can be used to indicate status (e.g., red = no SFP, green = paired, yellow = sending) to free up screen space. The shield also includes a four-way directional keypad and select button³⁾.

Operation is split into two primary modes: SFP diagnostic and tone. SFP diagnostic mode gets a subset of device parameters from the SFP over I2C [4] and displays it on the screen. Each page indicates the parameter name on the top row and the value (with units) on the bottom row. Tone mode transmits a signal through the SFP and watches for a return signal. If the partner device is detected, the screen lights green and a success message appears. The SELECT button cycles through modes.

If space permits, a serial debug mode would be handy. This mode would accept commands (possibly binary data for efficiency) over USB and offer direct read/write access to the hardware. It should probably be accessible only through a key combination.

On startup, the tester initializes I/O devices, prints a splash screen, and drops into SFP diagnostic mode.

At the beginning of the main loop, the tester verifies that an SFP is present. If not, we call a function to display a warning message, turn the screen red, and busy wait. Once an SFP is inserted, the tester gets button status, setting the appropriate action flags (on arrow buttons) or updating the mode byte (on SELECT button). That mode byte then determines what happens for the rest of the loop.

SFP diagnostic mode uses an offset into a table to determine which parameter to load from the SFP. If the user pressed UP or DOWN, then that offset is adjusted accordingly before the read. Once read, the parameter name is printed to the top row, and the parameter value is scaled as necessary and written to the bottom row (with units if applicable).

The tone functionality is bisected into two modes. We call these “tone” and “probe” by analogy to a copper tone and probe set. The unit in tone mode continuously transmits a signal⁴⁾ on the wire and awaits a return. The unit in probe mode watches for the toner's signal and transmits its own in return. Once a tester is both transmitting and receiving, the LCD lights green and indicates a connection.

In USB debug mode, the user can send commands to the tester and inspect its internal state. This mode should only be accessible by holding the mode select button to prevent accidental activation.

• 2x Arduino Uno Rev3 (\$28) Arduino Leonardo
• 2x Osmocom SFP experimenter (€65.45)
• 2x 20x4 LCD with RGB backlight (\$25)
• 2x LCD serial+USB backpack (\$13)
• 2x rotary encoder with push button (\$4.50)
• 15cm jumper wire assortment (\$8)

We don't want to rely on the Osmocom SFP Experimenter board for the final product, but it has the major advantage of a built-in differential transmitter and receiver⁵⁾.

Table 2 indicates proposed pin connections. Underlined items are ideally suited for interrupts.

Portable operation is a must for this tester.

• using an IR Arduino library
• Python-programmable IR USB receiver
• IR sensor tutorial
• some fiber transceiver boards
• serial fiber duplex modem
• fiber duplex breakout
• I2C LCD shield kit with keypad (LCD not included)
• 1W fiber optic light source
• Osmocom SFP experimenter
• single-ended vs differential signals
• Arduino optical power meter
• a card edge connector that might actually work; the EDAC 395 series (specifically 395-020-558-xxx models or 395-020-520-201) are also promising
• Adafruit Serial+USB LCD backpack
• the Feather platform might also be a viable brain for this project; the 32u4 model is software/pin compatible with Arduino and features built-in battery connections and monitoring
• Adafruit PowerBoost 500 rechargeable shield
• https://www.adafruit.com/product/326
• https://lastminuteengineers.com/rotary-encoder-arduino-tutorial/