NRF52832 - Send and receive up to 300 bytes via SPI

RE: NRF52832 - Send and receive up to 300 bytes via SPI

ovrebekk — Thu, 01 Dec 2022 14:57:59 GMT

The first step would have to be to change your current SPI read/write functions to be non blocking rather than blocking, so that you are able to process button presses and prepare the next SPI packet while the current packet is being transmitted.

The normal way to do this is to implement some kind of state machine, and remove all the steps in your code where you are running a while loop to wait for some event to occur, like the line below:

while (!radio_spi_transfer_finished) // wait for finish

Then you can process and prepare a new buffer while the current one is being transmitted, and as soon as the ongoing transaction is complete you can immediately proceed with the next.

Best regards
Torbjørn

RE: NRF52832 - Send and receive up to 300 bytes via SPI

nordicfreak — Wed, 30 Nov 2022 09:27:35 GMT

How would I go about implementing this buffered communication?

RE: NRF52832 - Send and receive up to 300 bytes via SPI

ovrebekk — Wed, 30 Nov 2022 09:25:35 GMT

You mean to say you are never able to get bi-directional communication, it will only send in one direction at a time?

It might be for the simple reason that both sides are too responsive. Since the button press on each side is unlikely to be processed at exactly the same time one side will start a transaction before the other one has a new packet ready?

Alternatively the problem could be that you are not able to prepare a new transaction while the current one is ongoing. If you try to send a new packet on either side while it is currently in the middle of a transaction then the new packet should be buffered, so that as soon as the current transaction is complete you will immediately send the next one. Then you should be able to schedule the communication more efficiently.

Best regards
Torbjørn

RE: NRF52832 - Send and receive up to 300 bytes via SPI

nordicfreak — Tue, 29 Nov 2022 20:05:48 GMT

Ok, the problem was that I forgot the call the nrf_drv_spis_buffers_set at the end of the spi_tx in the slave. Now both sides send and receive OK. The question is how to make it more performant?
I noticed that when i keep pressed both buttons only one of them sends, I would have expected that they both send intermittently.

RE: NRF52832 - Send and receive up to 300 bytes via SPI

nordicfreak — Tue, 29 Nov 2022 12:01:57 GMT

Thank you for that.

Meanwhile, I have put together some code, and I would like to know how it can be optimized.

Master sends to slave.

Slave sends to master

but after slave sends to master, master cannot send to slave anymore...

SPI Slave Code:

uint16_t total_data_length = 0;
/**
 * @brief SPIS user event handler.
 *
 * @param event
 */
void spis_event_handler(nrf_drv_spis_event_t event) {
  if (event.evt_type == NRF_DRV_SPIS_XFER_DONE) {
  uint16_t real_len;
    
  if (!spis_tx_mode)
    {
			
			if(!data_read_pending)		//if this is first/single transaction, 
			{
				total_data_length = bytes_to_u16(m_spi_rx_dma_buf[0],m_spi_rx_dma_buf[1]);		//get the payload size from the first 2 bytes
			}
			if(total_data_length > 250)		//payload size is greater then 250 
			{
				if(!data_read_pending)		//is this the first transaction?
				{
					//this is first transaction
					memcpy(rx_data1, m_spi_rx_dma_buf, 252);
					rx_data_len = total_data_length;
					data_read_pending = true;
				}
				else
				{
					//this is the second transaction
					uint16_t bytes_left = total_data_length - 250;
					memcpy(rx_data1+252, m_spi_rx_dma_buf, bytes_left);
					rx_data_len = total_data_length;
                                        data_read_pending = false;
                                        NRF_LOG_INFO("cnt: %d, received: %d, one: %X, last %X\n", rcv_cnt,rx_data_len, rx_data1[0], rx_data1[299]);
                                        rcv_cnt = rcv_cnt+1;
                                        //send_data_ble(rx_data); //here we need to ship this data by bluetooth (complete frame)
				    total_data_length = 0;
				}
			}
			else //payload size less than 250, this is a single transaction
			{
				
				if(!data_read_pending) //we should never have this flag set to true, since this is a single transaction
				{
					memcpy(rx_data1+252, m_spi_rx_dma_buf, total_data_length);
					rx_data_len = total_data_length;
                                        NRF_LOG_INFO("cnt: %d, received: %d, one: %X, last %X\n", rcv_cnt,rx_data_len, rx_data1[0], rx_data1[299]);
                                        rcv_cnt = rcv_cnt+1;
                                        //send_data_ble(rx_data); //here we need to ship this data by bluetooth (complete mini-frame)
				    total_data_length = 0;
				}
				else
				{
                                        NRF_LOG_INFO("CRITICAL FAILURE"); //data_read_pending should never be true for less than 250 bytes frames
					
				}
			}			
			
			nrf_drv_spis_buffers_set(&spis, NULL, 0, m_spi_rx_dma_buf, sizeof m_spi_rx_dma_buf - 1); // problem here
    }

    spis_xfer_done = true;
    
  }
}

