Valid CR values for sx1280 / sx1280PA?

[K4KDR]

Greetings. In searching the 'Discussions' category before creating a new post, I see that the topic of configuring sx1280 & sx1280PA devices has been talked about before. However, I was not able to locate exactly what I'm failing to understand clearly.

My RadioLib install in the Arduino IDE is v7.3.0.

I've been trying to find all the acceptable parameters for initializing a LilyGO 't3s3' device with an sx1280PA on board. I finally got everything working but am not understanding what I should be using for the Coding Rate parameter. (once I have everything tested, of course I'll post my configuration for everyone).

I'm not a 'real' programmer, but have been going through repositories from Meshtastic, tinyGS, and of course RadioLib to try to gain an understanding of what my valid CR values are for this device.

In src/modules/SX128x/SX128x.cpp, I see:

  if(modem == RADIOLIB_SX128X_PACKET_TYPE_LORA) {
    uint8_t sf = this->spreadingFactor >> 4;
    uint8_t cr = this->codingRateLoRa;
    // We assume same calculation for short and long interleaving, so map CR values 0-4 and 5-7 to the same values
    if (cr < 5) {
      cr = cr + 4;
    } else if (cr == 7) {
      cr = cr + 1;
    }

... and I see that there are -7- possible CR values and when using RadioLib, it might be wise to refer to them by the names listed in src/modules/SX128x/SX128x.h:

#define RADIOLIB_SX128X_LORA_CR_4_5                             0x01        //  7     0   LoRa coding rate: 4/5
#define RADIOLIB_SX128X_LORA_CR_4_6                             0x02        //  7     0                     4/6
#define RADIOLIB_SX128X_LORA_CR_4_7                             0x03        //  7     0                     4/7
#define RADIOLIB_SX128X_LORA_CR_4_8                             0x04        //  7     0                     4/8
#define RADIOLIB_SX128X_LORA_CR_4_5_LI                          0x05        //  7     0                     4/5, long interleaving
#define RADIOLIB_SX128X_LORA_CR_4_6_LI                          0x06        //  7     0                     4/6, long interleaving
#define RADIOLIB_SX128X_LORA_CR_4_8_LI                          0x07        //  7     0                     4/8, long interleaving

... but when I try to use (in radio.begin), for instance, RADIOLIB_SX128X_LORA_CR_4_5, I get error-10 (invalid CR). But if I just use "5", that works. However, thinking I was now understanding the situation, I tried a CR value of "1" (based on the list of 7 valid values) but "1" fails w/ the same error-10. So, I'm not clear if there are actually -7- valid values here or the -4- that I've always used w/ other devices.

So in short, would someone be kind enough to give me some guidance on what the correct way is to set my CR value w/ these t3s3 sx1280 & sx1280PA devices?

Thanks!

[jgromes]

Hi Scott,

the difference here is that the first 4 values (without the _LI suffix) are the coding rate with standard interleaver. To configure them, you set the denominator of the coding rate either as begin argument, or as argument for setCodingRate. If you want to use the long interleaver versions, you have to do it by setting the second argument of setCodingRate to true. So for example, radio.setCodingRate(5, true) will set CR 4/5 with long interleaver, as shown in the docs:

RadioLib/src/modules/SX128x/SX128x.h

Lines 638 to 646 in 1de9837

	/*!
	\brief Sets LoRa coding rate denominator. Allowed values range from 4 to 8. Note that a value of 4
	means no coding, is undocumented and not recommended without your own FEC.
	\param cr LoRa coding rate denominator to be set.
	\param longInterleaving Whether to enable long interleaving mode. Not available for coding rate 4/7,
	defaults to false.
	\returns \ref status_codes
	*/
	int16_t setCodingRate(uint8_t cr, bool longInterleaving = false);

Macros in the header file are only for internal use, and not really intended for the user in most cases (unless explicitly stated in documentation of a specific method).

[K4KDR]

Thank you SO much! You have always been so generous to give direction to those of us who 'try' to follow the documentation but don't always see a critical detail. Much appreciated!

[K4KDR]

Since I have seen numerous comments on various sites about the lack of success with getting these LilyGO T3S3 2.4 GHz devices to initialize, I wanted to share just the radio-init part of my now working solution to actually use these boards!

Here is the end result:

... and very important - here are the settings to be used in the Arduino IDE (set the PORT to where the device is visible on your system)

... and here is the code:

/*
 *   This code does nothing but attempt to initialize the LoRa radio on a 
 *   LilyGO t3s3 device, specifically the sx1280 / sx1280PA 2.4 GHz devices
 *   
 *   If successful, you have confirmed that your Arduino IDE settings,
 *   PIN numbers, and parameter values all work correctly
 */

/*
 *   Important Note:    to put the LilyGO t3s3 device into programming mode:
 *                      >slide power switch to ON
 *                      >press & hold BOOT button
 *                      >press & release RESET button
 *                      >after approx 2 seconds, release BOOT button
 *                      
 *                      ... after programming is complete
 *                      >slide power switch to OFF
 *                      >pause a second or two
 *                      >slide power switch to ON
 *                      >within 5 seconds, open Serial Monitor
 */

 
// include all libraries
#include <SPI.h>
#include <RadioLib.h>


// ---------- SPI / SX1280 wiring ----------
#define PIN_SCK    5      // SPI SCK
#define PIN_MISO   3      // custom MISO
#define PIN_MOSI   6      // custom MOSI
#define PIN_CS     7      // SX1280 NSS (chip select)

// confirm that an ESP32 device is selected
#ifndef ARDUINO_ARCH_ESP32
  #error "This sketch must be compiled for an ESP32 board! Select Tools → Board → ESP32 Dev Module (or another ESP32)."
#endif

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
//  !!! ADJUST SETTINGS BELOW FOR YOUR LORA DEVICE !!!
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------

//for TTGO ESP32-t3s3 sx1280 2.4 GHz
#define CS                    7      // SPI chip select, often shown as 'NSS'
#define DIO1                  9      // 
#define NRST                  8      // 
#define BUSY                  36     // 


// modem configuration
#define FREQUENCY             2403.0   //  Freq Range = 2400 MHz to 2500 MHz

#define BANDWIDTH             812.50    // Sets LoRa bandwidth. Allowed values are 203.13, 406.25, 812.50, 1625.00 kHz

#define SPREADING_FACTOR      10     // Sets LoRa spreading factor. Allowed values range from 5 to 12.

#define CODING_RATE            5     // Sets LoRa coding rate 4/x denominator (valid #'s are 5,6,7,8)
                                     // Note: CR is re-set after radio.begin statement by
                                     //       radio.setCodingRate as shown below

#define LI                    false   //  i.e., radio.setCodingRate(5, true) will set CR 4/5 with long interleaver

                                      /* valid CR settings:
                                         -----------------
                                         4/5 RADIOLIB_SX128X_LORA_CR_4_5
                                         4/6 RADIOLIB_SX128X_LORA_CR_4_6
                                         4/7 RADIOLIB_SX128X_LORA_CR_4_7
                                         4/8 RADIOLIB_SX128X_LORA_CR_4_8
                                         4/5 LI  RADIOLIB_SX128X_LORA_CR_4_5_LI
                                         4/6 LI  RADIOLIB_SX128X_LORA_CR_4_6_LI
                                         4/8 LI  RADIOLIB_SX128X_LORA_CR_4_8_LI
                                      */

#define OUTPUT_POWER          3      // dBm 
                                 
#define LORA_PREAMBLE_LEN     16       //  4 – 65,535 symbols   (12 or more recommended)

#define SYNC_WORD             0x12

#define CRC                   true
    
#define IQINVERTED            false


//-----------------------------------------------------------------------------
// set up radio module

// need custom SPI method below

Module* mod = new Module(CS, DIO1, NRST, BUSY, SPI,
                         SPISettings(2000000, MSBFIRST, SPI_MODE0));
                         
SX1280 radio = SX1280(mod);

//-----------------------------------------------------------------------------


// functions called from SETUP and/or LOOP code

//////////////////////////////////////////////////////////////////////////////////////////////////

int16_t setLoRa() {

  radio.reset();
  delay(10);
  
  int state = radio.begin(FREQUENCY,
                          BANDWIDTH,
                          SPREADING_FACTOR,
                          CODING_RATE,
                          SYNC_WORD,
                          OUTPUT_POWER,
                          LORA_PREAMBLE_LEN);

  radio.setCodingRate(CODING_RATE, LI);    // sx128x CR includes 4/x denominator AND 'long interleaver' true/false
  
  radio.setCRC(CRC);
  
  radio.invertIQ(IQINVERTED);

  Serial.print('\n');
  delay(250);
  return(state);
}//END: setLoRa

//////////////////////////////////////////////////////////////////////////////////////////////////

void radio_init() {
  
  // initialize the radio

  int state = setLoRa();


  if (state == RADIOLIB_ERR_NONE) {
    Serial.println(F("...... Radio initialization successful!"));\
    Serial.print('\n');
    Serial.println(F("ESP32-t3s3 set to LoRA Mode"));
    Serial.print('\n');
  } else {
    Serial.print(F("Failed to initialize radio, code: "));
    Serial.println(state);
    while (true);
  }

}//END: radio_init




//////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////

void setup() {

  
  Serial.begin(9600);
  Serial.print('\n');

  delay(5000);          // to allow time to open Serial Monitor
  
  Serial.print(F("Arduino Sketch File:  "));
  Serial.println(__FILE__);
  Serial.print('\n');

  // Print ESP32 Device info
  
  #ifdef ARDUINO_ARCH_ESP32
  Serial.print('\n');
  Serial.println("✅ Build target: ESP32 (ARDUINO_ARCH_ESP32 defined)");
  // Extra chip details (ESP32 core API):
  Serial.printf("Chip: %s, Rev %d, Cores %d\n",
                ESP.getChipModel(), ESP.getChipRevision(), ESP.getChipCores());
  Serial.printf("SDK: %s, CPU Freq: %d MHz\n",
                ESP.getSdkVersion(), (int)(ESP.getCpuFreqMHz()));
  #else
  Serial.println("❌ Not an ESP32 build!");
  #endif

  Serial.print('\n');
  

  // Start SPI on custom pins
  SPI.begin(PIN_SCK, PIN_MISO, PIN_MOSI, PIN_CS);  // SPI.begin(SCK, MISO, MOSI, SS);
  
  // initialize the radio
  radio_init();
  
}//END: setup

//////////////////////////////////////////////////////////////////////////////////////////////////

void loop() {

  
}//END: loop

[marshalleq]

Let's try that again. I have a simple TX and RX test for the SX1262 T3S3 boards I have. These are validated as working with meshtastic firmware. I seem to get to the point where the radio says it initialises and says it's transmitting but I never receive anything. I've broken this down to smaller tests to try prove the situation but was working on this as part of some other bigger code.

The code block isn't quite working for some reason, will try again:

The TX code:

/*
 * Simple SX1262 Radio Test for T3 S3 V1.2
 * Tests if radio hardware is actually transmitting
 * Monitor with SDR or another LoRa device
 */

#include <SPI.h>
#include <RadioLib.h>

// T3 S3 V1.2 pin definitions
#define PIN_SCK    5
#define PIN_MISO   3
#define PIN_MOSI   6
#define PIN_CS     7
#define CS         7
#define DIO1       33
#define NRST       8
#define BUSY       34

// Test parameters
#define FREQUENCY  915.0  // MHz - AU915 start frequency
#define BANDWIDTH  125.0  // kHz
#define SPREADING_FACTOR 7
#define CODING_RATE 5
#define SYNC_WORD 0x34  // Private sync word for testing
#define OUTPUT_POWER 14  // dBm

// Create radio module
Module* mod = new Module(CS, DIO1, NRST, BUSY, SPI,
                         SPISettings(2000000, MSBFIRST, SPI_MODE0));
SX1262 radio = SX1262(mod);

int txCount = 0;

void setup() {
    Serial.begin(115200);
    delay(2000);
    
    Serial.println("\n=== SX1262 Radio Test ===\n");
    
    // Initialize SPI
    Serial.println("Init SPI...");
    SPI.begin(PIN_SCK, PIN_MISO, PIN_MOSI, PIN_CS);
    
    // Reset radio
    Serial.println("Resetting radio...");
    pinMode(NRST, OUTPUT);
    digitalWrite(NRST, LOW);
    delay(10);
    digitalWrite(NRST, HIGH);
    delay(10);
    
    // Initialize radio WITHOUT parameters first
    Serial.println("Init radio (step 1 - basic init)...");
    int state = radio.begin();
    
    if (state != RADIOLIB_ERR_NONE) {
        Serial.print("Radio init FAILED: ");
        Serial.println(state);
        while (true) delay(1000);
    }
    Serial.println("Radio basic init OK");
    
    // Configure TCXO (CRITICAL for T3 S3)
    Serial.println("Setting TCXO to 1.8V...");
    state = radio.setTCXO(1.8);
    if (state != RADIOLIB_ERR_NONE) {
        Serial.print("TCXO config FAILED: ");
        Serial.println(state);
    } else {
        Serial.println("TCXO configured");
    }
    
    // Calibrate after TCXO (CRITICAL)
    Serial.println("Calibrating radio...");
    state = radio.calibrateImage(915.0);  // Center frequency
    if (state != RADIOLIB_ERR_NONE) {
        Serial.print("Calibration FAILED: ");
        Serial.println(state);
    } else {
        Serial.println("Calibration complete");
    }
    
    // Configure DIO2 as RF switch (CRITICAL for T3 S3)
    Serial.println("Setting DIO2 as RF switch...");
    state = radio.setDio2AsRfSwitch(true);
    if (state != RADIOLIB_ERR_NONE) {
        Serial.print("DIO2 config FAILED: ");
        Serial.println(state);
    } else {
        Serial.println("DIO2 configured");
    }
    
    // Now set modem parameters
    Serial.println("Setting modem parameters...");
    state = radio.setFrequency(FREQUENCY);
    if (state != RADIOLIB_ERR_NONE) {
        Serial.print("Set frequency FAILED: ");
        Serial.println(state);
    }
    
    state = radio.setBandwidth(BANDWIDTH);
    if (state != RADIOLIB_ERR_NONE) {
        Serial.print("Set bandwidth FAILED: ");
        Serial.println(state);
    }
    
    state = radio.setSpreadingFactor(SPREADING_FACTOR);
    if (state != RADIOLIB_ERR_NONE) {
        Serial.print("Set SF FAILED: ");
        Serial.println(state);
    }
    
    state = radio.setCodingRate(CODING_RATE);
    if (state != RADIOLIB_ERR_NONE) {
        Serial.print("Set CR FAILED: ");
        Serial.println(state);
    }
    
    state = radio.setSyncWord(SYNC_WORD);
    if (state != RADIOLIB_ERR_NONE) {
        Serial.print("Set sync word FAILED: ");
        Serial.println(state);
    }
    
    state = radio.setOutputPower(OUTPUT_POWER);
    if (state != RADIOLIB_ERR_NONE) {
        Serial.print("Set output power FAILED: ");
        Serial.println(state);
    }
    
    Serial.println("All parameters configured");
    
    // Print configuration
    Serial.println("\n--- Radio Config ---");
    Serial.print("Frequency: "); Serial.print(FREQUENCY); Serial.println(" MHz");
    Serial.print("Bandwidth: "); Serial.print(BANDWIDTH); Serial.println(" kHz");
    Serial.print("SF: "); Serial.println(SPREADING_FACTOR);
    Serial.print("CR: 4/"); Serial.println(CODING_RATE);
    Serial.print("Power: "); Serial.print(OUTPUT_POWER); Serial.println(" dBm");
    Serial.println("--------------------\n");
    
    Serial.println("Ready to transmit!");
    Serial.println("Monitor at 915 MHz with SDR or LoRa receiver\n");
}

void loop() {
    txCount++;
    
    char msg[32];
    snprintf(msg, sizeof(msg), "Test #%d", txCount);
    
    Serial.print("TX #");
    Serial.print(txCount);
    Serial.print(": ");
    Serial.println(msg);
    
    int state = radio.transmit(msg);
    
    if (state == RADIOLIB_ERR_NONE) {
        Serial.println("  -> Transmit OK");
        
        // Print packet stats
        Serial.print("  -> Data rate: ");
        Serial.print(radio.getDataRate());
        Serial.println(" bps");
        
    } else {
        Serial.print("  -> Transmit FAILED: ");
        Serial.println(state);
    }
    
    Serial.println();
    delay(5000);  // Transmit every 5 seconds
}

The rx code:

/*
 * Simple SX1262 Radio RX Test for T3 S3 V1.2
 * Receives packets from simple_radio_test transmitter
 * Must use identical radio parameters
 */

#include <SPI.h>
#include <RadioLib.h>
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

// T3 S3 V1.2 pin definitions
#define PIN_SCK    5
#define PIN_MISO   3
#define PIN_MOSI   6
#define PIN_CS     7
#define CS         7
#define DIO1       33
#define NRST       8
#define BUSY       34

// Display pins
#define OLED_SDA   18
#define OLED_SCL   17
#define SCREEN_WIDTH 128
#define SCREEN_HEIGHT 64
#define OLED_RESET -1
#define SCREEN_ADDRESS 0x3C

// Radio parameters - MUST MATCH transmitter exactly
#define FREQUENCY  915.0  // MHz
#define BANDWIDTH  125.0  // kHz
#define SPREADING_FACTOR 7
#define CODING_RATE 5
#define SYNC_WORD 0x34
#define OUTPUT_POWER 14  // dBm (not used for RX but set anyway)

// Create radio module
Module* mod = new Module(CS, DIO1, NRST, BUSY, SPI,
                         SPISettings(2000000, MSBFIRST, SPI_MODE0));
SX1262 radio = SX1262(mod);

// Display
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET);

