RE: TWIM easydma write write fails

Kenneth — Tue, 10 Mar 2020 12:14:16 GMT

The TX and RX buffer is setup on nrf_drv_twi_xfer().

Best regards,
Kenneth

RE: TWIM easydma write write fails

jawadk — Tue, 10 Mar 2020 12:02:30 GMT

Hi,

I was not able to fined where you set the TX buffer before the transfer.

I need to trigger by PPI a TWI transfer only .

Best Regards

Jawad

RE: TWIM easydma write write fails

Kenneth — Thu, 31 Oct 2019 09:25:14 GMT

A long time ago I made an example which I think can be used as a reference.

/* Copyright (c) 2015 Nordic Semiconductor. All Rights Reserved.
 *
 * The information contained herein is property of Nordic Semiconductor ASA.
 * Terms and conditions of usage are described in detail in NORDIC
 * SEMICONDUCTOR STANDARD SOFTWARE LICENSE AGREEMENT.
 *
 * Licensees are granted free, non-transferable use of the information. NO
 * WARRANTY of ANY KIND is provided. This heading must NOT be removed from
 * the file.
 *
 */

/**
 * @file
 * @brief File with example code presenting usage of drivers for TWI in master mode with EasyDMA
 *
 * @sa twi_master_with_mma7660_slave_example
 */

#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <ctype.h>
#include "config.h"
#include "app_uart.h"
#include "nrf_drv_twi_mod.h"
#include "nrf_gpio.h"
#include "app_error.h"
#include "nrf.h"
#include "bsp.h"
#include "app_util_platform.h"
#include "mma7660.h"
#include "nrf_delay.h"
#include "nrf_drv_twi_mod.h"
#include "nrf_drv_ppi.h"

#define SENSOR_POLL_RATE SAMPLES_PER_SEC_4

static const nrf_drv_twi_t m_twi_master = NRF_DRV_TWI_INSTANCE(0);
static uint8_t m_rxbuf[3] = {0, 0, 0};
static uint8_t m_txbuf[1] = {0};

// How frequently the RTC should read the accel.
uint32_t rtc_init(mma7660_mode_t sensor_poll_mode)
{
    NRF_CLOCK->TASKS_LFCLKSTART = 1;
    while (NRF_CLOCK->EVENTS_LFCLKSTARTED == 0);
    
    NRF_RTC0->PRESCALER = 0;
    NRF_RTC0->EVTENSET = RTC_EVTENSET_COMPARE0_Msk;    
    uint32_t cc0_value;
    switch (sensor_poll_mode)
    {
        case SAMPLES_PER_SEC_120:
            cc0_value = 273 - 1;
            break;
        case SAMPLES_PER_SEC_64:
            cc0_value = 512 - 1;
            break;
        case SAMPLES_PER_SEC_32:
            cc0_value = 1024 - 1;
            break;
        case SAMPLES_PER_SEC_16:
            cc0_value = 2048 - 1;
            break;
        case SAMPLES_PER_SEC_8:
            cc0_value = 4096 - 1;
            break;
        case SAMPLES_PER_SEC_4:
            cc0_value = 8192 - 1;
            break;
        case SAMPLES_PER_SEC_2:
            cc0_value = 16384 - 1;
            break;
        case SAMPLES_PER_SEC_1:
            cc0_value = 32768 - 1;
            break;
        default:
            return NRF_ERROR_INVALID_PARAM;            
    }
    NRF_RTC0->CC[0] = cc0_value;
    NRF_RTC0->TASKS_START =1;
    return NRF_SUCCESS;
}

// Enable PPI channels to connect the RTC Compare0 event to trigger TWI transfer without CPU interaction.
uint32_t ppi_init(uint32_t * p_twim_master_start_task)
{
    uint32_t err_code;
    nrf_ppi_channel_t ppi_channel, ppi_channel2;

    err_code = nrf_drv_ppi_channel_alloc(&ppi_channel);
    if (err_code != NRF_SUCCESS)
        return err_code;
    // Create a PPI channel from RTC Compare0 event to start TWI transfer task
    err_code = nrf_drv_ppi_channel_assign(ppi_channel, (uint32_t)&NRF_RTC0->EVENTS_COMPARE[0], (uint32_t)*p_twim_master_start_task);
    if (err_code != NRF_SUCCESS)
        return err_code;    

    err_code = nrf_drv_ppi_channel_enable(ppi_channel);
    if (err_code != NRF_SUCCESS)
        return err_code;    

    err_code = nrf_drv_ppi_channel_alloc(&ppi_channel2);
    if (err_code != NRF_SUCCESS)
        return err_code;
    // Create a PPI channel from Compare0 event to clear RTC timer (repeated until stopped)
    err_code = nrf_drv_ppi_channel_assign(ppi_channel2, (uint32_t)&NRF_RTC0->EVENTS_COMPARE[0], (uint32_t)&NRF_RTC0->TASKS_CLEAR);
    if (err_code != NRF_SUCCESS)
        return err_code;    

    err_code = nrf_drv_ppi_channel_enable(ppi_channel2);
    
    return err_code;
}

