ADS1015驱动程序

最新推荐文章于 2024-06-27 11:12:43 发布
最新推荐文章于 2024-06-27 11:12:43 发布
阅读量7.1k 收藏 13
点赞数 2
分类专栏： TI C2000 DSP
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fz835304205/article/details/42419575
版权

ADS1015.c

/**************************************************************************/
/*!
    @file     Adafruit_ADS1015.c
    @author   K.Townsend (Adafruit Industries)
    @license  BSD (see license.txt)

    Driver for the ADS1015/ADS1115 ADC

    This is a library for the Adafruit MPL115A2 breakout
    ----> https://www.adafruit.com/products/???

    Adafruit invests time and resources providing this open source code,
    please support Adafruit and open-source hardware by purchasing
    products from Adafruit!

    @section  HISTORY

    v1.0 - First release
    Edit by FangZheng 2014-12-11
*/

#include "global.h"

static Uint16 m_i2cAddress;
static Uint16 m_conversionDelay;
static Uint16 m_bitShift;
static adsGain_t m_gain;
static Uint16 m_chn;
#if 0
/**************************************************************************/
/*!
    @brief  Writes 16-bits to the specified destination register
*/
/**************************************************************************/
static void writeRegister(Uint16 i2cAddress, Uint16 reg, Uint16 value)
{
    Wire.beginTransmission(i2cAddress);
    i2cwrite((Uint16)reg);
    i2cwrite((Uint16)(value >> 8));
    i2cwrite((Uint16)(value & 0xFF));
    Wire.endTransmission();
}

/**************************************************************************/
/*!
    @brief  Writes 16-bits to the specified destination register
*/
/**************************************************************************/
static Uint16 readRegister(Uint16 i2cAddress, Uint16 reg)
{
    Wire.beginTransmission(i2cAddress);
    i2cwrite(ADS1015_REG_POINTER_CONVERT);
    Wire.endTransmission();
    Wire.requestFrom(i2cAddress, (Uint16)2);
    return ((i2cread() << 8) | i2cread());
}
#endif
/**************************************************************************/
/*!
    @brief  Instantiates a new ADS1015 class w/appropriate properties
*/
/**************************************************************************/
void ads1015_init(void)
{
    m_i2cAddress = ADS1015_ADDRESS;
    m_conversionDelay = ADS1015_CONVERSIONDELAY;
    m_bitShift = 4;
    m_gain = GAIN_ONE; /* +/- 6.144V range (limited to VDD +0.3V max!) */
    m_chn = 0;
}

#if 0
/**************************************************************************/
/*!
    @brief  Sets the gain and input voltage range
*/
/**************************************************************************/
void setGain(adsGain_t gain)
{
    m_gain = gain;
}

/**************************************************************************/
/*!
    @brief  Gets a gain and input voltage range
*/
/**************************************************************************/
adsGain_t getGain()
{
    return m_gain;
}
#endif

/**************************************************************************/
/*!
    @brief  Gets a single-ended ADC reading from the specified channel
*/
/**************************************************************************/
Uint16 readADC_SingleEnded(Uint16 channel)
{
    Uint16  config;
    if (channel > 3)
    {
        return 0;
    }

    // Start with default values
    config = ADS1015_REG_CONFIG_CQUE_NONE    | // Disable the comparator (default val)
            ADS1015_REG_CONFIG_CLAT_NONLAT  | // Non-latching (default val)
            ADS1015_REG_CONFIG_CPOL_ACTVLOW | // Alert/Rdy active low   (default val)
            ADS1015_REG_CONFIG_CMODE_TRAD   | // Traditional comparator (default val)
            ADS1015_REG_CONFIG_DR_1600SPS   | // 1600 samples per second (default)
            ADS1015_REG_CONFIG_MODE_SINGLE;   // Single-shot mode (default)

    // Set PGA/voltage range
    config |= m_gain;

    // Set single-ended input channel
    switch (channel)
    {
    case (0):
        config |= ADS1015_REG_CONFIG_MUX_SINGLE_0;
        break;
    case (1):
        config |= ADS1015_REG_CONFIG_MUX_SINGLE_1;
        break;
    case (2):
        config |= ADS1015_REG_CONFIG_MUX_SINGLE_2;
        break;
    case (3):
        config |= ADS1015_REG_CONFIG_MUX_SINGLE_3;
        break;
    }

    // Set 'start single-conversion' bit
    config |= ADS1015_REG_CONFIG_OS_SINGLE;

    // Write config register to the ADC
    writeRegister(m_i2cAddress, ADS1015_REG_POINTER_CONFIG, config);

    // Wait for the conversion to complete
    //DELAY_US(m_conversionDelay);
    DELAY_US(350);

    // Read the conversion results
    // Shift 12-bit results right 4 bits for the ADS1015
    return readRegister(m_i2cAddress, ADS1015_REG_POINTER_CONVERT) >> m_bitShift;
}


