Arduino Library for Proteus V4.0 (6 Boards, Working LEDs + Monitor)

Hello friends, I hope you all are doing great. Today, I am going to share our new Arduino Library for Proteus V4.0. It brings six Arduino boards to Proteus 8 in one library: the Arduino UNO, the Arduino Mega 2560, the Arduino Mega 1280, the Arduino Nano, the Arduino Pro Mini and the Arduino Mini. Every board is drawn as the real one, and its LEDs work like the real ones: ON lights with power, L follows pin 13, TX and RX flash with the serial traffic, and the RESET button really holds the chip in reset and then runs the bootloader.

This is the fourth version of our Arduino library for Proteus, after V1.0 (2015), V2.0 and V3.0 (2023). The microcontroller is still Proteus's own AVR model, so your sketch, the HEX upload and Proteus's AVR debug windows work as before. What is new is everything around the chip, and a serial monitor built into every board: press Run, and a window with the sketch's text, a live view of the board and a plotter opens, with no Virtual Terminal to wire. In this post, I will show you all six boards side by side, and each board also has its own V4.0 post with more pictures of it.

NOTICE: This library is very special to our team. Many of you have built your Proteus projects on our earlier Arduino boards, so for V4.0 we drew all six boards again from scratch and gave them what the old ones never had: working LEDs, a working RESET with the bootloader, real supply pins and a complete serial monitor inside each board. It took our team a lot of hard work and many test runs. Your feedback is the fuel that keeps us going, so please tell us what you think in the comments below or in the Arduino Proteus Library board of our forum. And if our free libraries help you, you can buy us a coffee. So, let's get started with the Arduino Library for Proteus V4.0:

What Is the Arduino Library for Proteus V4.0?

An Arduino board in Proteus has two parts: the AVR microcontroller that runs your sketch, and the board around it. In our V4.0 library, the microcontroller is Proteus's own AVR model, the same one V3.0 used. So everything you know keeps working: you load the HEX file of your sketch with Upload Hex File, the clock and the AVR fuses are Proteus's, and Proteus's AVR debug windows are there as before.

Around the chip, our model, TEPARDUINO.DLL, draws and drives what the real board has: its LEDs, its RESET button with the bootloader, its supply pins and its header pins. And it adds one thing no real board has: a built-in serial monitor on D0 / D1, with three tabs: Board, Monitor and Plotter.

The Six Boards at a Glance

The six boards in ArduinoV4TEP.LIB (one model for all: TEPARDUINO.DLL)

Board	Proteus device	Drawn as	Chip	Pins
Arduino UNO	ARDUINO UNO V4.0	Arduino UNO R3	ATmega328P, 16 MHz	31
Arduino Mega 2560	ARDUINO MEGA2560 V4.0	Arduino Mega 2560 R3	ATmega2560, 16 MHz	85
Arduino Mega 1280	ARDUINO MEGA1280 V4.0	Arduino Mega (ATmega1280)	ATmega1280, 16 MHz	85
Arduino Nano	ARDUINO NANO V4.0	Arduino Nano 3.x	ATmega328P, 16 MHz	30
Arduino Pro Mini	ARDUINO PRO MINI V4.0	Arduino Pro Mini 5V	ATmega328P, 16 MHz	34
Arduino Mini	ARDUINO MINI V4.0	Arduino Mini 05	ATmega328P, 16 MHz	33

What Is New in V4.0

V4.0 keeps the same six boards as V3.0, with the same AVR model inside. Here is what changed:

• Every board drawn again in its real orientation and colour, as a detailed top view: the real headers, chips, crystal, connectors and silkscreen.
• Working LEDs: ON / PWR lights with power, L follows pin 13, and TX / RX flash with the serial traffic on D0 / D1, held 40 ms so the eye sees them. They glow in steps and fade out over a few frames, like real LEDs.
• A working RESET button, drawn as a tactile switch: hold it and the chip is held in reset; release it and the bootloader runs: L flashes 3 times and the sketch starts 1 s later.
• Real supply pins: 5V and 3.3V are voltage sources, and the GND pins are tied to ground.
• A built-in serial monitor on D0 / D1 with the Board, Monitor and Plotter tabs.
• The missing pins added after the V3.0 pins (see the pin table below).
• V3.0 bugs fixed: the UNO's AREF, RESET, VCC and GND pins pointed into the board; the property was spelled "Clock Frequence"; the A6 / A7 pins of the Nano, Pro Mini and Mini had no electrical type; and the V3.0 Pro Mini and Mini had an AREF pin the real boards do not have.

V3.0 and V4.0 can stay installed together, because they use other file and device names. The pin positions changed, though, so a V3.0 design does not swap pin for pin: place the V4.0 board and wire it again.

Features of Arduino Library for Proteus V4.0

