mir3da.c

#include "da217.h"
#include "bn_twi.h"
#include "nrf_delay.h"


/*******************************************************************************
Macro definitions - Register define for Gsensor asic
********************************************************************************/
#define NSA_REG_SPI_I2C                 0x00
#define NSA_REG_WHO_AM_I                0x01
#define NSA_REG_ACC_X_LSB               0x02
#define NSA_REG_ACC_X_MSB               0x03
#define NSA_REG_ACC_Y_LSB               0x04
#define NSA_REG_ACC_Y_MSB               0x05
#define NSA_REG_ACC_Z_LSB               0x06
#define NSA_REG_ACC_Z_MSB               0x07 
#define NSA_REG_MOTION_FLAG				0x09
#define NSA_REG_STEPS_MSB				0x0D
#define NSA_REG_STEPS_LSB				0x0E
#define NSA_REG_G_RANGE                 0x0F
#define NSA_REG_ODR_AXIS_DISABLE        0x10
#define NSA_REG_POWERMODE_BW            0x11
#define NSA_REG_SWAP_POLARITY           0x12
#define NSA_REG_FIFO_CTRL               0x14
#define NAS_REG_INT_SET0				0x15
#define NSA_REG_INTERRUPT_SETTINGS1     0x16
#define NSA_REG_INTERRUPT_SETTINGS2     0x17
#define NSA_REG_INTERRUPT_MAPPING1      0x19
#define NSA_REG_INTERRUPT_MAPPING2      0x1a
#define NSA_REG_INTERRUPT_MAPPING3      0x1b
#define NSA_REG_INT_PIN_CONFIG          0x20
#define NSA_REG_INT_LATCH               0x21
#define NSA_REG_ACTIVE_DURATION         0x27
#define NSA_REG_ACTIVE_THRESHOLD        0x28
#define NSA_REG_TAP_DURATION            0x2A
#define NSA_REG_TAP_THRESHOLD           0x2B
#define NSA_REG_STEP_CONFIG1			0x2F
#define NSA_REG_STEP_CONFIG2			0x30
#define NSA_REG_STEP_CONFIG3			0x31
#define NSA_REG_STEP_CONFIG4			0x32
#define NSA_REG_STEP_FILTER				0x33
#define NSA_REG_SM_THRESHOLD			0x34
#define NSA_REG_CUSTOM_OFFSET_X         0x38
#define NSA_REG_CUSTOM_OFFSET_Y         0x39
#define NSA_REG_CUSTOM_OFFSET_Z         0x3a
#define NSA_REG_ENGINEERING_MODE        0x7f
#define NSA_REG_SENSITIVITY_TRIM_X      0x80
#define NSA_REG_SENSITIVITY_TRIM_Y      0x81
#define NSA_REG_SENSITIVITY_TRIM_Z      0x82
#define NSA_REG_COARSE_OFFSET_TRIM_X    0x83
#define NSA_REG_COARSE_OFFSET_TRIM_Y    0x84
#define NSA_REG_COARSE_OFFSET_TRIM_Z    0x85
#define NSA_REG_FINE_OFFSET_TRIM_X      0x86
#define NSA_REG_FINE_OFFSET_TRIM_Y      0x87
#define NSA_REG_FINE_OFFSET_TRIM_Z      0x88
#define NSA_REG_SENS_COMP               0x8c
#define NSA_REG_MEMS_OPTION             0x8f
#define NSA_REG_CHIP_INFO               0xc0
#define NSA_REG_CHIP_INFO_SECOND        0xc1
#define NSA_REG_MEMS_OPTION_SECOND      0xc7
#define NSA_REG_SENS_COARSE_TRIM        0xd1
#define NAS_REG_OSC_TRIM				0x8e



/*******************************************************************************
Typedef definitions
********************************************************************************/

typedef struct AccData_tag{
   int16_t ax;                                   //¼ÓËٶȼÆԭʼÊý¾Ý½á¹¹Ìå  Êý¾Ý¸ñʽ 0 0 1024
   int16_t ay;
   int16_t az;
}AccData;