void read_adc_config(void)
{
    Uint16  config;

    // Start with default values
    config = ADS1015_REG_CONFIG_CQUE_NONE    | // Disable the comparator (default val)
            ADS1015_REG_CONFIG_CLAT_NONLAT  | // Non-latching (default val)
            ADS1015_REG_CONFIG_CPOL_ACTVLOW | // Alert/Rdy active low   (default val)
            ADS1015_REG_CONFIG_CMODE_TRAD   | // Traditional comparator (default val)
            ADS1015_REG_CONFIG_DR_1600SPS   | // 1600 samples per second (default)
            ADS1015_REG_CONFIG_MODE_SINGLE;   // Single-shot mode (default)

    // Set PGA/voltage range
    config |= m_gain;

    // Set single-ended input channel
    switch (m_chn)
    {
    case (0):
        config |= ADS1015_REG_CONFIG_MUX_SINGLE_0;
        break;
    case (1):
        config |= ADS1015_REG_CONFIG_MUX_SINGLE_1;
        break;
    case (2):
        config |= ADS1015_REG_CONFIG_MUX_SINGLE_2;
        break;
    case (3):
        config |= ADS1015_REG_CONFIG_MUX_SINGLE_3;
        break;
    }

    // Set 'start single-conversion' bit
    config |= ADS1015_REG_CONFIG_OS_SINGLE;

    // Write config register to the ADC
    writeRegister(m_i2cAddress, ADS1015_REG_POINTER_CONFIG, config);
    
}

void read_adc_reg(volatile Uint16 *res0, volatile Uint16 *res1)
{
    if(m_chn)
    {
        *res1 = readRegister(m_i2cAddress, ADS1015_REG_POINTER_CONVERT) >> m_bitShift;
        m_chn = 0;
    }
    else
    {
        *res0 = readRegister(m_i2cAddress, ADS1015_REG_POINTER_CONVERT) >> m_bitShift;
        m_chn = 1;
    }
}
void get_adc(volatile Uint16 *res0, volatile Uint16 *res1)
{
    #define PER_CNT 6
    static volatile Uint16 i = 0;

    if(i == 0)
    {
        read_adc_config();
    }

    if(i == PER_CNT)
    {
        read_adc_reg(res0, res1);
    }
    if(i++ > PER_CNT) i = 0;
}
#if 0
/**************************************************************************/
/*!
    @brief  Reads the conversion results, measuring the voltage
            difference between the P (AIN0) and N (AIN1) input.  Generates
            a signed value since the difference can be either
            positive or negative.
*/
/**************************************************************************/
int16_t readADC_Differential_0_1(void)
{
    Uint16 res, config;
    // Start with default values
    config = ADS1015_REG_CONFIG_CQUE_NONE    | // Disable the comparator (default val)
             ADS1015_REG_CONFIG_CLAT_NONLAT  | // Non-latching (default val)
             ADS1015_REG_CONFIG_CPOL_ACTVLOW | // Alert/Rdy active low   (default val)
             ADS1015_REG_CONFIG_CMODE_TRAD   | // Traditional comparator (default val)
             ADS1015_REG_CONFIG_DR_1600SPS   | // 1600 samples per second (default)
             ADS1015_REG_CONFIG_MODE_SINGLE;   // Single-shot mode (default)

    // Set PGA/voltage range
    config |= m_gain;

    // Set channels
    config |= ADS1015_REG_CONFIG_MUX_DIFF_0_1;          // AIN0 = P, AIN1 = N

    // Set 'start single-conversion' bit
    config |= ADS1015_REG_CONFIG_OS_SINGLE;

    // Write config register to the ADC
    writeRegister(m_i2cAddress, ADS1015_REG_POINTER_CONFIG, config);

    // Wait for the conversion to complete
    DELAY_US(m_conversionDelay);

    // Read the conversion results
    res = readRegister(m_i2cAddress, ADS1015_REG_POINTER_CONVERT) >> m_bitShift;
    if (m_bitShift == 0)
    {
        return (int16)res;
    }
    else
    {
        // Shift 12-bit results right 4 bits for the ADS1015,
        // making sure we keep the sign bit intact
        if (res > 0x07FF)
        {
            // negative number - extend the sign to 16th bit
            res |= 0xF000;
        }
        return (int16)res;
    }
}

