Project Files of SX1262 LoRa Library for Proteus V1.1 (E22 + Arduino Mega)

SX1262 LoRa MODULE (Semtech SX1262, 150-960 MHz, +22 dBm - Ebyte E22-900M22S style) LIBRARY FOR PROTEUS - V1.1
Designed by The Engineering Projects
www.TheEngineeringProjects.com

IMPORTANT LINKS
Article (read it first - pictures, step by step, every feature explained):
  https://www.theengineeringprojects.com/2026/09/sx1262-lora-proteus-library.html
Report a bug or suggest a feature (our forum):
  https://www.theengineeringprojects.com/forum/category/sx1262-proteus-library
The demo uses our TEP Serial Monitor Advance (included) instead of Proteus's
Virtual Terminal - its own article:
  https://www.theengineeringprojects.com/2026/10/serial-monitor-advance-proteus-library.html
Support us (the libraries are free):
  https://www.theengineeringprojects.com/donate

FILE STRUCTURE
SX1262-TEP-v1.1/
|-- Proteus Library Files/
|   |-- ArduinoV3TEP.IDX                              0.8 KB   its index -> LIBRARY folder
|   |-- ArduinoV3TEP.LIB                             95.6 KB   TEP Arduino Mega 2560 (demo) -> LIBRARY folder
|   |-- TEPSERIALMON.LIB                             11.1 KB   TEP Serial Monitor Advance -> LIBRARY folder
|   |-- TEPSX1262.LIB                                86.1 KB   SX1262 Simple + Advance (2 devices) -> LIBRARY
|-- Proteus Model Files/
|   |-- TEPSERIALMON.DLL                            978.0 KB   Serial Monitor model -> MODELS folder
|   |-- TEPSX1278.DLL                               374.0 KB   LoRa family model (all TEP LoRa libraries) -> MODELS
|-- Proteus Simulation/
|   |-- SX1262_Receiver.hex                         139.5 KB   Mega 2560 2 (receiver v1.1)
|   |-- SX1262_Sender.hex                           142.1 KB   Mega 2560 1 (sender v1.1)
|   |-- SX1262-ArduinoMega2560.pdsprj                19.2 KB   demo: Mega 2560 1 + SX1262 Simple, Mega 2560 2 + Advance
|   |-- TEPSERIALMON.DLL                            978.0 KB   copy of the monitor model
|   |-- TEPSX1278.DLL                               374.0 KB   copy of the model so the demo runs as is
|-- Arduino Code/
|   |-- SX1262_Receiver/SX1262_Receiver.ino           9.4 KB   sketch (source of the .hex)
|   |-- SX1262_Sender/SX1262_Sender.ino              10.3 KB   sketch (source of the .hex)
|   |-- libraries/RadioLib/                         12.14 MB   RadioLib 7.8.1 (MIT, license.txt), 346 files
|-- README.txt                                      ~30.6 KB   this file
Total: 15.31 MB (unzipped). The C++ source code of the model is not included.

WHAT IS IT?
A simulation model of a Semtech SX1262 LoRa module (150-960 MHz, up to +22 dBm,
TCXO on DIO3 - like the Ebyte E22-900M22S) for Proteus 8. Your Arduino talks to
it over SPI exactly like to the real chip: the SX126x command interface
(SetStandby, SetPacketType, SetRfFrequency, SetModulationParams,
SetPacketParams, SetPaConfig, SetTxParams, WriteBuffer / ReadBuffer, SetTx /
SetRx, GetIrqStatus, GetPacketStatus, GetStats, calibration, sleep warm / cold,
...), the BUSY pin with its real timing, DIO1 interrupts, NRESET and the real
LoRa time on air. It runs the UNMODIFIED RadioLib 7.8.1 (Jan Gromes). Every TEP
LoRa module in a design (SX1262, RFM95W, Ra-02) shares one simulated air: radios
on the same frequency, spreading factor, bandwidth, sync word and IQ setting
talk to each other when the link budget allows (SX1262 sync word 0x1424 =
SX127x 0x12) - you choose the DISTANCE between the radios (10 m ... 20 km) and
the model works out the received level and SNR.
The part looks like the module, drawn clean and bold: the green Ebyte
E22-900M22S board (20 x 14 mm) with its silver can and white label (E22-900M22S,
EBYTE, QR code, RoHS, CE), the gold stamp holes on both long edges and the IPEX
socket in the can's corner with a coax cable up to an SMA rubber duck. While the
simulation runs the duck's ring and tip light orange while the module transmits
and green while it receives, radio waves above it ripple out (sending) or in
(receiving), and three LEDs show what happens: PWR (red, lit while VCC and GND
are connected), TX (orange, blinks for every packet sent) and RX (green, blinks
for every packet received). The PWR / TX / RX LEDs and the duck's lights are
a TEP addition - the real E22 has no LEDs.