/**
 * @brief SPIS TX function.
 *
 * @param event
 */
uint32_t spi_tx(uint8_t *data, uint32_t len) {
  uint32_t err_code;
  int i = 0;
  spis_tx_mode = 1;
  // check how many packets need to be sent if we send only 1 packet at a time with max size of 250 bytes
  uint8_t total_packets = 0; // total packets to send
  uint8_t packet_len = 0;
  if (len > 250) {
    total_packets = 2;
    packet_len = 250;
  } else {
    total_packets = 1;
    packet_len = len;
  }

  while (i < total_packets) {
    // split each packet and send
    uint8_t a = 0;
    uint8_t packet_to_send[255];
    if (i == 0) {
      // add the headers
      for (a = 0; a < packet_len; a++) {
        // keep space for headers in the first transaction
        packet_to_send[a + 2] = data[(i * 250) + a];
      }
    } else {
      for (a = 0; a < packet_len; a++) {
        // do not add any headers
        packet_to_send[a] = data[(i * 250) + a];
      }
    }
    i++;
    if (i != total_packets) {
      // add packet length in the first 2 bytes
      packet_to_send[0] = len >> 8;
      packet_to_send[1] = len;
    }
    // send the packet
    spis_xfer_done = false;
    if (i != total_packets) {
      // if its the first transaction, add 2 bytes count in the packet length
      err_code = nrf_drv_spis_buffers_set(&spis, packet_to_send, packet_len + 2, NULL, 0); // length byte + data
      VERIFY_SUCCESS(err_code);
    } else {
      err_code = nrf_drv_spis_buffers_set(&spis, packet_to_send, packet_len, NULL, 0); // length byte + data
      VERIFY_SUCCESS(err_code);
    }
    // NRF_LOG_INFO("Prepared %i bytes", packet_len);
    if (i == 1) {
      nrf_gpio_pin_set(CUSTOM_SPI_IRQ_PIN);
      nrf_delay_us(100);
      nrf_gpio_pin_clear(CUSTOM_SPI_IRQ_PIN);
    }
    while (!spis_xfer_done) {
      __WFE();
    }
    int d = 0;
    // calculate next data length
    if (i == total_packets) {
      // all data is sent
    } else if ((total_packets - i) == 1) {
      // only one packet left
      packet_len = len - 250;
    }
  }
  spis_tx_mode = 0;

  return NRF_SUCCESS;
}

/**
 * @brief Send data via bluetooth.
 *
 * @param payload
 */

void send_data_ble(uint8_t *payload, uint8_t size) {
  uint32_t err_code;
  do {
    uint16_t length = size;
    uint32_t err_code = ble_nus_data_send(&m_nus, payload, &length, m_conn_handle);
    if ((err_code != NRF_ERROR_INVALID_STATE) &&
        (err_code != NRF_ERROR_RESOURCES) &&
        (err_code != NRF_ERROR_NOT_FOUND)) {
      APP_ERROR_CHECK(err_code);
    }
  } while (err_code == NRF_ERROR_RESOURCES);
}

/**@brief Application main function.
 */
