/**
*!
* \file b_drv_ads124x.c
* \version v0.0.1
* \date 2024/09/18
* \author hmchen(chenhaimeng@189.cn)
*******************************************************************************
* @attention
*
* Copyright (c) 2020 Bean
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*******************************************************************************
*/
/*Includes ----------------------------------------------*/
#include "drivers/inc/b_drv_ads124x.h"
#include "drivers/inc/ADS124x_regs.h"
#include <string.h>
#include "utils/inc/b_util_log.h"
/**
* \addtogroup B_DRIVER
* \{
*/
/**
* \addtogroup HLW8112
* \{
*/
/**
* \defgroup HLW8112_Private_TypesDefinitions
* \{
*/
/**
* \}
*/
/**
* \defgroup HLW8112_Private_Defines
* \{
*/
#define DRIVER_NAME ADS124X
/** Device Identification (Who am I) **/
/**
* \}
*/
/**
* \defgroup ADS124X_Private_Macros
* \{
*/
/**
* \}
*/
/**
* \defgroup ADS124X_Private_Variables
* \{
*/
bDRIVER_HALIF_TABLE(bADS124X_HalIf_t, DRIVER_NAME);
static bAds124xPrivate_t bAds124xRunInfo[bDRIVER_HALIF_NUM(bADS124X_HalIf_t, DRIVER_NAME)];
/* Private Constants ------------------------------------------------------------*/
/**
* @brief Commands
*/
/*
* DRDY Polling Function
* Timeout = 0 is wait until DRDY goes low no matter how long it takes, otherwise wait the specified number of cycles
*/
int ADS1248WaitForDataReady(bDriverInterface_t *pdrv, int Timeout)
{
/* This function shows a method for polling DRDY instead of using as interrupt function
* -- Note: this method is not used in the demo, but if we the method was switched to polling from the interrupt method,
* the desired port is PORT2 on the MSP430 as this demo is configured.
*/
bDRIVER_GET_HALIF(_if, bADS124X_HalIf_t, pdrv);
if (Timeout > 0)
{
// wait for /DRDY = 1 to make sure it is high before we look for the transition low
while (!(bHalGpioReadPin(_if->drdy.port, _if->drdy.pin)) && (Timeout-- >= 0));
// wait for /DRDY = 0
while ( (bHalGpioReadPin(_if->drdy.port, _if->drdy.pin)) && (Timeout-- >= 0));
if (Timeout < 0)
return ADS1248_ERROR; //ADS1248_TIMEOUT_WARNING;
}
else
{
// wait for /DRDY = 1
while (!(bHalGpioReadPin(_if->drdy.port, _if->drdy.pin)));
// wait for /DRDY = 0
while ( (bHalGpioReadPin(_if->drdy.port, _if->drdy.pin)));
}
return ADS1248_NO_ERROR;
}
/*
* Primary Low Level Functions
*/
void ADS1248AssertCS(bDriverInterface_t *pdrv, int fAssert)
{
bDRIVER_GET_HALIF(_if, bADS124X_HalIf_t, pdrv);
if (fAssert){ // fAssert=0 is CS low, fAssert=1 is CS high
bHalDelayUs(100); // Must delay minimum of 7 tosc periods from last falling SCLK to rising CS
bHalGpioWritePin(_if->_spi.cs.port, _if->_spi.cs.pin, 1);
} else
bHalGpioWritePin(_if->_spi.cs.port, _if->_spi.cs.pin, 0);
}
void ADS1248SendByte(bDriverInterface_t *pdrv,unsigned char Byte)
{
bDRIVER_GET_HALIF(_if, bADS124X_HalIf_t, pdrv);
bHalSpiSend(&_if->_spi, &Byte, 1);
}
unsigned char ADS1248ReceiveByte(bDriverInterface_t *pdrv)
{
bDRIVER_GET_HALIF(_if, bADS124X_HalIf_t, pdrv);
unsigned char Result = 0;
bHalSpiReceive(&_if->_spi, &Result, 1);
return Result;
}
/*
* ADS1248 Higher Level Functions and Commands
*/
void ADS1248SendWakeup(bDriverInterface_t *pdrv)
{
// assert CS to start transfer
ADS1248AssertCS(pdrv,0);
// send the command byte
ADS1248SendByte(pdrv,ADS1248_CMD_WAKEUP);
// de-assert CS
ADS1248AssertCS(pdrv,1);
return;
}
void ADS1248SendSleep(bDriverInterface_t *pdrv)
{
// assert CS to start transfer
ADS1248AssertCS(pdrv,0);
// send the command byte
ADS1248SendByte(pdrv,ADS1248_CMD_SLEEP);
/*
* CS must remain low for the device to remain asleep by command...otherwise bring START low by pin control
*/
return;
}
void ADS1248SendSync(bDriverInterface_t *pdrv)
{
// assert CS to start transfer
ADS1248AssertCS(pdrv,0);
// send the command byte
ADS1248SendByte(pdrv,ADS1248_CMD_SYNC);
// de-assert CS
ADS1248AssertCS(pdrv,1);
return;
}
void ADS1248SendResetCommand(bDriverInterface_t *pdrv)
{
// assert CS to start transfer
ADS1248AssertCS(pdrv,0);
// send the command byte
ADS1248SendByte(pdrv,ADS1248_CMD_RESET);
// de-assert CS
ADS1248AssertCS(pdrv,1);
return;
}
long ADS1248ReadData(bDriverInterface_t *pdrv)
{
long Data;
// assert CS to start transfer
ADS1248AssertCS(pdrv,0);
// send the command byte
ADS1248SendByte(pdrv,ADS1248_CMD_RDATA);
// get the conversion result
#ifdef ADS1148
Data = ADS1248ReceiveByte(pdrv);
Data = (Data << 8) | ADS1248ReceiveByte();
// sign extend data if the MSB is high (16 to 32 bit sign extension)
if (Data & 0x8000)
Data |= 0xffff0000;
#else
Data = ADS1248ReceiveByte(pdrv);
Data = (Data << 8) | ADS1248ReceiveByte(pdrv);
Data = (Data << 8) | ADS1248ReceiveByte(pdrv);
// sign extend data if the MSB is high (24 to 32 bit sign extension)
if (Data & 0x800000)
Data |= 0xff000000;
#endif
// de-assert CS
ADS1248AssertCS(pdrv,1);
return Data;
}
void ADS1248ReadRegister(bDriverInterface_t *pdrv,int StartAddress, int NumRegs, unsigned * pData)
{
int i;
// assert CS to start transfer
ADS1248AssertCS(pdrv,0);
// send the command byte
ADS1248SendByte(pdrv,ADS1248_CMD_RREG | (StartAddress & 0x0f));
ADS1248SendByte(pdrv,(NumRegs-1) & 0x0f);
// get the register content
for (i=0; i< NumRegs; i++)
{
*pData++ = ADS1248ReceiveByte(pdrv);
}
// de-assert CS
ADS1248AssertCS(pdrv,1);
return;
}
void ADS1248WriteRegister(bDriverInterface_t *pdrv,int StartAddress, int NumRegs, unsigned * pData)
{
int i;
// set the CS low
ADS1248AssertCS(pdrv,0);
// send the command byte
ADS1248SendByte(pdrv,ADS1248_CMD_WREG | (StartAddress & 0x0f));
ADS1248SendByte(pdrv,(NumRegs-1) & 0x0f);
// send the data bytes
for (i=0; i < NumRegs; i++)
{
ADS1248SendByte(pdrv,*pData++);
}
// set the CS back high
ADS1248AssertCS(pdrv,1);
}
void ADS1248WriteSequence(bDriverInterface_t *pdrv,
int StartAddress, int NumRegs, unsigned * pData)
{
bDRIVER_GET_HALIF(_if, bADS124X_HalIf_t, pdrv);
uint8_t Buffer[6] = {0};
int i;
// set the CS low
ADS1248AssertCS(pdrv,0);
if (NumRegs > 6)
return ;
Buffer[0] = ADS1248_CMD_WREG | (StartAddress & 0x0f);
Buffer[1] = (NumRegs-1) & 0x0f;
for (i=2; i < NumRegs; i++)
{
Buffer[i] = *pData++;
}
bHalSpiSend(&_if->_spi, Buffer, sizeof(Buffer));
// set the CS back high
ADS1248AssertCS(pdrv,1);
}
void ADS1248SendRDATAC(bDriverInterface_t *pdrv)
{
// assert CS to start transfer
ADS1248AssertCS(pdrv,0);
// send the command byte
ADS1248SendByte(pdrv,ADS1248_CMD_RDATAC);
// de-assert CS
ADS1248AssertCS(pdrv,1);
return;
}
void ADS1248SendSDATAC(bDriverInterface_t *pdrv)
{
// assert CS to start transfer
ADS1248AssertCS(pdrv,0);
// send the command byte
ADS1248SendByte(pdrv,ADS1248_CMD_SDATAC);
// de-assert CS
ADS1248AssertCS(pdrv,1);
return;
}
void ADS1248SendSYSOCAL(bDriverInterface_t *pdrv)
{
// assert CS to start transfer
ADS1248AssertCS(pdrv,0);
// send the command byte
ADS1248SendByte(pdrv,ADS1248_CMD_SYSOCAL);
// de-assert CS
ADS1248AssertCS(pdrv,1);
return;
}
void ADS1248SendSYSGCAL(bDriverInterface_t *pdrv)
{
// assert CS to start transfer
ADS1248AssertCS(pdrv,0);
// send the command byte
ADS1248SendByte(pdrv,ADS1248_CMD_SYSGCAL);
// de-assert CS
ADS1248AssertCS(pdrv,1);
return;
}
void ADS1248SendSELFOCAL(bDriverInterface_t *pdrv)
{
// assert CS to start transfer
ADS1248AssertCS(pdrv,0);
// send the command byte
ADS1248SendByte(pdrv,ADS1248_CMD_SELFOCAL);
// de-assert CS
ADS1248AssertCS(pdrv,1);
return;
}
/*
* Register Set Value Commands
*
* These commands need to strip out old settings (AND) and add (OR) the new contents to the register
*/
int ADS1248SetBurnOutSource(bDriverInterface_t *pdrv,int BurnOut)
{
unsigned Temp;
int dError = ADS1248_NO_ERROR;
ADS1248ReadRegister(pdrv,ADS1248_0_MUX0, 0x01, &Temp);
Temp &= 0x3f;
switch(BurnOut) {
case 0:
Temp |= ADS1248_BCS_OFF;
break;
case 1:
Temp |= ADS1248_BCS_500nA;
break;
case 2:
Temp |= ADS1248_BCS_2uA;
break;
case 3:
Temp |= ADS1248_BCS_10uA;
break;
default:
dError = ADS1248_ERROR;
Temp |= ADS1248_BCS_OFF;
}
// write the register value containing the new value back to the ADS
ADS1248WriteRegister(pdrv,ADS1248_0_MUX0, 0x01, &Temp);
return dError;
}
int ADS1248SetChannel(bDriverInterface_t *pdrv,int vMux, int pMux)
{
unsigned Temp;
int dError = ADS1248_NO_ERROR;
ADS1248ReadRegister(pdrv,ADS1248_0_MUX0, 0x01, &Temp);
if (pMux==1) {
Temp &= 0xf8;
switch(vMux) {
case 0:
Temp |= ADS1248_AINN0;
break;
case 1:
Temp |= ADS1248_AINN1;
break;
case 2:
Temp |= ADS1248_AINN2;
break;
case 3:
Temp |= ADS1248_AINN3;
break;
case 4:
Temp |= ADS1248_AINN4;
break;
case 5:
Temp |= ADS1248_AINN5;
break;
case 6:
Temp |= ADS1248_AINN6;
break;
case 7:
Temp |= ADS1248_AINN7;
break;
default:
Temp |= ADS1248_AINN0;
dError = ADS1248_ERROR;
}
} else {
Temp &= 0xc7;
switch(vMux) {
case 0:
Temp |= ADS1248_AINP0;
break;
case 1:
Temp |= ADS1248_AINP1;
break;
case 2:
Temp |= ADS1248_AINP2;
break;
case 3:
Temp |= ADS1248_AINP3;
break;
case 4:
Temp |= ADS1248_AINP4;
break;
case 5:
Temp |= ADS1248_AINP5;
break;
case 6:
Temp |= ADS1248_AINP6;
break;
case 7:
Temp |= ADS1248_AINP7;
break;
default:
Temp |= ADS1248_AINP0;
dError = ADS1248_ERROR;
}
}
// write the register value containing the new value back to the ADS
ADS1248WriteRegister(pdrv,ADS1248_0_MUX0, 0x01, &Temp);
return dError;
}
int ADS1248SetBias(bDriverInterface_t *pdrv,unsigned char vBias)
{
unsigned Temp;
Temp = ADS1248_VBIAS_OFF;
if (vBias & 0x80)
Temp |= ADS1248_VBIAS7;
if (vBias & 0x40)
Temp |= ADS1248_VBIAS6;
if (vBias & 0x20)
Temp |= ADS1248_VBIAS5;
if (vBias & 0x10)
Temp |= ADS1248_VBIAS4;
if (vBias & 0x08)
Temp |= ADS1248_VBIAS3;
if (vBias & 0x04)
Temp |= ADS1248_VBIAS2;
if (vBias & 0x02)
Temp |= ADS1248_VBIAS1;
if (vBias & 0x01)
Temp |= ADS1248_VBIAS0;
// write the register value containing the new value back to the ADS
ADS1248WriteRegister(pdrv,ADS1248_1_VBIAS, 0x01, &Temp);
return ADS1248_NO_ERROR;
}
// Relate to Mux1
int ADS1248SetIntRef(bDriverInterface_t *pdrv,int sRef)
{
unsigned Temp;
int dError = ADS1248_NO_ERROR;
ADS1248ReadRegister(pdrv,ADS1248_2_MUX1, 0x01, &Temp);
Temp &= 0x1f;
switch(sRef) {
case 0:
Temp |= ADS1248_INT_VREF_OFF;
break;
case 1:
Temp |= ADS1248_INT_VREF_ON;
break;
case 2:
case 3:
Temp |= ADS1248_INT_VREF_CONV;
break;
default:
Temp |= ADS1248_INT_VREF_OFF;
dError = ADS1248_ERROR;
}
// write the register value containing the new value back to the ADS
ADS1248WriteRegister(pdrv,ADS1248_2_MUX1, 0x01, &Temp);
return dError;
}
int ADS1248SetVoltageReference(bDriverInterface_t *pdrv,int VoltageRef)
{
unsigned Temp;
int dError = ADS1248_NO_ERROR;
ADS1248ReadRegister(pdrv,ADS1248_2_MUX1, 0x01, &Temp);
Temp &= 0xe7;
switch(VoltageRef) {
case 0:
Temp |= ADS1248_REF0;
break;
case 1:
Temp |= ADS1248_REF1;
break;
case 2:
Temp |= ADS1248_INT;
break;
case 3:
Temp |= ADS1248_INT_REF0;
break;
default:
Temp |= ADS1248_REF0;
dError = ADS1248_ERROR;
}
// write the register value containing the new value back to the ADS
ADS1248WriteRegister(pdrv,ADS1248_2_MUX1, 0x01, &Temp);
return dError;
}
int ADS1248SetSystemMonitor(bDriverInterface_t *pdrv,int Monitor)
{
unsigned Temp;
int dError = ADS1248_NO_ERROR;
ADS1248ReadRegister(pdrv,ADS1248_2_MUX1, 0x01, &Temp);
Temp &= 0x78;
switch(Monitor) {
case 0:
Temp |= ADS1248_MEAS_NORM;
break;
case 1:
Temp |= ADS1248_MEAS_OFFSET;
break;
case 2:
Temp |= ADS1248_MEAS_GAIN;
break;
case 3:
Temp |= ADS1248_MEAS_TEMP;
break;
case 4:
Temp |= ADS1248_MEAS_REF1;
break;
case 5:
Temp |= ADS1248_MEAS_REF0;
break;
case 6:
Temp |= ADS1248_MEAS_AVDD;
break;
case 7:
Temp |= ADS1248_MEAS_DVDD;
break;
default:
Temp |= ADS1248_MEAS_NORM;
dError = ADS1248_ERROR;
}
// write the register value containing the new value back to the ADS
ADS1248WriteRegister(pdrv,ADS1248_2_MUX1, 0x01, &Temp);
return dError;
}
// Relate to SYS0
int ADS1248SetGain(bDriverInterface_t *pdrv,int Gain)
{
unsigned Temp;
int dError = ADS1248_NO_ERROR;
ADS1248ReadRegister(pdrv,ADS1248_3_SYS0, 0x01, &Temp);
Temp &= 0x0f;
switch(Gain) {
case 0:
Temp |= ADS1248_GAIN_1;
break;
case 1:
Temp |= ADS1248_GAIN_2;
break;
case 2:
Temp |= ADS1248_GAIN_4;
break;
case 3:
Temp |= ADS1248_GAIN_8;
break;
case 4:
Temp |= ADS1248_GAIN_16;
break;
case 5:
Temp |= ADS1248_GAIN_32;
break;
case 6:
Temp |= ADS1248_GAIN_64;
break;
case 7:
Temp |= ADS1248_GAIN_128;
break;
default:
Temp |= ADS1248_GAIN_1;
dError = ADS1248_ERROR;
}
// write the register value containing the new value back to the ADS
ADS1248WriteRegister(pdrv,ADS1248_3_SYS0, 0x01, &Temp);
return dError;
}
int ADS1248SetDataRate(bDriverInterface_t *pdrv,int DataRate)
{
unsigned Temp;
int dError = ADS1248_NO_ERROR;
ADS1248ReadRegister(pdrv,ADS1248_3_SYS0, 0x01, &Temp);
Temp &= 0x70;
switch(DataRate) {
case 0:
Temp |= ADS1248_DR_5;
break;
case 1:
Temp |= ADS1248_DR_10;
break;
case 2:
Temp |= ADS1248_DR_20;
break;
case 3:
Temp |= ADS1248_DR_40;
break;
case 4:
Temp |= ADS1248_DR_80;
break;
case 5:
Temp |= ADS1248_DR_160;
break;
case 6:
Temp |= ADS1248_DR_320;
break;
case 7:
Temp |= ADS1248_DR_640;
break;
case 8:
Temp |= ADS1248_DR_1000;
break;
case 9:
case 10:
case 11:
case 12:
case 13:
case 14:
case 15:
Temp |= ADS1248_DR_2000;
break;
default:
Temp |= ADS1248_DR_5;
dError = ADS1248_ERROR;
}
// write the register value containing the new value back to the ADS
ADS1248WriteRegister(pdrv,ADS1248_3_SYS0, 0x01, &Temp);
return dError;
}
//final output data = (input - ofc[2:0])* (fsc[2:0]/0x400000)
//offset regsiter
// Relate to OFC (3 registers)
int ADS1248SetOFC(bDriverInterface_t *pdrv,long RegOffset)
{
// find the pointer to the variable so we can write the value as bytes
unsigned *cptr=(unsigned *)(&RegOffset);
int i;
for (i=0; i<3; i++)
{
// write the register value containing the new value back to the ADS
ADS1248WriteRegister(pdrv,(ADS1248_4_OFC0 + i), 0x01, &cptr[i]);
}
return ADS1248_NO_ERROR;
}
//full scale regsister
// Relate to FSC (3 registers)
int ADS1248SetFSC(bDriverInterface_t *pdrv,long RegGain)
{
// find the pointer to the variable so we can write the value as bytes
unsigned *cptr=(unsigned *)(&RegGain);
int i;
for (i=0; i<3; i++)
{
// write the register value containing the new value back to the ADS
ADS1248WriteRegister(pdrv,(ADS1248_7_FSC0 + i), 0x01, &cptr[i]);
}
return ADS1248_NO_ERROR;
}
// Relate to IDAC0
int ADS1248SetDRDYMode(bDriverInterface_t *pdrv,int DRDYMode)
{
unsigned Temp;
int dError = ADS1248_NO_ERROR;
ADS1248ReadRegister(pdrv,ADS1248_10_IDAC0, 0x01, &Temp);
Temp &= 0xf7;
switch(DRDYMode) {
case 0:
Temp |= ADS1248_DRDY_OFF;
break;
case 1:
Temp |= ADS1248_DRDY_ON;
break;
default:
Temp |= ADS1248_DRDY_OFF;
dError = ADS1248_ERROR;
}
// write the register value containing the new value back to the ADS
ADS1248WriteRegister(pdrv,ADS1248_10_IDAC0, 0x01, &Temp);
return dError;
}
int ADS1248SetCurrentDACOutput(bDriverInterface_t *pdrv,int CurrentOutput)
{
unsigned Temp;
int dError = ADS1248_NO_ERROR;
ADS1248ReadRegister(pdrv,ADS1248_10_IDAC0, 0x01, &Temp);
Temp &= 0xf8;
switch(CurrentOutput) {
case 0:
Temp |= ADS1248_IDAC_OFF;
break;
case 1:
Temp |= ADS1248_IDAC_50;
break;
case 2:
Temp |= ADS1248_IDAC_100;
break;
case 3:
Temp |= ADS1248_IDAC_250;
break;
case 4:
Temp |= ADS1248_IDAC_500;
break;
case 5:
Temp |= ADS1248_IDAC_750;
break;
case 6:
Temp |= ADS1248_IDAC_1000;
break;
case 7:
Temp |= ADS1248_IDAC_1500;
break;
default:
Temp |= ADS1248_IDAC_OFF;
dError = ADS1248_ERROR;
}
// write the register value containing the new value back to the ADS
ADS1248WriteRegister(pdrv,ADS1248_10_IDAC0, 0x01, &Temp);
return dError;
}
// Relate to IDAC1
int ADS1248SetIDACRouting(bDriverInterface_t *pdrv,int IDACroute, int IDACdir) // IDACdir (0 = I1DIR, 1 = I2DIR)
{
unsigned Temp;
int dError = ADS1248_NO_ERROR;
ADS1248ReadRegister(pdrv,ADS1248_11_IDAC1, 0x01, &Temp);
if (IDACdir>0){
Temp &= 0xf0;
switch(IDACroute) {
case 0:
Temp |= ADS1248_IDAC2_A0;
break;
case 1:
Temp |= ADS1248_IDAC2_A1;
break;
case 2:
Temp |= ADS1248_IDAC2_A2;
break;
case 3:
Temp |= ADS1248_IDAC2_A3;
break;
case 4:
Temp |= ADS1248_IDAC2_A4;
break;
case 5:
Temp |= ADS1248_IDAC2_A5;
break;
case 6:
Temp |= ADS1248_IDAC2_A6;
break;
case 7:
Temp |= ADS1248_IDAC2_A7;
break;
case 8:
Temp |= ADS1248_IDAC2_EXT1;
break;
case 9:
Temp |= ADS1248_IDAC2_EXT2;
break;
case 10:
Temp |= ADS1248_IDAC2_EXT1;
break;
case 11:
Temp |= ADS1248_IDAC2_EXT2;
break;
case 12:
case 13:
case 14:
case 15:
Temp |= ADS1248_IDAC2_OFF;
break;
default:
Temp |= ADS1248_IDAC2_OFF;
dError = ADS1248_ERROR;
}
} else {
Temp &= 0x0f;
switch(IDACroute) {
case 0:
Temp |= ADS1248_IDAC1_A0;
break;
case 1:
Temp |= ADS1248_IDAC1_A1;
break;
case 2:
Temp |= ADS1248_IDAC1_A2;
break;
case 3:
Temp |= ADS1248_IDAC1_A3;
break;
case 4:
Temp |= ADS1248_IDAC1_A4;
break;
case 5:
Temp |= ADS1248_IDAC1_A5;
break;
case 6:
Temp |= ADS1248_IDAC1_A6;
break;
case 7:
Temp |= ADS1248_IDAC1_A7;
break;
case 8:
Temp |= ADS1248_IDAC1_EXT1;
break;
case 9:
Temp |= ADS1248_IDAC1_EXT2;
break;
case 10:
Temp |= ADS1248_IDAC1_EXT1;
break;
case 11:
Temp |= ADS1248_IDAC1_EXT2;
break;
case 12:
case 13:
case 14:
case 15:
Temp |= ADS1248_IDAC1_OFF;
break;
default:
Temp |= ADS1248_IDAC1_OFF;
dError = ADS1248_ERROR;
}
}
// write the register value containing the new value back to the ADS
ADS1248WriteRegister(pdrv,ADS1248_11_IDAC1, 0x01, &Temp);
return dError;
}
// Relate to GPIOCFG
int ADS1248SetGPIOConfig(bDriverInterface_t *pdrv,unsigned char cdata)
{
unsigned Temp;
Temp = 0x00;
if (cdata & 0x80)
Temp |= ADS1248_GPIO_7;
if (cdata & 0x40)
Temp |= ADS1248_GPIO_6;
if (cdata & 0x20)
Temp |= ADS1248_GPIO_5;
if (cdata & 0x10)
Temp |= ADS1248_GPIO_4;
if (cdata & 0x08)
Temp |= ADS1248_GPIO_3;
if (cdata & 0x04)
Temp |= ADS1248_GPIO_2;
if (cdata & 0x02)
Temp |= ADS1248_GPIO_1;
if (cdata & 0x01)
Temp |= ADS1248_GPIO_0;
// write the register value containing the new value back to the ADS
ADS1248WriteRegister(pdrv,ADS1248_12_GPIOCFG, 0x01, &Temp);
return ADS1248_NO_ERROR;
}
// Relate to GPIODIR
int ADS1248SetGPIODir(bDriverInterface_t *pdrv,unsigned char cdata)
{
unsigned Temp;
Temp = 0x00;
if (cdata & 0x80)
Temp |= ADS1248_IO_7;
if (cdata & 0x40)
Temp |= ADS1248_IO_6;
if (cdata & 0x20)
Temp |= ADS1248_IO_5;
if (cdata & 0x10)
Temp |= ADS1248_IO_4;
if (cdata & 0x08)
Temp |= ADS1248_IO_3;
if (cdata & 0x04)
Temp |= ADS1248_IO_2;
if (cdata & 0x02)
Temp |= ADS1248_IO_1;
if (cdata & 0x01)
Temp |= ADS1248_IO_0;
// write the register value containing the new value back to the ADS
ADS1248WriteRegister(pdrv,ADS1248_13_GPIODIR, 0x01, &Temp);
return ADS1248_NO_ERROR;
}
// Relate to GPIODAT
int ADS1248SetGPIO(bDriverInterface_t *pdrv,unsigned char cdata)
{
unsigned Temp;
Temp = 0x00;
if (cdata & 0x80)
Temp |= ADS1248_OUT_7;
if (cdata & 0x40)
Temp |= ADS1248_OUT_6;
if (cdata & 0x20)
Temp |= ADS1248_OUT_5;
if (cdata & 0x10)
Temp |= ADS1248_OUT_4;
if (cdata & 0x08)
Temp |= ADS1248_OUT_3;
if (cdata & 0x04)
Temp |= ADS1248_OUT_2;
if (cdata & 0x02)
Temp |= ADS1248_OUT_1;
if (cdata & 0x01)
Temp |= ADS1248_OUT_0;
// write the register value containing the new value back to the ADS
ADS1248WriteRegister(pdrv,ADS1248_14_GPIODAT, 0x01, &Temp);
return ADS1248_NO_ERROR;
}
/* Register Get Value Commands */
// Relate to MUX0
int ADS1248GetBurnOutSource(bDriverInterface_t *pdrv)
{
unsigned Temp;
ADS1248ReadRegister(pdrv,ADS1248_0_MUX0, 0x01, &Temp);
return ((Temp >> 6) & 0x03);
}
int ADS1248GetChannel(bDriverInterface_t *pdrv,int cMux) // cMux = 0, AINP; cMux = 1, AINN
{
unsigned Temp;
ADS1248ReadRegister(pdrv,ADS1248_0_MUX0, 0x01, &Temp);
if (cMux==0)
return ((Temp >> 3) & 0x07);
else
return (Temp & 0x07);
}
// Relate to VBIAS
unsigned char ADS1248GetBias(bDriverInterface_t *pdrv)
{
unsigned Temp;
ADS1248ReadRegister(pdrv,ADS1248_1_VBIAS, 0x01, &Temp);
return (Temp & 0xff);
}
//Relate to MUX1
int ADS1248GetCLKSTAT(bDriverInterface_t *pdrv)
{
unsigned Temp;
ADS1248ReadRegister(pdrv,ADS1248_2_MUX1, 0x01, &Temp);
return ((Temp >> 7) & 0x01);
}
int ADS1248GetIntRef(bDriverInterface_t *pdrv)
{
unsigned Temp;
ADS1248ReadRegister(pdrv,ADS1248_2_MUX1, 0x01, &Temp);
return ((Temp >> 5) & 0x03);
}
int ADS1248GetVoltageReference(bDriverInterface_t *pdrv)
{
unsigned Temp;
ADS1248ReadRegister(pdrv,ADS1248_2_MUX1, 0x01, &Temp);
return ((Temp >> 3) & 0x03);
}
int ADS1248GetSystemMonitor(bDriverInterface_t *pdrv)
{
unsigned Temp;
ADS1248ReadRegister(pdrv,ADS1248_2_MUX1, 0x01, &Temp);
return (Temp & 0x07);
}
// Relate to SYS0
int ADS1248GetGain(bDriverInterface_t *pdrv)
{
unsigned Temp;
ADS1248ReadRegister(pdrv,ADS1248_3_SYS0, 0x01, &Temp);
return ((Temp >> 4) & 0x07);
}
int ADS1248GetDataRate(bDriverInterface_t *pdrv)
{
unsigned Temp;
ADS1248ReadRegister(pdrv,ADS1248_3_SYS0, 0x01, &Temp);
return (Temp & 0x0f);
}
// Relate to OFC (3 registers)
long ADS1248GetOFC(bDriverInterface_t *pdrv)
{
long rData=0;
unsigned rValue=0;
unsigned regArray[3];
int i;
//write the desired default register settings for the first 4 registers NOTE: values shown are the POR values as per datasheet
regArray[0] = 0x00;
regArray[1] = 0x00;
regArray[2] = 0x00;
for (i=0; i<3; i++)
{
// read the register value for the OFC
ADS1248ReadRegister(pdrv,(ADS1248_4_OFC0 + i), 0x01, &rValue);
regArray[i] = rValue;
}
rData = regArray[2];
rData = (rData<<8) | regArray[1];
rData = (rData<<8) | regArray[0];
return rData;
}
// Relate to FSC (3 registers)
long ADS1248GetFSC(bDriverInterface_t *pdrv)
{
long rData=0;
unsigned rValue=0;
unsigned regArray[3];
int i;
//write the desired default register settings for the first 4 registers NOTE: values shown are the POR values as per datasheet
regArray[0] = 0x00;
regArray[1] = 0x00;
regArray[2] = 0x00;
for (i=0; i<3; i++)
{
// read the register value for the OFC
ADS1248ReadRegister(pdrv,(ADS1248_7_FSC0 + i), 0x01, &rValue);
regArray[i] = rValue;
}
rData = regArray[2];
rData = (rData<<8) | regArray[1];
rData = (rData<<8) | regArray[0];
return rData;
}
// Relate to IDAC0
int ADS1248GetID(bDriverInterface_t *pdrv)
{
unsigned Temp;
ADS1248ReadRegister(pdrv,ADS1248_10_IDAC0, 0x01, &Temp);
return ((Temp>>4) & 0x0f);
}
int ADS1248GetDRDYMode(bDriverInterface_t *pdrv)
{
unsigned Temp;
ADS1248ReadRegister(pdrv,ADS1248_10_IDAC0, 0x01, &Temp);
return ((Temp>>3) & 0x01);
}
int ADS1248GetCurrentDACOutput(bDriverInterface_t *pdrv)
{
unsigned Temp;
ADS1248ReadRegister(pdrv,ADS1248_10_IDAC0, 0x01, &Temp);
return (Temp & 0x07);
}
// Relate to IDAC1
int ADS1248GetIDACRouting(bDriverInterface_t *pdrv,int WhichOne) // IDACRoute (0 = I1DIR, 1 = I2DIR)
{
unsigned Temp;
ADS1248ReadRegister(pdrv,ADS1248_11_IDAC1, 0x01, &Temp);
if (WhichOne==0)
return ((Temp>>4) & 0x0f);
else
return (Temp & 0x0f);
}
// Relate to GPIOCFG
unsigned char ADS1248GetGPIOConfig(bDriverInterface_t *pdrv)
{
unsigned Temp;
ADS1248ReadRegister(pdrv,ADS1248_12_GPIOCFG, 0x01, &Temp);
return (Temp & 0xff);
}
// Relate to GPIODIR
unsigned char ADS1248GetGPIODir(bDriverInterface_t *pdrv)
{
unsigned Temp;
ADS1248ReadRegister(pdrv,ADS1248_13_GPIODIR, 0x01, &Temp);
return (Temp & 0xff);
}
// Relate to GPIODAT
unsigned char ADS1248GetGPIO(bDriverInterface_t *pdrv)
{
unsigned Temp;
ADS1248ReadRegister(pdrv,ADS1248_14_GPIODAT, 0x01, &Temp);
return (Temp & 0xff);
}
/* Miscellaneous Commands */
long ADS1248RDATACRead(bDriverInterface_t *pdrv) // reads data directly based on RDATAC mode (writes NOP) and 32 SCLKs
{
long Data;
// assert CS to start transfer
ADS1248AssertCS(pdrv,0);
// get the conversion result
#ifdef ADS1148
Data = ADS1248ReceiveByte(pdrv);
Data = (Data << 8) | ADS1248ReceiveByte(pdrv);
// sign extend data if the MSB is high (16 to 32 bit sign extension)
if (Data & 0x8000)
Data |= 0xffff0000;
#else
Data = ADS1248ReceiveByte(pdrv);
Data = (Data << 8) | ADS1248ReceiveByte(pdrv);
Data = (Data << 8) | ADS1248ReceiveByte(pdrv);
// sign extend data if the MSB is high (24 to 32 bit sign extension)
if (Data & 0x800000)
Data |= 0xff000000;
#endif
// de-assert CS
ADS1248AssertCS(pdrv,1);
return Data;
}
/* Hardware Control Functions for Device Pin Control */
// Possible Need for Reset, Start (power down) (0-low, 1-high, 2-pulse)
int ADS1248SetStart(bDriverInterface_t *pdrv,int nStart)
{
/*
* Code can be added here to set high or low the state of the pin for controlling the START pin
* which will differ depending on controller used and port pin assigned
*/
bDRIVER_GET_HALIF(_if, bADS124X_HalIf_t, pdrv);
if (nStart) // nStart=0 is START low, nStart=1 is START high
bHalGpioWritePin(_if->start.port, _if->start.pin, 1);
else
bHalGpioWritePin(_if->start.port, _if->start.pin, 0);
return ADS1248_NO_ERROR;
}
int ADS1248SetReset(bDriverInterface_t *pdrv,int nReset)
{
/*
* Code can be added here to set high or low the state of the pin for controlling the RESET pin
* which will differ depending on controller used and port pin assigned
*/
bDRIVER_GET_HALIF(_if, bADS124X_HalIf_t, pdrv);
if (nReset) // nReset=0 is RESET low, nReset=1 is RESET high
bHalGpioWritePin(_if->reset.port, _if->reset.pin, 1);
else
bHalGpioWritePin(_if->reset.port, _if->reset.pin, 0);
return ADS1248_NO_ERROR;
}
static void _bAds124xItHandler(bHalItNumber_t it, uint8_t index, bHalItParam_t *param,
void *user_data)
{
bDriverInterface_t *pdrv = user_data;
bDRIVER_GET_PRIVATE(_priv, bAds124xPrivate_t, pdrv);
uint32_t adc_raw_data = 0;
adc_raw_data = ADS1248ReadData(pdrv);
_priv->cb.cb(B_EVT_CONV_STA_OK, &adc_raw_data, NULL, _priv->cb.user_data);
}
void set_nsi8241_en1(uint8_t dev_no)
{
switch(dev_no)
{
case 0 :
bHalGpioWritePin(B_HAL_GPIOA, B_HAL_PIN5, 1);
bHalGpioWritePin(B_HAL_GPIOB, B_HAL_PIN15, 0);
bHalGpioWritePin(B_HAL_GPIOC, B_HAL_PIN2, 0);
bHalGpioWritePin(B_HAL_GPIOD, B_HAL_PIN9, 0);
bHalGpioWritePin(B_HAL_GPIOC, B_HAL_PIN9, 0);
bHalGpioWritePin(B_HAL_GPIOC, B_HAL_PIN14, 0);
break;
case 1 :
bHalGpioWritePin(B_HAL_GPIOA, B_HAL_PIN5, 0);
bHalGpioWritePin(B_HAL_GPIOB, B_HAL_PIN15, 1);
bHalGpioWritePin(B_HAL_GPIOC, B_HAL_PIN2, 0);
bHalGpioWritePin(B_HAL_GPIOD, B_HAL_PIN9, 0);
bHalGpioWritePin(B_HAL_GPIOC, B_HAL_PIN9, 0);
bHalGpioWritePin(B_HAL_GPIOC, B_HAL_PIN14, 0);
break;
case 2 :
bHalGpioWritePin(B_HAL_GPIOA, B_HAL_PIN5, 0);
bHalGpioWritePin(B_HAL_GPIOB, B_HAL_PIN15, 0);
bHalGpioWritePin(B_HAL_GPIOC, B_HAL_PIN2, 1);
bHalGpioWritePin(B_HAL_GPIOD, B_HAL_PIN9, 0);
bHalGpioWritePin(B_HAL_GPIOC, B_HAL_PIN9, 0);
bHalGpioWritePin(B_HAL_GPIOC, B_HAL_PIN14, 0);
break;
case 3 :
bHalGpioWritePin(B_HAL_GPIOA, B_HAL_PIN5, 0);
bHalGpioWritePin(B_HAL_GPIOB, B_HAL_PIN15, 0);
bHalGpioWritePin(B_HAL_GPIOC, B_HAL_PIN2, 0);
bHalGpioWritePin(B_HAL_GPIOD, B_HAL_PIN9, 1);
bHalGpioWritePin(B_HAL_GPIOC, B_HAL_PIN9, 0);
bHalGpioWritePin(B_HAL_GPIOC, B_HAL_PIN14, 0);
break;
case 4 :
bHalGpioWritePin(B_HAL_GPIOA, B_HAL_PIN5, 0);
bHalGpioWritePin(B_HAL_GPIOB, B_HAL_PIN15, 0);
bHalGpioWritePin(B_HAL_GPIOC, B_HAL_PIN2, 0);
bHalGpioWritePin(B_HAL_GPIOD, B_HAL_PIN9, 0);
bHalGpioWritePin(B_HAL_GPIOC, B_HAL_PIN9, 1);
bHalGpioWritePin(B_HAL_GPIOC, B_HAL_PIN14, 0);
break;
case 5 :
bHalGpioWritePin(B_HAL_GPIOA, B_HAL_PIN5, 0);
bHalGpioWritePin(B_HAL_GPIOB, B_HAL_PIN15, 0);
bHalGpioWritePin(B_HAL_GPIOC, B_HAL_PIN2, 0);
bHalGpioWritePin(B_HAL_GPIOD, B_HAL_PIN9, 0);
bHalGpioWritePin(B_HAL_GPIOC, B_HAL_PIN9, 0);
bHalGpioWritePin(B_HAL_GPIOC, B_HAL_PIN14, 1);
break;
default:
break;
}
bHalDelayMs(10);
}
/*
* ADS1248 Initial Configuration
*/
static int InitConfig(bDriverInterface_t *pdrv)
{
bDRIVER_GET_HALIF(_if, bADS124X_HalIf_t, pdrv);
int retval = -1;
int read_data_rate = 0;
int write_data_rate = 2;
set_nsi8241_en1(pdrv->drv_no);
ADS1248AssertCS(pdrv,1);
ADS1248SetReset(pdrv,0);
ADS1248SetStart(pdrv,0);
bHalDelayMs(4);
ADS1248SetReset(pdrv,1);
ADS1248SetStart(pdrv,1);
bHalDelayMs(20);
//establish some startup register settings
unsigned regArray[4];
// Send SDATAC command
ADS1248SendSDATAC(pdrv);
retval = ADS1248WaitForDataReady(pdrv,0);
ADS1248SendSDATAC(pdrv);
//write the desired default register settings for the first 4 registers NOTE: values shown are the POR values as per datasheet
regArray[0] = 0x01;
regArray[1] = 0x00;
regArray[2] = 0x00;
regArray[3] = 0x00;
ADS1248WriteSequence(pdrv,ADS1248_0_MUX0, 4, regArray);
ADS1248SetGain(pdrv,2); //gain = 2
ADS1248SetDataRate(pdrv,write_data_rate); //DR 20
read_data_rate = ADS1248GetDataRate(pdrv);
b_log("data_rate:%d\r\n",read_data_rate);
if(read_data_rate == write_data_rate)
{
retval = 0;
}
if (_if->it.it == B_HAL_IT_EXTI)
{
bHAL_IT_REGISTER(ads124x_it, B_HAL_IT_EXTI, _if->it.index, _bAds124xItHandler, pdrv);
}
return retval;
}
/**
* \}
*/
static int _bAds124xRead(bDriverInterface_t *pdrv, uint32_t off, uint8_t *pbuf, uint32_t len)
{
uint32_t adc_raw_data = 0;
set_nsi8241_en1(pdrv->drv_no);
ADS1248WaitForDataReady(pdrv,0);
adc_raw_data = ADS1248ReadData(pdrv);
memcpy(pbuf, &adc_raw_data, sizeof(adc_raw_data));
return sizeof(adc_raw_data);
}
static int _bAds124xCtl(bDriverInterface_t *pdrv, uint8_t cmd, void *param)
{
bDRIVER_GET_PRIVATE(_priv, bAds124xPrivate_t, pdrv);
set_nsi8241_en1(pdrv->drv_no);
switch (cmd)
{
case bCMD_ADS124X_REG_CALLBACK :
{
if (param == NULL)
{
return -1;
}
bAds124xDrvCallback_t *pcb = (bAds124xDrvCallback_t *)param;
_priv->cb.cb = pcb->cb;
_priv->cb.user_data = pcb->user_data;
}
break;
case bCMD_ADS124X_SET_AIN :
{
bADS124X_InputPin_t *pAIN = (bADS124X_InputPin_t *)param;
ADS1248SetChannel(pdrv,pAIN->AINN,1);
ADS1248SetChannel(pdrv,pAIN->AINP,0);
}
break;
case bCMD_ADS124X_SET_VREF :
{
uint8_t *pVREF = (uint8_t *)param;
ADS1248SetVoltageReference(pdrv,*pVREF);
}
break;
// case bCMD_ADS124X_SET_GCONFIG :
// break;
case bCMD_ADS124X_START_1CONV :
{
ADS1248SetStart(pdrv,1);
bHalDelayUs(10); // At least 3 clk times
ADS1248SetStart(pdrv,0);
}
break;
case bCMD_ADS124X_SET_FSC :
break;
case bCMD_ADS124X_SET_CURRENT :
{
uint8_t *pCURRENT = (uint8_t *)param;
ADS1248SetCurrentDACOutput(pdrv,*pCURRENT);
}
break;
case bCMD_ADS124X_GET_GDAT :
break;
case bCMD_ADS124X_SET_OFC :
break;
case bCMD_ADS124X_SET_MUX :
break;
case bCMD_ADS124X_SET_BURNOUT :
break;
case bCMD_ADS124X_SET_BIAS :
break;
case bCMD_ADS124X_SET_PWRDN :
break;
case bCMD_ADS124X_SET_PGA :
{
uint8_t *pPGA = (uint8_t *)param;
ADS1248SetGain(pdrv,*pPGA);
}
break;
case bCMD_ADS124X_SET_IREF :
{
uint8_t *pIREF = (uint8_t *)param;
ADS1248SetIntRef(pdrv,*pIREF);
}
break;
case bCMD_ADS124X_RESETDUT :
break;
case bCMD_ADS124X_SET_DATARATE :
{
uint8_t *pDATARATE = (uint8_t *)param;
ADS1248SetDataRate(pdrv,*pDATARATE);
}
break;
case bCMD_ADS124X_SET_GIO :
{
uint8_t *cdata = (uint8_t *)param;
ADS1248SetGPIODir(pdrv,*cdata);
}
break;
case bCMD_ADS124X_SET_IDAC :
{
bADS124X_IDACRouting_t *pIDACRouting = (bADS124X_IDACRouting_t *)param;
ADS1248SetIDACRouting(pdrv,pIDACRouting->IDACroute,pIDACRouting->IDACdir);
}
break;
default:
break;
}
return 0;
}
/**
* \addtogroup LIS3DH_Exported_Functions
* \{
*/
int bADS124X_Init(bDriverInterface_t *pdrv)
{
int retval = -1;
bDRIVER_STRUCT_INIT(pdrv, DRIVER_NAME, bADS124X_Init);
pdrv->read = _bAds124xRead;
pdrv->ctl = _bAds124xCtl;
pdrv->_private._p = &bAds124xRunInfo[pdrv->drv_no];
memset(pdrv->_private._p, 0, sizeof(bAds124xPrivate_t));
retval = InitConfig(pdrv);
bDRIVER_SET_READCACHE(pdrv, &bAds124xRunInfo[pdrv->drv_no].data[0],
sizeof(bAds124xRunInfo[pdrv->drv_no].data));
return retval;
}
#ifdef BSECTION_NEED_PRAGMA
#pragma section driver_init
#endif
bDRIVER_REG_INIT(B_DRIVER_ADS124X, bADS124X_Init);
#ifdef BSECTION_NEED_PRAGMA
#pragma section
#endif
/**
* \}
*/
/**
* \}
*/
/**
* \}
*/
/************************ Copyright (c) 2020 Bean *****END OF FILE****/