nrf52832 Not receiving from Arduino In SPI communication

[KM123]

This is the second time I am posting here related issue on nrf52832 SPI communication. I am still not able to get the response from the sensor. Here I am testing my SPI is working properly or not in NRF board. so I have tested with Arduino board .What I am getting that data is transferred clearly from nrf52 to the Arduino board but when I am trying to get the data from Arduino to nrf52 it is not responding. 

I am in doubt that the problem is in hardware or software. Please help me sort the problem out .

I am hereby attaching the main.c of both code for your references.

This is the Segger embedded code for nrf52.

.

/**
 * Copyright (c) 2015 - 2017, Nordic Semiconductor ASA
 * 
 * All rights reserved.
 * 
 * Redistribution and use in source and binary forms, with or without modification,
 * are permitted provided that the following conditions are met:
 * 
 * 1. Redistributions of source code must retain the above copyright notice, this
 *    list of conditions and the following disclaimer.
 * 
 * 2. Redistributions in binary form, except as embedded into a Nordic
 *    Semiconductor ASA integrated circuit in a product or a software update for
 *    such product, must reproduce the above copyright notice, this list of
 *    conditions and the following disclaimer in the documentation and/or other
 *    materials provided with the distribution.
 * 
 * 3. Neither the name of Nordic Semiconductor ASA nor the names of its
 *    contributors may be used to endorse or promote products derived from this
 *    software without specific prior written permission.
 * 
 * 4. This software, with or without modification, must only be used with a
 *    Nordic Semiconductor ASA integrated circuit.
 * 
 * 5. Any software provided in binary form under this license must not be reverse
 *    engineered, decompiled, modified and/or disassembled.
 * 
 * THIS SOFTWARE IS PROVIDED BY NORDIC SEMICONDUCTOR ASA "AS IS" AND ANY EXPRESS
 * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL NORDIC SEMICONDUCTOR ASA OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
 * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 * 
 */
#include "nrf_drv_spi.h"
#include "app_util_platform.h"
#include "nrf_gpio.h"
#include "nrf_delay.h"
#include "boards.h"
#include "app_error.h"
#include <string.h>
#include "nrf_log.h"
#include "nrf_log_ctrl.h"
#include "nrf_log_default_backends.h"

#define SPI_INSTANCE  0 /**< SPI instance index. */
static const nrf_drv_spi_t spi = NRF_DRV_SPI_INSTANCE(SPI_INSTANCE);  /**< SPI instance. */
static volatile bool spi_xfer_done;  /**< Flag used to indicate that SPI instance completed the transfer. */

//#define TEST_STRING "N"
static uint8_t       m_tx_buf[] = {'N'};           /**< TX buffer. */
static uint8_t       m_rx_buf[2];    /**< RX buffer. */
static const uint8_t m_length = sizeof(m_tx_buf);        /**< Transfer length. */

/**
 * @brief SPI user event handler.
 * @param event
 */
void spi_event_handler(nrf_drv_spi_evt_t const * p_event,
                       void *                    p_context)
{
    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));
    }
}

int main(void)
{
    bsp_board_leds_init();

    APP_ERROR_CHECK(NRF_LOG_INIT(NULL));
    NRF_LOG_DEFAULT_BACKENDS_INIT();
    
    NRF_LOG_INFO("SPI example.");

    nrf_drv_spi_config_t spi_config = NRF_DRV_SPI_DEFAULT_CONFIG;
    spi_config.ss_pin   = SPI_SS_PIN;
    spi_config.miso_pin = SPI_MISO_PIN;
    spi_config.mosi_pin = SPI_MOSI_PIN;
    spi_config.sck_pin  = SPI_SCK_PIN;


    spi_config.irq_priority = APP_IRQ_PRIORITY_LOW;
    spi_config.orc          = 0xCC;
    spi_config.frequency    = NRF_DRV_SPI_FREQ_500K;
    spi_config.mode         = NRF_DRV_SPI_MODE_0;
    spi_config.bit_order    = NRF_DRV_SPI_BIT_ORDER_MSB_FIRST;

    APP_ERROR_CHECK(nrf_drv_spi_init(&spi, &spi_config, spi_event_handler, NULL));

    while (1)
    {
        // Reset rx buffer and transfer done flag
        memset(m_rx_buf, 0, m_length);
        spi_xfer_done = false;

        APP_ERROR_CHECK(nrf_drv_spi_transfer(&spi, m_tx_buf, m_length, m_rx_buf, m_length));

        while (!spi_xfer_done)
        {
            __WFE();
        }

        NRF_LOG_FLUSH();

        bsp_board_led_invert(BSP_BOARD_LED_0);
        nrf_delay_ms(200);
    }
}