• Six boards in one library: ArduinoV4TEP.LIB and one model, TEPARDUINO.DLL.
• Proteus's own AVR model inside: your HEX file, the clock, the fuses and the AVR debug windows work as in V3.0.
• Detailed boards in the real colour and orientation; the UNO and the Megas in the real size.
• LEDs that behave like the real ones, including the UNO R3's dim L glow while pin 13 floats.
• RESET with the bootloader, and 5 V / 3.3 V supply pins you can use.
• A built-in serial monitor with a live Board tab, the serial Monitor and a Plotter.
• Six ready demo projects and one demo sketch for all of them.
• A small package: about 1.04 MB, without the C++ source code.

The Six Arduino Boards in Proteus V4.0

All six boards are our own drawings of the real boards, made from their layouts, with the parts where the real ones have them. The pictures below show each board running its demo in Proteus 8.5. The small squares beside the pins are Proteus's own logic-state markers (red = HIGH, blue = LOW, grey = floating). Each board has its own post too, linked in its section.

Arduino UNO V4.0

The UNO is drawn as the Arduino UNO R3, 2.7 x 2.1 inches (68.6 x 53.3 mm), the real size and layout: the USB-B socket and the power jack on the left, the digital header along the top and the power and analog headers along the bottom. On it you find the ATmega16U2 USB chip, the 16.000 MHz crystal, both ICSP headers, the op-amp that drives L, the ATmega328P-PU in its DIP socket and the RESET button in the top-left corner.

• LEDs: ON (red), L (green, pin 13), TX (orange) and RX (blue). L hangs on pin 13 through the R3's op-amp buffer, so it shows a dim glow while D13 floats.
• 31 pins: the 24 pins of V3.0 in V3.0's order, plus SDA / SCL on the top header (the same nets as A4 / A5), a GND next to AREF, and IOREF, 3.3V, VIN and a second GND on the power header. Top pins point up, bottom pins down.
• Monitor: click the USB port.

More pictures and the UNO's own demo: Arduino UNO Library for Proteus V4.0.

Arduino Mega 2560 V4.0

The Mega 2560 is drawn as the Arduino Mega 2560 R3, 4.0 x 2.1 inches (101.6 x 53.3 mm), the real size and layout. Its left part is the UNO's (USB-B, power jack, ATmega16U2, RESET), and then come the COMMUNICATION header (TX3 14 ... SCL 21), the analog pins up to A15, the ATmega2560 in its 100-pin TQFP package with its crystal and ICSP header, and the 2x18 header on the right end.

• LEDs: ON, L, TX and RX, as on the UNO; L also hangs on the R3's op-amp buffer.
• 85 pins: the 74 pins of V3.0 in V3.0's order, then SCL / SDA / GND on the top header, IOREF, 3.3V, VIN and a second GND on the power header, and the 5V and GND pairs of the 2x18 header.
• The 2x18 header (5V, 22 - 53, GND) is drawn as the real one. Its 36 pins leave the right edge as one comb, 50 thou apart: row by row, the even pin (22, 24 ... 52) at the row and the odd pin (23 ... 53) 50 thou below it.
• Monitor: click the USB port.

More pictures and the Mega 2560's own demo: Arduino Mega 2560 Library for Proteus V4.0.

Arduino Mega 1280 V4.0

The Mega 1280 is drawn as the first Arduino Mega (2009) with the ATmega1280: the same size and headers as the Mega 2560, but with the FT232RL USB chip instead of the 16U2 (so there is no second ICSP header), and "MEGA" in the white pill. The first Mega has no op-amp buffer for L, so here L hangs straight on pin 13: lit while D13 drives HIGH, a faint glow from INPUT_PULLUP, and dark while D13 floats or is LOW.

• 85 pins, the same as the Mega 2560, with the same 2x18 comb on the right edge.
• Monitor: click the USB port.

More pictures and the Mega 1280's own demo: Arduino Mega 1280 Library for Proteus V4.0.

Arduino Nano V4.0

The Nano is drawn as the Arduino Nano 3.x, 1.7 x 0.7 inches (43 x 18 mm), lying with the mini-USB socket on the left: gold pads with the pin names inside the rows, the reset button in the middle, the TX, RX, ON and L LEDs, the ATmega328P in its 32-pin TQFP package, the resonator and the ICSP pads. L hangs straight on pin 13.

• 30 pins: the 26 pins of V3.0 in V3.0's order, then the second RST and GND, 3V3 and VIN. A6 / A7 are analog inputs now (V3.0 had them with no electrical type).
• The rows: the top row (D12 ... TX1) points up, the bottom row (D13 ... VIN) down, and the pin ends sit on the 100 thou grid.
• Monitor: click the mini-USB socket.

More pictures and the Nano's own demo: Arduino Nano Library for Proteus V4.0.

Arduino Pro Mini V4.0

