Node Card Installation Guide

Table of contents

Node Card Installation Guide

Introduction

This guide walks you through the installation and setup of a fully assembled LCC Fusion Node Card into your layout.
It assumes that your Node Card has already been built (see the Assembly Guide) and is ready to be connected to power, the CAN bus, and optional I/O devices.

The purpose of this guide is to:

Show you how to connect the Node Card to the Node Bus Hub, CAN Network, and optional breakout boards.
Explain power supply options (CAN bus, USB-C, ATX 5557, DC-005, or battery backup).
Help verify correct installation using the card’s status indicators.
Provide troubleshooting steps if the Node Card does not power on or communicate with other devices.

The Node Card also includes automatic self-diagnostics at power-up and during operation.
It continuously monitors:

Power rails (3V3, 5V, 12V) to ensure stable supply
CAN bus health (termination, bias voltage, shorts)
CAN connectivity (ACKs, lost/restored communication)
I²C devices connected through the Node Bus Hub
Results are reported through the Serial Monitor (and optional LCD), while the on-board LEDs and buzzer provide clear visual/audio alerts.
This means most installation issues—like missing termination, weak power, or a loose cable—can be detected automatically without extra test equipment.

⚠️ Important: This document is for installation only. For building or soldering instructions, see the Node Card Assembly Guide.

Quick Start Checklist

Follow these steps to get your Node Card running quickly:

Insert Node Card into the Node Bus Hub.
Connect CAN Bus using a network cable (RJ45, J5/J6) or via the CAN I/O connector (J11).
Choose Power Source (only one):
- USB-C (J1)
- ATX 5557 (J2)
- DC-005 barrel jack (J3)
- CAN Bus cable (if configured for power)
- Battery Card (J12, optional)
Check Power LEDs – verify that 3V3, 5V, and 12V LEDs are lit.
Insert MCU – place the ESP32 DevKit-C module into the headers (antenna left, USB right).
Install Firmware – load the Node Card firmware using the ESP web tool or serial connection.
Connect I/O Devices – attach breakout boards or devices to J7 (I/O Devices).
Verify Operation – use JMRI or a serial monitor to confirm CAN communication and device responses.

✅ If all LEDs are on and the card appears in JMRI, your Node Card is ready for use.

What’s Needed

Component	Purpose
Computer / RPI (3B+)¹	Runs JMRI for CAN communications with Node Card
Power Supply (optional)²	Provides power to the Node Card and BOD Card (via the Node Bus Hub)
Node Bus Hub	Interfaces the Node Card with the BOD Card, providing both power and communications
Node Card	Interfaces with CAN network and cards (via Node Bus Hub)
Network Cable (CAT5/CAT6)	Connects CAN Bus with computer, RPI, and/or other LCC Nodes
3-wire cables	Connect devices to breakout board JST XH connectors

1) When using an RPi, you can simplify integration by using the RPi-CAN Card, which provides built-in CAN communication and connects directly to the LCC Fusion Node Bus—no extra wiring required. Otherwise, to run JMRI on a standalone Pi you will need:

Raspberry Pi 3B+ (or newer): Runs JMRI for CAN communications. We recommend Steve Todd’s preconfigured JMRI image
microSD card (8 GB or larger): Holds the JMRI OS image
microSD card reader & imaging tool: For flashing the image to your card (e.g., balenaEtcher)
2) Powering the Node Card can be done via the CAN Bus network cable or a separate power supply 3) The Node Bus communicates via the Node Bus Hub(s) by: 1) inserting the Node Card into the Node Bus Hub board 2) connecting the Node Card to the Node Bus Hub board using a network cable

Connection Diagram

flowchart
	direction LR;
  subgraph layout ["Train Layout"]
  	direction LR;
  	subgraph hub["Node Bus (network)"]
  		direction LR;
      nodeCard[["Node Card"]]
      card[["LCC Fusion card(s)"]]
      nodeBusHub[["Node Bus Hub (board)"]]
    end
    jmri["JMRI Software<br>CDI Config Tool"]
    computer["Computer, or <br>Raspberry PI"]
    pwrSupply(("Power Supply"))
    breakout1["LCC Fusion<br>Breakout Board(s)"]
    devices1(("Track Blocks (4x)"))
    nodeCard -.-|"Plugs Into Hub for<br>Power & Communications"|nodeBusHub
		card -.-|"Plugs Into Hub for<br>Power & Communications"|nodeBusHub
  end
  jmri -.- |"runs on"|computer <--> |"CAN Bus via<br>Network Cable"|nodeCard
  pwrSupply -.-> |"1+ A @ 40 v max via<br>2-wire"| nodeCard
  nodeCard <--> |"Digital I/O via<br>Node Bus Hub"|card
  card <--> |"Digital I/O via<br>Network Cable → J10" |breakout1
  breakout1 <-.-> |"Train Current"|devices1

  classDef lightBlueStyle fill:lightblue,stroke:#2c7a2c,stroke-width:2px,font-size:16px;
 	classDef lightGreenStyle fill:lightgreen,stroke:#333,stroke-width:2px,font-size:20px;
  class hub lightBlueStyle
    class nodeCard lightGreenStyle

