SPI MISO buffer doesn't fill

RE: SPI MISO buffer doesn't fill

haakonsh — Tue, 18 Sep 2018 13:09:56 GMT

I suggest you use GPIOTE driver or app_button library instead of the Board Support Library.

"Should I only set SPI_DEFAULT_CONFIG_IRQ_PRIORITY or also set NRFX_SPIM_DEFAULT_CONFIG_IRQ to a higher priority value, or something different altogether?"
- I would set both to the same value.

"Is it correct that GPIOTE_CONFIG_IRQ_PRIORITY is the relevant IRQ for the BSP handler?

- Yes, I believe so. The BSP uses the app_button library and it uses the GPIOTE peripheral.

"Include the name of the source and/or header file in the driver/library documentation in the infocenter. This way it's easier to match/find code files to documentation, or the other way around."
- I agree on this point, right now the library names do not reflect the naming convention used in the SDK.

RE: SPI MISO buffer doesn't fill

KevinL — Mon, 17 Sep 2018 08:24:13 GMT

I have found the solution and managed to confirm with another thread.

It comes down to the interrupt priority not being set correctly. To quote MartinBL:

It could be an issue with interrupt nesting. It seems like you start the SPI transfer 
from within the BSP event handler. If the SPI has lower interrupt priority than the 
BSP handler, then the SPI handler will not be executed before the BSP handler has 
completed. But since you are effectively waiting for the SPI in the BSP handler you 
end up in a dead lock.

I have set SPI_DEFAULT_CONFIG_IRQ_PRIORITY to 6. I think the button is configured in GPIOTE_CONFIG_IRQ_PRIORITY which is set to 7.

Due to this I have a few questions:

Should I only set SPI_DEFAULT_CONFIG_IRQ_PRIORITY or also set NRFX_SPIM_DEFAULT_CONFIG_IRQ to a higher priority value, or something different altogether?

Is it correct that GPIOTE_CONFIG_IRQ_PRIORITY is the relevant IRQ for the BSP handler?

I also want to do a suggestion:

Include the name of the source and/or header file in the driver/library documentation in the infocenter. This way it's easier to match/find code files to documentation, or the other way around.

RE: SPI MISO buffer doesn't fill

KevinL — Thu, 13 Sep 2018 10:39:51 GMT

If it turns out I cannot get the code to work in seperate files I will try placing everything in main.c. This would in my opinion be a bad practice, so I will first try to get it to work in peripheral.c. I'm convinced it should be possible.
I actually thought I had changed everything to now use the SPIM driver. I assume you are asking about the SPI driver because I had nrf_drv_spi.h included. I admittedly forgot to include nrfx_spim.h, which I have done now. I have also found that I was still using a few SPI driver types. I have now made the following changes:
main.c

extern void (*p_spim_event_handler)();        //Changed declaration
void spi_config(void)
{
  nrfx_spim_config_t spim_config = NRFX_SPIM_DEFAULT_CONFIG;
  spim_config.sck_pin = SPIM_SCK_PIN;
  spim_config.miso_pin = SPIM_MISO_PIN;
  spim_config.mosi_pin = SPIM_MOSI_PIN;
  spim_config.ss_pin = SPIM_SS_PIN != NRFX_SPIM_PIN_NOT_USED ? SPIM_SS_PIN : NRFX_SPIM_PIN_NOT_USED;    //Changed PIN_NOT_USED
  spim_config.frequency = SPIM_FREQUENCY;
  APP_ERROR_CHECK(nrfx_spim_init(p_spim_instance, &spim_config, *p_spim_event_handler, NULL));
}

peripheral.h

added
#include "nrfx_spim.h"

static void spim_event_handler(nrfx_spim_evt_t const *, void *);        //Added prototype

peripheral.c

static void spim_event_handler(nrfx_spim_evt_t const * p_event,                   //Changed parameter type
                       void *                  p_context)
{
    *p_spi_xfer_done = true;
    NRF_LOG_INFO("Transfer completed.");
    if (m_rx_buf[0] != 0)
    {
        NRF_LOG_INFO(" Received:");
        NRF_LOG_HEXDUMP_INFO(m_rx_buf, strlen((const char *)m_rx_buf));
    }
}
void (*p_spim_event_handler) = &spim_event_handler;

(I can edit to include the complete code again)

There is actually a type "nrfx_spim_evt_handler_t", but when I use this instead of void I get warnings for incompatible pointer types even though it does work. I have also tried making the event handler static or non-static and eliminating the function pointer.