#define mir3da_abs(x)          (((x) > 0) ? (x) : (-(x)))

uint8_t i2c_addr = 0x27;


int8_t da217_register_read(uint8_t addr, uint8_t *data_m, uint8_t len)
{
  //To do i2c read api
	
	OZ88106_register_read(addr,data_m,len);
  
  return 0;
  
}

int8_t da217_register_write(uint8_t addr, uint8_t data_m)
{
  //To do i2c write api
  
	OZ88106_register_write_1byte(addr,data_m);
	
  return 0;
  
}

int8_t da217_register_mask_write(unsigned char addr, unsigned char mask, unsigned char data){
    int     res = 0;
    unsigned char      tmp_data;

    res = da217_register_read(addr, &tmp_data, 1);
    if(res) {
        return res;
    }

    tmp_data &= ~mask; 
    tmp_data |= data & mask;
    res = da217_register_write(addr, tmp_data);

    return res;
}


//Initialization
int8_t da217_init(void){
	int8_t res = 0;
	uint8_t data_m = 0;

  //Retry 3 times
	res = da217_register_read(NSA_REG_WHO_AM_I,&data_m,1);
    if(data_m != 0x13){
        res = da217_register_read(NSA_REG_WHO_AM_I,&data_m,1);
        if(data_m != 0x13){
            res = da217_register_read(NSA_REG_WHO_AM_I,&data_m,1);
            if(data_m != 0x13){
                //printf("------da217 read chip id  error= %x-----\r\n",data_m);  
                return -1;
            }
        }
    }
    da217_register_mask_write(0x00, 0x24, 0x24);
	nrf_delay_ms(50); //delay 50ms
 
	//printf("------mir3da chip id = %x-----\r\n",data_m); 

	res |= da217_register_write(NSA_REG_G_RANGE, 0x01);               //+/-4G,14bit
	res |= da217_register_write(NSA_REG_POWERMODE_BW, 0x14);          //normal mode
	res |= da217_register_write(NSA_REG_ODR_AXIS_DISABLE, 0x07);      //ODR = 125hz
	
	//Engineering mode
	res |= da217_register_write(NSA_REG_ENGINEERING_MODE, 0x83);
	res |= da217_register_write(NSA_REG_ENGINEERING_MODE, 0x69);
	res |= da217_register_write(NSA_REG_ENGINEERING_MODE, 0xBD);
  
	//Reduce power consumption
	if(i2c_addr == 0x26){
		da217_register_mask_write(NSA_REG_SENS_COMP, 0x40, 0x00);
	}
#if 0
	mir3da_register_mask_write(0x8f, 0x02, 0x00);
#endif	
	return res;	    	
}




//enable/disable the chip
int8_t da217_set_enable(uint8_t enable)
{
	int8_t res = 0;
	if(enable)
		res = da217_register_write(NSA_REG_POWERMODE_BW,0x14);
	else	
		res = da217_register_write(NSA_REG_POWERMODE_BW,0x80);
	
	return res;	
}

//Read three axis data, 1024 LSB = 1 g
int8_t da217_read_data(int16_t *x, int16_t *y, int16_t *z)
{
    uint8_t    tmp_data[6] = {0};

#if 1
    if (da217_register_read(NSA_REG_ACC_X_LSB, tmp_data,6) != 0) {
        return -1;
    }
#else
	mir3da_register_read(NSA_REG_ACC_X_LSB, &tmp_data[0], 1);
	mir3da_register_read(NSA_REG_ACC_X_MSB, &tmp_data[1], 1);
	mir3da_register_read(NSA_REG_ACC_Y_LSB, &tmp_data[2], 1);
	mir3da_register_read(NSA_REG_ACC_Y_MSB, &tmp_data[3], 1);
	mir3da_register_read(NSA_REG_ACC_Z_LSB, &tmp_data[4], 1);
	mir3da_register_read(NSA_REG_ACC_Z_MSB, &tmp_data[5], 1);
 #endif
	
    *x = ((int16_t)(tmp_data[1] << 8 | tmp_data[0]))>> 3;
    *y = ((int16_t)(tmp_data[3] << 8 | tmp_data[2]))>> 3;
    *z = ((int16_t)(tmp_data[5] << 8 | tmp_data[4]))>> 3;	

    return 0;
}