int rxCount = 0;
int rxErrors = 0;
String lastMessage = "";
float lastRSSI = 0;
float lastSNR = 0;

void updateDisplay() {
    display.clearDisplay();
    display.setTextSize(1);
    display.setTextColor(SSD1306_WHITE);
    display.setCursor(0, 0);
    
    display.println("LoRa RX Monitor");
    display.println("===============");
    display.print("RX: "); display.println(rxCount);
    display.print("Errors: "); display.println(rxErrors);
    
    if (lastMessage.length() > 0) {
        display.println("");
        display.println("Last packet:");
        display.println(lastMessage);
        display.print("RSSI:"); display.print(lastRSSI, 0);
        display.print(" SNR:"); display.println(lastSNR, 1);
    } else {
        display.println("");
        display.println("Waiting...");
    }
    
    display.display();
}

void setup() {
    Serial.begin(115200);
    delay(2000);
    
    Serial.println("\n=== SX1262 Radio RX Test ===\n");
    
    // Initialize display
    Wire.begin(OLED_SDA, OLED_SCL);
    if (!display.begin(SSD1306_SWITCHCAPVCC, SCREEN_ADDRESS)) {
        Serial.println("Display init FAILED");
    } else {
        Serial.println("Display OK");
        display.clearDisplay();
        display.setTextSize(1);
        display.setTextColor(SSD1306_WHITE);
        display.setCursor(0, 0);
        display.println("LoRa RX");
        display.println("Initializing...");
        display.display();
    }
    
    // Initialize SPI
    Serial.println("Init SPI...");
    SPI.begin(PIN_SCK, PIN_MISO, PIN_MOSI, PIN_CS);
    
    // Reset radio
    Serial.println("Resetting radio...");
    pinMode(NRST, OUTPUT);
    digitalWrite(NRST, LOW);
    delay(10);
    digitalWrite(NRST, HIGH);
    delay(10);
    
    // Initialize radio WITHOUT parameters first
    Serial.println("Init radio (step 1 - basic init)...");
    int state = radio.begin();
    
    if (state != RADIOLIB_ERR_NONE) {
        Serial.print("Radio init FAILED: ");
        Serial.println(state);
        display.clearDisplay();
        display.setCursor(0, 0);
        display.println("RADIO INIT FAIL");
        display.print("Error: ");
        display.println(state);
        display.display();
        while (true) delay(1000);
    }
    Serial.println("Radio basic init OK");
    
    // Configure TCXO (CRITICAL for T3 S3)
    Serial.println("Setting TCXO to 1.8V...");
    state = radio.setTCXO(1.8);
    if (state != RADIOLIB_ERR_NONE) {
        Serial.print("TCXO config FAILED: ");
        Serial.println(state);
    } else {
        Serial.println("TCXO configured");
    }
    
    // Calibrate after TCXO (CRITICAL)
    Serial.println("Calibrating radio...");
    state = radio.calibrateImage(915.0);  // Center frequency
    if (state != RADIOLIB_ERR_NONE) {
        Serial.print("Calibration FAILED: ");
        Serial.println(state);
    } else {
        Serial.println("Calibration complete");
    }
    
    // Configure DIO2 as RF switch (CRITICAL for T3 S3)
    Serial.println("Setting DIO2 as RF switch...");
    state = radio.setDio2AsRfSwitch(true);
    if (state != RADIOLIB_ERR_NONE) {
        Serial.print("DIO2 config FAILED: ");
        Serial.println(state);
    } else {
        Serial.println("DIO2 configured");
    }
    
    // Now set modem parameters
    Serial.println("Setting modem parameters...");
    state = radio.setFrequency(FREQUENCY);
    if (state != RADIOLIB_ERR_NONE) {
        Serial.print("Set frequency FAILED: ");
        Serial.println(state);
    }
    
    state = radio.setBandwidth(BANDWIDTH);
    if (state != RADIOLIB_ERR_NONE) {
        Serial.print("Set bandwidth FAILED: ");
        Serial.println(state);
    }
    
    state = radio.setSpreadingFactor(SPREADING_FACTOR);
    if (state != RADIOLIB_ERR_NONE) {
        Serial.print("Set SF FAILED: ");
        Serial.println(state);
    }
    
    state = radio.setCodingRate(CODING_RATE);
    if (state != RADIOLIB_ERR_NONE) {
        Serial.print("Set CR FAILED: ");
        Serial.println(state);
    }
    
    state = radio.setSyncWord(SYNC_WORD);
    if (state != RADIOLIB_ERR_NONE) {
        Serial.print("Set sync word FAILED: ");
        Serial.println(state);
    }
    
    state = radio.setOutputPower(OUTPUT_POWER);
    if (state != RADIOLIB_ERR_NONE) {
        Serial.print("Set output power FAILED: ");
        Serial.println(state);
    }
    
    Serial.println("All parameters configured");
    
    // Print configuration
    Serial.println("\n--- Radio Config ---");
    Serial.print("Frequency: "); Serial.print(FREQUENCY); Serial.println(" MHz");
    Serial.print("Bandwidth: "); Serial.print(BANDWIDTH); Serial.println(" kHz");
    Serial.print("SF: "); Serial.println(SPREADING_FACTOR);
    Serial.print("CR: 4/"); Serial.println(CODING_RATE);
    Serial.println("--------------------\n");
    
    Serial.println("Ready to receive!");
    Serial.println("Listening for packets...\n");
    
    // Start receiving
    state = radio.startReceive();
    if (state != RADIOLIB_ERR_NONE) {
        Serial.print("Start receive FAILED: ");
        Serial.println(state);
    }
    
    updateDisplay();
}