Regardless of everything I have tried, I can only make it work when I'm calling the read function from main(), but not when I press a button. Every time I use the button I can see the correct result in m_rx_buf, but the code stays in an infinite loop.

For good measure I have placed the event handler in main.c without any pointers, removing the calls to the buffer. This shows the exact same behaviour where it works fine when calling the transfer from main(), but not when calling via a button press.

Unfortunately it is essential for my project to be able to take user input (button) to start a transfer.

RE: SPI MISO buffer doesn't fill

haakonsh — Fri, 07 Sep 2018 12:48:32 GMT

Why do you use the SPI driver and not the SPIM driver?

The easy fix is to place the code in main.c as I believe it executes as intended when built in that compile unit.

RE: SPI MISO buffer doesn't fill

KevinL — Wed, 05 Sep 2018 12:47:56 GMT

I have done single stepping through the driver when calling it from the button event handler before of which I have described the behaviour in a previous comment (4 September 14:43). I have now also tried single stepping through the driver when calling from main which causes it the a "softdevice: assertion failed" error. I assume this is due to timing requirements not being met as a result of single stepping. When I use breakpoints to evaluate specific points in the driver, specifically nrfx_spim.c line 536-540, the code immediately jumps to the spi event handler function. This behaviour seems correct to me.

So the difference is that after line 540 in nrfx_spim.c I either jump to the infinite while-loop or the spi event handler, using the button event handler or call from main respectively.

My optimization level for the solution has been set to "none" all the time.

RE: SPI MISO buffer doesn't fill

haakonsh — Wed, 05 Sep 2018 12:09:24 GMT

The SPIM driver controls the SS pin when using SPIM0-2.

Have you single stepped through the driver when you called the read function from main loop and compared it to when you called it from the button event handler?

Have your tried turning off compiler optimization?

RE: SPI MISO buffer doesn't fill

KevinL — Tue, 04 Sep 2018 13:55:02 GMT

When calling nrfx_spim_init: p_spi_event_handler = 0x00039e65

Checking the value of void (*p_spi_event_handler) = &spi_event_handler; in peripheral.h = 0x00039e65

The event handler is also being called correctly during writing and continuous reading, just not when using the button to read.

Sorry about the formatting, things get messed up when copy-pasting.

RE: SPI MISO buffer doesn't fill

KevinL — Tue, 04 Sep 2018 13:48:47 GMT

I've seen here that you note SPIM 0-2 do not have HW SS, while SPIM 3 does. I am however using SPIM0 and can observe SS toggling correctly with above code. It only stays at 0 when I'm also stuck in the infinite-loop.

This is quite confusing. Am I misunderstanding something about HW SS?

RE: SPI MISO buffer doesn't fill

haakonsh — Tue, 04 Sep 2018 13:46:32 GMT

What is the value of p_spi_event_handler when you execute nrfx_spim_init?

RE: SPI MISO buffer doesn't fill

KevinL — Tue, 04 Sep 2018 12:43:42 GMT

Ok, so I have created some pre-processor conditions so I can easily swap between SPI and SPIM. I will show both in case I've made a mistake.

Near the bottom of main() is a for(;;) loop to test continuous reading which works fine. Commenting this out and triggering the same read with a button enters an infinite while-loop in register_read() (peripheral.c). The buffer reflects the correct data, the event handler is simply not being called

main.c

//Button
#define USBBUTTON_BUTTON                BSP_EVENT_KEY_1                         /**< Button to start search for USB device */
//SPI
#define SPIM_INSTANCE                   0                                       /**< SPI instance index */
#if SPIM_DRIVER
#define SPIM_FREQUENCY                  NRF_SPIM_FREQ_4M                        /**< SPIM frequency */
//#define SPIM_HW_SS                      true                                    /**< SPIM use hardware slave select - only with SPIM3 */
#else
#define SPI_FREQUENCY                   NRF_DRV_SPI_FREQ_4M                     /**< SPI frequency */
#endif
#define SPIM_SCK_PIN                    3                                       /**< SPI_SCK_PIN - pin number */
#define SPIM_MOSI_PIN                   4                                       /**< SPI_SCK_PIN - pin number */
#define SPIM_MISO_PIN                   28                                      /**< SPI_SCK_PIN - pin number */
#define SPIM_SS_PIN                     29                                      /**< SPI_SCK_PIN - pin number */
//#define CUSTOM_SS_PIN                   29                                      /**< CUSTOM_SS_PIN - pin number */