Planning Your Installation

Before installing the Node Card, decide how you will supply power and connect to the CAN network.
Different methods are supported — you should choose only one power input and one CAN network connection for reliability.

Power Options

The Node Card accepts 14–28 VDC DC from several sources. Use whichever is most convenient for your layout:

CAN Bus Power (RJ45 J5/J6): If your CAN cables carry layout accessory bus power (per NMRA LCC standard), the Node Card can be powered directly from the network cable.
USB-C (J1): Standard USB-C laptop/brick supply. Recommended: ≥18 VDC, 3 A.
ATX 5557 (J2): Connect to an accessory bus or bench supply (>14 VDC).
DC-005 Barrel Jack (J3): Accepts common wall wart supplies.
Battery Card (J12): Optional backup or mobile operation (12 VDC).

⚠️ Important: Use only one input method at a time. Multiple simultaneous inputs can cause back-feed and instability, even though the board has protective diodes.

The Node Card can also daisy-chain power out to other devices:

ATX 5557 OUT (J4): Forward high-voltage supply to another Node Card.
USB-C OUT (J9): Provides regulated 5 VDC to external devices (e.g., Raspberry Pi).

CAN Network Options

The Node Card communicates with other LCC devices over the CAN bus at 125 kbps. Choose one of the following connection methods:

RJ45 CAN Bus (J5/J6): Use CAT5/6 network cables for in/out chaining. Supports both CAN data and optional power.
CAN I/O Header (J11): 2/3-wire connection to CAN-H / CAN-L (and optional GND). Useful for direct wiring or connecting to a CANable adapter.
Wi-Fi CAN Bridge: The Node Card’s ESP32 MCU can be configured to exchange LCC Events over Wi-Fi with other Node Cards or Nodes running in Wi-Fi mode. This eliminates the need for a physical CAN cable, though a wired CAN backbone is still recommended for reliability in larger layouts.

The Node Card includes auto-termination — it will detect when it is at the physical end of the bus and apply the required 120 Ω termination automatically. When mixing with other NMRA LCC devices, ensure only the two endpoints are terminated.

Installation Steps

This section assumes the Node Card is fully assembled. For assembly details, see the Node Card Assembly Guide.

1) Connect to the CAN Network

Choose one of the following ways to bring CAN to the Node Card:

RJ45 CAN Bus (J5/J6) — Daisy-chain with standard CAT5/6 when your cable is wired per NMRA LCC (power on pins 3/4, grounds on 7/8).
Node Bus Hub using a Power-CAN Card connected to the CAN Bus Network
CAN I/O header (J11) — 2/3-wire CAN-H/CAN-L (and GND if used). Observe silkscreen for CAN-H/CAN-L.

Auto-termination: The Node Card includes automatic 120 Ω termination. When the card is at a physical bus end, it applies termination; otherwise it removes it. If you share the bus with other LCC devices, ensure only the two physical ends are terminated.

2) Connect to the LCC Fusion Node Bus (optional)

Use one of the following to link the Node Card to a Node Bus Hub for power + I²C + distribution:

Insert the Node Card directly into a Node Bus Hub (edge connector).
Cable the Node Bus using RJ45 J8 from the Node Card to a Node Bus Hub.

3) Connect I/O Devices (optional)

Use RJ45 J7 (IO DEVICES) to attach either:

LCC Fusion breakout boards: Digital I/O Breakout, Digital Sensor Breakout, Relay, Card Monitor, UOD Breakout, etc.
Direct devices (digital, analog, touch, PWM) as supported by your firmware.

Line 7/8 selection: Use JP2 (Line 7) and JP3 (Line 8) to choose 5 VDC or I/O for those lines, depending on the breakout/device requirements.

4) Set Fusing