/**************************************************************************/
/*!
    @brief  Reads the conversion results, measuring the voltage
            difference between the P (AIN2) and N (AIN3) input.  Generates
            a signed value since the difference can be either
            positive or negative.
*/
/**************************************************************************/
int16_t readADC_Differential_2_3(void)
{
    Uint16 res, config;
    // Start with default values
    config = ADS1015_REG_CONFIG_CQUE_NONE    | // Disable the comparator (default val)
             ADS1015_REG_CONFIG_CLAT_NONLAT  | // Non-latching (default val)
             ADS1015_REG_CONFIG_CPOL_ACTVLOW | // Alert/Rdy active low   (default val)
             ADS1015_REG_CONFIG_CMODE_TRAD   | // Traditional comparator (default val)
             ADS1015_REG_CONFIG_DR_1600SPS   | // 1600 samples per second (default)
             ADS1015_REG_CONFIG_MODE_SINGLE;   // Single-shot mode (default)

    // Set PGA/voltage range
    config |= m_gain;

    // Set channels
    config |= ADS1015_REG_CONFIG_MUX_DIFF_2_3;          // AIN2 = P, AIN3 = N

    // Set 'start single-conversion' bit
    config |= ADS1015_REG_CONFIG_OS_SINGLE;

    // Write config register to the ADC
    writeRegister(m_i2cAddress, ADS1015_REG_POINTER_CONFIG, config);

    // Wait for the conversion to complete
    DELAY_US(m_conversionDelay);

    // Read the conversion results
    res = readRegister(m_i2cAddress, ADS1015_REG_POINTER_CONVERT) >> m_bitShift;
    if (m_bitShift == 0)
    {
        return (int16)res;
    }
    else
    {
        // Shift 12-bit results right 4 bits for the ADS1015,
        // making sure we keep the sign bit intact
        if (res > 0x07FF)
        {
            // negative number - extend the sign to 16th bit
            res |= 0xF000;
        }
        return (int16)res;
    }
}

/**************************************************************************/
/*!
    @brief  Sets up the comparator to operate in basic mode, causing the
            ALERT/RDY pin to assert (go from high to low) when the ADC
            value exceeds the specified threshold.

            This will also set the ADC in continuous conversion mode.
*/
/**************************************************************************/
void startComparator_SingleEnded(Uint16 channel, int16_t threshold)
{
    // Start with default values
    Uint16 config = ADS1015_REG_CONFIG_CQUE_1CONV   | // Comparator enabled and asserts on 1 match
                    ADS1015_REG_CONFIG_CLAT_LATCH   | // Latching mode
                    ADS1015_REG_CONFIG_CPOL_ACTVLOW | // Alert/Rdy active low   (default val)
                    ADS1015_REG_CONFIG_CMODE_TRAD   | // Traditional comparator (default val)
                    ADS1015_REG_CONFIG_DR_1600SPS   | // 1600 samples per second (default)
                    ADS1015_REG_CONFIG_MODE_CONTIN  | // Continuous conversion mode
                    ADS1015_REG_CONFIG_MODE_CONTIN;   // Continuous conversion mode

    // Set PGA/voltage range
    config |= m_gain;

    // Set single-ended input channel
    switch (channel)
    {
    case (0):
        config |= ADS1015_REG_CONFIG_MUX_SINGLE_0;
        break;
    case (1):
        config |= ADS1015_REG_CONFIG_MUX_SINGLE_1;
        break;
    case (2):
        config |= ADS1015_REG_CONFIG_MUX_SINGLE_2;
        break;
    case (3):
        config |= ADS1015_REG_CONFIG_MUX_SINGLE_3;
        break;
    }

    // Set the high threshold register
    // Shift 12-bit results left 4 bits for the ADS1015
    writeRegister(m_i2cAddress, ADS1015_REG_POINTER_HITHRESH, threshold << m_bitShift);

    // Write config register to the ADC
    writeRegister(m_i2cAddress, ADS1015_REG_POINTER_CONFIG, config);
}