//open active interrupt
int8_t da217_open_interrupt(uint8_t th){
	int8_t   res = 0;

	res = da217_register_write(NSA_REG_ACTIVE_DURATION,0x02);
	res = da217_register_write(NSA_REG_ACTIVE_THRESHOLD,th);
	res = da217_register_write(NSA_REG_INTERRUPT_MAPPING1,0x04);
	res = da217_register_write(NSA_REG_INT_LATCH, 0xEE);  //latch 100ms
	res = da217_register_write(NSA_REG_INTERRUPT_SETTINGS1,0x87);

	return res;
}

//close active interrupt
int8_t da217_close_interrupt(void){
	int8_t   res = 0;

	res = da217_register_write(NSA_REG_INTERRUPT_SETTINGS1,0x00 );
	res = da217_register_write(NSA_REG_INTERRUPT_MAPPING1,0x00 );

	return res;
}

mir3da.h

#ifndef __DA217_h
#define __DA217_h

#include <stdint.h>

int8_t da217_init(void);

int8_t da217_set_enable(uint8_t enable);

int8_t da217_read_data(int16_t *x, int16_t *y, int16_t *z);

int8_t da217_open_interrupt(uint8_t th);

int8_t da217_close_interrupt(void);

#endif

main.c

#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include "app_uart.h"
#include "app_error.h"
#include "nrf_delay.h"
#include "nrf.h"
#include "bsp.h"
#if defined (UART_PRESENT)
#include "nrf_uart.h"
#endif
#if defined (UARTE_PRESENT)
#include "nrf_uarte.h"
#endif

#include "da217.h"
#include "bn_twi.h"

//#define ENABLE_LOOPBACK_TEST  /**< if defined, then this example will be a loopback test, which means that TX should be connected to RX to get data loopback. */

#define MAX_TEST_DATA_BYTES     (15U)                /**< max number of test bytes to be used for tx and rx. */
#define UART_TX_BUF_SIZE 1024                         /**< UART TX buffer size. */
#define UART_RX_BUF_SIZE 1024                         /**< UART RX buffer size. */

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);
    }
}


#ifdef ENABLE_LOOPBACK_TEST
/* Use flow control in loopback test. */
#define UART_HWFC APP_UART_FLOW_CONTROL_ENABLED

/** @brief Function for setting the @ref ERROR_PIN high, and then enter an infinite loop.
 */
static void show_error(void)
{

    bsp_board_leds_on();
    while (true)
    {
        // Do nothing.
    }
}


/** @brief Function for testing UART loop back.
 *  @details Transmitts one character at a time to check if the data received from the loopback is same as the transmitted data.
 *  @note  @ref TX_PIN_NUMBER must be connected to @ref RX_PIN_NUMBER)
 */
static void uart_loopback_test()
{
    uint8_t * tx_data = (uint8_t *)("\r\nLOOPBACK_TEST\r\n");
    uint8_t   rx_data;

    // Start sending one byte and see if you get the same
    for (uint32_t i = 0; i < MAX_TEST_DATA_BYTES; i++)
    {
        uint32_t err_code;
        while (app_uart_put(tx_data[i]) != NRF_SUCCESS);

        nrf_delay_ms(10);
        err_code = app_uart_get(&rx_data);

        if ((rx_data != tx_data[i]) || (err_code != NRF_SUCCESS))
        {
            show_error();
        }
    }
    return;
}
#else
/* When UART is used for communication with the host do not use flow control.*/
#define UART_HWFC APP_UART_FLOW_CONTROL_DISABLED
#endif