Fast-blow fuse (FH1): Install a 1808, 3 A fuse in the fuse holder FH1.
Fuse bypass (JP1): For bench diagnostics only, you may temporarily bypass FH1. Remove the bypass for normal operation.
Polyfuse (F1, 1.5 A): This protects the 3V3/5V rails and is not user-configurable.

5) Choose a Power Source (use only one)

Provide 14–28 VDC DC from exactly one input path:

CAN Bus via RJ45 (J5/J6) if your LCC cable carries power (per NMRA LCC wiring)
USB-C PWR IN (J1)
ATX 5557 PWR IN (J2). Observe silkscreen for V+ and GND orientation.
DC-005 barrel PWR IN (J3)

Backfeed caution: Do not feed multiple inputs at once. The board includes reverse-/back-feed protection, but a single selected source avoids ground loops and unnecessary losses.

6) (Optional) Battery Input

Connect the Battery Card cable to BATT (J12), or an external 12 VDC+ source as labeled. Observe silkscreen for V+ and GND orientation.

7) (Optional) Provide Power to Other Devices

PWR OUT ATX 5557 (J4): Daisy-chain input power to another Node Card.
5 VDC OUT USB-C (J9): Supply 5 VDC to external devices (e.g., RPi). Observe current limits.

8) Insert the MCU

Install the ESP32 DevKit-C module into the headers.
Orientation: antenna to the left, USB connector to the right (as printed on the PCB).

9) Power On

Turn on the selected power source.

10) Verify Power

Confirm POWER LEDs for 3V3, 5 VDC, and 12 VDC are ON.

11) Install Firmware

Load the LCC Fusion Project Node Card firmware, then open a serial monitor at 115200 to confirm startup.

12) Configure Firmware

13) Verify Operation

Use JMRI (CDI/Monitor) or a serial console to confirm:
- CAN online / events sent/received
- I²C device discovery (if using Node Bus Hub + I/O cards)
- I/O lines toggle/read as expected via J7 and connected breakouts/devices

Post-Install Guidance

If you hear buzzer alerts, see warnings on the Serial Monitor, or messages on the LCD:

Check Power Rails
- Confirm that the 3V3, 5V, and 12V LEDs are lit.
- If a rail is reported low, verify your selected power input is supplying adequate current and voltage.
Check CAN Bus Health
- Ensure your CAN bus has exactly two terminations—one at each physical end.
- Inspect cables for shorts or opens if “short to GND/3V3” or “bus floating” errors are reported.
- If “missing termination” appears, verify the Node Card’s auto-termination is enabled and the opposite end of the bus is terminated.
Check Node Bus Hub and Breakout Boards
- Confirm the Node Card is fully seated in the Node Bus Hub.
- Inspect attached breakout boards and ribbon/network cables for firm connections.
Check I²C Devices
- If devices are repeatedly reported as not responding, confirm the correct breakout board type is used and its DIP/address jumpers are set properly.
Respond to Alerts
- Warnings ([W]) indicate possible issues (e.g., heavy load, weak bias) but the system may continue to operate.
- Errors ([E]) indicate hard faults (e.g., short to ground) that must be corrected before reliable operation.

✅ The built-in LED indicators, buzzer, Serial Monitor messages, and optional LCD provide all necessary feedback—no extra test equipment is required for installation checks.

Diagnostics and Troubleshooting

Testing and Troubleshooting Made Simple

The Node Card is designed for model railroaders who may not be electronics experts.
If something is wrong, it will tell you:

Buzzer + LED Alerts → quick audible/visual feedback (see table below).
Serial Monitor / LCD Messages → plain-language explanations with suggested fixes.
Optional Card Monitor Board → lets you confirm I/O signals visually.

✅ In most cases you do not need a meter or scope. If you connect something incorrectly, the Node Card will alert you and suggest the fix.

Firmware Self-Test and Diagnostics

The Node Card firmware performs continuous self-tests and health checks during startup and runtime. These checks help verify that your card is wired correctly, has stable power, and can communicate with other devices.

Troubleshooting Flowchart

How to read flowchart