/**************************************************************************/
/*!
    @brief  In order to clear the comparator, we need to read the
            conversion results.  This function reads the last conversion
            results without changing the config value.
*/
/**************************************************************************/
int16_t getLastConversionResults(void)
{
    Uint16 res;
    // Wait for the conversion to complete
    DELAY_US(m_conversionDelay);

    // Read the conversion results
    res = readRegister(m_i2cAddress, ADS1015_REG_POINTER_CONVERT) >> m_bitShift;
    if (m_bitShift == 0)
    {
        return (int16)res;
    }
    else
    {
        // Shift 12-bit results right 4 bits for the ADS1015,
        // making sure we keep the sign bit intact
        if (res > 0x07FF)
        {
            // negative number - extend the sign to 16th bit
            res |= 0xF000;
        }
        return (int16)res;
    }
}
#endif

ADS1015.h 

/**************************************************************************/
/*!
    @file     Adafruit_ADS1015.h
    @author   K. Townsend (Adafruit Industries)
    @license  BSD (see license.txt)

    This is a library for the Adafruit ADS1015 breakout board
    ----> https://www.adafruit.com/products/???

    Adafruit invests time and resources providing this open source code,
    please support Adafruit and open-source hardware by purchasing
    products from Adafruit!

    @section  HISTORY

    v1.0  - First release
    v1.1  - Added ADS1115 support - W. Earl
*/
/**************************************************************************/

#ifndef _ADS_1015_H_
#define _ADS_1015_H_

/*=========================================================================
    I2C ADDRESS/BITS
    -----------------------------------------------------------------------*/
#define ADS1015_ADDRESS                 (0x90)    // 1001 000 (ADDR = GND)
/*=========================================================================*/

/*=========================================================================
    CONVERSION DELAY (in uS)
    -----------------------------------------------------------------------*/
#define ADS1015_CONVERSIONDELAY         (10)
#define ADS1115_CONVERSIONDELAY         (8)
/*=========================================================================*/

/*=========================================================================
    POINTER REGISTER
    -----------------------------------------------------------------------*/
#define ADS1015_REG_POINTER_MASK        (0x03)
#define ADS1015_REG_POINTER_CONVERT     (0x00)
#define ADS1015_REG_POINTER_CONFIG      (0x01)
#define ADS1015_REG_POINTER_LOWTHRESH   (0x02)
#define ADS1015_REG_POINTER_HITHRESH    (0x03)
/*=========================================================================*/

/*=========================================================================
    CONFIG REGISTER
    -----------------------------------------------------------------------*/
#define ADS1015_REG_CONFIG_OS_MASK      (0x8000)
#define ADS1015_REG_CONFIG_OS_SINGLE    (0x8000)  // Write: Set to start a single-conversion
#define ADS1015_REG_CONFIG_OS_BUSY      (0x0000)  // Read: Bit = 0 when conversion is in progress
#define ADS1015_REG_CONFIG_OS_NOTBUSY   (0x8000)  // Read: Bit = 1 when device is not performing a conversion

#define ADS1015_REG_CONFIG_MUX_MASK     (0x7000)
#define ADS1015_REG_CONFIG_MUX_DIFF_0_1 (0x0000)  // Differential P = AIN0, N = AIN1 (default)
#define ADS1015_REG_CONFIG_MUX_DIFF_0_3 (0x1000)  // Differential P = AIN0, N = AIN3
#define ADS1015_REG_CONFIG_MUX_DIFF_1_3 (0x2000)  // Differential P = AIN1, N = AIN3
#define ADS1015_REG_CONFIG_MUX_DIFF_2_3 (0x3000)  // Differential P = AIN2, N = AIN3
#define ADS1015_REG_CONFIG_MUX_SINGLE_0 (0x4000)  // Single-ended AIN0
#define ADS1015_REG_CONFIG_MUX_SINGLE_1 (0x5000)  // Single-ended AIN1
#define ADS1015_REG_CONFIG_MUX_SINGLE_2 (0x6000)  // Single-ended AIN2
#define ADS1015_REG_CONFIG_MUX_SINGLE_3 (0x7000)  // Single-ended AIN3