WHY AN ARDUINO MEGA 2560
RadioLib's SX1262 driver plus the demo needs about 50 KB of flash - more than an
Arduino UNO has (32 KB). The demo therefore uses two TEP Arduino Mega 2560 boards
(the TEP Arduino V3 library is included).

TWO DEVICES IN ONE LIBRARY (search "SX1262" or "LoRa" in Pick Devices):
  SX1262 Simple    device SX1262TEP     "SX1262 LoRa Module (150-960 MHz) - Simple"
                   On-Sheet Panel: the control panel is drawn on the schematic
                   next to the module (the v1.0 panel): mode (SLEEP, STANDBY RC /
                   XOSC, FS, TX, RX, CAD - "(BUSY)" while it boots or
                   calibrates), frequency, SF, bandwidth, coding rate, sync
                   word, CRC, header, TX power, SENT / RECEIVED / TOO WEAK, the
                   last packet with RSSI / SNR, the DISTANCE buttons and the
                   predicted link budget. The red X in the panel header closes
                   it, the PANEL button on the board opens it again. Your v1.0
                   designs keep working with this device.
  SX1262 Advance   device SX1262ADVTEP  "SX1262 LoRa Module (150-960 MHz) - Advance"
                   Pop-Up Panel: only the module board on the schematic; at Run
                   a TEP pop-up window opens - the same look as the TEP Serial
                   Monitor (move it by its header, resize it, minimise it). The
                   header shows the state (SLEEP, STANDBY, FS, RX, TX, CAD); the
                   tabs Radio and Test sit in the header; the gear and ? icons
                   open Settings and Help; the palette icon switches the theme:
                     Radio     the state banner, RADIO - WHAT THE SKETCH SET
                               (frequency, TX power, sync word, preamble, SF /
                               bandwidth / coding rate, sensitivity, header, CRC,
                               LDRO, IQ), TRAFFIC (sent, received, too weak / CRC
                               errors, the last packet and its RSSI / SNR) and
                               DISTANCE (the eight buttons, the level at that
                               distance and how far these settings reach)
                     Test      four test tools, all measured on the model: Link
                               test, Time on air, Range, Register check (see THE
                               TEST TOOLS below)
                     Settings  theme (TEP Dark / Light), text size, open at Run,
                               window size - remembered for your Windows user
                     Help      Help & Support like the TEP Serial Monitor: report
                               a bug, suggest a feature, article, user guide,
                               updates, donate, website, forum; Copy diagnostics
                               (radio, command state, traffic, test results, the
                               other radios) for a bug report
                   The OPEN PANEL button on the board opens the window again
                   after you close it.
Both devices use the same model, TEPSX1278.DLL - the TEP LoRa family model (the
name comes from the first TEP LoRa library), also the model of our SX1278 (Ra-02)
and RFM95W libraries (identical TEPSX1278.DLL in all three packages, so
installing them all is safe; SX1262, RFM95W and Ra-02 modules in one design talk
to each other).

SIMPLE OR ADVANCE?
Simple when you want everything visible on the schematic (screenshots, a quick
look at the counters, the v1.0 behaviour). Advance when you want a clean
schematic and the tools: the link test, time on air with the duty-cycle rule,
the range per spreading factor and the command / BUSY check. Both simulate the
same chip; you can mix them in one design (the demo does).

NEW IN V1.1
* Two devices: SX1262 Simple (the panel on the sheet, close / open) and SX1262
  Advance (pop-up window with the radio page, four test tools, settings and
  help) - see above.
* Board: redrawn as the Ebyte E22-900M22S - the SX1262 + TCXO module that the
  demo's RadioLib setting (TCXO on DIO3) matches: green, 20 x 14 mm, the can with
  the white Ebyte label, stamp holes, the IPEX in the can's corner and a coax
  cable to an SMA rubber duck. The 9 Proteus pins stay where v1.0 had them, so
  the wiring of a v1.0 design fits. The duck lights orange while sending and
  green while receiving, radio waves above it; new LEDs PWR / TX / RX (a TEP
  addition - the real module has none): PWR lights with VCC, TX blinks for every
  packet sent, RX for every packet received (each blink held 0.3 / 0.4 s so you
  see it); a PANEL / OPEN PANEL button and a SIMPLE / ADVANCE badge.
