narrow band FSK using SX1278 device

[SHopper-prog]

I am trying to use RadioLib to implement narrow band FSK with channel spacing of 20kHz (i.e. I think too narrow for LoRa with the standard tolerance xtal). Currently I have a DRF1278F module (based on SX1278) mounted on an adaptor from stuartsprojects (via tindie.com) controlled by an arduino mini-pro also mounted on an adaptor (same source) to ease physical interconnection.
Using variious bits of code the hardware seems to work when set to LoRa, but it all seems to fall apart when trying FSK.
Deciding to use RadioLib I have set the interface pins I belive are DIO0 = 3, DIO1 = 5, RESET = 9 & NSS = 10, so slightly different than the example code.
However, again when using LoRa it seems to transmit fine, but changing to FSK all I get is
Failed, code -16
which seems to indicate SPI write failure.

My basic code is attached: I have changed the pin connections to what I belive is correct.

// include the library
#include <RadioLib.h>

// SX1278 has the following connections:
// NSS pin:   10
// DIO0 pin:  3
// RESET pin: 9
// DIO1 pin:  5
SX1278 radio = new Module(10, 3, 9, 5);



void setup() {
  // put your setup code here, to run once:
  Serial.begin(115200);

  // carrier frequency:           434.0 MHz
  // bit rate:                    48.0 kbps
  // frequency deviation:         50.0 kHz
  // Rx bandwidth:                125.0 kHz
  // output power:                13 dBm
  // preamble length:             16-bits
  // OOK modulation:              false
//  int state = radio.beginFSK(434.0, 48.0, 50.0, 125.0, 13, 16, false);
  int state = radio.beginFSK();
  if (state == ERR_NONE) {
    Serial.println(F("success!"));
  } else {
    Serial.print(F("failed, code "));
    Serial.println(state);
    while (true);
  }
  
  // the following settings can also
  // be modified at run-time
/*  state = radio.setFrequency(433.5);
  state = radio.setBitRate(100.0);
  state = radio.setFrequencyDeviation(10.0);
  state = radio.setRxBandwidth(250.0);
  state = radio.setOutputPower(10.0);
  state = radio.setCurrentLimit(100);
  state = radio.setDataShaping(RADIOLIB_SHAPING_0_5);
  uint8_t syncWord[] = {0x01, 0x23, 0x45, 0x67,
                        0x89, 0xAB, 0xCD, 0xEF};
  state = radio.setSyncWord(syncWord, 8);
  if (state != ERR_NONE) {
    Serial.print(F("Unable to set configuration, code "));
    Serial.println(state);
    while (true);
  }
*/
}

void loop() {
  Serial.print(F("[SX1278] Transmitting packet ... "));


  byte byteArr[] = {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF};
  int state = radio.transmit(byteArr, 8);

  if (state == ERR_NONE) {
    // the packet was successfully transmitted
    Serial.println(F(" success!"));

    // print measured data rate
    Serial.print(F("[SX1278] Datarate:\t"));
    Serial.print(radio.getDataRate());
    Serial.println(F(" bps"));

  } else if (state == ERR_PACKET_TOO_LONG) {
    // the supplied packet was longer than 256 bytes
    Serial.println(F("too long!"));

  } else if (state == ERR_TX_TIMEOUT) {
    // timeout occurred while transmitting packet
    Serial.println(F("timeout!"));

  } else {
    // some other error occurred
    Serial.print(F("failed, code "));
    Serial.println(state);

  }

  // wait for a second before transmitting again
  delay(1000);
}

Obviously I have not yet set the correct detailed parameters yet, but I would expect it to at least transmit.
I have tried adding the explicit FSK parameters as you can see by the commented out line, but no change.

I suspect its something glaringly obvious, but I can't see it!

As a supplementary question, on the receive side is it possible to set a specific Rx timeout? I think in the previous LoRaLib it was set to 500% of the air time, I want to implement an 'ack' message return, so I'm not sure how accurate I can time the Rx/Tx switching at both ends.

As an alternative are there any better RF modules capable of running arround 458MHz that anybody knows?
Thanks

[jgromes]

You seem to have directly used the FSKModem example, despite the note that states it's just an API guide. I suggest uploading the Transmit example with updated pins and beginFSK() instead of begin(). That's going to be a lot closer to the actual use case you're aiming for. Once you have that, if the problem persists, please enable debug and verbose mode and post the serial output. The instructions can be found here.

on the receive side is it possible to set a specific Rx timeout?

You're right it used to be 500% of the on-air time for maximum packet length, this is still the case when using a blocking receive(). Though I would argue that it's a lot better to not rely on that and use the interrupt-driven reception. Then you don't really have to worry about Rx timeouts anymore.

As an alternative are there any better RF modules capable of running arround 458MHz that anybody knows?

"Better" in what way? Higher range? Lower price? Lower power? AFAIK SX127x/SX126x is a pretty good fit for a lot of applications, because of its versatility. You might have to design a custom breakout board though, since all commercial modules I know of are designed for one of the ISM bands: 434/868/915 MHZ.