int main(void) {

  nrf_gpio_pin_dir_set(CUSTOM_SPI_IRQ_PIN, NRF_GPIO_PIN_DIR_OUTPUT);
  nrf_gpio_pin_clear(CUSTOM_SPI_IRQ_PIN);

  // Initialize.
  log_init();
  timers_init();
  power_management_init();
  ble_stack_init();
  gap_params_init();
  gatt_init();
  services_init();
  advertising_init();
  conn_params_init();
  // nrf_gpio_cfg_output(8);

  // Enable the constant latency sub power mode to minimize the time it takes
  // for the SPIS peripheral to become active after the CSN line is asserted
  // (when the CPU is in sleep mode).
  // NRF_POWER->TASKS_CONSTLAT = 1;

  nrf_drv_spis_config_t spis_config = NRF_DRV_SPIS_DEFAULT_CONFIG;
  spis_config.csn_pin = APP_SPIS_CS_PIN;
  spis_config.miso_pin = APP_SPIS_MISO_PIN;
  spis_config.mosi_pin = APP_SPIS_MOSI_PIN;
  spis_config.sck_pin = APP_SPIS_SCK_PIN;
  spis_config.orc = 0x55; // this one
  spis_config.bit_order = 1;
  uint32_t err_code;
  APP_ERROR_CHECK(nrf_drv_spis_init(&spis, &spis_config, spis_event_handler));
  err_code = nrf_drv_spis_buffers_set(&spis, NULL, 0, m_spi_rx_dma_buf, sizeof m_spi_rx_dma_buf - 1); // problem here
  VERIFY_SUCCESS(err_code);

  advertising_start();

  err_code = sd_ble_gap_tx_power_set(BLE_GAP_TX_POWER_ROLE_ADV, m_advertising.adv_handle, 4); // increase power to maximum
  APP_ERROR_CHECK(err_code);
  uint8_t spi_test_payload[] = {0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99, 0x99,
      0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88,
      0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77,
      0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66,
      0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55,
      0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44};

  // Enter main loop.
  uint8_t small_payload[14] = {0x2f, 0x38, 0xEF, 0xAB, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11};

  NRF_LOG_INFO("Slave SPI Started!");
  while (1) {

         if(!nrf_gpio_pin_read(BUTTON_1))
       {
            nrf_delay_ms(150);
            if(!nrf_gpio_pin_read(BUTTON_1))
            {
               spi_tx(spi_test_payload, 300);
            }
       }

  }
}

SPI Master Code:

static volatile uint8_t radio_spi_transfer_finished = 0;
static void radio_spi_handler(nrfx_spi_evt_t const *p_event, void *p_context) {
  radio_spi_transfer_finished = 1;
}

uint32_t radio_is_ready_to_read() {
  nrf_gpio_cfg(SPIRADIO_IO1,
      NRF_GPIO_PIN_DIR_INPUT,
      NRF_GPIO_PIN_INPUT_CONNECT,
      NRF_GPIO_PIN_PULLDOWN,
      NRF_GPIO_PIN_S0S1,
      NRF_GPIO_PIN_NOSENSE);

  return nrf_gpio_pin_read(SPIRADIO_IO1);
}

uint32_t radio_spi_read(uint8_t *dst, uint32_t dstlen) {
  uint16_t rx_data_len = 0;
  memset(dst, 0xFF, dstlen); // sanitize the buffer



  /***********************FIRST READ*************************************/
  nrfx_spim_xfer_desc_t xfer_desc = NRFX_SPIM_XFER_RX(dst, 252);

  flash_spi_transfer_finished = 0;
  if (NRFX_SUCCESS != nrfx_spim_xfer(&radio_spi, &xfer_desc, 0)) {
    NRF_LOG_INFO("SPI READ FAILED!");
    return 0;
  }

  while (!radio_spi_transfer_finished)
    ;
  /*********************************************************************/

  nrf_delay_us(500);
  uint16_t total_data_length = bytes_to_u16(dst[0], dst[1]);
  if (total_data_length > 250) // need to read more data in case its more then 250 bytes?
  {
    uint16_t bytes_left = total_data_length - 250;
    nrf_delay_ms(1); // give some delay so that slave can easily prepare the next packet
  /***********************SECOND READ (OPTIONAL)*************************************/
  nrfx_spim_xfer_desc_t xfer_desc = NRFX_SPIM_XFER_RX(dst+252, total_data_length-252);

  flash_spi_transfer_finished = 0;
  if (NRFX_SUCCESS != nrfx_spim_xfer(&radio_spi, &xfer_desc, 0)) {
    NRF_LOG_INFO("SPI READ FAILED!");
    return 0;
  }

  while (!radio_spi_transfer_finished)
    ;
  /************************************************************************************/
    nrf_delay_us(500);
    rx_data_len = total_data_length;
  } else {
    rx_data_len = total_data_length;
  }

  NRF_LOG_INFO("received: %d, one: %X, last %X\n", rcv_cnt, rx_data_len, dst[0], dst[299]);

  return dstlen;
}