The Pro Mini is drawn as the red Arduino Pro Mini 5V (16 MHz), 1.4 x 0.7 inches. The real board is 1.3 inches long, but the FTDI pads and A4 - A7 need their own columns. On the left end sits the 6-pin FTDI header, GRN (DTR), TXO, RXI, VCC, GND and BLK, with its pins pointing left; A4 - A7 are on the right end; and the two 12-pin rows carry TXO RXI RST GND 2 - 9 (top) and RAW GND RST VCC A3 - A0 13 - 10 (bottom).

• LEDs: PWR (red) and 13 (green, pin 13). The real board has no TX / RX LEDs, so ours has none either. The 13 LED hangs straight on pin 13.
• 34 pins and no AREF pin: the real board has none (V3.0 drew one).
• Auto-reset: GRN is DTR. A falling edge on it resets the chip, like the 0.1 uF capacitor on the real board does when an FTDI adapter opens its port.
• Monitor: click the FTDI header.

More pictures and the Pro Mini's own demo: Arduino Pro Mini Library for Proteus V4.0.

Arduino Mini V4.0

The Mini is drawn as the teal Arduino Mini 05, 1.4 x 0.7 inches. The real Mini 05 is 30 x 18 mm, but here too the programming pads and A4 - A7 need their own columns. The two 12-pin rows carry +9V GND RST +5V A3 - A0 13 - 10 (top) and TX RX RST GND 2 - 9 (bottom); the programming pads IO7, TX, RX, +5V and GND sit on the left end (IO7 is D7), A4 - A7 on the right end, and the Mini 05's reset button beside the chip.

• One LED: L (green, pin 13). The Mini has no USB chip, so there are no TX / RX LEDs.
• 33 pins and no AREF pin: the real Mini has none (V3.0 drew one).
• Monitor: click the programming pads.

More pictures and the Mini's own demo: Arduino Mini Library for Proteus V4.0.

Which Board Has What

The six V4.0 boards side by side

Board	LEDs	L on pin 13	Supply pins	Open the monitor
UNO	ON, L, TX, RX	Through the op-amp buffer	5V, 3.3V, IOREF, VIN, GND x 3	Click the USB port
Mega 2560	ON, L, TX, RX	Through the op-amp buffer	5V, 3.3V, IOREF, VIN, GND, the 2x18 5V / GND pairs	Click the USB port
Mega 1280	ON, L, TX, RX	Straight on D13	5V, 3.3V, IOREF, VIN, GND, the 2x18 5V / GND pairs	Click the USB port
Nano	TX, RX, ON, L	Straight on D13	5V, 3V3, VIN, GND x 2	Click the mini-USB socket
Pro Mini	PWR, 13	Straight on D13	VCC, RAW, GND x 4	Click the FTDI header
Mini	L	Straight on D13	+5V, +9V, GND x 3	Click the programming pads

Download Arduino Library for Proteus V4.0

Click the button below to download Arduino-Library-for-Proteus-v4.0.zip (about 1.04 MB, without the C++ source code):

Arduino Library for Proteus V4.0

• README.txt: a detailed guide to the files, the six boards, the monitor, the properties and real hardware.
• Proteus Library Files: ArduinoV4TEP.LIB, all six boards in one library.
• Proteus Model Files: TEPARDUINO.DLL, the board model.
• Proteus Simulation: the six demo projects (UNO-V4-Board-Demo.pdsprj, MEGA2560-V4-Board-Demo.pdsprj, MEGA1280-V4-Board-Demo.pdsprj, NANO-V4-Board-Demo.pdsprj, PROMINI-V4-Board-Demo.pdsprj and MINI-V4-Board-Demo.pdsprj), the demo sketch built for each board (TEP_Board_Demo_UNO.hex and so on) and a copy of the DLL.
• Arduino Code: TEP_Board_Demo.ino, the one demo sketch for all six boards; it needs no extra Arduino library.

Want only one board's demo? Every board post above has its own, smaller download with the same library and model.

How to Install Arduino Library for Proteus V4.0

You install the library once, and all six boards are there:

