math.frexp = function(x) {
_checkFloat(x);
var xx = x.__float__().val;
// check for 0, -0, NaN, Inf, -Inf
if (xx === 0 || !isFinite(xx)) {
return new types.Tuple([x.__float__(), new types.Int(0)]);
}
var buff = new Buffer(8);
buff.writeDoubleLE(x, 0);
var a = buff.readUInt32LE(0);
var b = buff.readUInt32LE(4);
var exp = ((b >> 20) & 0x7ff) - 1022;
var num;
// check for denormal number
if (exp == -1022) {
// each leading zero increases the exponent
num = (b & 0xfffff) * 4294967296 + a;
while ((num != 0) && (num < 0x8000000000000)) {
exp--;
num *= 2;
}
num = num / 0x10000000000000;
} else {
num = 0x10000000000000 + (b & 0xfffff) * 4294967296 + a;
num = num / 0x20000000000000;
}
if (b >> 31) {
num = -num;
}
return new types.Tuple([new types.Float(num), new types.Int(exp)]);
}
fs.read(fd, buffer, 0, 8, 0, function(err, bytesRead) {
var numberOfRoots = buffer.readUInt32LE(0);
var lastArticle = buffer.readUInt32LE(4);
if (page > numberOfRoots / 30) {
fs.closeSync(fd);
issue404(req, res);
return;
}
// Find the start of the root segment.
fs.read(fd, buffer, 0, 8, 4 * (2 + lastArticle + page),
function(err, bytesRead) {
var pageStart = buffer.readUInt32LE(0);
var pageEnd = buffer.readUInt32LE(4);
if (pageEnd == 0) {
fs.closeSync(fd);
issue404(req, res);
return;
}
buffer = new Buffer(pageEnd - pageStart);
fs.read(fd, buffer, 0, pageEnd - pageStart,
pageStart, function(err, bytesRead) {
writeRoots(req, res, buffer,
group, naked);
fs.closeSync(fd);
});
});
});
function(err, bytesRead) {
var pageStart = buffer.readUInt32LE(0);
var pageEnd = buffer.readUInt32LE(4);
if (pageEnd == 0) {
fs.closeSync(fd);
issue404(req, res);
return;
}
buffer = new Buffer(pageEnd - pageStart);
fs.read(fd, buffer, 0, pageEnd - pageStart,
pageStart, function(err, bytesRead) {
writeRoots(req, res, buffer,
group, naked);
fs.closeSync(fd);
});
});
$scope.$watch('txHex', function() {
if ($scope.txHex === '') return;
var txBuff = new Buffer($scope.txHex, 'hex');
var tx = {};
// Version
tx.version = txBuff.readUInt32LE(0);
// Tx inputs
tx.inputsCount = util.readVarInt(txBuff, 4).res;
var offset = util.readVarInt(txBuff, 4).offset;
tx.inputs = [];
for (var i = 0; i < tx.inputsCount; i++) {
var input = parseVin(txBuff.slice(offset));
tx.inputs.push(input);
offset += input.size;
}
// Tx outputs
var outputsCount = util.readVarInt(txBuff, offset);
offset = outputsCount.offset;
tx.outputsCount = outputsCount.res;
tx.outputs = [];
for (i = 0; i < tx.outputsCount; i++) {
var output = parseVout(txBuff.slice(offset));
tx.outputs.push(output);
offset += output.size;
}
// lockTime
tx.lockTime = txBuff.readUInt32LE(offset);
// binds the tx to the DOM
$scope.tx = tx;
var a = decodeScriptPubKey(new Buffer($scope.tx.outputs[0].scriptPubKey, 'hex'));
});// end $watch
function(err, bytesRead) {
var articleStart = buffer.readUInt32LE(0);
buffer = new Buffer(1024);
fs.read(fd, buffer, 0, 1024,
articleStart, function(err, bytesRead) {
writeThread(req, res, buffer,
group, naked);
fs.closeSync(fd);
});
});
fs.read(fd, buffer, 0, 8, 0, function(err, bytesRead) {
var numberOfRoots = buffer.readUInt32LE(0);
var lastArticle = buffer.readUInt32LE(4);
if (article > lastArticle) {
fs.closeSync(fd);
issue404(req, res);
return;
}
// Find the start of the root segment.
fs.read(fd, buffer, 0, 4, 4 * (2 + article),
function(err, bytesRead) {
var articleStart = buffer.readUInt32LE(0);
buffer = new Buffer(1024);
fs.read(fd, buffer, 0, 1024,
articleStart, function(err, bytesRead) {
writeThread(req, res, buffer,
group, naked);
fs.closeSync(fd);
});
});
});
fs.read(fd, buffer, 0, length, start, function(err, num) {
if(err){ dfd.resolve(new Long()); }
/// get the number of bytes readed
buffer = buffer.slice(0, num);
/// sum the
var hNumber = new Long();
for(var i=0; i<buffer.length; i+=8){
var low = buffer.readUInt32LE(i, true);
var high = buffer.readUInt32LE(i+4, true);
var n = new Long(low, high);
hNumber = hNumber.add(n);
}
dfd.resolve(hNumber);
});
client.request(FC.READ_HOLDING_REGISTERS, blocks[blockindex].start, blocks[blockindex].len, function(err, response)
{
if (err)
{
/* stop on error */
dbgout(err);
stop();
}
/* write modbus data array to buffer
* this is easier to handle/convert the data
* */
var buf = new buffer(response.length*2);
for (var i=0; i<response.length; i++)
{
buf.writeUInt16LE(response[i],i*2);
}
/* convert data depending on current block */
switch (blockindex)
{
case 0:
dp['serial'] = buf.readUInt32LE(4)+(buf.readUInt32LE(8)<<32);
dp['name'] = buf.toString('utf-8',12,32);
dp['version'] = buf.readUInt8(45)+'.'+ buf.readUInt8(44);
setState(settings.adapters.pluggit.firstId+1, dp['name']);
setState(settings.adapters.pluggit.firstId+2, dp['serial']);
setState(settings.adapters.pluggit.firstId+3, dp['version']);
dbgout("\r\nsn: " + dp['serial']);
dbgout("\r\nname: " + dp['name']);
dbgout("\r\nfw: " + dp['version']);
break;
case 1:
dp['t1'] = buf.readFloatLE(0);
dp['t2'] = buf.readFloatLE(4);
dp['t3'] = buf.readFloatLE(8);
dp['t4'] = buf.readFloatLE(12);
dp['t5'] = buf.readFloatLE(16);
setState(settings.adapters.pluggit.firstId+10, dp['t1']);
setState(settings.adapters.pluggit.firstId+11, dp['t2']);
setState(settings.adapters.pluggit.firstId+12, dp['t3']);
setState(settings.adapters.pluggit.firstId+13, dp['t4']);
setState(settings.adapters.pluggit.firstId+14, dp['t5']);
dbgout("\r\nt1: " + dp['t1'] + "°C");
dbgout("\r\nt2: " + dp['t2'] + "°C");
dbgout("\r\nt3: " + dp['t3'] + "°C");
dbgout("\r\nt4: " + dp['t4'] + "°C");
dbgout("\r\nt5: " + dp['t5'] + "°C");
break;
case 2:
dp['filter'] = buf.readUInt32LE(0);
dp['humidity'] = buf.readUInt32LE(4);
dp['bypass'] = buf.readUInt32LE(8);
switch (dp['bypass'])
{
case 0x0000:
dp['bypassState']='closed';
break;
case 0x0001:
dp['bypassState']='in process';
break;
case 0x0020:
dp['bypassState']='closing';
break;
case 0x0040:
dp['bypassState']='opening';
break;
case 0x00FF:
dp['bypassState']='opened';
break;
default:
dp['bypassState']='unknown';
break;
}
setState(settings.adapters.pluggit.firstId+20, dp['filter']);
setState(settings.adapters.pluggit.firstId+22, dp['humidity']);
setState(settings.adapters.pluggit.firstId+23, dp['bypass']);
setState(settings.adapters.pluggit.firstId+24, dp['bypassState']);
dbgout("\r\nfilter: " + dp['filter'] + " month");
dbgout("\r\nRH: " + dp['humidity'] + "%");
dbgout("\r\nBypass: "******"\r\nspeed: " + dp['speed']);
break;
case 4:
dp['alarm'] = buf.readUInt16LE(0);
switch (dp['alarm'])
{
case 0:
dp['alarmState']='None';
break;
case 1:
dp['alarmState']='Exhaust FAN Alarm';
break;
case 2:
dp['alarmState']='Supply FAN Alarm';
break;
case 3:
dp['alarmState']='Bypass Alarm';
break;
case 4:
dp['alarmState']='T1 Alarm';
break;
case 5:
dp['alarmState']='T2 Alarm';
break;
case 6:
dp['alarmState']='T3 Alarm';
break;
case 7:
dp['alarmState']='T4 Alarm';
break;
case 8:
dp['alarmState']='T5 Alarm';
break;
case 9:
dp['alarmState']='RH Alarm';
break;
case 10:
dp['alarmState']='Outdoor13 Alarm';
break;
case 11:
dp['alarmState']='Supply5 Alarm';
break;
case 12:
dp['alarmState']='Fire Alarm';
break;
case 13:
dp['alarmState']='Communication Alarm';
break;
case 14:
dp['alarmState']='FireTermostat Alarm';
break;
case 15:
dp['alarmState']='VOC Alarm';
break;
default:
dp['alarmState']='unknown';
break;
}
setState(settings.adapters.pluggit.firstId+30, dp['alarm']);
setState(settings.adapters.pluggit.firstId+31, dp['alarmState']);
dbgout("\r\nalarm: " + dp['alarm'] + ' ('+dp['alarmState']+')');
break;
case 5:
dp['filterReset'] = buf.readUInt16LE(0);
setState(settings.adapters.pluggit.firstId+22, dp['filterReset']);
dbgout("\r\nfilter reset: " + dp['filterReset'] + ' days');
break;
case 6:
dp['workTime'] = buf.readUInt32LE(0);
setState(settings.adapters.pluggit.firstId+40, dp['workTime']);
dbgout("\r\work time: " + dp['workTime'] + ' hours');
break;
default:
/* should not happen */
stop();
}
if (++blockindex < Object.keys(blocks).length)
{
/* request next block
* be aware that this is a recursive call
*/
requestBlock(blockindex);
}
else
{
/* store all data in database */
storeDatabase(timestamp, dp);
/* now all is done */
stop();
}
});
var tlv_fw_nonce_type = 39;
var tlv_fw_sig_type = 65;
var tlv_key_filler_type = 255;
var is_xip = false;
var app_fw_buf = new Buffer(fs.readFileSync(ip_file), 'hex');
/* Validate application firmware */
var magic_str = app_fw_buf.slice(0, 4);
if (magic_str != 'LVRM' && magic_str != 'MRVL') {
console.error("Invalid application firmware. Exiting.");
process.exit(1);
}
var magic_sig = app_fw_buf.readUInt32LE(4);
if (magic_sig != 0x2e9cf17b && magic_sig != 0x7bf19c2e) {
console.error("Invalid application firmware. Exiting.");
process.exit(1);
}
/* Check if XIP is enabled and encryption is required */
var entry = app_fw_buf.readUInt32LE(16);
if (((entry & 0x1f000000) === 0x1f000000) || (entry & 0x0000001f) === 0x0000001f)
is_xip = true;
if (typeof fw_enc_algo === "undefined" && typeof fw_sign_algo === "undefined") {
console.error("Info: No encryption or signing was asked for firmware");
console.error("Info: Doing nothing for firmware image");
var filename = get_outfile_name();