/***************************************  FUNCTION TO WRITE SPI DATA ******************************************/
uint32_t radio_spi_write(uint8_t *data, uint32_t len) {
  uint32_t err_code;
  int i = 0;
  // check how many packets need to be sent if we send only 1 packet at a time with max size of 250 bytes
  uint8_t total_packets = 0; // total packets to send
  uint8_t packet_len = 0;
  if (len > 250) {
    total_packets = 2;
    packet_len = 250;
  } else {
    total_packets = 1;
    packet_len = len;
  }

  while (i < total_packets) {
    // split each packet and send
    uint8_t a = 0;
    uint8_t packet_to_send[255];
    if (i == 0) {
      // add the headers
      for (a = 0; a < packet_len; a++) {
        // keep space for headers in the first transaction
        packet_to_send[a + 2] = data[(i * 250) + a];
      }
    } else {
      for (a = 0; a < packet_len; a++) {
        // do not add any headers
        packet_to_send[a] = data[(i * 250) + a];
      }
    }
    i++;
    if (i != total_packets) {
      // add packet length in the first 2 bytes
      packet_to_send[0] = len >> 8;
      packet_to_send[1] = len;
    }
    // send the packet
    radio_spi_transfer_finished = false;
    if (i != total_packets) {
      // if its the first transaction, add 2 bytes count in the packet length
      nrfx_spim_xfer_desc_t xfer_desc = NRFX_SPIM_XFER_TRX(packet_to_send, packet_len + 2, NULL, 0);

      if (NRFX_SUCCESS != nrfx_spim_xfer(&radio_spi, &xfer_desc, 0)) {
        NRF_LOG_INFO("SPI WRITE FAILED!");
        return 1;
      }
    } else {
      nrfx_spim_xfer_desc_t xfer_desc = NRFX_SPIM_XFER_TRX(packet_to_send, packet_len, NULL, 0);

      if (NRFX_SUCCESS != nrfx_spim_xfer(&radio_spi, &xfer_desc, 0)) {
        NRF_LOG_INFO("SPI WRITE FAILED!");
        return 1;
      }
    }

    while (!radio_spi_transfer_finished) // wait for finish
      ;
    nrf_delay_ms(3);

    int d = 0;
    // calculate next data length
    if (i == total_packets) {
      // all data is sent
    } else if ((total_packets - i) == 1) {
      // only one packet left
      packet_len = len - 250;
    }
  }

  return NRF_SUCCESS;
}

//****************************************************************************************************//

void radio_spi_init() {
  nrfx_spim_config_t spi_config = NRFX_SPIM_DEFAULT_CONFIG;
  spi_config.frequency = NRF_SPIM_FREQ_4M;
  spi_config.ss_pin = SPIRADIO_CS;
  spi_config.miso_pin = SPIRADIO_MISO;
  spi_config.mosi_pin = SPIRADIO_MOSI;
  spi_config.sck_pin = SPIRADIO_SCK;
  spi_config.bit_order = NRF_SPI_BIT_ORDER_LSB_FIRST;
  spi_config.ss_active_high = false;
  spi_config.orc = 0x5A;
  APP_ERROR_CHECK(nrfx_spim_init(&radio_spi, &spi_config, radio_spi_handler, NULL));
}




  //////////////////MAIN LOOP/////////////////
  memset(spi_buffer, 0, sizeof(spi_buffer));
  nrf_gpio_cfg_input(BUTTON_1, NRF_GPIO_PIN_PULLUP);   //for devboard testing
  while(1){

       if(!nrf_gpio_pin_read(BUTTON_1))
       {
            nrf_delay_ms(150);
            if(!nrf_gpio_pin_read(BUTTON_1))
            {
               radio_spi_write(spi_test_payload, sizeof spi_test_payload); 
            }
       }

                
if(radio_is_ready_to_read() == 1) 
		{
                    uint8_t rx_data1[320];
                    radio_spi_read(rx_data1, 320);
		}


  }

Looking forward to your reply.

RE: NRF52832 - Send and receive up to 300 bytes via SPI

ovrebekk — Mon, 28 Nov 2022 13:56:58 GMT

This code shouldn't have to be much more complicated than the code you've already written, but I don't mind writing a small example for it, Christmas or not 😉

I'll try to have it done by the end of the week.

Best regards
Torbjørn

RE: NRF52832 - Send and receive up to 300 bytes via SPI

nordicfreak — Fri, 25 Nov 2022 20:18:22 GMT

Ok, this is way above my coding capabilities. Is there any way someone your team can write some some sample code for this? I am sure it will benefit many users who want to use SPI on any device other than nrf52840.

Time to get into the Christmas spirit and give the gift of code to the community.