* Model: every radio keeps a record of each packet it sent or heard (decoded,
  CRC error, too weak, nobody heard it) with level, SNR and time on air, and of
  the Arduino's SPI commands with their status byte and BUSY time - what the
  test tools show. The air, the link budget, the DISTANCE buttons and everything
  of v1.0 are unchanged (100 m: RSSI -77 dBm, SNR 10 dB at 868 MHz, +14 dBm).
* The demo uses the TEP Serial Monitor Advance instead of Virtual Terminals - one
  monitor per Arduino (U3 = Mega 1, U4 = Mega 2) with quick buttons - and shows
  both styles: Mega 1 with SX1262 Simple, Mega 2 with SX1262 Advance.
* The demo sketches (v1.1) keep every v1.0 output line and add Serial Monitor
  commands (SEND, PING, STATUS, SF, BW, PWR, AUTO, HELP) and a link line every
  10 s; the sender now listens between its packets, so the receiver can send to
  it too (and answer PING with PONG).
* Version 1.1 everywhere; the C++ source code of the model is no longer included.

TEST STATUS
v1.1 was tested in Proteus 8.5 SP0 (6 Oct 2026) with this demo (two Mega 2560,
RadioLib): "[SX1262] Sent OK, time on air 41 ms" (46 ms from #10), the receiver
RSSI -77.0 dBm / SNR 10.00 dB, PING -> PONG after 81.1 ms, the E22 board's duck /
PWR / TX / RX LEDs, 5 km -> TOO WEAK (-128 dBm, -3.7 dB) and SF 9 on both monitors
brings it back (-127.5 dBm, SNR -11.25 dB), the Register check (command state,
TCXO on, BUSY low, the command log with status bytes, U1 = PARTNER).
v1.0 was tested in Proteus 8.5 SP0 (30 Sep 2026) with the v1.0 demo at 868 MHz
and the unmodified RadioLib 7.8.1: the sender printed "Sent OK, time on air
46 ms" for every "Hello TEP #n" and the receiver each packet with RSSI -77.0 dBm
/ SNR 10.00 dB at 100 m; 5 km on the receiver panel made the SF7 packets TOO
WEAK (-128 dBm against the -125 dBm SF7 needs), 100 m restored the link.
PC tests of v1.1 (670 automatic checks of the SX1262 side, all passed; the
SX127x side has 1293 more): 49 with the UNMODIFIED RadioLib 7.8.1 driving the
SX1262 model bit by bit over SPI (the v1.0 tests, unchanged: begin(),
transmit(), blocking and interrupt receive, RX timeout, CAD, sleep warm / cold,
NRESET, SF / BW / sync word / IQ / header / CR / power, an SX1262 talking to an
RFM95W); 89 on the complete Proteus model (the 36 of v1.0 unchanged + both
devices, the red X and PANEL, OPEN PANEL, a v1.0 design, the duck's lights, the
PWR / TX / RX LEDs, the pop-up window, its pages, the four tools with measured
numbers, the command log with BUSY times); 30 with the two REAL v1.1 demo
sketches running on two simulated Megas at once (every v1.0 line, the commands,
PING both ways, SF / BW / PWR / AUTO, the link line); 502 on the rendered pop-up
windows and boards (every page fits in TEP Dark and Light, at Large text and
150 % DPI; every tool's hint lines fit; the header line fits beside the tabs;
the LEDs lit / dark as they should be).

INSTALLATION (about 2 minutes)
1. Close Proteus. Extract the WHOLE ZIP to a normal folder (e.g. Desktop).
2. Copy everything in "Proteus Library Files" (TEPSX1262.LIB with both devices,
   TEPSERIALMON.LIB and the TEP Arduino V3 library ArduinoV3TEP.LIB / .IDX with
   the Mega 2560 used by the demo) to 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 TEPSX1278.DLL and TEPSERIALMON.DLL from "Proteus Model Files" to the
   MODELS folder (...\Proteus 8 Professional\MODELS).
4. Updating from v1.0: replace TEPSX1262.LIB (delete any TEPSX1262.IDX) and
   TEPSX1278.DLL. A v1.0 design keeps its v1.0 symbol: it runs with the new
   model (the v1.0 panel and its DISTANCE buttons, without the v1.1 board parts
   and the red X) - re-pick the part to get the v1.1 symbol. If you also use our
   SX1278 or RFM95W library, their TEPSX1278.DLL is the same file. Never put back
   an older TEPSX1278.DLL (before 30 Sep 2026 it did not know the SX1262).
5. Start Proteus. In Pick Devices (P) search "SX1262": you get the Simple and the
   Advance device (category Peripherals > Wireless).

RUN THE DEMO
"Proteus Simulation\SX1262-ArduinoMega2560.pdsprj" - keep the two .hex files and
the two DLLs beside the project.
  Mega 1 (ARD1): SX1262_Sender.hex, SX1262 Simple (U1) and Serial Monitor U3.
  Mega 2 (ARD2): SX1262_Receiver.hex, SX1262 Advance (U2) and Serial Monitor U4.
  1. Press Run. Both monitor windows open (9600 baud) and so does U2's pop-up.
     U3 shows "[SX1262] Transmitting: Hello TEP #0" and "[SX1262] Sent OK, time
     on air 41 ms" every second, U4 "[SX1262] Received: Hello TEP #0" and
     "[SX1262] RSSI: -77.0 dBm   SNR: 10.00 dB"; U1's panel counts SENT, U2's
     pop-up RECEIVED; the ducks light orange (U1 sending) and green (U2
     receiving), U1's TX LED and U2's RX LED blink.
  2. U3 / U4 quick buttons: PING (the other node answers PONG - the round trip,
     about 74 ms), STATUS, SEND Hello from node 1 / 2 (the other monitor prints
     it), HELP. Type your own: SEND <text>, SF 9 (then on the other monitor too),
     BW 250 (both), PWR 22, AUTO OFF / ON (Mega 1).
  3. Click 5 km on U1's panel (or on U2's Radio page): the SF7 packets arrive TOO
     WEAK (-128 dBm, SF7 needs -125 dBm) and nothing is printed. Type SF 9 on both
     monitors and they arrive again. Back to 100 m and SF 7. Close U1's panel
     with its red X, open it with PANEL.
  4. U2 (Advance): open the Test tab:
       Link test: 10 packets, Run test - U1's next 10 packets with their level;
         click 5 km during the test and watch the bars turn red.
       Time on air: 12 / 32 / 64 / 255 bytes, Run test - every SF and bandwidth,
         the SetTx -> TxDone time with the TCXO start-up, and the 1 % duty cycle
         of the EU 868 MHz band.
       Range: Run test - one packet per SF at each of the 8 distances.
       Register check: the command state, the SPI commands with their BUSY
         times, U1 as partner.
  5. Close U2's window and open it again with OPEN PANEL on the board.
