139 lines
5.0 KiB
JavaScript
139 lines
5.0 KiB
JavaScript
'use strict';
|
|
|
|
const assert = require('assert');
|
|
const i2c = require('../');
|
|
|
|
const DS1621_ADDR = 0x48;
|
|
const CMD_ACCESS_CONFIG = 0xac;
|
|
const CMD_ACCESS_TL = 0xa2;
|
|
|
|
// Wait while non volatile memory busy
|
|
const waitForWrite = cb => {
|
|
i2c1.readByte(DS1621_ADDR, CMD_ACCESS_CONFIG, (err, config) => {
|
|
assert(!err, 'can\'t read config to determine memory status');
|
|
if (config & 0x10) {
|
|
return waitForWrite(cb);
|
|
}
|
|
cb();
|
|
});
|
|
};
|
|
|
|
const finished = _ => i2c1.close(_ => console.log('ok - async'));
|
|
|
|
const i2cPlainReadWrite = _ => {
|
|
// Test i2cWrite & i2cRead
|
|
// Change value of tl to 25 and verify that tl has been changed
|
|
const cmdSetTL = Buffer.from([CMD_ACCESS_TL, 25, 0]);
|
|
const cmdGetTL = Buffer.from([CMD_ACCESS_TL]);
|
|
const tl = Buffer.alloc(2);
|
|
|
|
i2c1.i2cWrite(DS1621_ADDR, cmdSetTL.length, cmdSetTL, (err, bytesWritten, buffer) => {
|
|
assert(!err, 'can\'t i2cWrite cmdSetTL');
|
|
assert.strictEqual(bytesWritten, cmdSetTL.length, 'expected i2cWrite to write 3 bytes');
|
|
assert.strictEqual(cmdSetTL, buffer, 'expected cmdSetTL to be passed to i2cWrite callback');
|
|
|
|
waitForWrite(_ => {
|
|
i2c1.i2cWrite(DS1621_ADDR, cmdGetTL.length, cmdGetTL, (err, bytesWritten, buffer) => {
|
|
assert(!err, 'can\'t i2cWrite cmdGetTL');
|
|
assert.strictEqual(bytesWritten, cmdGetTL.length, 'expected i2cWrite to write 1 byte');
|
|
assert.strictEqual(cmdGetTL, buffer, 'expected cmdGetTL to be passed to i2cWrite callback');
|
|
|
|
i2c1.i2cRead(DS1621_ADDR, 2, tl, (err, bytesRead, buffer) => {
|
|
assert(!err, 'can\'t i2cRead tl');
|
|
assert.strictEqual(bytesRead, 2, 'expected i2cRead to read 2 bytes');
|
|
assert.strictEqual(tl.readUInt16LE(0), 25, 'expected i2cRead to read value 25');
|
|
assert.strictEqual(tl, buffer, 'expected tl to be passed to i2cRead callback');
|
|
|
|
finished();
|
|
});
|
|
});
|
|
});
|
|
});
|
|
};
|
|
|
|
const readWriteI2cBlock = _ => {
|
|
// Test writeI2cBlock & readI2cBlock
|
|
// Change value of tl to 22 and verify that tl has been changed
|
|
const newtl = Buffer.alloc(10);
|
|
|
|
newtl.writeUInt16LE(22, 0);
|
|
i2c1.writeI2cBlock(DS1621_ADDR, CMD_ACCESS_TL, 2, newtl, (err, bytesWritten, buffer) => {
|
|
assert(!err, 'can\'t writeI2cBlock to tl');
|
|
assert.strictEqual(bytesWritten, 2, 'expected writeI2cBlock to write 2 bytes');
|
|
assert.strictEqual(newtl, buffer, 'expected newtl to be passed to writeI2cBlock callback');
|
|
|
|
waitForWrite(_ => {
|
|
i2c1.readI2cBlock(DS1621_ADDR, CMD_ACCESS_TL, 2, newtl, (err, bytesRead, buffer) => {
|
|
assert(!err, 'can\'t readI2cBlock from tl');
|
|
assert.strictEqual(bytesRead, 2, 'expected readI2cBlock to read 2 bytes');
|
|
assert.strictEqual(buffer.readUInt16LE(0), 22, 'expected readI2cBlock to read value 22');
|
|
assert.strictEqual(newtl, buffer, 'expected newtl to be passed to readI2cBlock callback');
|
|
|
|
i2cPlainReadWrite();
|
|
});
|
|
});
|
|
});
|
|
};
|
|
|
|
const readWriteWord = _ => {
|
|
// Test writeWord & readWord
|
|
// Change value of tl and verify that tl has been changed
|
|
i2c1.readWord(DS1621_ADDR, CMD_ACCESS_TL, (err, oldtl) => {
|
|
assert(!err, 'can\'t readWord from tl');
|
|
assert(typeof oldtl === 'number' && oldtl <= 0xffff, 'expeted readWord to read a word');
|
|
|
|
const newtl = (oldtl === 24 ? 23 : 24);
|
|
i2c1.writeWord(DS1621_ADDR, CMD_ACCESS_TL, newtl, err => {
|
|
assert(!err, 'can\'t write word to tl');
|
|
|
|
i2c1.readWord(DS1621_ADDR, CMD_ACCESS_TL, (err, newtl2) => {
|
|
assert(!err, 'can\'t read new word from tl');
|
|
assert(typeof newtl2 === 'number' && newtl2 <= 0xffff, 'expeted readWord to read a word');
|
|
assert.strictEqual(newtl, newtl2, 'expected to read word written');
|
|
|
|
readWriteI2cBlock();
|
|
});
|
|
});
|
|
});
|
|
};
|
|
|
|
const sendReceiveByte = epectedConfig => {
|
|
// Test sendByte & receiveByte
|
|
// Read config and verify that it's epectedConfig
|
|
i2c1.sendByte(DS1621_ADDR, CMD_ACCESS_CONFIG, err => {
|
|
assert(!err, 'can\'t send byte to config');
|
|
|
|
i2c1.receiveByte(DS1621_ADDR, (err, config) => {
|
|
assert(!err, 'can\'t receive byte from config');
|
|
assert(typeof config === 'number' && config <= 0xff, 'expeted receiveByte to receive a byte');
|
|
assert.strictEqual(config, epectedConfig, '1st and 2nd config read differ');
|
|
|
|
readWriteWord();
|
|
});
|
|
});
|
|
};
|
|
|
|
const readWriteByte = _ => {
|
|
// Test writeByte & readByte
|
|
// Enter continuous mode and verify that continuous mode has been entered
|
|
i2c1.writeByte(DS1621_ADDR, CMD_ACCESS_CONFIG, 0x0, err => {
|
|
assert(!err, 'can\'t write byte to config');
|
|
|
|
waitForWrite(_ => {
|
|
i2c1.readByte(DS1621_ADDR, CMD_ACCESS_CONFIG, (err, config) => {
|
|
assert(!err, 'can\'t read byte from config');
|
|
assert(typeof config === 'number' && config <= 0xff, 'expeted readByte to read a byte');
|
|
assert.strictEqual(config & 0x1, 0, 'continuous mode not eneterd');
|
|
|
|
sendReceiveByte(config);
|
|
});
|
|
});
|
|
});
|
|
};
|
|
|
|
const i2c1 = i2c.open(1, err => {
|
|
assert(!err, 'can\'t open i2c bus');
|
|
readWriteByte();
|
|
});
|
|
|