Quick Start

1. What LadderIDE is

LadderIDE is a ladder logic editor for Arduino-class boards. You draw rungs the way you would in an industrial PLC editor, run them in a built-in simulator, and then compile the program to an Arduino sketch and upload it. Once the board is running you can go Online and watch live values on the rungs themselves.

If you have used RSLogix or Studio 5000, the shape will be familiar: contacts and coils, timers and counters, a tag database rather than numbered addresses. If you have not, the rest of this page assumes nothing — it goes from a fresh install to a working output.

2. Install and first launch

Run LadderIDE-Setup.exe and launch it. Nothing else is required to build for an Arduino Uno, Nano or Mega: the compiler, the board support and the device libraries all ship inside the install. The first Compile prints Preparing bundled board support… once and takes a few extra seconds while it unpacks them.

No internet connection is needed for those boards. Other families — STM32 Nucleo, Raspberry Pi Pico, Teensy, ESP32 — download their board support once, and LadderIDE offers that download the first time you compile for one.

3. Connect your controller

Plug the board in over USB, then choose Arduino ▸ Detect Boards and pick the detected port. Board Config is where the board and port live if you want to set them by hand; ⟳ Refresh Ports re-reads the port list at any time.

Genuine Arduino boards install their USB driver automatically. Clone boards usually use a CH340 USB-serial chip and may need its driver installed before a port appears.

If the port list is empty, that is a real condition with several causes and its own page: No ports detected. On a Teensy or a Pico it is expected — those boards have no port until their first upload, and uploading does not need one.

4. Create a project

File ▸ New Project, then pick your board. Choose Arduino Uno if you are unsure — every bundled example targets it.

Ctrl+S saves the project as a .ldp file, which you can keep anywhere. The .ldp holds everything: your rungs, your tags, the board you chose, and the devices and blocks the project uses.

5. Create your first tags

LadderIDE addresses data by name, not by file number. A tag has a name, a data type, and — if it is a board pin — a pin binding. D13 is a tag. So is MotorRun.

For a first program you need one output. The board pins already exist as tags, so D13 (the LED on an Uno) is ready to use without creating anything. To make a named one, use New Tag in the Tag Browser: give it a name, choose BOOL, and leave it unbound if it is just memory.

Two rules worth knowing now, because they explain most early surprises:

• A contact or coil needs a tag that resolves to a BOOL — a BOOL tag, a structure member such as Tmr.DN, or a bit of a word such as Word.3.
• Instruction dialogs do not create tags for you. A name that does not exist paints the rung red; right-click it and choose Add New Tag….

6. Build your first rung

Place instructions by dragging them from the palette onto the rung, or select a spot on the rung and press Insert for the picker. A click selects an element; it never places one.

For the classic first rung:

1. Place an XIC (examine if closed) on the left. Double-click it and give it the tag D2.
2. Place an OTE (output energise) on the right. Double-click it and give it the tag D13.
3. Edit ▸ Add Rung adds another rung below. Ctrl+Z undoes.

A rung reads left to right: contacts on the left are the conditions, the coil or block on the right is the output. A rung with instructions but no output is an error; an empty rung is fine.

Before touching hardware, press F5 (Edit ▸ Start Simulator). The rungs colour by state and the Tag Browser shows every tag’s live value.

• Drive an input pin by right-clicking its row — or the contact on the rung — and choosing Force On / Force Off. Forces are for I/O only.
• Toggle a memory bit by double-clicking it, or Ctrl+T. A bit that a coil controls cannot be toggled; the logic owns it.
• Type a value into an INT, DINT, REAL or STRING to preset it. The value stands until the logic writes it.

Force D2 on and D13 should follow. Press F5 again to stop. The simulator models the board’s scan loop, so what you see here is what the board will do.

7. Verify

Ctrl+Shift+B compiles. Errors and warnings land in the Problems pane at the bottom; the full compiler log is in Output.

Most first-time errors come from validation rather than the compiler, and they name the instruction and the tag: an unresolved contact or coil, a pin used as both an input and an output, an instruction missing an operand. Fix what it names and compile again.

8. Download to controller

Ctrl+U uploads; Ctrl+Shift+U compiles and uploads in one step.

Arduino calls this an upload — putting the sketch on the board. If you come from the PLC world, this is the step you would call a download.

9. Watch it run

With the program on the board, Ctrl+K (Arduino ▸ Get Online) opens the serial link. The board streams every referenced tag about ten times a second, and the rungs and the Tag Browser show live state. Forces and value edits reach the board the same way they do in the simulator.

Pins D0 and D1 carry that link and can never be used as ladder I/O. Boards with native USB — Teensy and the Pico — are the exception: Get Online rides the USB port itself, so every header pin stays free.

To watch a port without going Online, Tools ▸ Network Utility ▸ Port Tester opens a plain serial terminal on any port, with hex display for raw traffic.

10. Where to go next

Learn from the examples. Help ▸ Open Example… opens the bundled series, copied into Documents\LadderIDE\Examples on first use so you can edit them freely. Work them in order; every rung carries a comment explaining what it does and why:

File	Teaches
01_StartStop.ldp	The seal-in latch: start, hold, stop
02_FlipFlop.ldp	Two timers driving each other into an oscillator
03_BitShift.ldp	BSL marching bits through a register
04_TrafficLight.ldp	SQO sequencer with a step table
05_AnalogPWM.ldp	SCP scaling an analog input to a PWM output

Every numbered example runs on a bare Uno with no wiring: press F5 and force D2 (Start) and D3 (Stop) from the Tag Browser.

Then:

• Instruction Reference — every instruction, its operands, its scan behavior and a worked example.
• Reusable logic — Assets ▸ MBS is a block you write once and place on any rung; Assets ▸ Struct (UDS) is a named data type. Both export to .mbs / .uds files you can share.
• Sensors and shields — the Network tree adds catalog devices (I²C sensors, Ethernet shields, Modbus or DF1 serial devices). Each exposes member tags your rungs read and write.
• Talking to a PLC — the MSG instruction sends EtherNet/IP, Modbus TCP, Modbus RTU or DF1 messages to another controller, and an Ethernet shield can serve EtherNet/IP and Modbus TCP to one.
• Trends — the Trend panel records tags over time, in the simulator or Online, and exports the capture as CSV.

Where things live

What	Where
Your projects	Anywhere you save them (.ldp)
Examples	Documents\LadderIDE\Examples
Your MBS blocks and UDS structs	Documents\LadderIDE\MBS, Documents\LadderIDE\UDS
Board support and compiler cache	%LOCALAPPDATA%\Praxous\LadderIDE\arduino15

File ▸ Export Project Bundle writes a .zip carrying the project and every library it uses, so it opens and compiles on another machine with no downloads.