#define ADS1015_REG_CONFIG_PGA_MASK     (0x0E00)
#define ADS1015_REG_CONFIG_PGA_6_144V   (0x0000)  // +/-6.144V range = Gain 2/3
#define ADS1015_REG_CONFIG_PGA_4_096V   (0x0200)  // +/-4.096V range = Gain 1
#define ADS1015_REG_CONFIG_PGA_2_048V   (0x0400)  // +/-2.048V range = Gain 2 (default)
#define ADS1015_REG_CONFIG_PGA_1_024V   (0x0600)  // +/-1.024V range = Gain 4
#define ADS1015_REG_CONFIG_PGA_0_512V   (0x0800)  // +/-0.512V range = Gain 8
#define ADS1015_REG_CONFIG_PGA_0_256V   (0x0A00)  // +/-0.256V range = Gain 16

#define ADS1015_REG_CONFIG_MODE_MASK    (0x0100)
#define ADS1015_REG_CONFIG_MODE_CONTIN  (0x0000)  // Continuous conversion mode
#define ADS1015_REG_CONFIG_MODE_SINGLE  (0x0100)  // Power-down single-shot mode (default)

#define ADS1015_REG_CONFIG_DR_MASK      (0x00E0)
#define ADS1015_REG_CONFIG_DR_128SPS    (0x0000)  // 128 samples per second
#define ADS1015_REG_CONFIG_DR_250SPS    (0x0020)  // 250 samples per second
#define ADS1015_REG_CONFIG_DR_490SPS    (0x0040)  // 490 samples per second
#define ADS1015_REG_CONFIG_DR_920SPS    (0x0060)  // 920 samples per second
#define ADS1015_REG_CONFIG_DR_1600SPS   (0x0080)  // 1600 samples per second (default)
#define ADS1015_REG_CONFIG_DR_2400SPS   (0x00A0)  // 2400 samples per second
#define ADS1015_REG_CONFIG_DR_3300SPS   (0x00C0)  // 3300 samples per second

#define ADS1015_REG_CONFIG_CMODE_MASK   (0x0010)
#define ADS1015_REG_CONFIG_CMODE_TRAD   (0x0000)  // Traditional comparator with hysteresis (default)
#define ADS1015_REG_CONFIG_CMODE_WINDOW (0x0010)  // Window comparator

#define ADS1015_REG_CONFIG_CPOL_MASK    (0x0008)
#define ADS1015_REG_CONFIG_CPOL_ACTVLOW (0x0000)  // ALERT/RDY pin is low when active (default)
#define ADS1015_REG_CONFIG_CPOL_ACTVHI  (0x0008)  // ALERT/RDY pin is high when active

#define ADS1015_REG_CONFIG_CLAT_MASK    (0x0004)  // Determines if ALERT/RDY pin latches once asserted
#define ADS1015_REG_CONFIG_CLAT_NONLAT  (0x0000)  // Non-latching comparator (default)
#define ADS1015_REG_CONFIG_CLAT_LATCH   (0x0004)  // Latching comparator

#define ADS1015_REG_CONFIG_CQUE_MASK    (0x0003)
#define ADS1015_REG_CONFIG_CQUE_1CONV   (0x0000)  // Assert ALERT/RDY after one conversions
#define ADS1015_REG_CONFIG_CQUE_2CONV   (0x0001)  // Assert ALERT/RDY after two conversions
#define ADS1015_REG_CONFIG_CQUE_4CONV   (0x0002)  // Assert ALERT/RDY after four conversions
#define ADS1015_REG_CONFIG_CQUE_NONE    (0x0003)  // Disable the comparator and put ALERT/RDY in high state (default)
/*=========================================================================*/

typedef enum
{
    GAIN_TWOTHIRDS    = ADS1015_REG_CONFIG_PGA_6_144V,
    GAIN_ONE          = ADS1015_REG_CONFIG_PGA_4_096V,
    GAIN_TWO          = ADS1015_REG_CONFIG_PGA_2_048V,
    GAIN_FOUR         = ADS1015_REG_CONFIG_PGA_1_024V,
    GAIN_EIGHT        = ADS1015_REG_CONFIG_PGA_0_512V,
    GAIN_SIXTEEN      = ADS1015_REG_CONFIG_PGA_0_256V
} adsGain_t;

extern void ads1015_init(void);

extern Uint16 readADC_SingleEnded(Uint16 channel);

extern void get_adc(volatile Uint16 *res0, volatile Uint16 *res1);

#endif

i2c 

