Arduino Mini Library for Proteus V4.0 (Mini 05 + Serial Monitor)

Hello friends, I hope you all are doing great. Today, I am going to share our new Arduino Mini Library for Proteus V4.0. The Arduino Mini is one of the smallest classic Arduino boards: the same ATmega328P at 16 MHz as the Arduino UNO, on a tiny teal board of only 30 x 18 mm, with no USB port. With this library, you place Arduino's Mini 05 in Proteus, load your sketch's HEX file and watch the board behave like the real one: its pin-13 LED follows your code, its reset button restarts the sketch through the bootloader, and its +5V pin powers the other parts of your circuit.

V4.0 is the next version of our Arduino libraries for Proteus. The Mini is one of six boards in it; this post is all about the Mini, and our Arduino Library for Proteus V4.0 post shows all six boards side by side. The Mini V4.0 also gets something the real board does not have: a built-in serial monitor, so you see what your sketch prints without wiring a Virtual Terminal. In the monitor screenshots, it runs in its compact Simple interface.

NOTICE: This library is very special to our team. We drew the Mini 05 again from the real board, gave it a working LED, a working reset button with the bootloader, a real +5V pin, and built our TEP Serial Monitor right into it. 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 Mini Library for Proteus V4.0:

What is the Arduino Mini?

The Arduino Mini is a small microcontroller board made for breadboards and for projects where space is tight. The version we drew is the Mini 05: an ATmega328P running at 16 MHz with a resonator, a voltage regulator, a reset button and one LED, on a teal board of 30 x 18 mm. Its main pins sit in two rows of 12 along the long edges, so the Mini plugs straight into a breadboard.

The Mini has no USB port and no USB-to-serial chip. You program it through a USB-to-serial adapter (Arduino made a Mini USB Adapter for it) wired to its TX, RX, +5V and GND pins. That is also why the Mini has no TX and RX LEDs, and it has no power LED either: the LED on pin 13 is its only light.

The Arduino Mini at a Glance

Arduino Mini vs Arduino Pro Mini

The Mini is often mixed up with the Arduino Pro Mini. Both are small ATmega328P boards without USB, but they are different boards, and V4.0 has both:

In our library, both are drawn 1.4 x 0.7 in. If your board is a Pro Mini, read our Arduino Pro Mini Library for Proteus V4.0 instead.

What's New in Arduino Mini Library for Proteus V4.0

Our Arduino Library for Proteus V3.0 already had a Mini. V4.0 keeps its microcontroller model and rebuilds everything around it:

• Drawn as the real Mini 05: the teal board lying lengthwise, with gold pads and the pin names printed inside the rows, the programming pads, the reset button, the ATmega328P, the resonator and the pin-13 LED.
• A working L LED on pin 13: lit while your sketch drives D13 HIGH, dark while it is LOW.
• A working reset button with the bootloader: L flashes 3 times and the sketch starts 1 s after you let go.
• A real supply pin: +5V is a 5 V source you can power other parts from, and the GND pins are tied to ground.
• A built-in serial monitor on D0 / D1, with Board, Monitor and Plotter tabs: no Virtual Terminal to wire.
• The Mini's own pins: the five programming pads on the left end and A4 - A7 on the right end. A6 and A7 are proper analog inputs now (V3.0 gave them no electrical type), and the AREF pin of V3.0 is gone, because the real Mini has none.
• "Clock Frequency": the property is spelled correctly now (V3.0 said "Clock Frequence").
• A small package: about 0.90 MB, with the Mini's demo project and its HEX file, without the C++ source code.

The microcontroller itself is still Proteus's own AVR model, the one V3.0 used. So your sketch, the HEX upload, the clock and fuse properties and Proteus's AVR debug windows work as before; the board adds what the real Mini has around the chip, plus the monitor.

Download Arduino Mini Library for Proteus V4.0

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

• README.txt: a detailed guide to the board, its pins, the monitor, the properties, real hardware and troubleshooting.
• Proteus Library Files: ArduinoV4TEP.LIB, the TEP Arduino Library V4.0 with all six boards (UNO, Mega 2560, Mega 1280, Nano, Pro Mini and Mini).
• Proteus Model Files: TEPARDUINO.DLL, the board model.
• Proteus Simulation: MINI-V4-Board-Demo.pdsprj, its sketch TEP_Board_Demo_MINI.hex and a copy of TEPARDUINO.DLL.
• Arduino Code: TEP_Board_Demo.ino, the demo sketch; it needs no extra Arduino library.

The library file holds all six boards, so once you install this zip, you have the other five boards, too. Only the demo project is the Mini's.

How to Install Arduino Mini Library for Proteus V4.0