// Callback  executed after every twi transfer (in this case just outputs the data over the UART)
void twi_cb_handler(nrf_drv_twi_evt_t const * p_event, void * p_context)
{
    // Pack the raw data into a more representable format and cast to int8_t (or with 0xE0, see MMA7660 data output values)
    if(m_rxbuf[0] > 31) m_rxbuf[0] = m_rxbuf[0] | 0xE0;        
    if(m_rxbuf[1] > 31) m_rxbuf[1] = m_rxbuf[1] | 0xE0;        
    if(m_rxbuf[2] > 31) m_rxbuf[2] = m_rxbuf[2] | 0xE0;        
    
    printf("%4i %4i %4i \n\r", (int8_t)m_rxbuf[0], (int8_t)m_rxbuf[1], (int8_t)m_rxbuf[2]);
}

// Init the TWI module; speed, pins, and callback 'twi_cb_handler()'
static ret_code_t twi_master_init(void)
{
    ret_code_t ret;
    const nrf_drv_twi_config_t config =
    {
       .scl                = 27,
       .sda                = 26,
       .frequency          = NRF_TWI_FREQ_400K,
       .interrupt_priority = APP_IRQ_PRIORITY_HIGH
    };

    do
    {
        ret = nrf_drv_twi_init(&m_twi_master, &config, twi_cb_handler, NULL);
        if(NRF_SUCCESS != ret)
        {
            break;
        }
        nrf_drv_twi_enable(&m_twi_master);
    }while(0);
    return ret;
}

// UART error handler.
static void uart_error_handle(app_uart_evt_t * p_event)
{
    if (p_event->evt_type == APP_UART_COMMUNICATION_ERROR)
    {
        APP_ERROR_HANDLER(p_event->data.error_communication);
    }
    else if (p_event->evt_type == APP_UART_FIFO_ERROR)
    {
        APP_ERROR_HANDLER(p_event->data.error_code);
    }
}

// UART used to output debug and accel. data in 'twi_cb_handler()'
uint32_t uart_init(void)
{
    uint32_t err_code;
    const app_uart_comm_params_t comm_params =
    {
        RX_PIN_NUMBER,
        TX_PIN_NUMBER,
        RTS_PIN_NUMBER,
        CTS_PIN_NUMBER,
        APP_UART_FLOW_CONTROL_ENABLED,
        false,
        UART_BAUDRATE_BAUDRATE_Baud460800
    };

    APP_UART_FIFO_INIT(&comm_params,
                       4,
                       32,
                       uart_error_handle,
                       APP_IRQ_PRIORITY_LOW,
                       err_code);
    return err_code;
}

// Setup parameters (buffers, type of transfer, and flags) for the next twi transfer by calling 'nrf_drv_twi_xfer()'
// Useful information: 'nrf_drv_twi_rx()' and 'nrf_drv_twi_tx()' wraps around this function (refer to those also for example on how to setup 'nrf_drv_twi_xfer()')
uint32_t twim_sync_xfer_setup(uint32_t * p_twim_master_start_task)
{
    nrf_drv_twi_xfer_desc_t p_xfer_desc;
    uint32_t err_code;    
    
    p_xfer_desc.address = MMA7660_DEFAULT_ADDRESS;
    p_xfer_desc.type = NRF_DRV_TWI_XFER_TXRX;
    p_xfer_desc.primary_length = 1;
    p_xfer_desc.secondary_length = 3;
    p_xfer_desc.p_primary_buf = m_txbuf;
    p_xfer_desc.p_secondary_buf = m_rxbuf;
    
    uint32_t flags = NRF_DRV_TWI_FLAG_HOLD_XFER | NRF_DRV_TWI_FLAG_REPEATED_XFER;

    do 
    {
        err_code = nrf_drv_twi_xfer(&m_twi_master, &p_xfer_desc, flags);
        
        // If success, read out task required to start the twi transfer, will be used to setup the correct PPI channel to trigger the twi transfer.
        if(err_code == NRF_SUCCESS)
        {
            * p_twim_master_start_task = nrf_drv_twi_start_task_get(&m_twi_master, NRF_DRV_TWI_XFER_TXRX); 
        }
    } while (err_code == NRF_ERROR_BUSY);   
    
    return err_code;
}