Closed a monitor window? Click OPEN MONITOR on the monitor part.
The simulation log shows "[AVR SPI] Clock frequency changed while in the Master
mode" a few times at start-up: Proteus's ATmega model noticing that the SPI
library set its clock - harmless.

WIRING (the same on both Megas - RadioLib's standard SX126x pins)
  In the sketch: SX1262 radio = new Module(10, 2, 3, 9);   // NSS, DIO1, NRST, BUSY
  SX1262 VCC -> supply (+5 V in the simulation - the real module needs 3.3 V!),
  GND -> GND, NSS -> D10, DIO1 -> D2 (INT0), RST (NRESET) -> D3, BUSY -> D9,
  SCK -> D52, MISO -> D50, MOSI -> D51 (the Mega's hardware SPI pins).
  radio.begin(868.0, 125.0, 7, 5, RADIOLIB_SX126X_SYNC_WORD_PRIVATE, 14)
    = 868 MHz, BW 125 kHz, SF7, CR 4/5, sync word 0x12, +14 dBm (both sketches;
      915.0 for the US / AU band - sender and receiver must match).
  The BUSY pin matters: RadioLib waits for BUSY low before and after every SPI
  command, exactly as on the real chip. Leave it unconnected and begin() fails.
  Serial Monitor RXD <- Arduino D1 (TX0), Serial Monitor TXD -> Arduino D0 (RX0),
  Serial Monitor GND -> ground. RXD2 is not needed for SPI radios: the monitor's
  second input watches a serial line, and the SX1262 has none (it talks SPI).
  Serial.begin(9600) in the sketches.
Pin order in Proteus: VCC GND NSS BUSY RST DIO1 MISO MOSI SCK (chosen so the demo
wires do not cross - wire them in any order you like).

REAL HARDWARE
 * 3.3 V only: feed VCC from 3.3 V and use a level shifter (or a 3.3 V board)
   for SCK, MOSI, NSS and RST - SX1262 modules are NOT 5 V tolerant.
 * Fit the antenna before you transmit: at +22 dBm, sending into a missing
   antenna can destroy the power amplifier.
 * The E22-900M22S has its own RF switch pins RXEN / TXEN: drive them from two
   Arduino pins (radio.setRfSwitchPins(rxen, txen)) or follow Ebyte's wiring
   with DIO2. Modules with a crystal instead of a TCXO (e.g. some Ai-Thinker
   Ra-01SH) need begin(..., tcxoVoltage 0).
 * Use the frequency and duty cycle your country allows: EU 868.0 - 868.6 MHz
   1 % duty cycle, 25 mW e.r.p. (869.4 - 869.65 MHz: 10 %, up to 500 mW), US
   902 - 928 MHz (400 ms dwell time per channel), Australia 915 - 928 MHz; +22 dBm is far more than
   the 25 mW (+14 dBm) of the EU 868.0 - 868.6 MHz sub-band. The Time on air
   tool shows the rule for your frequency and how long to wait between packets.

HOW THE RADIOS TALK (the model)
A packet arrives when frequency (within a quarter of the bandwidth), SF,
bandwidth, sync word, IQ, header mode (and in implicit mode length, CR and CRC)
agree, the receiver is in RX when the preamble starts, and the SNR is enough for
the spreading factor:
  RSSI = TX power - path loss(distance, frequency)  (free space to 1 m, then
         exponent 3.0 - a built-up area; 31.2 dB at 1 m at 868 MHz)
  SNR  = RSSI - noise floor (-174 dBm/Hz + 10 log BW + 6 dB: -117 dBm at 125 kHz)
  decoded if SNR >= SF5 -2.5, SF6 -5, SF7 -7.5 ... SF12 -20 dB
The link uses the LARGER of the two radios' DISTANCE settings. Packets take their
real LoRa time on air (Semtech AN1200.13): 41.2 ms for 12 bytes at SF7 / 125 kHz
with CRC, 1155 ms at SF12 (with the low data rate optimisation); SetTx -> TxDone
adds the TCXO start-up (5 ms), 40 us and the 200 us PA ramp. Typical at +14 dBm,
868 MHz: 100 m -77 dBm, 1 km -107 dBm, 2 km -116 dBm (SF7 works, SNR +0.8 dB),
5 km -128 dBm (SF9 or more; reported at the -127.5 dBm floor of the SX126x RSSI
scale), 10 km -137 dBm (+22 dBm and SF9 or more), 20 km out of reach even at
+22 dBm and SF12. The SX1262 tunes 150-960 MHz (RadioLib refuses other values).

THE TEST TOOLS (SX1262 Advance, Test tab) - what they really do
Every tool runs on the live model with your sketch and shows one "Good for:"
line plus one line on how it measures.
  Link test     Records the next 10, 20 or 50 packets THIS radio sends or hears
                (the sketch's real traffic): for each whether it was decoded,
                had a CRC error, was too weak or nobody heard it, with its RSSI,
                SNR and time on air; a bar graph with the sensitivity your SF
                needs as a dashed line. The DISTANCE buttons are on the tool, so
                you can move the radios while it runs. Below: the link budget at
                your SF, bandwidth and power at every distance and the lowest SF
                that works there. Example (the demo, U2): 10 packets decoded at
                -77 dBm / 10 dB at 100 m (42.8 ms on air each); at 5 km -128 dBm,
                too weak (SF9 needed, 164.9 ms per packet). No packet for 15 s
                stops it.
  Time on air   Two model SX1262s in a private test air (your design never hears
                them) send one packet for every SF7..SF12 x 125 / 250 / 500 kHz
                at your payload size (12 / 32 / 64 / 255 bytes): the time on air
                (Semtech's formula, measured on the model) and, in brackets, the
                measured SetTx -> TxDone time with the TCXO start-up, LDRO marked.
                Measured, 12 bytes, CRC on: SF7 41.2 (46.5) / 20.6 (25.8) / 10.3
                (15.5) ms, SF12 1155.1 (1160.3) / 577.5 / 247.8 ms at 125 / 250 /
                500 kHz. Below: the DUTY CYCLE rule at your frequency (EU 868.0-
                868.6 MHz 1 %, US 902-928 MHz 400 ms dwell, ...), how long to wait
                between packets and how many fit in an hour (868 MHz, SF7,
                12 bytes: wait at least 4.08 s, at most 873 packets per hour),
                and the last packet this radio heard, measured.
  Range         One packet per SF at each of the 8 DISTANCE steps between two
                model radios (your bandwidth and power): a table of the levels,
                green = decoded, red = too weak, and the link budget per SF.
                Measured at +14 dBm, 868 MHz, 125 kHz: SF7 reaches 2 km (budget
                3.8 km), SF12 5 km (9.9 km). Below: how far the TEP LoRa modules
                reach at their maximum power (SX1262 868 MHz +22 dBm: SF7 7.0 km
                ... SF12 18.2 km; Ra-02 433 MHz +20 dBm: 9.5 ... 24.8 km; RFM95W
                868 MHz +20 dBm: 6.0 ... 15.6 km).
  Register check The SX1262 has commands, not registers: the COMMAND STATE read
                live (GetStatus, packet type, RF frequency, modulation and packet
                parameters, sync word 0x0740, SetPaConfig, SetTxParams, TCXO on
                DIO3, IRQ status and DIO1 mask, GetPacketStatus, RX buffer
                status, buffer base, GetStats, GetDeviceErrors, fallback mode,
                the BUSY pin) with their meaning, the SPI counters, the
                Arduino's last SPI commands (time, command, data, status byte,
                how long BUSY stayed high, identical commands in a row folded)
                and THE OTHER RADIOS: does each match this one (frequency, SF,
                bandwidth, sync word, level here)?

THE DEMO SKETCHES ON THE SERIAL MONITOR (SX1262_Sender / SX1262_Receiver v1.1)
  SEND <text>             a message to the other node now
  PING                    the other node answers PONG - prints the round trip
  STATUS                  frequency, SF, bandwidth, coding rate, sync word,
                          power, counters, the last packet's RSSI / SNR
  SF <5-12>               spreading factor (type it on both monitors)
  BW <kHz>                bandwidth 7.8 ... 125, 250, 500 (both)
  PWR <-9..22>            transmit power in dBm
  AUTO <ON|OFF>           (sender) the Hello TEP packet every second
  HELP                    the command list
Monitor quick buttons in the demo: PING, STATUS, SEND Hello from node 1 / 2, HELP.
Every 10 s each node prints a link line (sent, received, average RSSI / SNR).

EXPECTED MONITOR OUTPUT (from the PC test of the real sketches)
U3 (Mega 1, sender):
  TEP SX1262 LoRa sender (Arduino Mega 2560 + RadioLib)
  [SX1262] Initializing ... success!
  Demo v1.1 - type HELP in the Serial Monitor for the commands
  [SX1262] Transmitting: Hello TEP #0
  [SX1262] Sent OK, time on air 41 ms
  PING: PONG from node 2 after 74.2 ms (RSSI -77.0 dBm, SNR 10.00 dB)
  [SX1262] Received from node 2: Hello from node 2  (RSSI -77.0 dBm, SNR 10.00 dB)
  Status: 868.000 MHz, SF7, BW 125 kHz, CR 4/5, sync 0x12, +14 dBm
    sent 4, received 0, auto-send ON (every 1 s)
  Link (10 s): 10 sent, 0 received
U4 (Mega 2, receiver):
  TEP SX1262 LoRa receiver (Arduino Mega 2560 + RadioLib)
  [SX1262] Initializing ... success!
  [SX1262] Starting to listen ... success!
  Demo v1.1 - type HELP in the Serial Monitor for the commands
  [SX1262] Received: Hello TEP #0
  [SX1262] RSSI: -77.0 dBm   SNR: 10.00 dB
  [SX1262] Received: PING
    -> PONG sent back
  Sent: Hello from node 2  (17 bytes, 51.4 ms on air)
  Link (10 s): 10 received, RSSI -77.0 dBm avg, SNR 10.0 dB avg, 0 sent

PROPERTIES
The module has no user properties: the sketch sets frequency, SF, bandwidth and
power over SPI (as on the real chip), and the DISTANCE is chosen on the panel
(100 m at every Run). The panel style is chosen by the device (Simple /
Advance). The Advance window settings (theme, text size, open at Run, size) are
on its Settings page. The
…