static void IIC_Delay(void)
{
    DELAY_US(1);
}
static void IIC_Delay_Half(void)
{
    DELAY_US(1);
}
static Uint16 IsCharOne(void)
{
    Uint16 retcode = 0;
    if (SDA_IN())
    {
        retcode = 1;
    }
    return retcode;
}

static void StartRom(void)
{
    SET_SDA_OUT();
    SET_SCL_OUT();
    SetSDA();
    IIC_Delay();
    SetSCL();
    IIC_Delay();
    ClrSDA();
    IIC_Delay();
    ClrSCL();
    IIC_Delay();
    
}

static void StopRom(void)
{
    ClrSDA();
    IIC_Delay();
    SetSCL();
    IIC_Delay();
    SetSDA();
    IIC_Delay();
    ClrSCL();
    IIC_Delay();
}

static Uint16 SendToRom(Uint16 data)
{
    Uint16 count, retcode = 0;
    for (count = 0; count < 8; count++)
    {
        if ((data & BIT7) == BIT7)
        {
            SetSDA();
        }
        else
        {
            ClrSDA();
        }
        IIC_Delay();
        SetSCL();
        data = data << 1;
        IIC_Delay();
        ClrSCL();
        //IIC_Delay();
    }
    SET_SDA_IN();
    IIC_Delay();
    SetSCL();
    //IIC_Delay();
    IIC_Delay_Half();
    retcode = IsCharOne();
    IIC_Delay_Half();
    //IIC_Delay();
    ClrSCL();
    IIC_Delay();
    SET_SDA_OUT();
    
    return retcode;
}

static Uint16 ReceiveFromRom(void)
{
    Uint16 m = 0, count;
    SET_SDA_IN();
    IIC_Delay();
    for (count = 0; count < 8; count++)
    {
        m = m << 1;
        SetSCL();
        //IIC_Delay();
        //DELAY_US(3);
        IIC_Delay_Half();
        if (IsCharOne())
        {
            m |= BIT0;
        }
        //IIC_Delay();
        //DELAY_US(2);
        IIC_Delay_Half();
        ClrSCL();
        IIC_Delay();
    }
    SET_SDA_OUT();
    
    return m;
}

static void mack(void)
{
    ClrSDA();
    IIC_Delay();
    SetSCL();
    IIC_Delay();
    ClrSCL();
    IIC_Delay();
}

static void nmack(void)
{
    SetSDA();
    IIC_Delay();
    SetSCL();
    IIC_Delay();
    ClrSCL();
    IIC_Delay();
}
void writeRegister(Uint16 i2cAddress, Uint16 reg, Uint16 value) 
{
    Uint16 i;

    EALLOW;
    for(i = 0; i < ADS_RE_COUNT; i++)
    {               
        StopRom();
        //IIC_Delay();
        IIC_Delay();
        StartRom();
        if(SendToRom(i2cAddress) == 1)
            continue;
        if(SendToRom(reg&0xFF) == 1)
            continue;
        if(SendToRom(value>>8) == 1)
            continue;
        if(SendToRom(value&0xFF) == 1)
            continue;
        
        break;        
    }    
    StopRom(); 
    IIC_Delay();
    EDIS;
    
    //return i;
}

Uint16 readRegister(Uint16 i2cAddress, Uint16 reg) 
{
    Uint16 i, ret;

    EALLOW;
    for(i = 0; i < ADS_RE_COUNT; i++)
    {               
        StopRom();
        IIC_Delay();
        StartRom();
        if(SendToRom(i2cAddress) == 1)
            continue;
        if(SendToRom(ADS1015_REG_POINTER_CONVERT) == 1)
            continue;
        StopRom();
        IIC_Delay();
        StartRom();
        if(SendToRom(i2cAddress|BIT0) == 1)
            continue;
        ret = ReceiveFromRom() << 8;
        mack();

        ret |= ReceiveFromRom();
        mack();

        break;        
    }    
    StopRom(); 
    IIC_Delay();
    EDIS;
    
    return ret;  
}

做个备份以后遇到底层的东西就可以省的心了