Here is main.c for Arduino code mentioned below.

// what to do with incoming data
volatile byte command = 0;
int select_slave = 0; //1: selected, 2: not selected

void setup (void)
  {

  Serial.begin (9600);
  Serial.println ("This is SPI slave test");
  // have to send on master in, *slave out*
  pinMode(MISO, OUTPUT);

  // turn on SPI in slave mode
  SPCR |= _BV(SPE);

  // turn on interrupts
  SPCR |= _BV(SPIE);

  }  // end of setup


// SPI interrupt routine
ISR (SPI_STC_vect)
  {
  byte c = SPDR;
  
  if(command == 0)
  {
    SPDR = 0;
  }
  else
  {
    SPDR = c;
    Serial.print ("Rx is:");
    delay(1000);
    Serial.println (c, DEC);
    Serial.print ("Tx is:");
    delay(1000);
    Serial.println (33, DEC);
    
  }
  
  }  // end of interrupt service routine (ISR) SPI_STC_vect

void loop (void)
  {

    // if SPI not active, clear current command
    if (digitalRead (SS) == HIGH)
    {
      command = 0;
      if(select_slave!=2)
      { Serial.println("Slave is not selected");
      select_slave = 2;}
    }
    else
    {
      command = 1;
      if(select_slave!=1)
      { 
        Serial.println("**Slave is selected");
        Serial.println(select_slave);
        select_slave = 1;
      }
    }
  }  // end of loop

[Karl Ylvisaker]

Hello,

What I am getting that data is transferred clearly from nrf52 to the Arduino board but when I am trying to get the data from Arduino to nrf52 it is not responding. 

I am in doubt that the problem is in hardware or software. Please help me sort the problem out .

If you are able to transfer data from the nRF52 to the other device, we know that the hardware connection is ok.
Could you elaborate how you verify that the Arduino is receiving the data from the nRF52 properly?
What happens when you attempt to send data from the Arduino to the nRF52?
Do you have access to a oscilloscope or a logical analyzer, so we may see what is happening on the lines when you try to send data from the Arduino? A logical analyzer is a very powerful tool to wield when debugging serial interfaces.

Here is main.c for Arduino code mentioned below.

We do not support Arduino, and unfortunately I have very little personal experience with Arduino, so it is hard for me to know what to look for here, sorry. What have you based your Arduino code on, is there a SPI example or similar that you have used as reference?

Best regards,
Karl

[KM123]

Hi @Karl Ylvisaker,

 We have checked in the serial port in Arduino IDE that thing. Because we have Rx variable mentioned in the Arduino code to receive . So we just transfer random data from from NRF and we can see that it shows on the serial port of Arduino IDE.

No we don't have that access to use scope or analyzer.

Thanks!

[Karl Ylvisaker]

Hello again,

KM123 said:

We have checked in the serial port in Arduino IDE that thing. Because we have Rx variable mentioned in the Arduino code to receive . So we just transfer random data from from NRF and we can see that it shows on the serial port of Arduino IDE.

Thank you for clarifying. Could you show me what these logs look like on either side, when you try to communicate back and forth?

The issue might very well be with the Arduino side of the code here. I suspect that it is, since you are basing your nRF application on the SPI example, and are able to successfully send data from the nRF and receive it in the Arduino.

Please see my previous question about the origin of the Arduino program.

KM123 said:

No we don't have that access to use scope or analyzer.

That is unfortunate, as these are excellent tools to use for these types of issues.
Logical analyzers are fortunately getting cheaper and better all the time, so I highly recommend that you acquire one in the future, if you intend to work a lot with serial interfaces.
 
Best regards,
Karl