/**
 *  The begin of the journey
 */
int main(void)
{    
	uint32_t twim_master_start_task;
	
    // For debugging purposes only, writes accel. data to UART in twi callback 'twi_cb_handler()'
    APP_ERROR_CHECK(uart_init());  

    // Init. twi module, need to provide a callback 'twi_cb_handler()', else each call to twi driver will be blocking
    APP_ERROR_CHECK(twi_master_init());        
    
    // Write some init. twi data to the accel. to enable it, create new data every 'SENSOR_POLL_RATE'
    APP_ERROR_CHECK(mma7660_init(&m_twi_master, SENSOR_POLL_RATE));    

    // Setup repeated twi transfer (e.g. provide tx and rx buffers and type of twi transfer), each twi transfer can now be triggered by 'twim_master_start_task'
    APP_ERROR_CHECK(twim_sync_xfer_setup(&twim_master_start_task));    
    
    // Enable ppi channel from RTC compare0 event to start twi transfer 'twim_master_start_task'
    // Useful information: Could have used a pin interrupt from the accel. to trigger twi transfer, but the mbed module doesn't expose the interrupt data ready pin, so use RTC instead
    APP_ERROR_CHECK(ppi_init(&twim_master_start_task));
    
    // Start RTC, RTC ompare0 event will execute twi transfer on every 'SENSOR_POLL_RATE'
    APP_ERROR_CHECK(rtc_init(SENSOR_POLL_RATE));
    
    // No more CPU activity needed, go to sleep, CPU only interrupted when data is ready in buffer in twi callback 'twi_cb_handler()'.
    // RTC Compare0 event wil ensure data is read at specific intervals by triggering twi transfer through PPI, while CPU can process the data at it's own pace.
    SCB->SCR |= SCB_SCR_SEVONPEND_Msk;    
    while(1)
    {
        __sev();
        __wfe();
        __wfe();
    }        
}

/** @} */ /* End of group twi_master_with_mma7660_slave_example */

RE: TWIM easydma write write fails

Paul — Wed, 30 Oct 2019 17:40:54 GMT

Hi Kenneth,

Thanks for your reply!

When you say the twi driver, do you refer to the current or legacy?

The code above which works uses the legacy form of the twi driver, however its either

blocking or interrupt based. I've looked at the source and it all seems to map down to

the same NRFX easydma based driver.

If I make the calls in form:

uint8_t tx_buf[1] = {0x88};
nrfx_twim_xfer_desc_t xfer = NRFX_TWIM_XFER_DESC_TX(addr, (uint8_t*)tx_buf, sizeof(tx_buf));

uint32_t err_code = nrfx_twim_xfer(&(twi_instance_00.u.twim), &xfer, 0);

APP_ERROR_CHECK(err_code);

Which replicates whats in nrf_drv_twi_tx , its work, and successfully writes.

However my understanding is that this code is blocking the same as nrf_drv_twi_tx .

If however I try to make defer execution and suitable for initiation via PPI:

uint32_t flags = NRF_DRV_TWI_FLAG_NO_XFER_EVT_HANDLER |
NRFX_TWIM_FLAG_TX_NO_STOP |
NRF_DRV_TWI_FLAG_HOLD_XFER;

uint32_t err_code = nrfx_twim_xfer(&(twi_instance_00.u.twim), &xfer, flags);

then the nrfx_twim_xfer call never completes?!?

Any ideas?

BR, Paul

RE: TWIM easydma write write fails

Kenneth — Tue, 29 Oct 2019 15:17:27 GMT

Why not use the TWI driver?

Kenneth

RE: TWIM easydma write write fails

Paul — Mon, 28 Oct 2019 14:40:05 GMT

Hi,

Additionally would like to add main:

int main(void)
{
ret_code_t err_code;
log_init();
NRF_LOG_INFO("Start fwtest\r\n");
NRF_LOG_FLUSH();

NRF_TWIM0->PSEL.SCL = PIN_SCL;
NRF_TWIM0->PSEL.SDA = PIN_SDA;

NRF_TWIM0->ADDRESS = DEVICE_ADDRESS;
NRF_TWIM0->FREQUENCY = TWIM_FREQUENCY_FREQUENCY_K400 << TWIM_FREQUENCY_FREQUENCY_Pos;
NRF_TWIM0->SHORTS = 0;

NRF_TWIM0->ENABLE = TWIM_ENABLE_ENABLE_Enabled << TWIM_ENABLE_ENABLE_Pos;

simple_test();
//simple_mixed_test();

while (1)
{
__WFE();
}

}