/**
 * @brief Function for main application entry.
 */
int main(void)
{
    uint32_t err_code;
		int16_t x = 0,y = 0,z = 0;

    bsp_board_init(BSP_INIT_LEDS);

    const app_uart_comm_params_t comm_params =
      {
          RX_PIN_NUMBER,
          TX_PIN_NUMBER,
          RTS_PIN_NUMBER,
          CTS_PIN_NUMBER,
          UART_HWFC,
          false,
#if defined (UART_PRESENT)
          NRF_UART_BAUDRATE_115200
#else
          NRF_UARTE_BAUDRATE_115200
#endif
      };

    APP_UART_FIFO_INIT(&comm_params,
                         UART_RX_BUF_SIZE,
                         UART_TX_BUF_SIZE,
                         uart_error_handle,
                         APP_IRQ_PRIORITY_LOWEST,
                         err_code);

    APP_ERROR_CHECK(err_code);

#ifndef ENABLE_LOOPBACK_TEST
    printf("\r\n1111UART example started.\r\n");
			
		OZ88106_twi_init();

    da217_init();
		
		da217_set_enable(true);
			
		//mir3da_open_interrupt(0x14);
			
		while (true)
    {
				da217_read_data(&x,&y,&z);
			
				printf("\r\n x=%d y=%d z=%d \r\n",x,y,z);
			
				nrf_delay_ms(1000);
		}
		
#else

    // This part of the example is just for testing the loopback .
    while (true)
    {
        uart_loopback_test();
    }
#endif
}


/** @} */

bn_twi.h

#include <stdio.h>
#include "boards.h"
#include "app_util_platform.h"
#include "app_error.h"
#include "nrf_drv_twi.h"
#include "nrf_delay.h"


#include "nrf_log.h"
#include "nrf_log_ctrl.h"
#include "nrf_log_default_backends.h"


void OZ88106_twi_init (void);

bool OZ88106_register_write_1byte(uint8_t register_address, uint8_t value);

bool OZ88106_register_read(uint8_t register_address, uint8_t * destination, uint8_t number_of_bytes);

/** @} */

bn_twi.c

#include <stdio.h>
#include "boards.h"
#include "app_util_platform.h"
#include "app_error.h"
#include "nrf_drv_twi.h"
#include "nrf_delay.h"


#include "nrf_log.h"
#include "nrf_log_ctrl.h"
#include "nrf_log_default_backends.h"
#include "bn_twi.h"

/* TWI instance ID. */
#define TWI_INSTANCE_ID     0

#define TWI_SCL_M 8 //I2C SCL
#define TWI_SDA_M 7 //I2C SDA

#define TWI_IIC_POWER_EN 30 //I2C POWER_EN

#define OZ88106_ADDRESS_LEN (1)
#define OZ88106_ADDRESS ((0x4E) >> 1)

#define OZ8816_COUNTER_MAX (100000000)
#define OZ8816_COUNTER_DELAY_US (1)
#define OZ8816_DEBUG (0)

typedef enum{
	TWI_INTERRUPT_STATUS_INVALID = 0,
	TWI_INTERRUPT_STATUS_DONE,
	TWI_INTERRUPT_STATUS_START,
	TWI_INTERRUPT_STATUS_ADDRESS_NACK,
	TWI_INTERRUPT_STATUS_DATA_NACK
}TWI_INTERRUPT_STATUS_E;

/* Indicates if operation on TWI has ended. */
static volatile TWI_INTERRUPT_STATUS_E m_xfer_done = TWI_INTERRUPT_STATUS_INVALID;

/* TWI instance. */
static const nrf_drv_twi_t m_twi = NRF_DRV_TWI_INSTANCE(TWI_INSTANCE_ID);


/**
 * @brief TWI events handler.
 */