void loop() {
    // Check if packet was received
    if (radio.available()) {
        String message;
        int state = radio.readData(message);
        
        if (state == RADIOLIB_ERR_NONE) {
            rxCount++;
            lastMessage = message;
            lastRSSI = radio.getRSSI();
            lastSNR = radio.getSNR();
            
            Serial.print("RX #");
            Serial.print(rxCount);
            Serial.print(": ");
            Serial.println(message);
            Serial.print("  RSSI: ");
            Serial.print(lastRSSI);
            Serial.print(" dBm, SNR: ");
            Serial.print(lastSNR);
            Serial.println(" dB");
            Serial.println();
            
            updateDisplay();
            
        } else {
            rxErrors++;
            Serial.print("RX Error: ");
            Serial.println(state);
            updateDisplay();
        }
        
        // Start receiving again
        radio.startReceive();
    }
    
    delay(10);  // Small delay to prevent CPU spinning
}

Does anything jump out at you as wrong around the initialisation sequence? I have a feeling that it's something like that that's basically wrong, or perhaps the SX1262 is just different. I'm about to give up and use another library.

[jgromes]

@marshalleq this is offtopic for this discussion, and it is even about a completely different hardware, which will make your post harder to find for others in the future.

Does anything jump out at you as wrong around the initialisation sequence?