#if SPIM_DRIVER
static const nrfx_spim_t peripheral = NRFX_SPIM_INSTANCE(SPIM_INSTANCE);       /**< SPIM instance */
const nrfx_spim_t *p_spim_instance = &peripheral;
#else
static const nrf_drv_spi_t peripheral = NRF_DRV_SPI_INSTANCE(SPIM_INSTANCE);       /**< SPI instance */
const nrf_drv_spi_t *p_spi_instance = &peripheral;
#endif
static volatile bool spi_xfer_done;                                             /**< Flag used to indicate that SPI instance completed the transfer */


void usb_timers_start(void)     //Triggered on button press
{
  peripheral_read_17();
}

extern void *p_spi_event_handler;
void spi_config(void)
{
#if SPIM_DRIVER
  nrfx_spim_config_t spim_config = NRFX_SPIM_DEFAULT_CONFIG;
  spim_config.sck_pin = SPIM_SCK_PIN;
  spim_config.miso_pin = SPIM_MISO_PIN;
  spim_config.mosi_pin = SPIM_MOSI_PIN;
  spim_config.ss_pin = SPIM_SS_PIN != NRF_DRV_SPI_PIN_NOT_USED ? SPIM_SS_PIN : NRF_DRV_SPI_PIN_NOT_USED;
  spim_config.frequency = SPIM_FREQUENCY;
//  spim_config.use_hw_ss = SPIM_HW_SS;
  APP_ERROR_CHECK(nrfx_spim_init(p_spim_instance, &spim_config, p_spi_event_handler, NULL));
#else
  nrf_drv_spi_config_t spi_config = NRF_DRV_SPI_DEFAULT_CONFIG;
  spi_config.sck_pin  = SPIM_SCK_PIN;
  spi_config.miso_pin = SPIM_MISO_PIN;
  spi_config.mosi_pin = SPIM_MOSI_PIN;
  spi_config.ss_pin = SPIM_SS_PIN != NRF_DRV_SPI_PIN_NOT_USED ? SPIM_SS_PIN : NRF_DRV_SPI_PIN_NOT_USED;
  spi_config.frequency = SPI_FREQUENCY;
  APP_ERROR_CHECK(nrf_drv_spi_init(p_spi_instance, &spi_config, p_spi_event_handler, NULL));
#endif      //SPIM_DRIVER
  /*Configure GPIO as slave select for SPI*/
  //nrf_gpio_cfg_output(CUSTOM_SS_PIN);
  //nrf_gpio_pin_set(CUSTOM_SS_PIN);
}

static void bsp_event_handler(bsp_event_t event)
{
    ret_code_t err_code;

    switch (event)
    {
        //default cases from example
        //..
        case USBBUTTON_BUTTON:
          usb_timers_start();
          break;
        default:
            break;
    }
}

int main(void)
{
    bool erase_bonds;

    // Initialize.
    log_init();
    timers_init();
    buttons_leds_init(&erase_bonds);
    power_management_init();
    ble_stack_init();
    gap_params_init();
    gatt_init();
    advertising_init();
    services_init();
    conn_params_init();
    peer_manager_init();

    //SPI configuration and initialization
    spi_config();
    //peripheral initialization
    peripheral_init(/*peripheral, */&spi_xfer_done);

    // Start execution.
    NRF_LOG_INFO("Template example started.");
    //application_timers_start();
    advertising_start(erase_bonds);

//For testing - Comment this out for button to trigger peripheral_read_17();
for(;;)      //This works normally
{
nrf_delay_ms(500);
  peripheral_read_17();
}


    // Enter main loop.
    for (;;)
    {
        idle_state_handle();
    }
}

peripheral.h

#ifndef PERIPHERAL_H__
#define PERIPHERAL_H__

#include "nrf_drv_spi.h"


#define SPIM_DRIVER       1         /**< SPI driver = 0 - SPIM driver = 1 */

#if SPIM_DRIVER
extern const nrfx_spim_t *p_spim_instance;
#else
extern const nrf_drv_spi_t *p_spi_instance;                                      /**< Pointer to SPI instance */
#endif      //SPIM_DRIVER

#endif  //PERIPHERAL_H__

peripheral.c