1. Close Proteus and extract the whole zip file to a normal folder, for example your Desktop.
2. Copy ArduinoV4TEP.LIB from Proteus Library Files into the LIBRARY folder of Proteus, for example 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.
4. If an ArduinoV4TEP.IDX file is in the LIBRARY folder, delete it.
5. Start Proteus, press P (Pick Devices) and search for V4.0 or Arduino. The Mini is ARDUINO MINI V4.0, in the category Arduino > Arduino Boards.

Note: Tested in Proteus 8.5; Proteus 7 is not supported. V3.0 and V4.0 can stay installed together, because their file and device names differ. The pin positions changed, though, so a V3.0 design does not swap pin for pin: place the V4.0 Mini and wire it again.

The Arduino Mini in Proteus

We drew the board as our own clean top view of the real Mini 05, lying lengthwise in Arduino's teal: the gold pads with the pin names printed inside the two rows, the five programming pads on the left end, A4 - A7 on the right end, the reset button with its red cap, the ATmega328P, the silver resonator, the L LED with a small capacitor and a "102" resistor, and the MINI and TEP marks. Here it is while the demo runs:

Pinout

The Mini V4.0 has 33 pins. The two long rows carry 24 of them, as on the real board; the pins at the two ends stick out sideways:

Some pins appear twice, as on the real Mini: RST and GND are in both rows, and TX, RX and +5V also sit on the programming pads, so an adapter (or a terminal) can use the end of the board. IO7 is the same pin as 7, and the three GND pins are one ground. The pins that V3.0 had keep their names and their order in the part's pin list, but they sit in new places on the symbol.

The L LED

The Mini has a single LED, L, on pin 13. On the real Mini 05 it is a yellow LED (in its schematic); we made it green, like the L LED of the other five boards of V4.0. It hangs straight on D13, as on the real board, so it shows what the pin really does:

The LED lights up in steps and fades out over a few frames, like a real LED seen by the eye; that is a drawing choice of ours, not a measured LED. On the UNO and the Mega 2560, L sits behind an op-amp buffer and glows dimly while D13 floats. The Mini, like the Nano and the Pro Mini, has no such buffer, so its L is simply dark then.

There are no TX and RX LEDs: on the boards that have them, the USB chip drives them, and the Mini has no USB chip. You still see the serial traffic: the built-in monitor counts the bytes both ways in its status bar.

Supply Pins

+5V and GND are real supply pins in the simulation:

• +5V (in the top row and on the programming pads) is a 5 V source with 0.1 ohm, so you can power LEDs, sensors and modules from it. The Board tab shows its voltage: 5.00 V in our run.
• GND (three pins) is tied to ground.
• +9V is only a load (1 Mohm) here. On a real Mini, it feeds the voltage regulator; in the simulation, the board runs as if it had a clean 5 V supply, so you do not need to wire anything to it.

There is no 3.3 V pin: the real Mini has none either.

The Reset Button and the Bootloader

The real Mini 05 has a small reset button, and so does ours. It works like the real one:

• Click and hold it: the chip is held in reset. The cap sinks in (it turns darker and loses its shine), the sketch stops and L goes dark.
• Let go: the bootloader runs. L flashes 3 times in 62.5 ms steps (D13 really toggles), and your sketch starts again 1 s after the release, the way a real board waits for an upload after a reset.
• BOOTLOADER=NO skips the wait: the sketch starts at once. A power-on (pressing Run) always starts the sketch at once.

The monitor's Board tab has a RESET key, too: it gives a 20 ms press, followed by the bootloader. In our Proteus run, holding the button kept the chip in reset with L dark; after the release, the model's log showed the bootloader flashing L and the sketch starting again 1 s later.

Component Properties

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

Run the Arduino Mini Demo in Proteus

Open MINI-V4-Board-Demo.pdsprj from the Proteus Simulation folder, with TEP_Board_Demo_MINI.hex and TEPARDUINO.DLL beside it. There is nothing to wire: the demo is the Mini on its own, and its LED and the built-in monitor show everything.

1. Press Run. The monitor window opens with the sketch's start-up text, and L blinks once a second.
2. Type a command in the send box and press Enter (the line ending is Newline).
3. Hold the reset button, then let go, and watch L flash 3 times before the sketch starts again.

Start-Up

=== TEP Arduino Mini 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 banner names the board: the one demo sketch is built for each of the six boards, and the Arduino IDE tells it which one (you will see how below). Nothing else is printed until you type a command.

The Demo Commands

Every answer starts with "You typed: ..." and your line. Upper or lower case and extra spaces do not matter, and anything else gets "Unknown command - type HELP".

READ: The Eight Analog Inputs

READ
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)
A6: 0  (0.00 V)
A7: 0  (0.00 V)

