Hello friends, I hope you all are doing great. Today, I am going to share the nRF54LM20 DK Library for Proteus, so you can run a Bluetooth LE simulation of Nordic Semiconductor's nRF54LM20 development kit. The nRF54LM20 is a member of the new nRF54L series: an Arm Cortex-M33 with a RISC-V coprocessor, Bluetooth LE, 802.15.4 for Thread and high-speed USB, with many GPIOs for bigger designs. With this library the kit runs your Arduino sketch in Proteus 8.5, uses its GPIO headers for sensors, lights its LEDs, reads its buttons and talks to a phone over Bluetooth LE.

Figure: The nRF54LM20 DK pedestrian crossing running in the Proteus simulation: green, yellow, walk, the countdown and the night mode.
Updates

nRF54LM20 DK Library for Proteus

Latest version: V1.0 (November 2026, this tutorial)

Other new Arduino boards: UNO R4 WiFi · Nano ESP32 · UNO WiFi Rev2 · Nano 33 IoT · UNO Q · UNO R4 Minima · Nano Every · MKR WiFi 1010 · Nano RP2040 Connect · STM32 Black Pill · Nucleo-F401RE · STM32 Blue Pill · Teensy 4.1 · Arduino Due · Arduino Leonardo · Arduino Micro · BBC micro:bit V2 · GIGA R1 WiFi · MKR WAN 1310 · Nano 33 BLE Sense · XIAO nRF52840 Sense · RAK4631 WisBlock · Nano Matter · nRF52840 DK · nRF5340 DK · nRF9151 DK · nRF7002 DK · Nordic Thingy:53 · xG24 Dev Kit · xG24 Explorer Kit · Thunderboard BG22 · SiWx917 Dev Kit · B-L475E-IOT01A · NUCLEO-WB55RG · NUCLEO-WL55JC1 · NUCLEO-H743ZI2 · SAM R21 Xplained Pro · FRDM-MCXN947 · Portenta H7 · LP-CC2652R7 · PSoC 6 WiFi-BT · Feather nRF52840 · Thingy:91 X · xG26 Dev Kit · nRF52 DK · nRF52833 DK · nRF52840 Dongle · nRF5340 Audio DK · nRF54H20 DK

RF modules: nRF24L01 · nRF24L01 PA LNA · CC1101 · RFM69HCW · HC-12 · 433MHz RF · XBee

Temperature and weather sensors: DHT11 / DHT22 · DS18B20 · BME280 · BMP280 · SHT31 · AHT20 · BME680 · MLX90614 · MAX6675

Helping Tools

For the demo we built a Bluetooth pedestrian crossing. Three 5 mm LEDs are the cars' traffic light, the kit's BUTTON0 is the pedestrians' request, its four LEDs count the walk time down while a buzzer ticks, and a phone follows every step.

NOTICE: Proteus has no nRF54LM20 model, so our team has put a lot of effort into building this board ourselves: the GPIOs, the LEDs, the buttons and Bluetooth LE are all our own model, and your sketch compiles with our free TEP Boards for Proteus add-on. Your feedback is the fuel that keeps us going, so please tell us what you think in the comments below. And if our free libraries help you, you can buy us a coffee. So, let's get started with the nRF54LM20 DK Library for Proteus:

Figure: The nRF54LM20 DK Library for Proteus: the pedestrian crossing at WALK.

What is the nRF54LM20 DK?

The nRF54LM20 DK (PCA10184) is Nordic Semiconductor's development kit for the nRF54LM20. The "M" chips of the nRF54L series add more memory, more GPIOs and a high-speed USB port to the line, for products such as keyboards, mice, game controllers and gateways. The kit carries the chip with its antenna, an interface MCU that programs and debugs it over USB, the chip's own USB port, an external SPI flash, four buttons, four green LEDs and pin headers for its GPIO ports.

The real nRF54LM20 DK and the library
PartThe real nRF54LM20 DKIn the library
SoCnRF54LM20: Cortex-M33 with a RISC-V coprocessoryour Arduino sketch
RadioBluetooth LE, 802.15.4 (Thread)ArduinoBLE
LEDsLED0 to LED3 on P1.22, P1.25, P1.27, P1.28, active HIGHLED0 to LED3
ButtonsBUTTON0 to BUTTON3 on P1.26, P1.09, P1.08, P0.05BUTTON0 to BUTTON3
HeadersGPIO ports P0 to P332 GPIOs by their port names
USBinterface MCU; high-speed USB on the chipthe serial monitor; drawn

A Kit Without an Arduino Header

