NRF52840 AD7124 Code
Inital nRF52840 code that talks to the AD7124-8
/**
* 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"
#include "SEGGER_RTT.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. */
/* AD7124 parameters */
char FS[2] = { 0x01, 0x40 }; /* Filter Select (FS) default: 320 */
char PGA = 0x07; /* PGA default: 128 */
char AINM = 0x06; /* Negative analog input: 6 */
char AINP = 0x07; /* Positive analog input: 7 */
enum { LOW_POWER=0x00, MEDIUM_POWER=0x40, HIGH_POWER=0x80 } power_mode = HIGH_POWER;
int data_register=0;
int return_code = 0;
char wrBuf[8] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
char rdBuf[8] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
int number_active_channels=1;
int number_of_filtered_samples = 0;
int data_array[64];
int number_of_samples = 16; /* Number of data reads to average */
int sum = 0;
int sample_counter = 0;
/* *****************************************************************************************
*
* reset_AD7124
*
* sends 64 ones (eight 0xFF) to the AD7124 to reset it
*
* **************************************************************************************** */
void reset_AD7124 ( void )
{
SEGGER_RTT_WriteString(0, "reset_AD7124.\n");
/* reset AD7124 by writing 64 ones (eight 0xFF) */
uint8_t wrBuf[8] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
uint8_t rdBuf[8] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
// memset(m_rx_buf, 0, m_length);
spi_xfer_done = false;
nrf_delay_ms(10);
APP_ERROR_CHECK(nrf_drv_spi_transfer(&spi, wrBuf, 8, rdBuf, 8));
/* check reset by reading device ID code */
wrBuf[0]= 0x45;
nrf_delay_ms(10);
APP_ERROR_CHECK(nrf_drv_spi_transfer(&spi, wrBuf, 2, rdBuf, 2));
SEGGER_RTT_printf(0, "Device ID Code: 0x%02x\n", rdBuf[1]);
if ( rdBuf[1] != 0x14 )
{
bsp_board_led_invert(BSP_BOARD_LED_3);
SEGGER_RTT_printf(0, "Reset failed: 0x%02x 0x%02x\n", rdBuf[0], rdBuf[1]);
}
}
/* ******************************************************************************************
*
* initialize_AD7124
*
* turns of default number_active_channel
* turns on
* sets the filter
*
* **************************************************************************************** */
void initialize_AD7124 ( void )
{
uint8_t wrBuf[8] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
uint8_t rdBuf[8] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
SEGGER_RTT_WriteString(0, "Starting initialize_AD7124.\n");
wrBuf[0]= 0x09; wrBuf[1]= 0x00; wrBuf[2]= 0x01; /* Turn off channel_0 (on by default) */
APP_ERROR_CHECK(nrf_drv_spi_transfer(&spi, wrBuf, 3, rdBuf, 3));
SEGGER_RTT_WriteString(0, "Turned off channel 0.\n");
//wrBuf[1] = ( AIMP & 0x18 ) >> 3 ;
wrBuf[0]= 0x0a;
wrBuf[1] = (( AINP >> 3) & 0x07 ) | 0x80;
wrBuf[2] = (( AINP & 0x07 ) << 5) | ( AINM & 0x1F );
SEGGER_RTT_printf(0, "Write buffers: 0x%02x 0x%02x 0x%02x\n", wrBuf[0], wrBuf[1], wrBuf[2]);
APP_ERROR_CHECK(nrf_drv_spi_transfer(&spi, wrBuf, 3, rdBuf, 3));
SEGGER_RTT_WriteString(0, "Set up AINP.\n");
wrBuf[0]= 0x19; wrBuf[1]= 0x08; wrBuf[2]= 0x7F;
APP_ERROR_CHECK(nrf_drv_spi_transfer(&spi, wrBuf, 3, rdBuf, 3));
wrBuf[0]= 0x21; wrBuf[1]= 0x06; wrBuf[2]= FS[0]; wrBuf[3]= FS[1]; /* Set the Filter Select bits */
APP_ERROR_CHECK(nrf_drv_spi_transfer(&spi, wrBuf, 4, rdBuf, 4));
SEGGER_RTT_WriteString(0, "Set up FS bits.\n");
wrBuf[0]= 0x07; wrBuf[1]= 0x03; wrBuf[2]= 0xF0; wrBuf[3]= 0x38;
APP_ERROR_CHECK(nrf_drv_spi_transfer(&spi, wrBuf, 4, rdBuf, 4));
}
/* ******************************************************************************************
*
* wait_for_AD7124_ready
*
* waits for AD7124 to finish conversion by testing the busy busy bit
* if it times out, it return busy (1)
* waiting set the how long it will wait for the conversion before it times out
*
* **************************************************************************************** */
uint8_t wait_for_AD7124_ready(void)
{
uint8_t wrBuf[8] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
uint8_t rdBuf[8] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
unsigned int waiting=10000;
uint8_t busy = 1;
while( busy && waiting )
{
/* Read the Status Register */
wrBuf[0]= 0x40;
APP_ERROR_CHECK(nrf_drv_spi_transfer(&spi, wrBuf, 2, rdBuf, 2));
busy = rdBuf[1] & 0x80 ; /* Test the Not Ready bit */
nrf_delay_ms(1); /* wait 0.1 msec */
waiting--;
}
// SEGGER_RTT_printf(0, "waiting: %d\n", waiting);
return busy;
}
/* ******************************************************************************************
*
* read_AD7124
*
* turn on load cell excitation
* start continuous data conversion
* Read the data register
* Read the error register
* Loop for the number of samples or untill have tried 128 times
* turn off load cell excitation
*
* **************************************************************************************** */
void read_AD7124(void)
{
uint8_t wrBuf[8] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
uint8_t rdBuf[8] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
int i = 0;
int read_counter = 0;
SEGGER_RTT_WriteString(0, "read_AD7124.\n");
NRF_LOG_FLUSH();
/* turn on load cell excitation using PDSW Power Down Switch */
wrBuf[0]= 0x03; wrBuf[1]= 0x00; wrBuf[2]= 0x80; wrBuf[3]= 0x00;
APP_ERROR_CHECK(nrf_drv_spi_transfer(&spi, wrBuf, 4, rdBuf, 4));
SEGGER_RTT_printf(0, "Load Cell turned ON.\n");
/* start data conversion, Continuous conversion mode 00 0084 ADC Control High power, Mode 0*/
wrBuf[0]= 0x01; wrBuf[1]= 0x06; wrBuf[2]= power_mode;
APP_ERROR_CHECK(nrf_drv_spi_transfer(&spi, wrBuf, 3, rdBuf, 3));
SEGGER_RTT_printf(0, "Data conversion started.\n");
wrBuf[0]= 0x41; wrBuf[1]= 0x00; wrBuf[2]= 0x00;
nrf_delay_ms(100);
APP_ERROR_CHECK(nrf_drv_spi_transfer(&spi, wrBuf, 3, rdBuf, 3));
SEGGER_RTT_printf(0, "read from controll register.\n");
SEGGER_RTT_printf(0, "Control register: 0x%02x 0x%02x 0x%02x\n", rdBuf[0], rdBuf[1], rdBuf[2]);
sum=0;
sample_counter=0;
read_counter = 0;
while ( read_counter < 128 && sample_counter < number_of_samples )
{
for ( i=0; i< number_active_channels; i++ )
{
if ( !wait_for_AD7124_ready() )
{
/* Read the data register */
wrBuf[0]= 0x42;
APP_ERROR_CHECK(nrf_drv_spi_transfer(&spi, wrBuf, 5, rdBuf, 5));
data_register = (rdBuf[1] << 16) | (rdBuf[2] << 8) | (rdBuf[3]);
SEGGER_RTT_printf(0, "Data register: 0x%02x 0x%02x 0x%02x\n", rdBuf[1], rdBuf[2], rdBuf[3]);
/* Read the error register */
wrBuf[0]= 0x46;
APP_ERROR_CHECK(nrf_drv_spi_transfer(&spi, wrBuf, 4, rdBuf, 4));
/* Check for errors */
// SEGGER_RTT_printf(0, "Error register: 0x%02x 0x%02x 0x%02x\n", rdBuf[1], rdBuf[2], rdBuf[3]);
if ( (rdBuf[1] | rdBuf[2] | rdBuf[3]) == 0 ) /* if no errors, use data to calculate average */
{
data_array[sample_counter] = data_register;
sum += data_register;
sample_counter++;
}
}
}
read_counter++;
}
/* turn off load cell excitation using PDSW Power Down Switch */
wrBuf[0]= 0x03; wrBuf[1]= 0x00; wrBuf[2]= 0x00; wrBuf[3]= 0x00;
APP_ERROR_CHECK(nrf_drv_spi_transfer(&spi, wrBuf, 4, rdBuf, 4));
SEGGER_RTT_printf(0, "Load Cell turned OFF.\n");
//if (sample_counter == 0) return 5;
number_of_filtered_samples = sample_counter;
}
/************************* median_select *********************************
*
* from http://ndevilla.free.fr/median/median/
* This Quickselect routine is based on the algorithm described in
* "Numerical recipes in C", Second Edition,
* Cambridge University Press, 1992, Section 8.5, ISBN 0-521-43108-5
* This code by Nicolas Devillard - 1998. Public domain.
*
***************************************************************************/
#define ELEM_SWAP(a,b) { register int t=(a);(a)=(b);(b)=t; }
int median_select(int arr[], int n)
{
int low, high;
int median;
int middle, ll, hh;
low = 0 ; high = n-1 ; median = (low + high) / 2;
for (;;) {
if (high <= low) /* One element only */
return arr[median];
if (high == low + 1) { /* Two elements only */
if (arr[low] > arr[high]) ELEM_SWAP(arr[low], arr[high]);
return arr[median];
}
/* Find median of low, middle and high items; swap into position low */
middle = (low + high) / 2;
if (arr[middle] > arr[high]) ELEM_SWAP(arr[middle], arr[high]);
if (arr[low] > arr[high]) ELEM_SWAP(arr[low], arr[high]);
if (arr[middle] > arr[low]) ELEM_SWAP(arr[middle], arr[low]);
/* Swap low item (now in position middle) into position (low+1) */
ELEM_SWAP(arr[middle], arr[low+1]);
/* Nibble from each end towards middle, swapping items when stuck */
ll = low + 1;
hh = high;
for (;;) {
do ll++; while (arr[low] > arr[ll]);
do hh--; while (arr[hh] > arr[low]);
if (hh < ll)
break;
ELEM_SWAP(arr[ll], arr[hh]);
}
/* Swap middle item (in position low) back into correct position */
ELEM_SWAP(arr[low], arr[hh]);
/* Re-set active partition */
if (hh <= median) low = ll;
if (hh >= median) high = hh - 1;
}
}
#undef ELEM_SWAP
int main(void)
{
char buffer[50];
int j=0;
bsp_board_leds_init();
APP_ERROR_CHECK(NRF_LOG_INIT(NULL));
NRF_LOG_DEFAULT_BACKENDS_INIT();
SEGGER_RTT_printf(0, "\n\nStarted main routine ...\n");
NRF_LOG_INFO("SPI example.");
nrf_drv_spi_config_t spi_config = NRF_DRV_SPI_DEFAULT_CONFIG;
spi_config.frequency = NRF_SPI_FREQ_4M;
spi_config.mode = NRF_DRV_SPI_MODE_3;
spi_config.ss_pin = 29; // SPI_SS_PIN; // 29
spi_config.miso_pin = 28; // SPI_MISO_PIN; // 28
spi_config.mosi_pin = 4; // SPI_MOSI_PIN; // 4
spi_config.sck_pin = 3; // SPI_SCK_PIN; // 3
// APP_ERROR_CHECK(nrf_drv_spi_init(&spi, &spi_config, spi_event_handler, NULL));
APP_ERROR_CHECK(nrf_drv_spi_init(&spi, &spi_config, NULL, NULL));
SEGGER_RTT_printf(0, "SPI Initialized.\n");
// SEGGER_RTT_WriteString(0, "SPI Initialized.\n");
reset_AD7124();
initialize_AD7124();
while (1)
{
bsp_board_led_invert(BSP_BOARD_LED_0);
// reset_AD7124();
// initialize_AD7124();
read_AD7124();
bsp_board_led_invert(BSP_BOARD_LED_0);
int median = median_select( data_array, sample_counter );
sum = 0;
number_of_filtered_samples = 0;
/* set limits for outliers */
int high_limit = median * 1.00002;
int low_limit = median * .99998;
/* Test for outliers and throw them away */
for ( j=0; j<sample_counter; j++ )
{
if ( data_array[j] < high_limit && data_array[j] > low_limit )
{
number_of_filtered_samples++;
sum += data_array[j];
// printf ("data_array: %d less median: %d\n", data_array[j], data_array[j] - median);
}
// else
// printf ("OUTLIER %d less median: %d\n", data_array[j], data_array[j] - median);
}
if (number_of_filtered_samples == 0) return 6;
/* calculate raw average */
int filtered_average = sum/number_of_filtered_samples;
SEGGER_RTT_printf(0, "Filtered average: %d\n", filtered_average);
// float weight = (float)(filtered_average - 8413535) * .0003375;
// float weight = (float) (filtered_average * 0.0003438388) - 2892.912;
// SEGGER_RTT_printf(0, "Weight: %7.3f\n", (0.0003438388 * (sum/number_of_filtered_samples)) - 2892.912 );
// float weight = (filtered_average * 0.3438388) - 2892912;
float weight = (filtered_average * 0.0003438388) - 2892.912;
sprintf(buffer, "Samples: %d Weight: %7.3f lb\n",number_of_filtered_samples, weight);
SEGGER_RTT_printf(0, buffer);
// SEGGER_RTT_WriteString(0, buffer);
// SEGGER_RTT_printf(0, "weight: %d\n", weight);
nrf_delay_ms(1000);
}
}