The Mini answers with all eight analog inputs, A0 to A7, because the Arduino core gives this board eight analog pins. Nothing is wired to them in the demo, so each one reads 0. Wire a potentiometer or a sensor to an analog pin (and power it from +5V), and READ shows its count and its voltage.

The Built-In Serial Monitor (a TEP Addition)

The real Mini has no serial monitor of its own: you would watch it through an adapter and the Arduino IDE. Our Mini V4.0 has a copy of our TEP Serial Monitor Advance for Proteus built in, wired inside the board to its hardware serial port. It listens to D1 (the sketch's TX) and drives D0 (the sketch's RX) through a weak driver, so a module you wire to D0 still wins.

• Opening it: it opens at Run (AUTOOPEN=YES). If you close it, click the programming pads on the left end of the board; Proteus's Debug menu lists the window, too.
• Three tabs: Board, Monitor and Plotter.
• Two interfaces: the full one with the tabs, and the compact Simple interface with only the text and the send box.
• Your own terminal instead: set MONITOR=NO, and D0 / D1 are free for a Virtual Terminal or a separate TEP Serial Monitor.

The Board Tab

The Board tab is the first tab. The header shows TEP, Arduino Mini, V4.0 and ARD1 with 9600 8N1; below it:

• ARDUINO MINI 05 with a RUNNING pill (it also says IN RESET or BOOTLOADER) and the board's L (13) LED, glowing as it does on the sheet (dark in this shot).
• A red RESET key (a 20 ms press plus the bootloader) and two options: Bootloader after RESET (L flashes 3x) and Open this window at Run.
• Chip ATmega328P @ 16 MHz, Sketch TEP_Board_Demo_MINI.hex, Resets 1 and Speed 62 % of real time.
• DIGITAL PINS: D0 - D13, each with its state: D0 pull-up and D1 HIGH (the serial lines), D2 - D12 input (the demo does not use them) and D13 LOW, in the dark half of the blink.
• ANALOG PINS: the volts and the analogRead count. A0 - A5 say "open": nothing is wired to them, so Proteus has no node to read (the sketch reads 0). A6 and A7, the analog-only inputs, show 0.00 V and 0.
• SUPPLY PINS: +5V 5.00 V and +9V 0.00 V (+9V is only a load here).

The status bar at the bottom shows Running, 9600 8N1, the bytes received from the Mini (RX 2,921) and sent to it (TX 13), No errors, the line count and the simulation time (t = 37.330 s). The speed is set by Proteus's AVR model, as with V3.0: about 62 % of real time on our PC, with the monitor open and the plot stream running.

The Monitor Tab and the Simple Interface

The Monitor tab is the serial text both ways: a line to send (Enter), the line endings, the baud rate and format, ASCII or HEX, time stamps, search and save. The up and down keys bring back the lines you sent before.

The two monitor screenshots above show the Simple interface. It keeps only the text, the send box with the line ending and Send, and one slim row on top: the baud rate, follow, pause, search and clear, the board's name with 9600 8N1, and the window buttons.

• Switch to it: press Ctrl+Shift+U, or choose it in the ... menu.
• Back to the full interface: press Esc, or click the expand arrows at the top right.

The Plotter Tab

Type PLOT ON, and the sketch prints a line like sin:0.794,cos:0.322,ramp:-0.60 every 200 ms. The Plotter tab turns every name:value line into live traces:

The legend at the top names the three traces; the chips below the plot show each one's last, minimum and maximum value (sin: last 0.794, min -0.998, max 0.997; the ramp runs from -1 to 0.95). Last 500 samples and Auto scale set the window and the scale, and the buttons on the right pause or clear the plot. Type PLOT OFF to stop the stream.

Help & Support

The ? icon at the top opens Help & Support, with eight cards: report a bug and suggest a feature (both go to our forum), read the article and the user guide (both open this post), check for updates, support / donate, our website and the community forum. The palette and gear icons beside it open the colour themes and the Settings.

Copy diagnostics copies the monitor's diagnostics text: please add it to a bug report, with a screenshot, the monitor text and the simulation log. A links.ini file next to the DLL can change the links. The monitor's own post, linked above, shows all of its features in detail.

Use Your Own Sketch with the Arduino Mini in Proteus

1. In the Arduino IDE, select the board Arduino Mini (Tools > Board) and the processor ATmega328P (Tools > Processor).
2. Choose Sketch > Export Compiled Binary. It makes two HEX files: use the one without "with_bootloader" in its name.
3. In Proteus, double-click the Mini and set Upload Hex File to that file. Press Run.

Use Serial.begin(9600), or set the board's BAUD property to your sketch's rate (or AUTO), and the built-in monitor shows your text. If your circuit needs D0 / D1 for something else, set MONITOR=NO.

Inside the Demo Sketch