Like the other nRF54L kits, the nRF54LM20 DK does not copy the Arduino Uno layout. Its GPIOs come out on headers grouped by port, and the pins are named after the chip's ports: P1.04, P2.01, P3.00 and so on. Our library does the same: the part's pins carry those names, and in your sketch you write P3_00 for P3.00. The 32 GPIOs are the ones Zephyr's board files for the kit describe: the expansion header, the LEDs, the buttons and the UART30 port.

Buttons and LEDs on GPIOs

The LEDs and buttons are ordinary GPIOs on the headers, so they appear on the part as well. The LEDs light when the pin is HIGH and the buttons read LOW while pressed. Note the numbering: on the nRF54L kits Nordic counts from zero - LED0 to LED3, BUTTON0 to BUTTON3.

Our Choices for the Arduino Buses

Arduino sketches expect fixed pins for Serial1, I2C, SPI and the analog inputs. For Serial1 we use the kit's own UART30 pins, P0.06 for TX and P0.07 for RX. For the rest we picked pins from the expansion header: SDA and SCL on P1.02 and P1.03, A0 to A3 on P1.04 to P1.07, and SPI on P2.01, P2.02, P2.04 and P2.05. The README lists them all.

Where Is It Used?

The nRF54LM20 targets Bluetooth products with many inputs or a wired USB link: keyboards and mice, game controllers, remote controls, USB dongles and smart home hubs. Its high-speed USB port also makes it a good bridge between a PC and a Bluetooth or Thread network.

A simulation lets you try the whole design before the kit is on the desk: the sensor, the buttons, the LEDs and the Bluetooth service. When the sketch works in the Proteus simulation, the real kit only has to confirm it.

Features of the nRF54LM20 DK Library for Proteus

  • The board as it looks: the blue kit with the nRF54LM20 and its antenna, the interface MCU with its USB-C port, the SoC's own USB port, the external flash, the power switch, RESET, the four buttons, the four LEDs and the P0 to P3 headers, drawn compact, with our small TEP signature.
  • Your sketch: a .hex for "Nordic nRF54LM20 DK (TEP Proteus)" with the 32 GPIOs by name, LED0 to LED3 and BUTTON0 to BUTTON3.
  • Sensors on the headers: digital I/O, analogRead, PWM, interrupts, pulse timing, Serial1, Wire and SPI.
  • Bluetooth LE: ArduinoBLE, with our phone as the central.
  • A complete package: about 4.4 MB with the part, the add-on, the LEDs, the buzzer, the resistors, the phone and the demo, without the source code of the models.

The nRF54LM20 DK in Proteus Simulation

Figure: The part as the library draws it, with our small TEP signature.

Search NRF54LM20 in Pick Devices; the device NRF54LM20 DK is in TEPNRF54LM20DK.LIB (Microprocessor ICs, Bluetooth Boards), with the prefix U. The USB-C port opens the serial monitor.

Figure: U1 in the demo, before Run: P3.00 to P3.03 go down to the labels.

The Pins

