Data loss SPI communication (Master Slave) (ESP32) - esp32

Question

I am trying to make a simple SPI Master/slave comunication between two ESP32, using this code as reference https://github.com/hideakitai/ESP32DMASPI
My code is (master) :
#include <stdio.h>
#include <stdint.h>
#include <Arduino.h>
#include "maspn18_e3_a_r2_c_can_cr09338.h"
#include <ESP32DMASPIMaster.h>
//#include <ESP32DMASPISlave.h>
#include <ESP32CAN.h>
#include <CAN_config.h>
#include <iostream>
#include <stdlib.h>
//#include <SPI.h>
/*
#include <string.h>
#include <math.h>
*/
// === [ START ] Master Configuration ===
ESP32DMASPI::Master master;
static const uint32_t BUFFER_SIZE = 8; // deve essere un multiplo di 4 ==> 8192
uint8_t* spi_master_tx_buf;
//uint8_t* spi_master_rx_buf;
uint8_t num_msg = 0;
uint8_t msg_src[]= {num_msg, 0x80, 0x4A, 0x0F, 0x00, 0x00, 0x00, 0x00};
//uint8_t msg_src[]= {0x00, 0x80, 0x4A, 0x0F, 0x00, 0x00, 0x00, 0x00};
void set_buffer() {
for (uint32_t i = 0; i < BUFFER_SIZE; i++) {
spi_master_tx_buf[i] = msg_src[i];
//spi_master_tx_buf[i] = i & 0xFF;
}
//memset(spi_master_rx_buf, 0, BUFFER_SIZE);
}
// === [ STOP ] Master Configuration ===
using namespace std;
CAN_device_t CAN_cfg; // CAN Config
const int rx_queue_size = 10; // Receive Queue size
void setup() {
Serial.begin(115200);
Serial.println("CAN reader on primary CAN bus - MASTER SPI");
//CAN_cfg.speed = CAN_SPEED_500KBPS;
//CAN_cfg.tx_pin_id = GPIO_NUM_22;
//CAN_cfg.rx_pin_id = GPIO_NUM_21;
//CAN_cfg.rx_queue = xQueueCreate(rx_queue_size, sizeof(CAN_frame_t));
//////////// Init CAN Module
//ESP32Can.CANInit();
// === [ START ] Master setup ===
// to use DMA buffer, use these methods to allocate buffer
spi_master_tx_buf = master.allocDMABuffer(BUFFER_SIZE);
//spi_master_rx_buf = master.allocDMABuffer(BUFFER_SIZE);
set_buffer();
delay(5000);
master.setDataMode(SPI_MODE0); // default: SPI_MODE0
master.setFrequency(4000000); // default: 8MHz (too fast for bread board...) // 4000000
master.setMaxTransferSize(BUFFER_SIZE); // default: 4092 bytes
// begin() after setting
Serial.println("master.begin() - default: VSPI (CS: 5, CLK: 18, MOSI: 23, MISO: 19)");
master.begin(VSPI); // default: HSPI (CS: 15, CLK: 14, MOSI: 13, MISO: 12)
// === [ STOP ] Master setup ===
}
void loop() {
master.transfer(spi_master_tx_buf, BUFFER_SIZE);
printf("[%d] Send data ==>\n", msg_src[0]);
msg_src[0]++;
for (uint32_t i = 0; i < BUFFER_SIZE; i++) {
spi_master_tx_buf[i] = msg_src[i];
//spi_master_tx_buf[i] = i & 0xFF;
}
delay(2000);
// === [ STOP ] Master loop ===
}
And for the slave :
#include <stdio.h>
#include <stdint.h>
#include <Arduino.h>
#include "maspn18_e3_a_r2_c_can_cr09338.h"
#include <ESP32DMASPISlave.h>
#include <ESP32CAN.h>
#include <CAN_config.h>
#include <iostream>
#include <stdlib.h>
#include <SPI.h>
/*
#include <string.h>
#include <math.h>
*/
// MASTER SPI ==> https://github.com/hideakitai/ESP32DMASPI/blob/master/examples/master_simple/master_simple.ino
ESP32DMASPI::Slave slave;
static const uint32_t BUFFER_SIZE = 8; // 8192
//uint8_t* spi_slave_tx_buf;
uint8_t* spi_slave_rx_buf;
using namespace std;
CAN_device_t CAN_cfg; // CAN Config
const int rx_queue_size = 10; // Receive Queue size
void setup() {
Serial.begin(115200);
Serial.println("CAN writer on second CAN bus - SLAVE SPI");
spi_slave_rx_buf = slave.allocDMABuffer(BUFFER_SIZE);
//set_buffer();
delay(5000);
// slave device configuration
slave.setDataMode(SPI_MODE0);
slave.setMaxTransferSize(BUFFER_SIZE);
// begin() after setting
//slave.begin(); // HSPI = CS: 15, CLK: 14, MOSI: 13, MISO: 12 -> default
// VSPI (CS: 5, CLK: 18, MOSI: 23, MISO: 19)
Serial.println("slave.begin(VSPI); - VSPI (CS: 5, CLK: 18, MOSI: 23, MISO: 19)");
slave.begin(VSPI);
}
void loop() {
// if there is no transaction in queue, add transaction
if (slave.remained() == 0) {
//slave.queue(spi_slave_rx_buf, spi_slave_tx_buf, BUFFER_SIZE);
slave.queue(spi_slave_rx_buf, BUFFER_SIZE);
}
// if transaction has completed from master,
// available() returns size of results of transaction,
// and buffer is automatically updated
while (slave.available()) {
printf("Received data ==> ");
// show received data
for (size_t i = 0; i < BUFFER_SIZE; ++i) {
printf("%d ", spi_slave_rx_buf[i]);
}
printf("\n");
slave.pop();
}
}
Basically it just sends a simple array over and over again with an incremental number in the first place. However, apparently at random, the comunication will "skip" a number or it will print the same a couple of time and then skip it. Image for reference :
Print of the received message on the slave:
What could be the cause of this problem?
I tried altering the frequence of the communication and i tried varying the buffer size to the smallest possible, but it does not seem to have any effect
Thanks a lot in advance