C1101 with ESP32 initialization fails with return code -2?

[diff-arch]

Hi,

I'm trying to get a CC1101 (868/900MHz) working with an ESP32 WROOM-32 (pinout) over SPI. I'm fairly new to all of this.

Here's how I've currently wired things:

EPS32	CC1101
3V3	VCC
GND	GND
GPIO 23	MOSI
GPIO 18	SCLK
GPIO 19	MISO
GPIO 4	GBO2
GPIO 2	GBO0
GPIO 5	CSN

And here's my RadioLib related code:

#include <Arduino.h>
#include <RadioLib.h>

SPIClass newSPI(VSPI);
CC1101 radio = new Module(5, 2, RADIOLIB_NC, 4, newSPI, SPISettings(2000000, MSBFIRST, SPI_MODE0));

void setup()
{
    Serial.begin(9600);
    Serial.println("Start Setup");

    newSPI.begin();

    const int state = radio.begin();
    if (state == RADIOLIB_ERR_NONE)
    {
        Serial.println("C1101 initialized successfully");
    }
    else
    {
        Serial.print("C1101 initialization failed, code ");
        Serial.println(state);
        while (true)
        {
            delay(10);
        }
    }
}

void loop()
{
}

When I flash the ESP32 with the same code, I get a return code of -2. I've checked my wiring with a multimeter and everything seems fine.

What am I overlooking here?

Thanks.

EDIT 1:

I've tested the CC1101 board with my Flipper Zero and it gets instantly recognized as external device and I can send data through it. The only difference concerning the wiring is that the GBO2 doesn't get wired to the GPIO.
With the ESP32 I still get a state of -2.

[jgromes]

You can start by enabling the debug mode, you will most likely see that the device isn't returning any data, pointing to an issue with the SPI. You should double-check the SPI pins; you haven't provided any pin numbers for newSPI.begin();, so I'm guessing it will use some defaults - are you sure they are the ones you expect?

[diff-arch]

OK, thanks anyway. I'll investigate it and share what I find out.
Thanks for your patience and kind help.

[diff-arch]

I don't know what those numbers represent, but that seems unlikely.

It turns out it's similar to what I imagined before. The sign indeed represents the pin state (- = LOW, + = HIGH) of transmitting pin, but the unsigned integer value represents the timing between flips (i.e. from low to high or vis versa).

Example:
raw data: 2 -3 6

__      ______
   |___|
 2  -3     6  

[diff-arch]

Hi @jgromes,

I've made it this far and the CC1101 is indeed broadcasting over 868.35 MHz, but the remote button behavior is not "emulated" yet.

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

#include <vector>
#include <sstream>

#include "raw_data.h"

constexpr uint8_t SCLK_PIN = 18;  // active-low chip select signal
constexpr uint8_t MISO_PIN = 19;  // main in, sub out
constexpr uint8_t MOSI_PIN = 23;  // main out, sub in
constexpr uint8_t CS_PIN = 5;    // chip select

constexpr uint8_t GDO0_PIN = 2;
constexpr uint8_t GDO2_PIN = 4;
constexpr float CC1101_FREQ = 868.35;

SPIClass spi(VSPI);  // SPI bus attached to pins 5, 18, 19, 23
SPISettings spiSettings(2000000, MSBFIRST, SPI_MODE0);

CC1101 radio = new Module(CS_PIN, GDO0_PIN, RADIOLIB_NC, GDO2_PIN, spi, spiSettings);

void setup()
{
    Serial.begin(115200);
    Serial.print(F("[CC1101] Initializing ... "));

    spi.begin(SCLK_PIN, MISO_PIN, MOSI_PIN, CS_PIN);

    int state = radio.begin(CC1101_FREQ); 
    if (state == RADIOLIB_ERR_NONE)
    {
        Serial.println(F("success!"));
    }
    else
    {
        Serial.print(F("failed: code "));
        Serial.println(state);
        while (true);
    }

    Serial.println(F("Parsing raw data ..."));
    std::istringstream iss(RAW_DATA_STR);
    std::vector<int> numbers;
    int number;

    while (iss >> number)
    {
        numbers.push_back(number);
    }

    // Set the modulation
    Serial.print(F("[CC1101] Setting modulation to OOK ... "));
    state = radio.setOOK(true);
    if (state == RADIOLIB_ERR_NONE)
    {
        Serial.println(F("success!"));
    }
    else
    {
        Serial.print("failed: code ");
        Serial.println(state);
        while (true);
    }

    // Set the data rate
    Serial.print(F("[CC1101] Setting the bit rate to 512 kbps ... "));
    state = radio.setBitRate(512);
    if (state == RADIOLIB_ERR_NONE)
    {
        Serial.println(F("success!"));
    }
    else
    {
        Serial.print("failed: code ");
        Serial.println(state);
        while (true);
    }

    // Enable direct asynchronous mode for transmission
    Serial.print(F("[CC1101] Enabling direct asynchronous mode ... "));
    state = radio.transmitDirect();
    if (state == RADIOLIB_ERR_NONE)
    {
        Serial.println(F("success!"));
    }
    else
    {
        Serial.print("failed: code ");
        Serial.println(state);
        while (true);
    }

    // Transmit custom asynchronous data via GPIO
    pinMode(GDO0_PIN, OUTPUT);

    Serial.println(F("Transmitting RAW DATA ..."));
    uint8_t count = 1;
    while (count > 0)
    {
        for (const int num : numbers)
        {
            const unsigned int delay = std::abs(num);
            if (num <= 0)
                digitalWrite(GDO0_PIN, LOW);
            else
                digitalWrite(GDO0_PIN, HIGH);
            delayMicroseconds(delay);
        }
        count--;
    }

}

void loop()
{
}

Am I maybe overlooking something?

[diff-arch]

OK, I got it to work. The problem was that I explicitly set the modulation to OOK, instead of FSK, which is set by default.
Thanks again. RadioLib is a super neat and handy library and indeed rules them all! ;)

[jgromes]

Glad you were able to get it to work, and that you find this project useful! :)