/** * Copyright (c) 2015 - 2019, 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 #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 #include "nrf_log.h" #include "nrf_log_ctrl.h" #include "nrf_log_default_backends.h" #include "SEGGER_RTT.h" #include "ADS118.h" //#include "drv_gpio.h" #include "boards.h" #include "nrf_gpio.h" #include "nrf_drv_gpiote.h" #include "app_error.h" #include "nrf_drv_qspi.h" static uint8_t m_tx_buf[2]={0x00,0x00}; //= TEST_STRING; /**< TX buffer. */ static uint8_t m_rx_buf[2];//sizeof(TEST_STRING) + 1]; /**< RX buffer. */ static const uint8_t m_length = sizeof(40); /**< Transfer length. */ static uint8_t m_rx_buf1[2];//sizeof(TEST_STRING) + 1]; /**< RX buffer. */ #define PIN_IN 30 #define SPI_INSTANCE 0 /**< SPI instance index. */ // 0 indicates cpha=0 and cpol=0 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 "Nordic" void in_pin_handler(nrf_drv_gpiote_pin_t pin, nrf_gpiote_polarity_t action) { nrf_gpio_pin_set(27); nrf_gpio_pin_clear(31); nrf_delay_ms(500); nrf_gpio_pin_clear(27); nrf_gpio_pin_set(31); nrf_delay_ms(500); //nrf_delay_ms(100); // nrf_drv_gpiote_out_toggle(PIN_OUT); } static void gpio_init(void) { ret_code_t err_code; err_code = nrf_drv_gpiote_init(); // APP_ERROR_CHECK(err_code); nrf_drv_gpiote_out_config_t out_config = GPIOTE_CONFIG_OUT_SIMPLE(false); //err_code = nrf_drv_gpiote_out_init(PIN_OUT, &out_config); //APP_ERROR_CHECK(err_code); nrf_drv_gpiote_in_config_t in_config = GPIOTE_CONFIG_IN_SENSE_HITOLO(true);//GPIOTE_CONFIG_IN_SENSE_TOGGLE(true); in_config.pull = NRF_GPIO_PIN_PULLUP; err_code = nrf_drv_gpiote_in_init(PIN_IN, &in_config, in_pin_handler); APP_ERROR_CHECK(err_code); nrf_drv_gpiote_in_event_enable(PIN_IN, true); } /** * @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."); //SEGGER_RTT_printf(0, "variable value: %s\n", strlen((const char *)m_rx_buf)); if (m_rx_buf1[0] != 0) { // NRF_LOG_INFO(" Received:"); NRF_LOG_HEXDUMP_INFO(m_rx_buf, strlen((const char *)m_rx_buf1)); // SEGGER_RTT_printf(0," Transfer12 completed. Received: %d\n",m_rx_buf1); } } int main(void) { uint32_t i; uint32_t err_code; nrf_gpio_cfg_output(31); nrf_gpio_cfg_output(27); uint8_t temp[2]={0x06,0xeb}; // bsp_board_init(BSP_INIT_LEDS); APP_ERROR_CHECK(NRF_LOG_INIT(NULL)); NRF_LOG_DEFAULT_BACKENDS_INIT(); 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; APP_ERROR_CHECK(nrf_drv_spi_init(&spi, &spi_config, spi_event_handler, NULL)); nrf_gpio_pin_clear(31);//cs nrf_delay_us(100); gpio_init(); APP_ERROR_CHECK(nrf_drv_spi_transfer(&spi, m_tx_buf, 2, NULL, 1)); nrf_delay_ms(100); while (!spi_xfer_done) { __WFE(); } nrf_gpio_pin_set(31); while (1) { nrf_gpio_pin_clear(31); nrf_delay_us(100); APP_ERROR_CHECK(nrf_drv_spi_transfer(&spi, temp, 2, m_rx_buf1, 2)); while (!spi_xfer_done) { __WFE(); } nrf_delay_ms(100); nrf_gpio_pin_set(31); SEGGER_RTT_printf(0," Data Received1: %x\n",m_rx_buf1[0]); SEGGER_RTT_printf(0," Data Received2: %x\n",m_rx_buf1[1]); } } #define NRF_DRV_SPI_DEFAULT_CONFIG \ { \ .sck_pin = NRF_DRV_SPI_PIN_NOT_USED, \ .mosi_pin = NRF_DRV_SPI_PIN_NOT_USED, \ .miso_pin = NRF_DRV_SPI_PIN_NOT_USED, \ .ss_pin = NRF_DRV_SPI_PIN_NOT_USED, \ .irq_priority = SPI_DEFAULT_CONFIG_IRQ_PRIORITY, \ .orc = 0xFF, \ .frequency = NRF_DRV_SPI_FREQ_4M, \ .mode = NRF_DRV_SPI_MODE_1, \ .bit_order = NRF_DRV_SPI_BIT_ORDER_MSB_FIRST, \ }