1. Close Proteus and extract the whole zip file to a normal folder (for example, the Desktop).
2. Copy ArduinoV4TEP.LIB from Proteus Library Files into the LIBRARY folder of Proteus, usually C:\Program Files (x86)\Labcenter Electronics\Proteus 8 Professional\LIBRARY (on some PCs C:\ProgramData\Labcenter Electronics\Proteus 8 Professional\LIBRARY; use the folder that already holds Proteus's own .LIB files).
3. Copy TEPARDUINO.DLL from Proteus Model Files into the MODELS folder (...\Proteus 8 Professional\MODELS).
4. If an ArduinoV4TEP.IDX is in the LIBRARY folder, delete it.
5. Start Proteus, press P (Pick Devices) and search for V4.0 or Arduino. The six boards are in the category Arduino > Arduino Boards.

Note: Tested in Proteus 8.5; Proteus 7 is not supported. Keep the .hex files and TEPARDUINO.DLL beside the demo projects, so that they run as they are. Your V3.0 boards can stay installed next to V4.0.

How the LEDs Work on the V4.0 Boards

The LEDs are not pictures that switch on and off: the model watches the pins and the power, and lights each LED the way the real board's circuit would (with one difference for TX / RX, below).

• ON / PWR (red): lit while the board has power, so all the time the simulation runs.
• L (green, pin 13): follows D13. On the UNO R3 and the Mega 2560 R3, L hangs on an op-amp buffer, and the model copies that, including the buffer's dim glow while D13 floats. On the Mega 1280, Nano, Pro Mini and Mini, L hangs straight on D13.
• TX (orange) and RX (blue): TX flashes while the sketch sends on D1, RX while data arrives on D0. Each flash is held 40 ms after the last edge, so that the eye sees even one short line.
• Glow and fade: the LEDs light up in steps and fade out over a few frames, and TX / RX shimmer while busy. This is our drawing, to make them look like real LEDs; it is not a model of the LED physics.

How L follows pin 13

D13	UNO, Mega 2560 (op-amp buffer)	Mega 1280, Nano, Pro Mini, Mini (straight on D13)
OUTPUT, HIGH	Lit	Lit
OUTPUT, LOW	Dark	Dark
INPUT_PULLUP	Lit (the buffer sees a HIGH)	A faint glow (the pull-up's small current)
INPUT, nothing wired (floating)	A dim glow	Dark
Chip held in reset	A dim glow (the pins float)	Dark

On a real board, the USB chip drives the TX / RX LEDs, so they show the USB traffic only. Here they flash for any traffic on D0 / D1, also when a module you wired there talks to the sketch.

RESET Button and Bootloader

Every V4.0 board has a working RESET button, drawn as the real tactile switch: on the UNO and the Megas in the top-left corner, on the Nano in the middle, on the Pro Mini near the right end and on the Mini 05 beside its chip.

1. Hold the button (click and keep the mouse button down): the cap sinks, and the chip is held in reset. Its pins float, so L dims on the UNO and the Mega 2560 and goes dark on the other boards.
2. Release it: the bootloader runs. L flashes 3 times (D13 really toggles, in 62.5 ms steps).
3. 1 s after the release, your sketch starts again from setup().

This is what a real board does after a reset: its bootloader waits about a second for an upload before it starts the sketch (optiboot on the UNO and the Nano also flashes L 3 times). A power-on, so pressing Run, starts the sketch at once. Set the property BOOTLOADER=NO if you want the sketch to start at once after a reset too. The monitor's Board tab has its own RESET key: a 20 ms press, followed by the bootloader.

Supply Pins: 5V, 3.3V, VIN and GND

In V4.0, the supply pins are part of the circuit:

• 5V, VCC, +5V and IOREF are 5 V sources (0.1 ohm), so you can power a sensor or a module straight from the board, as on a real one.
• 3.3V / 3V3 is a 3.3 V source (0.5 ohm, with no current limit).
• GND pins are tied to ground.
• VIN, RAW and +9V are loads only (1 Mohm): the board runs as if it was powered from USB, so you do not need to feed them.

The monitor's Board tab shows the voltage of every supply pin while the simulation runs: in our runs 5.00 V, 3.30 V and 5.00 V for 5V, 3.3V and IOREF, and 0.00 V on VIN with nothing wired to it.

Pins: V3.0 Order First, Then the Missing Pins

Each V4.0 board starts with the pins of its V3.0 board, in V3.0's order, and then adds the pins V3.0 did not have. The pins sit where the real headers are, so they changed position:

The pins of the V4.0 boards

Board	V4.0 pins	What V4.0 adds or changes
UNO	31	The 24 V3.0 pins, then SDA, SCL, a GND by AREF, IOREF, 3.3V, VIN and a second power GND
Mega 2560, Mega 1280	85	The 74 V3.0 pins, then SCL / SDA / GND, IOREF, 3.3V, VIN, a second GND and the 2x18 header's 5V / GND pairs; the 2x18 header as one comb
Nano	30	The 26 V3.0 pins, then the second RST and GND, 3V3 and VIN; A6 / A7 are analog inputs
Pro Mini	34	The FTDI header (GRN / DTR, TXO, RXI, VCC, GND, BLK) on the left end, A4 - A7 on the right end; no AREF
Mini	33	The programming pads (IO7, TX, RX, +5V, GND) on the left end, A4 - A7 on the right end; no AREF

A6 and A7 on the Nano, Pro Mini and Mini are analog-only pins, as on the real ATmega328P in its TQFP package: use analogRead() on them, not digitalRead().

The Built-In Serial Monitor of the V4.0 Boards

This is the biggest change in V4.0, and it is a TEP addition: no real Arduino board has a monitor on it. Inside every board sits a copy of our TEP Serial Monitor Advance, wired to the board's hardware serial port the way the real USB chip is. It listens to D1 (the sketch's TX) and drives D0 (the sketch's RX) through a weak driver, as the USB chip sits behind its 1 k resistors, so a module you wire to D0 still wins.

• It opens at Run (property AUTOOPEN=YES), or when you click the board's USB port (Nano: the mini-USB socket, Pro Mini: the FTDI header, Mini: the programming pads). Proteus's Debug menu also lists it.
• Want your own terminal instead? Set MONITOR=NO on the board, and D0 / D1 are free for a Virtual Terminal or one of our TEP Serial Monitors.

Read all about the monitor itself in TEP Serial Monitor Advance for Proteus.

The Monitor in Its Simple Interface

Here is the UNO's monitor after Run, in its Simple interface: only the text, the line to send and one slim toolbar row (baud rate, follow, pause, search and clear, then the part's reference, ARD1, and 9600 8N1). Press Ctrl+Shift+U (or use the ... menu) to switch to it, and Esc to go back to the full interface with its tabs. Type a command in the send box and press Enter. The demo prints:

=== TEP Arduino UNO V4.0 - board demo (9600 baud) ===
Commands:
  HELP      this list
  LED ON    pin 13's LED on (stops the blink)
  LED OFF   pin 13's LED off
  BLINK     blink it again (1 s)
  READ      the analog pins (volts)
  PLOT ON   stream sin / cos / ramp for the Plotter tab
  PLOT OFF  stop the stream
  STATUS    LED, plot and uptime
Ready - L blinks; type a command and press Enter.

The Board Tab

The Board tab is the first tab of the full interface. It shows the board as the model sees it, live while the simulation runs. Here it is on the Mega 2560:

• The board card: the board's name (here ARDUINO MEGA 2560 R3), a RUNNING / IN RESET / BOOTLOADER pill, its LEDs as they glow on the sheet (ON, L (13), TX, RX), and a red RESET key.
• Options: "Bootloader after RESET (L flashes 3x)" and "Open this window at Run".
• Chip, Sketch, Resets and Speed: here ATmega2560 @ 16 MHz, TEP_Board_Demo_MEGA2560.hex, 1 reset and 70 % of real time.
• Digital pins: every pin, with a legend: HIGH, LOW, pull-up or input. The Mega has 54, D0 to D53.
• Analog pins: the volts and the analogRead count of every analog pin, or "open" when nothing is wired to it. The Mega shows A0 - A15 in two rows.
• Supply pins: the live voltage of each supply pin.

At the bottom, the status bar counts the bytes received and sent (here RX 3,199 and TX 13), the lines and the simulation time. The same tab on the Nano looks like this, caught while the sketch was printing:

On the Nano, each pin tile names its state. A0 - A5 say "open": nothing is wired to them, so Proteus has no node to read (the sketch reads 0). A6 and A7 are analog-only pins and show 0.00 V.

The Plotter Tab

The Plotter draws every "name:value" line the sketch prints as a live trace. Type PLOT ON in the demo, and the sketch streams three traces every 200 ms:

The toolbar picks the window and the scale, and the chips below the chart show each trace's last, minimum and maximum value. Type PLOT OFF to stop the stream.

Help and Support

The header of the full interface has a zoom control and three icons: the palette (theme), the gear (Settings) and the ?, which opens Help & Support:

• Report a bug and Suggest a feature open the Arduino board of our forum, shared by all six boards.
• Read the article, User guide and Check for updates open the board's own V4.0 post, so the UNO's monitor opens the UNO post.
• Copy diagnostics copies the details we need for a bug report.

Board Properties

Double-click a board to edit its properties. They are the same on all six boards:

Properties of the V4.0 boards (double-click the board)

Property	Meaning	Default
Upload Hex File	The sketch: a HEX, ELF or COFF file	The demo's HEX in the demo projects
Clock Frequency	The AVR model's clock (V3.0's "Clock Frequence" typo is fixed)	16MHz
BOOTLOADER	YES: after RESET, L flashes 3 times and the sketch starts 1 s later; NO: at once	YES
MONITOR	YES: the built-in serial monitor on D0 / D1; NO: D0 / D1 are free for your own terminal	YES
BAUD	The monitor's baud rate: 300 to 2000000, or AUTO (it measures the sketch's bits)	9600
AUTOOPEN	YES: the monitor window opens at Run; NO: click the USB port / programming header	YES