The pins in the library
PinsWhat the library does with them
P0.03, P0.04, P1.13, P3.00 to P3.06GPIO, PWM, interrupt, pulse timing
P0.06, P0.07Serial1 TX and RX (the kit's UART30), or GPIO
P1.02, P1.03Wire SDA and SCL, or GPIO
P1.04 to P1.07A0 to A3: analogRead 0 to 1023, or GPIO
P2.00 to P2.05GPIO; SPI on P2.01, P2.02, P2.04, P2.05
P1.22, P1.25, P1.27, P1.28LED0 to LED3, lit when HIGH
P1.26, P1.09, P1.08, P0.05BUTTON0 to BUTTON3, LOW when pressed

Download nRF54LM20 DK Library for Proteus

Click the button below to download nRF54LM20-DK-Library-for-Proteus-v1.0.zip (about 4.4 MB, without the source code of the models):

nRF54LM20 DK Library for Proteus V1.0
  • README.txt: installation, the demo, the pins, the properties, troubleshooting and the limits.
  • Proteus Library Files: TEPNRF54LM20DK.LIB, the LEDs, the buzzer and the resistors (TEPLED5MM.LIB, TEPPASSIVE.LIB, TEPRESISTOR.LIB) and the phone and laptop.
  • Proteus Model Files: TEPNET.DLL, TEPLED5MM.DLL, TEPPASSIVE.DLL and TEPRESISTOR.DLL.
  • Arduino Code: the demo sketch and the TEP Boards for Proteus add-on 1.86.0, with ArduinoBLE.
  • Proteus Simulation: the demo project, its HEX file and copies of the DLLs.

No Proteus yet? Read How to Download and Install Proteus 7 and 8. New to libraries? Follow How to Install a New Library in Proteus.

How to Install nRF54LM20 DK Library for Proteus

  1. Close Proteus and extract the whole zip file, for example to your Desktop.
  2. Copy the files from Proteus Library Files into the LIBRARY folder of Proteus.
  3. Copy the DLLs from Proteus Model Files into the MODELS folder, replacing an older TEPNET.DLL.
  4. Delete TEPNRF54LM20DK.IDX from the LIBRARY folder if it is there.
  5. For your own sketches, copy Arduino Code\TEP Boards for Proteus\hardware into your Arduino sketchbook (Documents\Arduino) and restart the Arduino IDE; the board is Nordic nRF54LM20 DK (TEP Proteus).
  6. Start Proteus, press P and search for NRF54LM20.

Demo: a Bluetooth Pedestrian Crossing in Simulation

A push-button crossing is a small state machine everyone knows: the cars have green until somebody presses the button, then the light goes through yellow to red, the walk signal comes on, and a ticking sound tells blind pedestrians that it is safe to cross. Ours runs on the kit, uses its buttons and LEDs, and reports to a phone over Bluetooth LE.

Open nRF54LM20-DK-BLE-Pedestrian-Crossing.pdsprj. U1 runs DK54LM_BLE_Crossing.hex; the cars' light is three of our 5mm LED Library for Proteus - D1 RED on P3.00, D2 YELLOW on P3.01, D3 GREEN on P3.02, each through a 220 ohm resistor; BZ1 is our Passive Buzzer Library for Proteus on P3.03; MOB1 is our Mobile WiFi Monitor, the phone.

Figure: The whole demo: the cars' light, the buzzer, the nRF54LM20 DK and the phone.
The crossing
StateCarsPedestriansHow long
CARS GOGREENwait (LED0 to LED3 off)until a request, at least 4 s
YELLOWYELLOWwait2 s
WALKREDLED0 to LED3 count down, the buzzer ticks8 s
CLEARINGREDoff1 s
NIGHTYELLOW flashingrequests waitBUTTON1 on / off

The States

The crossing is always in exactly one state, and each state has a name for the monitor and the phone:

enum State { CARS_GO, CARS_YELLOW, WALK, CLEARING, NIGHT };
const char *const STATE_NAMES[] = {"CARS GO", "YELLOW", "WALK", "CLEARING", "NIGHT"};

Entering a State

enter() sets the lights for the new state, remembers when it started and tells the phone. Entering WALK also counts the crossing and clears the request:

void enter(State s) {
  state = s;
  since = millis();
  nextTick = 0;
  if (s == CARS_GO) { lights(0, 0, 1); walkBar(0); }
  else if (s == CARS_YELLOW) lights(0, 1, 0);
  else if (s == WALK) { lights(1, 0, 0); walkBar(4); waiting = false; waitingChar.writeValue(0); crossings++; crossingsChar.writeValue(crossings); }
  else if (s == CLEARING) { lights(1, 0, 0); walkBar(0); }
  else { lights(0, 1, 0); walkBar(0); }
  stateChar.writeValue(STATE_NAMES[s]);
  Serial.print(F(">> ")); Serial.print(STATE_NAMES[s]);
  if (s == WALK) { Serial.print(F(" (crossing ")); Serial.print(crossings); Serial.print(')'); }
  Serial.println();
}

A Request

BUTTON0 calls request(). A second press, or a press while people are already walking, changes nothing:

void request() {
  if (waiting || state == WALK || state == CLEARING) return;
  waiting = true;
  waitingChar.writeValue(1);
  Serial.println(state == NIGHT ? F("Request (night mode: it waits)") : F("Request: the pedestrians are waiting"));
}

The Steps

run() is called from the loop over and over. It moves to the next state when the time is up, counts the walk time down on the four LEDs and ticks the buzzer - once a second, then four times a second in the last 2 s:

void run() {                                                // the crossing's steps
  const unsigned long t = millis() - since;
  if (state == CARS_GO && waiting && t >= MIN_GREEN) enter(CARS_YELLOW);
  else if (state == CARS_YELLOW && t >= YELLOW_MS) enter(WALK);
  else if (state == WALK) {
    if (t >= WALK_MS) { enter(CLEARING); return; }
    walkBar(4 - t * 4 / WALK_MS);                           // the countdown: 4 LEDs, one off every 2 s
    const unsigned long gap = t >= WALK_MS - 2000 ? 250 : 1000;   // the ticks: once a second, 4 a second at the end
    if (millis() >= nextTick) { nextTick = millis() + gap; tone(BUZZ, 2400, 40); }
  }
  else if (state == CLEARING && t >= CLEAR_MS) enter(CARS_GO);
  else if (state == NIGHT && millis() >= nextTick) { nextTick = millis() + 500; blink = !blink; lights(0, blink, 0); }
}

The Bluetooth Service

Three characteristics carry the state, the number of crossings and a waiting request, each with a readable 0x2901 name for the phone:

BLEService crossingService("19B100D0-E8F2-537E-4F6C-D104768A1214");
BLEStringCharacteristic stateChar("19B100D1-E8F2-537E-4F6C-D104768A1214", BLERead | BLENotify, 12);
BLEIntCharacteristic crossingsChar("19B100D2-E8F2-537E-4F6C-D104768A1214", BLERead | BLENotify);
BLEByteCharacteristic waitingChar("19B100D3-E8F2-537E-4F6C-D104768A1214", BLERead | BLENotify);

Run the Simulation

Press Run. The serial monitor - the same window as our TEP Serial Monitor Advance for Proteus - shows the name the kit advertises, and the cars get green:

nRF54LM20 DK Bluetooth Pedestrian Crossing - The Engineering Projects
Advertising as "nRF54LM20 Crossing"   BUTTON0 = request, BUTTON1 = night mode
>> CARS GO
Figure: The serial monitor at the start.
Figure: CARS GO: the green LED.

Connect the Phone

On the phone open the Bluetooth app, press SCAN and connect to "nRF54LM20 Crossing":

Figure: The phone's scan.
Figure: The phone: CARS GO.

Press the Button

Click BUTTON0. The cars have had their 4 s of green, so the light turns yellow at once, and 2 s later red:

Figure: YELLOW.

Walk

Red for the cars, and the pedestrians walk: all four of the kit's LEDs light and the buzzer ticks. Here is the complete circuit while the simulation runs:

Figure: WALK: the countdown starts with all four LEDs.
Figure: The complete circuit running in the Proteus workspace.
Figure: The phone: WALK.

The Countdown

Every 2 s one LED goes out; in the last 2 s the buzzer ticks faster. Then CLEARING for 1 s, and the cars get green again:

Figure: The countdown: two LEDs left.
Figure: The phone: CARS GO, one crossing.

Night Mode

Click BUTTON1: NIGHT, the yellow LED flashes and a request waits. BUTTON1 again ends the night mode:

Figure: NIGHT: the yellow LED flashes.
Phone connected
Request: the pedestrians are waiting
>> YELLOW
>> WALK (crossing 1)
>> CLEARING
>> CARS GO
>> NIGHT
Request (night mode: it waits)
Night mode off
>> CARS GO
Figure: The serial monitor after the run.

Why a State Machine?

A crossing written with delay() would be blind while it waits: no buttons, no Bluetooth, no ticking. As a state machine, every pass of the loop asks one question - is it time for the next state? - and the rest of the time the kit is free. The same pattern runs washing machines, lifts and vending machines.

The Sound for Blind Pedestrians

Many countries add an accessible signal to crossings: a slow tick while pedestrians wait or walk and a faster one when the time is nearly up, often with a vibrating arrow on the button. Our buzzer ticks once a second during WALK and four times a second in the last 2 s. tone() with a duration makes each tick without stopping the loop.

Why a Minimum Green?

Without a minimum green, a pedestrian pressing the button again and again could stop the traffic every few seconds. Real controllers give the main road a minimum green time - often 20 s or more; the demo uses 4 s so the simulation stays short.

How Long Should the Walk Phase Be?

Traffic engineers size the walk phase from the width of the road and a walking speed. A common design speed is about 1.2 m/s; slower values are used near schools, hospitals and homes for the elderly. A 10 m road at 1.2 m/s needs a little over 8 s, plus a few seconds for people to notice the signal and step off the kerb. That is why the demo gives WALK 8 s and then a short CLEARING phase in which nobody gets green: anybody still on the road has time to reach the other side before the cars move.

Reading the Buttons Safely

A real push button bounces: for a few milliseconds its contacts open and close many times, and a fast loop could read one press as several. The sketch reacts only to the change from HIGH to LOW, and a request that is already waiting ignores further presses, so a bouncing BUTTON0 does no harm. BUTTON1 toggles the night mode, so on a real board it needs a short debounce time - accept a new press only 30 to 50 ms after the last change. In the Proteus simulation the kit's buttons are clean.

What the Phone Sees

The phone is a Bluetooth LE central: it scans, finds the advertised name and connects. Each characteristic is a small value with a UUID; the phone reads it once and then gets a notification whenever the kit writes a new value. That is how the state, the number of crossings and the waiting flag change on the phone the moment they change on the kit, without the phone asking again and again.

Resistors for the LEDs

A 5 mm LED drops about 2 V; with a 3.3 V pin and 220 ohm the current is about 6 mA - bright enough on a desk and gentle on the pin. The buzzer gets 100 ohm. Our LED and resistor libraries show the current and the brightness in their pop-ups.

The nRF54L Series

Nordic's nRF54L chips are the successors of the nRF52 family: a faster Cortex-M33, a RISC-V coprocessor for real-time jobs, a newer radio and lower power. The nRF54LM20 is the version with the most memory and I/O and a high-speed USB port. Its multicore cousin with even more processing power is the nRF54H20 - see our nRF54H20 DK Library for Proteus.

Try It Yourself

  • Make the walk time longer when the button is held down (for slower pedestrians).
  • Blink the green LED for 2 s before the yellow.
  • Count the requests that came during the night mode and send the count to the phone.
  • Add a writable characteristic so the phone can press the button.

Ideas to Extend the Crossing

  • Add a second crossing on the P2 header for a crossroads.
  • Use a PIR sensor to start the walk phase for people who forget the button.
  • Show a countdown in seconds on a 7-segment display.
  • Log every crossing with a time stamp on the phone.

Your Own Sketches

Write the sketch in the Arduino IDE with the board Nordic nRF54LM20 DK (TEP Proteus), use Sketch > Export Compiled Binary and set the part's PROGRAM property to the .hex.

Moving to a Real nRF54LM20 DK

  1. Install Nordic's nRF Connect SDK with the board nrf54lm20dk/nrf54lm20a/cpuapp.
  2. Wire three LEDs with their resistors and a small buzzer (through a transistor) to free GPIOs on the headers.
  3. Start from Nordic's Bluetooth peripheral samples and Zephyr's GPIO and PWM APIs.
  4. Move the logic of the demo across: the states, the request, the countdown and the service.
  5. Program the kit through the interface MCU's USB and test with a phone app.

The pins, the states and the Bluetooth service stay the same; on the real kit Nordic's SDK takes the place of the Arduino calls.

Things to Know Before Using a Real nRF54LM20 DK

  • Low-voltage GPIOs: check the voltage of the port you use before connecting a module.
  • Active-HIGH LEDs: HIGH switches an LED on.
  • Two USB ports: one for the interface MCU, one for the chip itself.
  • Buzzers: drive a buzzer through a transistor; a pin alone gives only a few milliamps.

Properties of the nRF54LM20 DK

Double-click the kit to change them
PropertyWhat it does
PROGRAMthe sketch: a .hex from TEP Boards for Proteus (board "Nordic nRF54LM20 DK")
MONITOR, BAUD, AUTOOPENthe built-in serial monitor: on, its baud rate (115200), open at Run

Troubleshooting

  • The phone finds nothing: call BLE.begin(), set a local name and BLE.advertise(); call BLE.poll() in loop().
  • An LED stays dark: each 5 mm LED needs its resistor and its cathode (K) to ground; the pins are P3.00 to P3.02.
  • A button does nothing: use pinMode(BUTTONx, INPUT_PULLUP) and act when digitalRead() is LOW.
  • A kit LED stays dark: the nRF54LM20 DK's LEDs light when the pin is HIGH.
  • A number goes wrong above 32767: int is 16 bits in the simulation - use long.

Limitations of the Simulation

  • Bluetooth LE: the kit is a peripheral only, with one phone as the central.
  • 802.15.4 / Thread, the RISC-V coprocessor, the SoC's USB port and the external flash are drawn, not modelled.
  • Your sketch gets 8 KB of RAM in the simulation, and int is 16 bits there.
  • nRF54LM20 and Nordic Semiconductor are names of Nordic Semiconductor ASA and Arduino of Arduino, and the Bluetooth word mark belongs to Bluetooth SIG; this library is not made or endorsed by them or by Labcenter.
  • Tested in Proteus 8.5 in November 2026 (the demo as shipped, about 48 s of simulation). Proteus 7 is not supported.

So, that was all about the nRF54LM20 DK Library for Proteus. I hope it helps you try your Bluetooth ideas in a simulation before the kit is on your desk - the LEDs, the buzzer, the buttons and the phone, all on one sheet. If you have any questions, ask in the comments and I will help you out. Till the next tutorial, take care and have fun!