Hello,
I try to interface the Voltemer based on ADS1115 in nodejs.
The only given sample is based on C++ and Arduino code, but there is no detailled documentation on which command and parameters can be sent to register, in order to get measure for each range of voltage.
I try to measure a battery voltage, like the picture here.
Here is my code. Can you give me more information ?
- which element is to read : MUX_DIFF_0_1 : (0x0000), MUX_DIFF_0_3 : (0x1000), MUX_DIFF_1_3 : (0x2000), MUX_DIFF_2_3 : (0x3000), MUX_SINGLE_0 : (0x4000), MUX_SINGLE_1 : (0x5000), MUX_SINGLE_2 : (0x6000), MUX_SINGLE_3 : (0x7000) ?
- which mathematical operation is to do with the value read in ther register ? multiply with what, depending of what (gain ?) ?
Thank you for information.
/* sample*/
var ADS1X15 = {};
/* Register values. Most of these aren't used
and this is hidden, so it'll get optimised out
when minified */
ADS1X15.CONFIG = {
OS_MASK : (0x8000),
OS_SINGLE : (0x8000), // Write: Set to start a single-conversion
OS_BUSY : (0x0000), // Read: Bit = 0 when conversion is in progress
OS_NOTBUSY : (0x8000), // Read: Bit = 1 when device is not performing a conversion
MUX_MASK : (0x7000),
MUX_DIFF_0_1 : (0x0000), // Differential P = AIN0, N = AIN1 (default)
MUX_DIFF_0_3 : (0x1000), // Differential P = AIN0, N = AIN3
MUX_DIFF_1_3 : (0x2000), // Differential P = AIN1, N = AIN3
MUX_DIFF_2_3 : (0x3000), // Differential P = AIN2, N = AIN3
MUX_SINGLE_0 : (0x4000), // Single-ended AIN0
MUX_SINGLE_1 : (0x5000), // Single-ended AIN1
MUX_SINGLE_2 : (0x6000), // Single-ended AIN2
MUX_SINGLE_3 : (0x7000), // Single-ended AIN3
PGA_MASK : (0x0E00),
PGA_6_144V : (0x0000), // +/-6.144V range = Gain 2/3
PGA_4_096V : (0x0200), // +/-4.096V range = Gain 1
PGA_2_048V : (0x0400), // +/-2.048V range = Gain 2 (default)
PGA_1_024V : (0x0600), // +/-1.024V range = Gain 4
PGA_0_512V : (0x0800), // +/-0.512V range = Gain 8
PGA_0_256V : (0x0A00), // +/-0.256V range = Gain 16
MODE_MASK : (0x0100),
MODE_CONTIN : (0x0000), // Continuous conversion mode
MODE_SINGLE : (0x0100), // Power-down single-shot mode (default)
DR_MASK : (0x00E0),
DR_128SPS : (0x0000), // 128 samples per second
DR_250SPS : (0x0020), // 250 samples per second
DR_490SPS : (0x0040), // 490 samples per second
DR_920SPS : (0x0060), // 920 samples per second
DR_1600SPS : (0x0080), // 1600 samples per second (default)
DR_2400SPS : (0x00A0), // 2400 samples per second
DR_3300SPS : (0x00C0), // 3300 samples per second
CMODE_MASK : (0x0010),
CMODE_TRAD : (0x0000), // Traditional comparator with hysteresis (default)
CMODE_WINDOW : (0x0010), // Window comparator
CPOL_MASK : (0x0008),
CPOL_ACTVLOW : (0x0000), // ALERT/RDY pin is low when active (default)
CPOL_ACTVHI : (0x0008), // ALERT/RDY pin is high when active
CLAT_MASK : (0x0004), // Determines if ALERT/RDY pin latches once asserted
CLAT_NONLAT : (0x0000), // Non-latching comparator (default)
CLAT_LATCH : (0x0004), // Latching comparator
CQUE_MASK : (0x0003),
CQUE_1CONV : (0x0000), // Assert ALERT/RDY after one conversions
CQUE_2CONV : (0x0001), // Assert ALERT/RDY after two conversions
CQUE_4CONV : (0x0002), // Assert ALERT/RDY after four conversions
CQUE_NONE : (0x0003) // Disable the comparator and put ALERT/RDY in high state (default)
};
/*
Voltage_measurement_range Maximum_input_DC_voltage(V) Minimum_resolution(mV) Gain_factor
PAG_4096(Calibrated) ±128 7.85 0.125
2.048 64 3.93 0.0625
1.024 32 1.96 0.03125
0.512 16 0.98 0.015625
PAG_256(Calibrated) ±8 0.49 0.007813
*/
ADS1X15.GAINS = {
6144 : ADS1X15.CONFIG.PGA_6_144V, // +/-6.144V range = Gain 2/3
4096 : ADS1X15.CONFIG.PGA_4_096V, // +/-4.096V range = Gain 1
2048 : ADS1X15.CONFIG.PGA_2_048V, // +/-2.048V range = Gain 2 (default)
1024 : ADS1X15.CONFIG.PGA_1_024V, // +/-1.024V range = Gain 4
512 : ADS1X15.CONFIG.PGA_0_512V, // +/-0.512V range = Gain 8
256 : ADS1X15.CONFIG.PGA_0_256V // +/-0.256V range = Gain 16;
};
ADS1X15.VOLT_RANGE = {
"0_8V": 256,
"0_16V": 512,
"0_32V": 1024,
"0_64V": 2048,
"0_128V": 4096
};
ADS1X15.MULTICATOR = {
6144: 0.187500,
4096: 0.125000,
2048: 0.062500,
1024: 0.031250,
512: 0.015625,
256: 0.007813
};
ADS1X15.COEFFICIENT = 0.015918958;
ADS1X15.DIFFS = {
"0,1" : ADS1X15.CONFIG.MUX_DIFF_0_1, // Differential P = AIN0, N = AIN1 (default)
"0,3" : ADS1X15.CONFIG.MUX_DIFF_0_3, // Differential P = AIN0, N = AIN3
"1,3" : ADS1X15.CONFIG.MUX_DIFF_1_3, // Differential P = AIN1, N = AIN3
"2,3" : ADS1X15.CONFIG.MUX_DIFF_2_3 // Differential P = AIN2, N = AIN3
};
ADS1X15.SINGLE_CHANELS = [
ADS1X15.CONFIG.MUX_SINGLE_0,
ADS1X15.CONFIG.MUX_SINGLE_1,
ADS1X15.CONFIG.MUX_SINGLE_2,
ADS1X15.CONFIG.MUX_SINGLE_3
];
ADS1X15.REG = {
MASK : 3,
CONVERT : 0,
CONFIG : 1,
LOWTHRESH : 2,
HITHRESH : 3
};
// prototypes
if (Number.prototype.toHexa === undefined) {
Number.prototype.toHexa = function( len) {
return "0x" + this.toString( 16).padStart( len, '0');
}
}
if (Buffer.prototype.toHexa === undefined) {
Buffer.prototype.toHexa = function() {
let str = "";
let arr = [...this];
arr.forEach( a => {
str = '0x' + a.toString(16).padStart( 2, '0') + ' ' + str;
});
return str;
}
}
// used internally for writing to the ADC
function writeRegister( i2c, register, value) {
const funcName = "writeRegister";
const buff = Buffer.from( [register & 3, value >> 8, value & 0xFF]);
console.log( `${funcName}> write to ${addr.toHexa(2)}, buff: ${buff.toHexa()}...`);
try {
let nbBytesWritten = i2c.i2cWriteSync( addr, 3, buff);
console.log( `${funcName}> ${nbBytesWritten} written`);
} catch( err1) {
console.log( `${funcName}> write FAILS > err1: ${err1}`);
}
}
// used internally for reading from the ADC
function readRegister( i2c, register) {
const funcName = "readRegister";
let value = null;
do {
const buffW = Buffer.from( [register] );
console.log( `${funcName}> write to ${addr.toHexa(2)} register: ${register.toHexa(2)}...`);
try {
i2c.i2cWriteSync( addr, 1, buffW);
} catch( err1) {
console.log( `${funcName}> write FAILS > err1: ${err1}`);
break;
//!!!!!
}
let buffR = Buffer.from( [ 0, 0]);
try {
let nbBytesRead = i2c.i2cReadSync( addr, 2, buffR);
value = (buffR[0] << 8) | buffR[1];
console.log( `${funcName}> ${nbBytesRead} read, buffR: ${buffR.toHexa()}, value: ${value}`);
} catch( err2) {
console.log( `${funcName}> read FAILS > err2: ${err2}`);
break;
//!!!!!
}
} while( false);
return value;
}
function getADC( i2c, channelSpec, callback) {
let config = ADS1X15.CONFIG.CQUE_NONE | // Disable the comparator (default val)
ADS1X15.CONFIG.CLAT_NONLAT | // Non-latching (default val)
ADS1X15.CONFIG.CPOL_ACTVLOW | // Alert/Rdy active low (default val)
ADS1X15.CONFIG.CMODE_TRAD | // Traditional comparator (default val)
ADS1X15.CONFIG.DR_1600SPS | // rate: 1600 samples per second (default)
ADS1X15.CONFIG.MODE_SINGLE; // Single-shot mode (default)
// single ended (channelSpec is a number) or differential (channelSpec is array w/ valid channel duo)
if ("number" == typeof channelSpec) { // Set single-ended input channel
if ( ! ADS1X15.SINGLE_CHANELS.includes( channelSpec)) {
throw new Error( `Invalid single-ended channelSpec ${channelSpec.toHexa()} ! use one of ADS1X15.SINGLE_CHANELS ${ADS1X15.SINGLE_CHANELS}`);
}
config |= channelSpec;
} else {
// Set differential input channels from channelSpec
if ( ! (channelSpec in ADS1X15.DIFFS)) {
throw new Error( `Invalid differention channelSpec ${channelSpec} ! use one of ADS1X15.DIFFS`);
}
let diffChannel = ADS1X15.DIFFS[ channelSpec];
config |= diffChannel;
}
// Set PGA/voltage range
config |= ADS1X15.GAINS[ gain];
// Set 'start single-conversion' bit
config |= ADS1X15.CONFIG.OS_SINGLE;
// Write config register to the ADC
writeRegister( i2c, ADS1X15.REG.CONFIG, config);
// Wait for the conversion to complete
setTimeout(function() {
// Read the conversion results
let d = readRegister( i2c, ADS1X15.REG.CONVERT);
if ( d & 0x8000) {
d -= 65535; // sign
}
let volts = parseFloat( d) * resolution;
console.log( `d: ${d}, resolution: ${resolution}, volts: ${volts}`);
callback( volts);
}, 8);
}
var i2cBus = null;
var DEV_I2C = 1;
var I2C_BUS = require("i2c-bus");
console.log( `VoltMeter.js > on linux > i2c-bus loaded.`);
var addr = 0x49;
var voltRange = "0_8V";
var gain = ADS1X15.VOLT_RANGE[ voltRange];
var multiplicator = ADS1X15.MULTICATOR[ gain];
var resolution = parseFloat( multiplicator / ADS1X15.COEFFICIENT);
console.log( `gain: ${gain.toHexa()}, multiplicator: ${multiplicator}, COEFFICIENT: ${ADS1X15.COEFFICIENT}, resolution: ${resolution}...`);
i2cBus = I2C_BUS.open( DEV_I2C, err1 => {
if (err1) {
console.log( `i2c.open FAILS > err1: ${err1}`);
} else {
setInterval( function() {
// getADC( i2cBus, ADS1X15.CONFIG.MUX_SINGLE_0, function( value) {
getADC( i2cBus, "0,1", function( value) {
console.log( `${new Date().toISOString()} > mesure ${value} volts`);
});
}, 1000);
}
});
Best regards.