RE: NRF52832 - Send and receive up to 300 bytes via SPI

ovrebekk — Fri, 25 Nov 2022 14:41:43 GMT

That is a bit less straight forward. It is the master that decides how many bytes to clock out, which the slave would have to tell it somehow.

This is another argument for including the packet length as the first bytes of the message.

Then you could have a basic approach like this:

1) IRQ pin is asserted by the slave

2) The master sets the chip select pin low and starts a 2 byte transaction to read the length

3) Based on the length the master sets up the second transaction, to pick up the data (for the slave this looks like a continuation of the first transaction, since chip select was kept low)

4) The master sets the chip select pin high

5) If the data length was > 253 bytes, the spi master sends another command to pick up the remaining bytes

Best regards
Torbjørn

RE: NRF52832 - Send and receive up to 300 bytes via SPI

nordicfreak — Fri, 25 Nov 2022 09:31:34 GMT

will this work for bi-directional transfers? master send to slave and slave send to master (using irq pin)

RE: NRF52832 - Send and receive up to 300 bytes via SPI

ovrebekk — Fri, 25 Nov 2022 09:21:18 GMT

That was more or less my original idea, but I think I might have come up with a better one:

Rather than adding header bytes or similar to your data it is possible to simply use the length of the packet as an indication whether or not there is another packet coming.

Essentially if you receive a packet that is 255 bytes long then you assume that the real message is longer, and that the next packet will have to be appended to the first.

The advantage of this method is that you don't need to manually append the data from the two packets, since you can just set the EasyDMA pointer of the SPI slave to the right place in the buffer for the second transaction.

The only special case here is if you ever need to send a packet that is exactly 255 bytes long, since that would cause the SPI slave to assume another transaction was coming.

To solve this issue you either need to send a 1 byte dummy packet after the 255 byte transaction, to wrap it up, or you need to include a length field or something at the start of the first packet so the SPI slave can tell whether or not the second packet is needed (similar to the first suggestion, but if you only include the header on the first packet you can still append the two packets seamlessly without requiring a memcpy).

Best regards
Torbjørn

RE: NRF52832 - Send and receive up to 300 bytes via SPI

nordicfreak — Thu, 24 Nov 2022 16:09:41 GMT

So basically creating a global 300 bytes buffer and a bool called "complex_transaction".
When IRQ triggers, if first byte of the payload is 254, complex_transaction will be set to true and the next transaction will be automatically appended to the buffer after the first one.

Does that sound right to you? How do you see it?

RE: NRF52832 - Send and receive up to 300 bytes via SPI

ovrebekk — Thu, 24 Nov 2022 16:03:29 GMT

Sorry about that, I read PCA10040 and thought of the 52840 for some reason...

Unfortunately that trick won't really work with the nRF52832, since both the SPIM and SPIS interfaces are limited to 255 bytes maximum.

I think you need to split the update into two separate transactions, and possibly use a header byte or similar at the start of the transaction to signify whether or not there are more transactions coming which should be appended to the first.

Then you need to compile the two transaction into a single message on the receiving end, before passing it along to other parts of the system.

I don't think we have any examples showing this exact procedure, but you basically just need to send two transactions in succession whenever the payload in question is larger than 255 bytes (or larger than 254, if you use 1 byte for the header).

Best regards
Torbjørn

RE: NRF52832 - Send and receive up to 300 bytes via SPI

nordicfreak — Thu, 24 Nov 2022 15:30:37 GMT

Thank you for the reply.

Yes, as stated in the subject of my question, I am using nrf52832.

So the trick with keeping the line low will work for the 52832 also?

If not, what are my alternatives? Any example code?

Please note, the communication must be bi-directional, and it can happen in either direction at any arbitrary time.

RE: NRF52832 - Send and receive up to 300 bytes via SPI

ovrebekk — Thu, 24 Nov 2022 15:28:47 GMT

When it comes to SPI the chip select line is used to signal the start and end of a transaction, so as long as you don't pull the chip select low for each transaction, but pull it low for the duration of both transactions, the slave should read it as one transaction.

With that being said, there is no 256 byte limit on the SPIM or SPIS interfaces in the nRF52840.

If you take a look at the TXD or RXD MAXCNT registers (like this one) you will see that they can be as large as 0xFFFF, or 65535 bytes.

Most likely you are thinking of the nRF52832, which was the first device in the nRF52 series, and was a bit more limited in terms of how large EasyDMA buffers you could use.

Best regards
Torbjørn