Power LEDs off → fix power first.
Buzzer codes → tell you exactly where to look (power vs CAN).
LCD/Serial messages → guide you if devices or I/O aren’t detected.
Card Monitor Board → optional tool for deeper checks. ```mermaid flowchart TD subgraph Node Card Troubleshooting Flow start([“Power on Node Card”]) –> leds{“Are 3V3 / 5V / 12V
LEDs lit?”}

leds – “No” –> power[“Check power source:
- Only use one input
- Try USB-C or DC jack
- Verify fuse FH1 installed”] –> leds leds – “Yes” –> buzzer{“Do you hear
buzzer alerts?”}

buzzer – “3 short beeps” –> lowv[[“Low voltage detected
Check power supply and cables”]] buzzer – “4 short beeps” –> canwarn{“CAN Bus issue
(check messages)”}

canwarn – “High voltage warning” –> missTerm[[“Bus floating
Add 120Ω terminator at bus end”]] canwarn – “Low voltage warning” –> overTerm[[“Too many terminators / long cable
Remove extra terminators”]] canwarn – “Error: short to GND/3V3” –> shortFault[[“Replace CAN cable
Check connectors”]]

buzzer – “2 long beeps” –> canlost[[“CAN network lost
Check cables and that only 2 ends are terminated”]] buzzer – “1 long beep” –> canok[[“CAN connection restored – normal”]]

buzzer – “No alerts” –> devices{“Any missing device
messages on LCD/Serial?”}

devices – “Yes” –> i2c[[“I²C device not found
Check breakout cables and DIP switch addresses”]] devices – “No” –> io{“Is I/O working?”}

io – “Yes” –> done([“System ready for use”]) io – “No” –> testBoard[[“Test with Card Monitor Board
to confirm signals”]] –> |”fix connections
CDI configuration”|io end

```

Testing with the Card Monitor Board

For testing of I/O lines and connected devices, we recommend using the Card Monitor Board.

The Card Monitor Board plugs into the Node Bus Hub and provides a clear view of signal activity on each I/O line.
It can confirm that:
- Output lines are driving as expected
- Input lines respond correctly when sensors or buttons are actuated
- No shorts or miswirings exist between the Node Card and attached breakout boards

By combining the Node Card’s built-in self-diagnostics with the Card Monitor Board, you can fully verify both the internal health of the Node Card and the end-to-end wiring to your devices. This is especially useful during installation, troubleshooting, or when validating new breakout boards.

What the Firmware Monitors

Voltage Rails (3V3, 5V, 12V)
- Confirms each regulator is providing sufficient voltage.
- Low voltage conditions may indicate insufficient power supply, USB-only powering, or noise on the accessory bus.
- If a rail drops below its threshold:
  - ⚠️ A warning is printed to the Serial Monitor/LCD.
  - 🔔 The buzzer sounds 3 short beeps once per minute until voltage recovers.
CAN Bus Bias (CAN-H line)
- Samples the idle CAN-H voltage to ensure the bus is properly terminated and not shorted.
- Detects conditions such as:
  - Over-terminated / heavy load (<2.1 VDC)
  - Missing termination / floating (>2.8 VDC)
  - Short to GND (~0 VDC) or short to 3V3 / stuck dominant (~3.3 VDC)
- Alerts include:
  - ⚠️ Warnings for over- or under-bias conditions.
  - ❌ Errors for hard faults (shorts).
  - 🔔 The buzzer gives 4 short beeps for CAN voltage alerts.
CAN / TWAI Connectivity
- Monitors transmit/receive statistics from the ESP32 CAN controller.
- Reports when CAN connectivity is lost or restored.
- 🔔 One long beep = connection restored, two long beeps = connection lost.
Communications with Configured LCC Fusion Cardss
- Verifies loopback on both COMM (I²C) buses (A and B).
- Scans for expected LCC Fusion Cards (using MCP23017 IC & PCA9685 IC) attached to the Node Bus Hub.
- Reports when devices are found, removed, or not responding.
Node I/O Devices
- Checks GPIO pins for attached devices on the Node Card’s I/O header.
- Reports when I/O devices are connected or disconnected.
Brown-Out Resets
- Detects if the ESP32 reset due to low 3V3 voltage.
- Reports this event to the Serial Monitor for troubleshooting.

How Results Are Reported

Serial Monitor / LCD (if installed)
Detailed diagnostic messages (with measured voltages) are printed to the serial console at 115200 baud.
If an optional I²C LCD is connected, key messages are also displayed there.
LED Indicators
- Power LEDs show live 3V3, 5V, and 12V status.
- The Node status LED blinks according to firmware state.
Buzzer Alerts
Distinct beep codes indicate alert type:
- 3 short beeps = low regulator voltage
- 4 short beeps = CAN bus voltage alert
- 1 long beep = CAN connection restored
- 2 long beeps = CAN connection lost
- Continuous = error condition (e.g., short)