#include "peripheral.h"
#include "nrf_gpio.h"
#include "nrf_log.h"
#include "nrf_drv_spi.h"
#include <stdint.h>

static volatile bool *p_spi_xfer_done;                                           /**< Pointer to SPI_xfer_done flag */
static uint8_t m_tx_buf[2] = {};                                                /**< TX buffer */
static uint8_t m_rx_buf[sizeof(m_tx_buf) + 1];                                  /**< RX buffer */
static const int8_t tx_buf_length = sizeof(m_tx_buf);                               /**< Transfer length */
static const int8_t rx_buf_length = sizeof(m_rx_buf);                               /**< Transfer length */

static void register_read(peripheral_host_registers_t register_to_access, int rx_length)
{
  peripheral_host_result_codes_t result;
  uint8_t command;

  memset(m_tx_buf, 0, tx_buf_length);
  memset(m_rx_buf, 0, rx_buf_length);
  *p_spi_xfer_done = false;

  m_tx_buf[0] = command_byte_set(register_to_access, read);
#if SPIM_DRIVER
  nrfx_spim_xfer_desc_t transfer_descriptor;                                      //SPIM
  transfer_descriptor.p_tx_buffer = m_tx_buf;
  transfer_descriptor.tx_length = 1;
  transfer_descriptor.p_rx_buffer = m_rx_buf;
  transfer_descriptor.rx_length = rx_length + 1;
  APP_ERROR_CHECK(nrfx_spim_xfer(p_spim_instance, &transfer_descriptor, 0));        //SPIM
#else
  APP_ERROR_CHECK(nrf_drv_spi_transfer(p_spi_instance, m_tx_buf, 1, m_rx_buf, rx_length + 1));      //SPI
#endif      //SPIM_DRIVER

  while (!*p_spi_xfer_done)                ////This is an infinite loop
  {
    __WFE();
  }
}

static void register_write(peripheral_host_registers_t register_to_access, uint8_t data, int tx_length)
{
  peripheral_host_result_codes_t result;
  uint8_t command;

  memset(m_tx_buf, 0, tx_buf_length);
  memset(m_rx_buf, 0, rx_buf_length);
  *p_spi_xfer_done = false;

  m_tx_buf[0] = command_byte_set(register_to_access, write);
  m_tx_buf[1] = data;         //append data to buffer

#if SPIM_DRIVER
  nrfx_spim_xfer_desc_t transfer_descriptor;                                      //SPIM
  transfer_descriptor.p_tx_buffer = m_tx_buf;
  transfer_descriptor.tx_length = tx_length + 1;
  transfer_descriptor.p_rx_buffer = m_rx_buf;
  transfer_descriptor.rx_length = 1;
  APP_ERROR_CHECK(nrfx_spim_xfer(p_spim_instance, &transfer_descriptor, 0));        //SPIM
#else
  APP_ERROR_CHECK(nrf_drv_spi_transfer(p_spi_instance, m_tx_buf, tx_length + 1, m_rx_buf, 1));        //SPI
#endif      //SPIM_DRIVER

  while (!*p_spi_xfer_done)
  {
    __WFE();
  }
}

void spi_event_handler(nrf_drv_spi_evt_t const * p_event,
                       void *                    p_context)
{
    *p_spi_xfer_done = true;
    NRF_LOG_INFO("Transfer completed.");
    if (m_rx_buf[0] != 0)
    {
        NRF_LOG_INFO(" Received:");
        NRF_LOG_HEXDUMP_INFO(m_rx_buf, strlen((const char *)m_rx_buf));
    }
}
void (*p_spi_event_handler) = &spi_event_handler;                   //Function pointer declared in main.c

////Below this is the same as before

void peripheral_init(volatile bool *spi_xfer_done)
{
  p_spi_xfer_done = spi_xfer_done;

  register_init(17, 0, 0, 0, 1, 1, 0, 1, 0);        //creates byte with configuration value (0x1a) and calls register_write
}

static void register_init(peripheral_registers_t register_to_access,
                     uint8_t bit_value7,
                     uint8_t bit_value6,
                     uint8_t bit_value5,
                     uint8_t bit_value4,
                     uint8_t bit_value3,
                     uint8_t bit_value2,
                     uint8_t bit_value1,
                     uint8_t bit_value0)
{
  uint8_t register_value = 0;
  uint8_t bit_value_array[8] = {bit_value0, bit_value1, bit_value2, bit_value3, bit_value4, bit_value5, bit_value6, bit_value7};   //Array and binary MSB/LSB are reverse in order!

  for(int8_t bit_shift = 7; bit_shift >= 0; bit_shift--)
  {
    //Shift configuration bit into the right place of the register value
    register_value |= shift_bit(register_value, bit_value_array[bit_shift], bit_shift);
  }
  register_write(register_to_access, register_value, 1);
}