The demo is one sketch for all six boards. The Arduino IDE defines a macro for the board you select, and the sketch takes the board's name from it; for the Mini, the macro is ARDUINO_AVR_MINI:

#elif defined(ARDUINO_AVR_MINI)
const char BOARD[] = "Arduino Mini";

The LED pin and the timing:

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

setup() prints the banner and the command list you saw at start-up:

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; Enter, or a 100 ms pause with "No line ending", hands the line to handleLine():

  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

The heartbeat: L toggles every 500 ms, so it blinks once a second:

  if (blinking && (long)(millis() - nextBlinkAt) >= 0) {
    nextBlinkAt += BLINK_MS;
    setLed(!ledOn);
  }

LED ON stops the heartbeat and switches L on:

  } else if (strcmp(cmd, "LED ON") == 0) {
    blinking = false; setLed(true);
    Serial.println(F("L (pin 13) is ON"));

READ loops over NUM_ANALOG_INPUTS pins, which is 8 on the Mini, so it prints A0 to A7:

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)"));
  }
}

And PLOT ON prints the name:value lines for the Plotter tab:

  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++;
  }

The sketch uses only the Arduino core, so it runs on a real Mini, too. To change it, edit the .ino, export a new HEX file and load it into the board.

Things to Know Before Using a Real Arduino Mini

• Programming: the real Mini has no USB. Wire a USB-to-serial adapter to TX, RX, +5V and GND, crossed over: the adapter's TX goes to the Mini's RX, and its RX to the Mini's TX. If the adapter does not reset the board for you, press the Mini's reset button just as the upload starts.
• Power: feed the regulator on +9V, or a regulated 5 V on +5V. Arduino's own guide warns against more than 9 V and against reversed power: either one can kill the board.
• The L LED is yellow on the real Mini 05 and hangs on pin 13, too, so the demo blinks it the same way.
• The bootloader: after a reset, a real board waits about a second for an upload before the sketch starts; a power-on starts the sketch at once. The model does the same. Its 3 flashes of L are the habit of the optiboot bootloader on the UNO and the Nano; we show them on every board, so you can see the bootloader run.
• The serial monitor with its Board and Plotter tabs is our addition, not part of the real board. On real hardware, use the Arduino IDE's Serial Monitor through the adapter.
• A6 and A7 are analog only, on the real chip as in the model: read them with analogRead(), not digitalRead().
• The size: the real Mini 05 is 30 x 18 mm (about 1.2 x 0.7 in). We drew it 1.4 in long, because the programming pads and A4 - A7 need their own columns in the symbol.

Troubleshooting

• The board does not simulate, or L never lights: TEPARDUINO.DLL is missing from MODELS and from the project folder.
• No monitor window: click the programming pads on the left end of the board, or check MONITOR=YES; Proteus's Debug menu lists the window, too.
• The monitor shows nothing: the sketch's Serial.begin() and BAUD differ. Set BAUD to the sketch's rate, or 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).
• The sketch starts 1 s late after a reset: that is the bootloader, as on a real board; set BOOTLOADER=NO to skip it.
• 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 D2 (INT0) or D3 (INT1), or digitalRead().
• A V3.0 design does not line up: V4.0 moved the pins (and dropped the AREF pin). Place the V4.0 Mini and wire it again.

Limitations of the Simulation

• Modelled: the L LED on D13 (with the faint INPUT_PULLUP glow), the reset button with the bootloader wait, the +5V source and the GND pins, and the built-in serial monitor on D0 / D1.
• Not modelled: the voltage regulator (+9V is only a load) and any current limit on +5V. The microcontroller is Proteus's own AVR model, which also sets the simulation speed, as with V3.0.
• The glow and fade of L and the whole serial monitor are our additions. The board is our own drawing of the Mini 05, not an Arduino product; Arduino is a trademark of Arduino SA. The HEX file contains the Arduino AVR core 1.8.6, which includes LGPL-licensed code; its source code is on GitHub.
• Tested in Proteus 8.5 in October 2026, with the demo project as shipped and the built-in monitor: L blinking; RESET held, the chip in reset and L dark; after the release, the model's log showed the bootloader flashing L and the sketch restarting 1 s later; +5V at 5.00 V; about 62 % of real time on our PC with the monitor open and the plot stream running. Our library generator also checks the board: no parts or texts overlap, every text sits on the board, the LED and RESET regions are clear, and the pin positions and the V3.0 pin order are right; the demo project is read back after it is written. Proteus 7 is not supported.

So, that was all about the Arduino Mini Library for Proteus V4.0. I hope the working L LED, the reset button with its bootloader and the built-in serial monitor make the little Mini 05 easy to try before you wire a real one. If you use the Arduino Mini 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!