fz835304205
关注
专栏目录
ADS1015.zip
10-11
ADS1015在单片机上的驱动程序，这个驱动是使用的模拟IIC，模拟IIC的程序没有贴出来，这个很好找免费的也很多。
ADS1015驱动程序和ADS1015手册
03-23
ADS1015驱动程序和ADS1015手册
ads1115驱动程序 STM32
最新发布
qq_42949957的博客
06-27 594
ads1115驱动程序 STM32。
基于51单片机的电阻测量（放大器版）proteus、原理图、流程图、物料清单、仿真图、源代码
01-07
基于51单片机的电阻测量（放大器版）proteus、原理图、流程图、物料清单、仿真图、源代码 基于51单片机的电阻测量（放大器版） 电阻测量仪 1、分为4个档位：10-100，100-1k，1k-10k,10k-100k 2、自动切换档位 原理： 使用放大器对固定信号进行放大，放大倍数由待测电阻决定，这样就能得到一个线性度较高的输出电压。这个电压和待测电阻阻值成线性关系，很容易就能计算出阻值大小。 误差分析： 该方案的误差很小，只要选用足够精度的ADC芯片，精度可以任意提高。 影响精度的因素有：运放性能、ADC精度
Adafruit_ADS1X15:TI ADS1015的驱动程序
05-17
Adafruit_ADS1015 TI ADS1X15的驱动器：具有PGA和比较器的12位和16位差分或单端ADC 信息 该系列ADC提供4个单端或2个差分通道。 每个都有一个可编程的增益放大器，范围为2/3到16x。 提供12或16位版本： 该芯片非常小，因此位于带有铁氧体的分线板上，可保持AVDD和AGND安静。 接口通过I2C完成。 该地址可以更改为四个选项之一（请参见数据表表5），因此您可以在一条单线2线I2C总线上连接多达4个ADS1x15，以用于16个单端输入。 Adafruit投入时间和资源来提供此开源代码，请通过从购买产品来支持Adafruit和开源硬件！ 执照 BSD许可，以上所有文本都必须包含在任何重新分发中。
ADS1015驱动程序-STM32F103C8T6
07-23
ADS1015芯片 驱动程序--STM32F103C8T6 IIC通信,直接将数据读出,通过串口打印出数据
ADS1015驱动程序.7z
12-02
这个是ADS1015的驱动代码，由于官方给的驱动代码不能直接用在STM32上面，这是我改过后的驱动代码，软件模拟IIC通信的驱动是正点原子的，程序功能是直接将ADS1015四个通道的数据通过串口发送到串口助手。
Jetson-nano ADS1015驱动
FREEDOM_X的专栏
04-08 893
jetson nano adc 驱动
ads1015源码
07-20
ads1015源码
ADS1015使用指南及STM32驱动程序
热门推荐
Dinvent的博客
12-03 1万+
ADS1015使用指南及驱动程序ADS1015使用指南简介ADS1015的引脚介绍ADS1015的寄存器介绍寄存器相关配置驱动程序 ADS1015使用指南 由于网上关于TI公司的ADS1015数模转换芯片的资料比较少，而且官方给的驱动不适合STM32这种单片机，在本博客中主要介绍了ADS1015的一些基本信息以及STM32的驱动程序。 简介 ADS1015是TI公司生产的一款AD转换芯片，采用II...
ADS1220驱动程序
05-17
首先，我们来看标题"ADS1220驱动程序"，这表明我们需要编写或使用已经存在的驱动代码，以便STM32能够与ADS1220通信。驱动程序是操作系统或嵌入式系统中的一段代码，它负责管理硬件设备，并确保软件应用程序可以与...
基于STM32的ADS1015程序
07-20
使用stm32hal库通过I2C总线与ADS1015模数转换芯片进行通信，实现通道的读取及配置。
micropython-adafruit-ads1015:用于精密模数转换器AD1015的MicroPython驱动程序
05-09
＃此仓库不再在开发中。 随意分叉吧！ 用于精密模数转换器ADS1015和ADS1115的MicroPython驱动程序。 文档位于
ADS1015_ads1015_
10-02
ads1015部分驱动，对ads1015进行读写操作，寄存器的定义等
ads1015.pdf
04-11
ADS101x Ultra-Small, Low-Power, I2C-Compatible, 3.3-kSPS, 12-Bit ADCs With Internal Reference, Oscillator, and Programmable Comparator 1 Features 1• Ultra-Small X2QFN Package: 2 mm × 1.5 mm × 0.4 mm • 12-Bit Noise-Free Resolution • Wide Supply Range: 2.0 V to 5.5 V • Low Current Consumption: 150 μA (Continuous-Conversion Mode) • Programmable Data Rate: 128 SPS to 3.3 kSPS • Single-Cycle Settling • Internal Low-Drift Voltage Reference • Internal Oscillator • I2C Interface: Four Pin-Selectable Addresses • Four Single-Ended or Two Differential Inputs (ADS1015) • Programmable Comparator (ADS1014 and ADS1015) • Operating Temperature Range: –40°C to +125°C
ads1015调试心得.docx
08-13
  公司产品需要用到ad采样芯片，由于采样路数较多且分布比较分散，检测的是电平值，变化率较慢，所以想选择分辨率高、体积小、最好是iic接口的芯片。因为个人比较喜欢德州仪器这个公司，所以就先去TI的官网上查询了一番。一番查询，发现了ads1015芯片还是比较适合的，12位的分辨率，能有4路输入，iic接口。所以下载了该芯片的datasheet，仔细阅读一看，发现居然有更多惊喜！！这款芯片内置震荡源，内置参考电压源，而且内置PGA（可编程增益控制器），也就是说，在检测电平较小的情况下，通过调节PGA单元，可以适当将信号放大，这样以增加检测精度。去淘宝简单查询了价格，一片大概15元左右，心中一喜，就这么愉快地决定了。
