Maybe updates for: SPI, Wire, ili9341_t3 libraries...

Adafruit_SSD1306 display(OLED_RESET, Wire2);

// Quick and dirty I2c Master/Slave combination test.

#define SLAVE_ADDR 8
#include <Wire.h>
// Lets try alternate pins for Wire
#define SDA0 34
#define SCL0 33
#define SLAVE_I2C  Wire3
uint8_t *buffer;
#define MASTER_I2C  Wire
#define REG_COUNT 8
extern void requestEvent();
void setup()
{
  pinMode(0, OUTPUT);
  pinMode(1, OUTPUT);
  while (!Serial && (millis() < 3000)) ;
  Serial.begin(115200);
  delay(250);
  buffer = (uint8_t*)malloc(32);
  // Quick check to see if we can change pins
  Wire.setSCL(SCL0);
  Wire.setSDA(SDA0);

  // Start up both Master and save SPIs
  Serial.println("Before Master begin");
  MASTER_I2C.begin(); // join i2c bus (address optional for master)
  Serial.println("Before Slave Begin");
  SLAVE_I2C.onReceive(receiveEvent);  // register a slave even handler
  SLAVE_I2C.onRequest(requestEvent);
  SLAVE_I2C.begin(SLAVE_ADDR);
  pinMode(13, OUTPUT); 
  digitalWrite(13, LOW);
}

uint8_t vals_to_write = REG_COUNT;

void loop()
{
  digitalWrite(13, HIGH);
  for (uint8_t i = 0; i < REG_COUNT; i++) {
    digitalWrite(0, HIGH);
    uint8_t reg_val = ReadReg(i);
    digitalWrite(0, LOW);
    Serial.printf("Reg %d = %d\n", i, reg_val);
  }

  // lets try updating all of them...
  Serial.println("Update values");
  for (uint8_t i = 0; i < REG_COUNT; i++) {
    digitalWrite(0, HIGH);
    WriteReg(i, vals_to_write++);
    digitalWrite(0, LOW);
  }
  digitalWrite(13, LOW);

  
  Serial.println("\nHit any key to repeat");
  while (Serial.read() == -1) ;
  while (Serial.read() != -1) ; // get rid of other data.
}

//==========================================================================================
// Some master request or set register functions
uint8_t ReadReg(uint8_t reg) {
  MASTER_I2C.beginTransmission(SLAVE_ADDR); // transmit to device #8
  MASTER_I2C.write(0);              // Do a read
  MASTER_I2C.write(reg);
  MASTER_I2C.write(1);              // one byte
  MASTER_I2C.endTransmission();    // stop transmitting

  // Then request data from other side
  if (MASTER_I2C.requestFrom(SLAVE_ADDR, 1)) { // Try to get the data back from the other side
    return MASTER_I2C.read(); // read in the result and return it.
  }
  return 0xff;
}

void WriteReg(uint8_t reg, uint8_t val) {
  //Serial.printf("Write Reg %d = %d\n", reg, val);
  MASTER_I2C.beginTransmission(SLAVE_ADDR); // transmit to device #8
  MASTER_I2C.write(1);              // Do a read
  MASTER_I2C.write(reg);
  MASTER_I2C.write(val);              // one byte
  MASTER_I2C.endTransmission();    // stop transmitting
}

//===========================================================================================
// Some slave registers and state values
uint8_t registers[REG_COUNT] = {0, 1, 2, 3, 4, 5, 6, 7}; // some dummy registers to play with.
uint8_t  read_write = 0;
uint8_t  start_reg = 0;
uint8_t  cnt_reg = 1;

void receiveEvent(int count_bytes)
{
  digitalWrite(1, HIGH);
//  Serial.println("Receive");
  read_write = SLAVE_I2C.read();  // first byte is command
  if (count_bytes > 1) start_reg = SLAVE_I2C.read();
  if (read_write) {
    while (SLAVE_I2C.available()) {
      registers[start_reg] = SLAVE_I2C.read();
      //Serial.printf("RcE: %d %d\n", start_reg, registers[start_reg]);
      start_reg++;
    }

  } else {
    // read mode
    if (SLAVE_I2C.available()) {
      cnt_reg = SLAVE_I2C.read();
    }
  }
  digitalWrite(1, LOW);
}