void OZ88106_twi_handler(nrf_drv_twi_evt_t const * p_event, void * p_context)
{
    switch (p_event->type)
    {
        case NRF_DRV_TWI_EVT_DONE:
            m_xfer_done = TWI_INTERRUPT_STATUS_DONE;
            break;
				
				case NRF_DRV_TWI_EVT_ADDRESS_NACK:
						m_xfer_done = TWI_INTERRUPT_STATUS_ADDRESS_NACK;
            break;
				
				case NRF_DRV_TWI_EVT_DATA_NACK:
						m_xfer_done = TWI_INTERRUPT_STATUS_DATA_NACK;
            break;
				
        default:
						m_xfer_done = TWI_INTERRUPT_STATUS_INVALID;
            break;
    }
}

/**
 * @brief UART initialization.
 */
void OZ88106_twi_init (void)
{
    ret_code_t err_code;

    const nrf_drv_twi_config_t twi_config = {
       .scl                = TWI_SCL_M,
       .sda                = TWI_SDA_M,
       .frequency          = NRF_DRV_TWI_FREQ_400K,
       .interrupt_priority = APP_IRQ_PRIORITY_HIGH,
       .clear_bus_init     = false
    };
		
		nrf_gpio_cfg_output(TWI_IIC_POWER_EN);
		nrf_gpio_pin_clear(TWI_IIC_POWER_EN);
		nrf_delay_ms(500);
	  nrf_gpio_pin_set(TWI_IIC_POWER_EN);
		nrf_delay_ms(500);

    err_code = nrf_drv_twi_init(&m_twi, &twi_config, OZ88106_twi_handler, NULL);
    if (err_code != NRF_SUCCESS)
    {                                  
       printf("err_code=%d",err_code);
    }

    nrf_drv_twi_enable(&m_twi);
}

bool OZ88106_register_write_1byte(uint8_t register_address, uint8_t value)
{
	ret_code_t err_code;
	uint8_t tx_buf[OZ88106_ADDRESS_LEN+1];
	
	tx_buf[0] = register_address;
	tx_buf[1] = value;
	m_xfer_done = TWI_INTERRUPT_STATUS_START;
	err_code = nrf_drv_twi_tx(&m_twi, OZ88106_ADDRESS, tx_buf, OZ88106_ADDRESS_LEN+1, false);
	while(m_xfer_done == TWI_INTERRUPT_STATUS_START);
	if(m_xfer_done != TWI_INTERRUPT_STATUS_DONE)
	{
			printf("\r\nwrite_1byte nm_xfer_done=%d\n",m_xfer_done);
	}
	if (NRF_SUCCESS != err_code)
	{
			return true;
	}
	return false;
}

bool OZ88106_register_read(uint8_t register_address, uint8_t * destination, uint8_t number_of_bytes)
{
	ret_code_t err_code;
	
	m_xfer_done = TWI_INTERRUPT_STATUS_START;
	err_code = nrf_drv_twi_tx(&m_twi, OZ88106_ADDRESS,&register_address, 1, true);
	while(m_xfer_done == TWI_INTERRUPT_STATUS_START);
	if(m_xfer_done != TWI_INTERRUPT_STATUS_DONE)
	{
			printf("\r\nwrite_register nm_xfer_done=%d\n",m_xfer_done);
	}
	if (NRF_SUCCESS != err_code)
	{
		return true;
	}
	
	//nrf_delay_ms(20);
	
	m_xfer_done = TWI_INTERRUPT_STATUS_START;
	err_code = nrf_drv_twi_rx(&m_twi, OZ88106_ADDRESS, destination, number_of_bytes);
	while(m_xfer_done == TWI_INTERRUPT_STATUS_START);
	if(m_xfer_done != TWI_INTERRUPT_STATUS_DONE)
	{
			printf("\r\read_register nm_xfer_done=%d\n",m_xfer_done);
	}
	if (NRF_SUCCESS != err_code)
	{
		return true;
	}
	return false;
}

/** @} */