The AVR fuses, the EEPROM file and the trace switches are Proteus's own, hidden as in V3.0.

Run the Six Demo Projects

The zip has one ready demo project per board. Each is just the board on a sheet, running the demo sketch built for that board: nothing to wire, because the board's LEDs and its built-in monitor show everything.

Which demo is which (all in the Proteus Simulation folder)

Demo project	Board	HEX file
UNO-V4-Board-Demo.pdsprj	Arduino UNO	TEP_Board_Demo_UNO.hex
MEGA2560-V4-Board-Demo.pdsprj	Arduino Mega 2560	TEP_Board_Demo_MEGA2560.hex
MEGA1280-V4-Board-Demo.pdsprj	Arduino Mega 1280	TEP_Board_Demo_MEGA1280.hex
NANO-V4-Board-Demo.pdsprj	Arduino Nano	TEP_Board_Demo_NANO.hex
PROMINI-V4-Board-Demo.pdsprj	Arduino Pro Mini	TEP_Board_Demo_PROMINI.hex
MINI-V4-Board-Demo.pdsprj	Arduino Mini	TEP_Board_Demo_MINI.hex

1. Open the demo of your board from the Proteus Simulation folder, with the .hex files and TEPARDUINO.DLL beside it.
2. Press Run. The board powers up (ON / PWR lit on the boards that have one), the monitor opens with the sketch's start text, and L blinks once a second.
3. Type a command in the monitor and press Enter. On the boards with TX / RX LEDs, RX flashes while it arrives, TX while the sketch answers.
4. Hold the board's RESET button: the sketch stops. Release it: L flashes 3 times and the sketch starts again 1 s later.
5. Open the Board tab to watch the pins, and type PLOT ON and open the Plotter tab.