/**@brief Read register 17 on button press
 * Expected result is 0x1a
 */
void peripheral_read_17(void)
{
  uint8_t result;
  register_read(17, 1);
}

When I follow the call to nrfx_spim_xfer (reading) I get up to nrfx_spim.c line 540, this seems to return NRFX_SUCCESS. After this I either enter the infinite while-loop or immediately get an error (softdevice assertion failed & spi_xfer_done symbol not found in watch). I assume getting the error is due to timing not working out after being stuck in the loop for a bit or stepping through the code.

All of this is with NRFX_SPIM_ENABLED, NRFX_SPIM0_ENABLED, SPI_ENABLED, SPI0_ENABLED, SPI0_USE_EASY_DMA being enabled. The interrupt priorities of these are set to 7.

Let me know if there is anything else you need to know

RE: SPI MISO buffer doesn't fill

haakonsh — Tue, 04 Sep 2018 08:39:27 GMT

"Is there anything else I could try, or is it not possible to have an SPI transaction being triggered by a button?"
- It is certainly possible.

Do you mind sharing your updated code and show us where you're stuck in a loop?

RE: SPI MISO buffer doesn't fill

KevinL — Mon, 03 Sep 2018 12:46:35 GMT

Thank you for your clear response, but I have not managed to solve it completely yet. The received data now properly reflect in the receive buffer. Despite this I'm still stuck in the infinite loop in register_read().

I have changed everything SPI related to use the SPIM driver. With this I have had nrf_drv_spi enabled and also disabled (and commented out). I do not see any difference in behaviour between these two. I have also used regular SPI, which yields the same result.

This infinite loop only occurs when I trigger a transfer by pressing a button. Any transfer started in main(), whether for configuration or repeatedly reading a register, works perfectly normal. I don't have any timers running anymore to eliminate possibly disruptive sources, so the only difference I can think of is having the button or not. Note that the softdevice is running in every scenario.

Is there anything else I could try, or is it not possible to have an SPI transaction being triggered by a button?

RE: SPI MISO buffer doesn't fill

haakonsh — Fri, 31 Aug 2018 09:29:03 GMT

Use nrfx_spim_init and nrfx_spim_xfer.

"To ensure this I have been commenting the legacy layer SPI configurations in sdk_config.h out. Is this the right way to go?"

-No, not really. You should leave it as is, and enable the SPI instance in the legacy layer SPI of sdk_config.h, I believe the nrfx driver has an #ifdef or two that requires it.

"Lastly, should I create the SPI instance as in the SPI master example (NRF_DRV_SPI_INSTANCE() macro) or the nrfx version?"
- Yes.

I suggest you try this out and verify the implementation by reading the SPIM registers before and after you've called nrfx_spim_xfer (debug session). That way you can see if the SPIM peripheral is set up correctly, and what might be missing, like enabled interrupts, clk frequency, CPOL/CPHA config, RXD/TXD pointers, etc.

RE: SPI MISO buffer doesn't fill

KevinL — Wed, 29 Aug 2018 14:01:55 GMT

Hello again, sorry for the delay as I've had a week off.

I have looked into using the SPIM peripheral and the examples. Specifically the SPI Master example as I have been using this from the start. It seems to me as if this uses the SPI peripheral making use of the older nrf driver. Is this correct?

It seems to me as to use SPIM I should also make sure I use the nrfx driver. To ensure this I have been commenting the legacy layer SPI configurations in sdk_config.h out. Is this the right way to go?

Lastly, should I create the SPI instance as in the SPI master example (NRF_DRV_SPI_INSTANCE() macro) or the nrfx version? I guess this ties into my other questions.

Is there anything I should specifically watch for to transition to SPIM?

Edit: I think the best question would be: Can you link the api reference from the infocenter of the SPIM master driver I should be using (e.g. this)?

RE: SPI MISO buffer doesn't fill

haakonsh — Mon, 20 Aug 2018 11:30:47 GMT

I suggest you use the SPI Master Example or SPI Transaction Manager Example, and use SPIM0-2 as the instance. SPIM3 is the Quad SPI peripheral.