ADS1015使用指南及STM32-M0驱动程序
qq_39640572的博客
07-26 5169
ADS1015使用指南及STM32-M0驱动程序一、ADS1015简介二、本案例使用软硬件三、重要参数介绍（I/O以及配置模式）3.0 I/O简单介绍3.1 PGA（增益放大器）3.2 ALERT/RDY 引脚3.3 复位3.4 工作模式3.4.1 Continuous-Conversion Mode3.4.2 Continuous-Conversion Mode3.5 低功耗运行（Duty Cycling For Low Power）四、寄存器介绍4.0 简介（四大寄存器地址指针）4.1 Config 寄
ESP32设备驱动-ADS1015(ADC)驱动
视觉与物联智能
01-30 1378
ADS1015 是一款具有 12 位分辨率的精密模数转换器 (ADC)，采用超小型无引线 QFN-10 封装或 MSOP-10 封装。 ADS1015 的设计考虑了精度、功率和易于实施。 ADS1015 具有板载基准和振荡器。 数据通过 I2C 兼容的串行接口传输； 可以选择四个 I2C 从地址。 ADS1015 采用 2.0V 至 5.5V 的单电源供电。
ADS1015调试心得
XiaoQiXiaoWei_J的博客
06-11 2669
3. 最近刚好调了一下ads1015，顺便借此机会梳理一下iic协议 首先我们只看ads1015.c和.h文件，对于模拟iic.c和.h的文件以后有机会再说 为了保证连续性，我们先讲讲这个iic协议的怎么传输数据，然后我们来说说寄存器怎么配置，也就是说下时序图怎么弄，我们可以对照着代码一起看看，不好看的话，我建议再打开一个手册，分屏看下，图片大小不好弄 如图，这个过程可以被这样拆解，先是start，发送Slave address(就是ADS的地址，地址怎么看的，后面附一张...
ads1015bqdgsrq1驱动程序
12-15
ads1015bqdgsrq1是一种高性能、低功耗的12位模数转换器(ADC)，适用于测量微小信号的应用。它集成了多个输入通道，可以测量不同的信号源。 ads1015bqdgsrq1驱动程序是用来控制该ADC的软件程序。驱动程序提供了访问ADC的接口和功能，使用户能够通过编程来控制和读取ADC的数据。用户可以通过驱动程序设置输入通道、增益、采样速率和其他参数，还可以读取转换后的模拟值。 ads1015bqdgsrq1驱动程序通常是针对特定的硬件平台和操作系统开发的，例如针对Arduino或树莓派等开发板，或者针对Windows、Linux或嵌入式系统等操作系统。开发者可以根据自己的需求选择合适的驱动程序，并根据相关文档进行安装和配置。 驱动程序通常提供了一系列API函数，用于初始化ADC、配置参数、启动转换和读取数据等操作。用户可以通过调用这些函数来完成相应的操作。驱动程序还可能提供了一些附加功能，如中断处理、自动校准和数据滤波等，用于提高ADC的性能和可靠性。 总之，ads1015bqdgsrq1驱动程序是控制和操作该ADC的软件程序，用户可以借助驱动程序来实现对ADC的控制和数据获取。它为用户提供了便捷的接口和功能，使得使用该ADC更加方便和灵活。
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值