The Demo Sketch: One Sketch for All Six Boards

All six HEX files come from the same sketch, TEP_Board_Demo.ino. It uses only the Arduino core and the hardware Serial at 9600 baud. The Arduino IDE tells the sketch which board it is built for, so it can print the right name:

#if defined(ARDUINO_AVR_MEGA2560)
const char BOARD[] = "Arduino Mega 2560";
#elif defined(ARDUINO_AVR_MEGA)
const char BOARD[] = "Arduino Mega 1280";
#elif defined(ARDUINO_AVR_NANO)
const char BOARD[] = "Arduino Nano";
#elif defined(ARDUINO_AVR_PRO)
const char BOARD[] = "Arduino Pro Mini";
#elif defined(ARDUINO_AVR_MINI)
const char BOARD[] = "Arduino Mini";
#else
const char BOARD[] = "Arduino UNO";
#endif

Pin 13 drives L on every board. L toggles every 500 ms (so it blinks once a second), and a plot line goes out every 200 ms while the stream is on:

const int LED_PIN = 13;
const unsigned long BLINK_MS = 500, PLOT_PERIOD_MS = 200, LINE_TIMEOUT_MS = 100;

setup() prints the banner with the board's name, the command list and the "Ready" line you saw in the monitor:

void setup() {
  pinMode(LED_PIN, OUTPUT);
  Serial.begin(9600);
  Serial.println();
  Serial.print(F("=== TEP "));
  Serial.print(BOARD);
  Serial.println(F(" V4.0 - board demo (9600 baud) ==="));
  printHelp();
  Serial.println(F("Ready - L blinks; type a command and press Enter."));
  nextBlinkAt = millis();
}

The loop never calls delay(). It collects the typed characters into a line, and a line ends with a line ending or, with "No line ending" in the monitor, with a pause of 100 ms:

  while (Serial.available() > 0) {
    char c = Serial.read();
    lastCharAt = millis();
    if (c == '\r' || c == '\n') handleLine();
    else if (lineLength < sizeof(line) - 1) line[lineLength++] = c;
  }
  if (lineLength > 0 && millis() - lastCharAt >= LINE_TIMEOUT_MS) handleLine();   // "No line ending": a pause ends it

Then come the blink and the plot stream. The plot line has the "name:value" form the Plotter tab reads:

  if (blinking && (long)(millis() - nextBlinkAt) >= 0) {
    nextBlinkAt += BLINK_MS;
    setLed(!ledOn);
  }
  if (plotOn && (long)(millis() - nextPlotAt) >= 0) {
    nextPlotAt += PLOT_PERIOD_MS;
    float a = sample * 0.15;
    Serial.print(F("sin:"));
    Serial.print(sin(a), 3);
    Serial.print(F(",cos:"));
    Serial.print(cos(a * 0.7), 3);
    Serial.print(F(",ramp:"));
    Serial.println((sample % 40) / 20.0 - 1.0, 2);
    sample++;
  }

