How to do SPIM with handshakes

Question

I'm using SDK15.3 on an nRF52840 with FreeRTOS and specifically non-preemptive scheduling. 
 I want to so some transfers on SPIM (it's configure with DMA but that's not a requirement)... I've got a part I'm talking to that has a READY handshake signal coming back from it that kicks in during long transfers... basically it's implementing XON/XOFF for the regular SPI transaction. 
 Got any hints at how to handle that?

Simonr · Accepted Answer

Hi 
 I'm sorry, but I'm not sure what you're asking how to handle here. Is the READY handshake interrupting your transfers when you're not expecting it to, or what exactly is the issue here? There could be buffer that reaches its limit for example, but please share some more information here on what the issue here is. 
 Best regards, 
 Simon

Susheel Nuguru · Answer

I got involved just because I saw FreeRTOS here but the code that you seek does not necessarily depend on FreeRTOS. 
 After you initialize the SPI using nrf_drv_spim_init, I think you can use something like below code as template to have the connections you see through PPI to the tasks. 
 static nrf_ppi_channel_t ppi_channel_suspend;
static nrf_ppi_channel_t ppi_channel_resume;

void gpio_ppi_init(void)
{
 APP_ERROR_CHECK(nrf_drv_gpiote_init());

// Set up the READY_PIN as an input that can detect both active and inactive edges.
 // This will let us sense when the external device signals us to pause or resume.
 nrf_drv_gpiote_in_config_t ready_pin_config = GPIOTE_CONFIG_IN_SENSE_TOGGLE(false);
 ready_pin_config.pull = NRF_GPIO_PIN_NOPULL; // adjust if your circuit requires it.
 APP_ERROR_CHECK(nrf_drv_gpiote_in_init(READY_PIN, &ready_pin_config, NULL));

// Reserve two PPI channels: one for pausing SPI (SUSPEND) and one for resuming it (RESUME).
 APP_ERROR_CHECK(nrf_drv_ppi_channel_alloc(&ppi_channel_suspend));
 APP_ERROR_CHECK(nrf_drv_ppi_channel_alloc(&ppi_channel_resume));

// Link the READY_PIN's "active edge" event to the SPIM's SUSPEND task.
 // This ensures the SPI pauses when the device signals us to stop.
 APP_ERROR_CHECK(nrf_drv_ppi_channel_assign(
 ppi_channel_suspend,
 nrf_drv_gpiote_in_event_addr_get(READY_PIN),
 (uint32_t)&NRF_SPIM0->TASKS_SUSPEND
 ));

// Link the READY_PIN's "inactive edge" event to the SPIM's RESUME task.
 // This ensures the SPI resumes when the device signals it's ready to continue.
 APP_ERROR_CHECK(nrf_drv_ppi_channel_enable(ppi_channel_suspend));
 APP_ERROR_CHECK(nrf_drv_ppi_channel_enable(ppi_channel_resume));
} 
 This is uncompiled code trying to show you the logic. Please use that as template.

Hieu · Answer

You are right that there is only a single event for both edge. The PPI will not actually pingpong anything. It will simply trigger the PPI channel that is enabled. 
 So, if both the suspend and resume channels are enabled, both tasks are triggered, which is obviously not what we want, and I have no idea what will happen in that case. 
 And you are also completely right that you will need to use ISR. 
 There are several options to do this: 
 
 Manual "pingpong" like you mentioned. The simplest and fastest (shortest ISR time) way is to only enable one of the two PPI channels during initialization. The ISR handle will disable one channel and enable the other.
 
 A potential downside with this approach is a race condition if the next edge arrive before the ISR handling is done. How big a risk this is depends on the particularities of your system. There might be ways to work around it.

The ISR handler controls the SPI suspending and resuming. It can do both tasks; or it can do one, and the other task is still done by PPI.

hmolesworth · Answer

Don't need toggle. The trick is to know the a single pin can be input to several GPIOTE channels. This works, I tested it on some other stuff. #define PIN_SPIM_XON_XOFF 14 #define PPI_SPIM_SUSPEND 0 #define PPI_SPIM_RESUME 1 #define GPIOTE_SPIM_SUSPEND 0 #define GPIOTE_SPIM_RESUME 1 static void TestPPI_SPIM_SuspendResume(void) { NRF_P0->OUTCLR = (1 << PIN_SPIM_XON_XOFF); // Configuration Direction Input Pullup Drive Level Sense Level // ================================ ========== ============== ============ ============== ============= NRF_P0->PIN_CNF[PIN_SPIM_XON_XOFF] = (PIN_INPUT | PIN_CONNECT | PIN_PULLNONE | PIN_DRIVE_H0H1 | PIN_SENSE_LOW); // Configure input for resume on rising edge with suspend on falling edge NRF_GPIOTE->CONFIG[GPIOTE_SPIM_RESUME] = GPIOTE_CONFIG_MODE_Event << GPIOTE_CONFIG_MODE_Pos | GPIOTE_CONFIG_POLARITY_LoToHi << GPIOTE_CONFIG_POLARITY_Pos | PIN_SPIM_XON_XOFF << GPIOTE_CONFIG_PSEL_Pos | GPIOTE_CONFIG_OUTINIT_Low << GPIOTE_CONFIG_OUTINIT_Pos; NRF_GPIOTE->CONFIG[GPIOTE_SPIM_SUSPEND] = GPIOTE_CONFIG_MODE_Event << GPIOTE_CONFIG_MODE_Pos | GPIOTE_CONFIG_POLARITY_HiToLo << GPIOTE_CONFIG_POLARITY_Pos | PIN_SPIM_XON_XOFF << GPIOTE_CONFIG_PSEL_Pos | GPIOTE_CONFIG_OUTINIT_Low << GPIOTE_CONFIG_OUTINIT_Pos; // Resume SPIM transfer on rising edge of pulse via PPI NRF_PPI->CH[PPI_SPIM_RESUME].EEP = (uint32_t)&NRF_GPIOTE->EVENTS_IN[GPIOTE_CHANNEL_B]; NRF_PPI->CH[PPI_SPIM_RESUME].TEP = (uint32_t)&NRF_SPIM0->TASKS_RESUME; // Suspend SPIM transfer on falling edge via PPI NRF_PPI->CH[PPI_SPIM_SUSPEND].EEP = (uint32_t)&NRF_GPIOTE->EVENTS_IN[GPIOTE_CHANNEL_A]; // Event NRF_PPI->CH[PPI_SPIM_SUSPEND].TEP = (uint32_t)&NRF_SPIM0->TASKS_SUSPEND; // Task #1 // Let's add an EGU interrupt to play with NRF_PPI->FORK[PPI_SPIM_SUSPEND].TEP = (uint32_t)&NRF_EGU0->TASKS_TRIGGER[0]; // Task #2 // Enable the Suspend/Resume PPI channels NRF_GPIOTE->EVENTS_PORT = 0; NRF_PPI->CHENSET = (1UL << PPI_SPIM_RESUME) | (1UL << PPI_SPIM_SUSPEND); blah_blah(); }

How to do SPIM with handshakes

Top Replies