RE: SPI MISO buffer doesn't fill

KevinL — Fri, 17 Aug 2018 14:05:27 GMT

I have a question considering the SPIM peripheral. There are 2 examples, namely \examples\peripheral\spi and \examples\peripheral\nrfx_spim. According to the SDK documentation both (can) use SPIM, they are considerably different in their setup however. Can it be as easy as changing sdk_config.h to use NRFX_SPIM3_ENABLED instead of SPI0_ENABLED?

Which should I be using, assuming I only want to transmit data without special interactions?

RE: SPI MISO buffer doesn't fill

KevinL — Fri, 17 Aug 2018 12:29:59 GMT

I have been hesitant to do this since SPI seemed more straight forward without having to worry about easyDMA. I will try to change it to SPIM.

I am using a timer to start the SPI transfer, I also have 2 other timers running not related to SPI. I have not found anything indicating it, but could this potentially be of influence?

RE: SPI MISO buffer doesn't fill

haakonsh — Fri, 17 Aug 2018 12:10:52 GMT

You really should use the SPIM peripheral and not the SPI peripheral, as this will play a lot better with the SoftDevice and the rest of your application.

RE: SPI MISO buffer doesn't fill

KevinL — Fri, 17 Aug 2018 10:14:53 GMT

I have tried finding what causes spi_event_handler not to get called in my project. I have set breakpoints at

- nrf_drv_spi.c line 94

- nrfx_spi.c line 234, 416 and 423

None of these breakpoints are getting triggered in my own project when reading registers. They do however trigger when writing registers.

RE: SPI MISO buffer doesn't fill

KevinL — Fri, 17 Aug 2018 09:58:18 GMT

Thank you for your fast reply.

The if-statement on the slave select pin indeed does nothing. I implemented it when I used a gpio for slave select and still have that code in case I am going to need it in future. That is also why I haven't removed that condition yet. As I see it it should not cause any problems though.

1. It has to be properly connected. This is proven by the debug terminal which outputs the 0x19 every time I write a configuration.

<info> app: Received:
<info> app: 19 |.

I can also see the spi_xfer_done being toggled using a watch in the debugger.

2.1. I have loaded the spim example (\examples\peripheral\spi\) onto the board and edited m_tx_buf to {136}. Scope shows:

MOSI [10001000, 11111111] (0x88, 0xFF)

MISO [00011001, 00000000] (0x19, 0x00)

The debug terminal doesn't show anything, but I can see m_rx_buf containing [0x19, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]. The code also does not get stuck, opposed to my own project.

2.2. I have copied peripheral.h and peripheral.c almost completely (excluding some irrelevant code) into main.c of the example. Added my configuration of the internal SPI peripheral and initialization of the external peripheral, and substituted the content of the while-loop to let it read a register (1000 ms delay). This is running correctly and I can see the m_rx_buf reflect the data.

One thing I have noticed here is that it hits a certain breakpoint (nrf_drv_spi_transfer()) 4 times before it continues. On the third time it actually sends and receives as I can see on the scope and rx_buffer watch. I suspect this has something to do with timings. I have not observed this at any point before.

I'm not sure what to conclude from this. To me it seems the only difference is the code being in 3 files or only main.c to get it to work

Edit: Thinking about it, my projectis advertising as per examples\ble_peripheral\ble_app_template. I have merged these 2 examples. Maybe this could be of an influence?

Edit2: To expand on my previous thought. I have added the read to trigger continuously in main() with a 500 ms delay instead of at the press of a button. This works for a few times until I get a "SOFTDEVICE: ASSERTION FAILED" error.

The button I'm using triggers a timer to execute the reading a few times.

RE: SPI MISO buffer doesn't fill

haakonsh — Fri, 17 Aug 2018 08:36:10 GMT

Is the MISO line connected?
Does the read function work if you place everything in main.c of the SPIM example?

"P.s.: I think there is a bug where I can't upload, remove, then reupload a different image with the same name. It will then show the first image again in the editor."
- yeah we know, I think it will use the new file once you submit the post though.

Also, spi_config.ss_pin = SPI_SS_PIN != NRF_DRV_SPI_PIN_NOT_USED ? SPI_SS_PIN : NRF_DRV_SPI_PIN_NOT_USED; //this if statement does nothing, you might as well just use spi_config.ss_pin = SPI_SS_PIN;