handleLine() trims the line, makes it upper case, echoes it and runs the command. The LED commands stop or restart the blink:

  Serial.print(F("You typed: "));
  Serial.println(line);
  if (strcmp(cmd, "HELP") == 0) {
    printHelp();
  } else if (strcmp(cmd, "LED ON") == 0) {
    blinking = false; setLed(true);
    Serial.println(F("L (pin 13) is ON"));
  } else if (strcmp(cmd, "LED OFF") == 0) {
    blinking = false; setLed(false);
    Serial.println(F("L (pin 13) is OFF"));
  } else if (strcmp(cmd, "BLINK") == 0) {
    blinking = true; nextBlinkAt = millis();
    Serial.println(F("L (pin 13) blinks again"));

READ prints every analog pin of the board. NUM_ANALOG_INPUTS comes from the board's Arduino core files: 6 on the UNO, 16 on the Megas and 8 on the Nano, Pro Mini and Mini (A6 / A7 included):

void readAnalog() {
  for (byte i = 0; i < NUM_ANALOG_INPUTS; i++) {
    int v = analogRead(A0 + i);
    Serial.print('A');
    Serial.print(i);
    Serial.print(F(": "));
    Serial.print(v);
    Serial.print(F("  ("));
    Serial.print(v * 5.0 / 1023.0, 2);
    Serial.println(F(" V)"));
  }
}

With nothing wired to the analog pins, the UNO reads 0 on every pin, so READ answers:

You typed: READ
A0: 0  (0.00 V)
A1: 0  (0.00 V)
A2: 0  (0.00 V)
A3: 0  (0.00 V)
A4: 0  (0.00 V)
A5: 0  (0.00 V)

Wire a potentiometer or a sensor to an analog pin, and READ shows its count and voltage; the Board tab shows the same pin live. STATUS builds one line from the sketch's flags and the uptime, and anything the sketch does not know gets a hint:

  } else if (strcmp(cmd, "STATUS") == 0) {
    Serial.print(F("LED "));
    Serial.print(blinking ? F("blinking") : ledOn ? F("ON") : F("OFF"));
    Serial.print(F(", plot "));
    Serial.print(plotOn ? F("ON") : F("OFF"));
    Serial.print(F(", uptime "));
    Serial.print(millis() / 1000.0, 1);
    Serial.println(F(" s"));
  } else {
    Serial.println(F("Unknown command - type HELP"));
  }

Apart from these answers, the sketch prints nothing on its own after the start, except while PLOT ON runs, so the monitor stays quiet until you type.

Demo Commands

Commands of the demo sketch (any case; Enter sends the line)

Command	What the sketch does	What you see
HELP	Prints the command list	The list in the monitor
LED ON	Stops the blink and drives pin 13 HIGH; answers "L (pin 13) is ON"	L stays lit
LED OFF	Stops the blink and drives pin 13 LOW; answers "L (pin 13) is OFF"	L stays dark
BLINK	Blinks pin 13 again; answers "L (pin 13) blinks again"	L blinks once a second
READ	Prints every analog pin: the count and the volts	A0 - A5 (UNO), A0 - A15 (Megas), A0 - A7 (Nano, Pro Mini, Mini)
PLOT ON	Streams sin / cos / ramp every 200 ms; answers "Plot stream ON - open the Plotter tab"	Three traces on the Plotter tab
PLOT OFF	Stops the stream; answers "Plot stream OFF"	The traces stop
STATUS	Prints the LED (blinking, ON or OFF), the plot (ON or OFF) and the uptime in seconds	One line
Anything else	Answers "Unknown command - type HELP"	One line

Use Your Own Sketch on a V4.0 Board

Any sketch you build in the Arduino IDE for the matching board runs on the V4.0 board. Select the board like this:

The Arduino IDE board for each V4.0 board

V4.0 board	Arduino IDE: Tools > Board	Processor
Arduino UNO	Arduino Uno	ATmega328P
Arduino Mega 2560	Arduino Mega or Mega 2560	ATmega2560 (Mega 2560)
Arduino Mega 1280	Arduino Mega or Mega 2560	ATmega1280
Arduino Nano	Arduino Nano	ATmega328P
Arduino Pro Mini	Arduino Pro or Pro Mini	ATmega328P (5V, 16 MHz)
Arduino Mini	Arduino Mini	ATmega328P

1. In the Arduino IDE, select the board and the processor from the table.
2. Choose Sketch > Export Compiled Binary. Use the .hex file without "with_bootloader" in its name.
3. Double-click the board in Proteus and set Upload Hex File to that .hex file. Press Run.

If your sketch uses Serial, the built-in monitor shows it. Set the board's BAUD to the rate of your Serial.begin(), or to AUTO. To rebuild the demo itself, open TEP_Board_Demo.ino, select the board and export it the same way, then replace the .hex file in the Proteus Simulation folder.

Want sensors and modules to wire to your board? Our Must-Have Proteus Libraries for Arduino Simulation post lists the ones we use most with Arduino.

Arduino Library for Proteus V4.0: Simulation Results

We ran the six demo projects, exactly as they are in the zip, in Proteus 8.5 in October 2026, with the built-in monitor open. Every board loaded and ran; ON / PWR lit (on the boards that have one), L blinked, and the monitor opened at Run with the banner. Board by board:

• UNO: TX / RX flashed with the serial traffic. RESET held: the chip in reset, its pins floating, L dim; released: the bootloader flashed L and the sketch restarted 1 s later. Supply pins 5.00 V / 3.30 V / 5.00 V; READ answered A0 - A5; the plot stream drew sin / cos / ramp.
• Mega 2560: TX flashed; READ answered A0 - A15 (two-way serial on D0 / D1); RESET held: the chip in reset, L dim; the Board tab showed all 54 digital and 16 analog pins; 5.00 V / 3.30 V / 5.00 V.
• Mega 1280: TX flashed; READ answered A0 - A15; RESET held: the chip in reset; the Board tab showed all 54 + 16 pins.
• Nano: TX flashed with the plot stream; RESET held: the chip in reset and L dark (straight on D13); 5.00 V / 3.30 V; A6 / A7 read as analog inputs (0.00 V unwired).
• Pro Mini: PWR lit, 13 blinking; RESET held: the chip in reset and 13 dark; VCC 5.00 V. The DTR pin is connected to the model and uses the same reset path as the Board tab's RESET, which we verified; a DTR edge itself was not driven in our Proteus run.
• Mini: L blinking; RESET held: the chip in reset and L dark; released: the bootloader flashed L and the sketch restarted 1 s later; +5V 5.00 V.

Speed: with the monitor open and the plot stream running, our PC simulated the UNO and the Mega 2560 at about 70 % of real time, the Mega 1280 and the Mini at about 62 %, and the Nano and the Pro Mini at about 80 %. Proteus's AVR model sets the pace, as with V3.0, and the Board tab shows the speed on your own PC.

Things to Know About the Real Arduino Boards

The demo sketch uses only the Arduino core, so it runs on a real board too, and the monitor commands work in the Arduino IDE's Serial Monitor (9600 baud). Besides the TX / RX LEDs (above), keep in mind:

• The 3.3V pin of a real board gives 50 - 150 mA; here it is a 3.3 V source with 0.5 ohm and no current limit.
• VIN, RAW and +9V are inputs on a real board, through its regulator; here they are loads only, and the board runs as if it was powered from USB.
• The Pro Mini and the Mini have no USB chip: on a real one, you program and talk to it through a USB-to-serial adapter on its serial pins.

Troubleshooting

• The board does not simulate, or no LED lights: TEPARDUINO.DLL is missing from the MODELS folder and from the project folder.
• No monitor window: click the USB port (Nano: the mini-USB socket, Pro Mini: the FTDI header, Mini: the programming pads), or check MONITOR=YES. Proteus's Debug menu also lists the window.
• The monitor shows nothing: the sketch's Serial.begin() and the BAUD property differ. Set BAUD to the sketch's rate, or to AUTO.
• A Virtual Terminal on D0 / D1 shows the text twice, or fights the monitor: set MONITOR=NO on the board.
• An analog tile says "open": nothing is wired to that pin, so Proteus has no node to read (the sketch reads 0).
• Your sketch waits for a pin-change interrupt and nothing happens: Proteus 8.5's AVR model did not run pin-change interrupts in our tests. Use attachInterrupt() on INT0 / INT1 (the Megas: INT0 - INT5) or digitalRead().
• Mega: a grey bar beside the 2x18 header's pins while running: Proteus draws its logic-state square on every pin, and at 50 thou apart they touch. Turn them off in System > Set Animation Options (Show Logic State of Pins) if you like.

Found a bug? Please post it in our forum with a screenshot, the monitor text, the simulation log and the monitor's Copy diagnostics text.

Limitations of the Simulation

• The microcontroller is Proteus's AVR model; our model adds the board around it (LEDs, RESET and the bootloader wait, the supply pins, the pins and the built-in monitor). It does not model the USB chip itself, the regulator or the LED physics.
• The built-in monitor, the LED glow and fade, the TX / RX shimmer and the Board tab are TEP additions; no real board has them.
• Arduino is a trademark of Arduino SA. The boards are our own drawings of the real boards.
• The HEX files contain the Arduino AVR core 1.8.6, which includes LGPL-licensed code; its source code is on GitHub. The demo sketch uses no extra Arduino library.
• Tested in Proteus 8.5 in October 2026 (the six demo projects as shipped, with the built-in monitor, and every screenshot here). Proteus 7 is not supported.

So, that was all about the Arduino Library for Proteus V4.0. I hope the working LEDs, the RESET with its bootloader and the built-in monitor make your Arduino simulations feel much closer to a real board on your desk. Pick your board, open its demo, and then try your own sketch on it. If you use the Arduino Library for Proteus V4.0 in a project, please share your feedback in the comments or in our forum, and if you have any questions, ask in the comments and I will help you out. Till the next tutorial, take care and have fun!