Yes, couple of things:

1. Why are you manually toggling the radio reset pin? The library does it in the begin method anyway, if there is a part of the documentation or examples that led you to believe this must be done, please point it out so that we can correct it.
2. Why are you calling begin without arguments and then setting them sequentially? Especially for the TCXO voltage, that will cause issues. The TCXO voltage should be part of begin, so that all calibrations are done correctly (calibrateImage is just image rejection, not all calibrations).
3. Manually calibrating frequency is unnecessary, it will be done in setFrequency. Again, if there is some part of the docs that led you to believe this is needed, please point it out.
4. I have no idea what "CPU spinning" is.
5. You are using LoRa sync word 0x34 which is reserved for LoRaWAN, please don't do that.

Other than that, it's exactly as @K4KDR wrote - without error codes, description of what "seems to be transmitting" means, we cannot help you. You wrote that Meshtastic is working on your devices - Meshtastic uses RadioLib, so the issue is almost certainly in your code.

[K4KDR]

What exact output do you get to the serial monitor? Any RadioLib error codes?

[marshalleq]

Just wanted to say thanks very much, it's now working! After all this time, I have successful transmit and receive using RadioLib on esp32 t3 s3! Also managed to get a test packet to the things network, that's real progress and couldn't have done it without you. Thanks again!

[StevenCellist]

Hold up.. @marshalleq you got a message to TTN using an SX1280?

[marshalleq]

No, an SX1262.

[marshalleq]

I am in a very fringe area, so I have to stand in a specific area. The signal is actually below the noise floor, but it works there anyway.