void requestEvent()
{
  digitalWrite(1, HIGH);
//  Serial.println("Request");
  // Host is asking for data.
  for (uint8_t i = 0; i < cnt_reg; i++) {
    //Serial.printf("RQE: %d %d\n", start_reg, registers[start_reg]);
    SLAVE_I2C.write(registers[start_reg++]);
  }
  digitalWrite(1, LOW);
}

 for (uint8_t i = 0; i < REG_COUNT; i++) {
    digitalWrite(0, HIGH);
    uint8_t reg_val = ReadReg(i);
    digitalWrite(0, LOW);
    Serial.printf("Reg %d = %d\n", i, reg_val);
  }

	// BUGBUG: see if I can loop a little 
	uint8_t delay_count = 0xff;
	while (delay_count-- && (i2c_status(kinetisk_pi2c) & I2C_S_BUSY)) ;

       // Needs to be done before we clobber the status line
	kinetisk_pi2c->S = I2C_S_IICIF | I2C_S_ARBL;

LSM303 compass(Wire2);

// rf95_server.pde
// -*- mode: C++ -*-
// Example sketch showing how to create a simple messageing server
// with the RH_RF95 class. RH_RF95 class does not provide for addressing or
// reliability, so you should only use RH_RF95  if you do not need the higher
// level messaging abilities.
// It is designed to work with the other example rf95_client
// Tested with Anarduino MiniWirelessLoRa, Rocket Scream Mini Ultra Pro with
// the RFM95W, Adafruit Feather M0 with RFM95

#include <SPI.h>
#include <RH_RF95.h>
#define TRY_SPI1
#ifdef TRY_SPI1
#include <RHHardwareSPI1.h>
// MISO 1, MOSI 0, SCK 20
#define RFM95_CS 31
#define RFM95_RST 37
#define RFM95_INT 2

// SPI1 Miso=D5, Mosi=21, sck=20, CS=31
RH_RF95 rf95(RFM95_CS, RFM95_INT, hardware_spi1);

// Singleton instance of the radio driver
#else
//  RH_RF95(uint8_t slaveSelectPin = SS, uint8_t interruptPin = 2, RHGenericSPI& spi = hardware_spi);
#define RFM95_CS 10
#define RFM95_RST 9
#define RFM95_INT 2

RH_RF95 rf95(RFM95_CS, RFM95_INT);
#endif

// Change to 434.0 or other frequency, must match RX's freq!
#define RF95_FREQ 915.0


void setup() 
{
  pinMode(RFM95_RST, OUTPUT);
  digitalWrite(RFM95_RST, HIGH);

  Serial.begin(9600);
  while (!Serial) ; // Wait for serial port to be available

#ifdef TRY_SPI1
  SPI1.setMISO(5);
  SPI1.setMOSI(21);
  SPI1.setSCK(20); 
#endif

  if (!rf95.init())
    Serial.println("init failed");  
  // Defaults after init are 434.0MHz, 13dBm, Bw = 125 kHz, Cr = 4/5, Sf = 128chips/symbol, CRC on

  if (!rf95.setFrequency(RF95_FREQ)) {
    Serial.println("setFrequency failed");
    while (1);
  }
  Serial.print("Set Freq to: "); Serial.println(RF95_FREQ);
  rf95.setTxPower(23, false);

}

void loop()
{
  if (rf95.available())
  {
    // Should be a message for us now   
    uint8_t buf[RH_RF95_MAX_MESSAGE_LEN];
    uint8_t len = sizeof(buf);
    if (rf95.recv(buf, &len))
    {
//      digitalWrite(led, HIGH);
//      RH_RF95::printBuffer("request: ", buf, len);
      Serial.print("got request: ");
      Serial.println((char*)buf);
      Serial.print("RSSI: ");
      Serial.println(rf95.lastRssi(), DEC);
      
      // Send a reply
      uint8_t data[] = "And hello back to you";
      delay(5);
      bool sent = rf95.send(data, sizeof(data));
      Serial.print("Send reply ");
      Serial.println((int)sent, DEC);
      rf95.waitPacketSent();
      Serial.println("Sent a reply");
//       digitalWrite(led, LOW);
    }
    else
    {
      Serial.println("recv failed");
    }
  }
}