456 lines
19 KiB
JavaScript
456 lines
19 KiB
JavaScript
"use strict";
|
|
|
|
var p7 = {};
|
|
|
|
|
|
(function() {
|
|
/* ---------------------Utilitaries--------------------- */
|
|
|
|
/* Convert a string into an array of ascii numbers */
|
|
String.prototype.toAscii = function () {
|
|
return this.split('').map((char) => char.charCodeAt(0))
|
|
}
|
|
|
|
/* Convert an hex number into an array of ascii values
|
|
* Use the uppercase representation of the number */
|
|
Number.prototype.hexToAscii = function (padding) {
|
|
return this.toString(16).toUpperCase().padStart(padding, 0).toAscii();
|
|
}
|
|
|
|
/* Sum individual bytes
|
|
* NOT + 1, as defined in fxReverse documentation.
|
|
* Be sure it's under 256! */
|
|
Array.prototype.p7Checksum = function () {
|
|
return (((~(this.reduce((accumulator, currentValue) => accumulator + currentValue))) + 1) & 0xFF)
|
|
}
|
|
|
|
/* Add the Checksum (CS) field to a packet */
|
|
Array.prototype.addP7Checksum = function () {
|
|
return this.concat(this.slice(1, this.length).p7Checksum().hexToAscii(2));
|
|
}
|
|
|
|
/* Convert an ascii array into a string */
|
|
Array.prototype.asciiToString = function () {
|
|
let string = [];
|
|
this.forEach((element) => string.push(String.fromCharCode(element)));
|
|
return string.join('');
|
|
}
|
|
|
|
/* Convert an ascii array representing an hex number into a number */
|
|
Array.prototype.asciiToHex = function () {
|
|
return Number('0x' + this.asciiToString());
|
|
}
|
|
|
|
/* Return the decoded Data (D) field */
|
|
Array.prototype.decodeDataField = function () {
|
|
let buffer = [...this]
|
|
buffer.forEach((element, index) => {
|
|
if (element === 0x5C)
|
|
buffer.splice(index, 2, buffer[index + 1] - (buffer[index + 1] !== 0x5C) * 0x20);
|
|
});
|
|
return buffer;
|
|
}
|
|
|
|
/* Return the encoded Data (D) field */
|
|
Array.prototype.encodeDataField = function () {
|
|
return this.flatMap((element) => (element < 0x20) ? [0x5C, (element + 0x20)] : (element === 0x5C) ? [0x5C, 0x5C] : element);
|
|
}
|
|
|
|
/* Return all the informations of the device, and trim string's overage (255) */
|
|
Array.prototype.extendedAckPacket = function () {
|
|
return {
|
|
hardwareIdentifier : this.slice(8, 16).asciiToString(),
|
|
processorIdentifier : this.slice(16, 32).asciiToString(),
|
|
preprogrammedROMCapacity : this.slice(32, 40).asciiToString(),
|
|
flashROMCapacity : this.slice(40, 48).asciiToString(),
|
|
ramCapacity : this.slice(48, 56).asciiToString(),
|
|
prepogrammedROMVersion : this.slice(56, 72).asciiToString(),
|
|
bootCodeVersion : this.slice(72, 88).asciiToString(),
|
|
bootCodeOffset : this.slice(88, 96).asciiToString(),
|
|
bootCodeSize : this.slice(96, 104).asciiToString(),
|
|
osCodeVersion : this.slice(104, 120).filter(number => number !== 0xFF).asciiToString(),
|
|
osCodeOffset : this.slice(120, 128).asciiToString(),
|
|
osCodeSize : this.slice(128, 136).asciiToString(),
|
|
protocolVersion : this.slice(136, 140).asciiToString(),
|
|
productID : this.slice(140, 156).filter(number => number !== 0xFF).asciiToString(),
|
|
username : this.slice(156, 172).filter(number => number !== 0xFF).asciiToString()
|
|
}
|
|
};
|
|
|
|
/* Return the value (as an number) of the Overwrite (OW) subfield of the Data (D) field of an extended command packet */
|
|
Array.prototype.commandPacketOverWrite = function () {
|
|
return this.slice(8, 10).asciiToHex();
|
|
}
|
|
|
|
/* Return the value (as an number) of the Data type (DT) subfield of the Data (D) field of an extended command packet */
|
|
Array.prototype.commandPacketDataType = function () {
|
|
return this.slice(10, 12).asciiToHex();
|
|
}
|
|
|
|
/* Return the value (as an number) of the FileSize (FS) subfield of the Data (D) field of an extended command packet */
|
|
Array.prototype.commandPacketFileSize = function () {
|
|
return this.slice(12, 20).asciiToHex();
|
|
}
|
|
|
|
/* Return the value (as a string) of the requested Data (D) subfield of the Data (D) field of an extended command packet */
|
|
Array.prototype.commandPacketDataField = function (field) {
|
|
let fieldSize = [];
|
|
|
|
/* Decode the length of Data {1 - ${length}} (D{1 - ${length}}) subfields */
|
|
for (let index = 20, i = 0; i < field ; i++)
|
|
fieldSize.push(this.slice(index, (index += 2)).asciiToHex());
|
|
|
|
/* Get the requested field size */
|
|
let fieldLength = fieldSize.pop();
|
|
|
|
/* Get the index of the requested field */
|
|
let fieldIndex = (fieldSize.length) ? fieldSize.reduce((accumulator, currentValue) => accumulator + currentValue) + 32 : 32;
|
|
|
|
/* Return the ascii array as a string */
|
|
return this.slice(fieldIndex, fieldIndex + fieldLength).asciiToString();
|
|
};
|
|
|
|
/* Return an array containing the value (as a string) of all the Data (D) subfield of the Data (D) field of an extended command packet */
|
|
Array.prototype.commandPacketAllDataFields = function () {
|
|
let dataFieldSize = [];
|
|
let index = 20
|
|
while(index < 32)
|
|
dataFieldSize.push(this.slice(index, (index += 2)).asciiToHex());
|
|
|
|
return dataFieldSize.map((element) => this.slice(index, (index += element)).asciiToString());
|
|
}
|
|
|
|
/* Return the value (as a number) of the Total number (CN) subfield of the Data (D) field of a data packet */
|
|
Array.prototype.dataPacketDataFieldGetTotalNumber = function () {
|
|
return this.slice(0, 4).asciiToHex();
|
|
}
|
|
|
|
/* Return the value (as a number) of the Current number (CN) subfield of the Data (D) field of a data packet */
|
|
Array.prototype.dataPacketDataFieldGetCurrentNumber = function () {
|
|
return this.slice(4, 8).asciiToHex();
|
|
}
|
|
|
|
/* Return the Data (D) subfield of the Data (D) field of a data packet */
|
|
Array.prototype.dataPacketDataFieldGetData = function () {
|
|
return this.slice(8, this.length);
|
|
}
|
|
|
|
/* ---------------------Packet making--------------------- */
|
|
|
|
p7.make = {
|
|
/* Create a basic (Non-Extended) packet
|
|
* Return the packet */
|
|
basicPacket: (type, subtype) =>
|
|
([type, //Type (T)
|
|
...subtype.hexToAscii(2), //Subtype (ST)
|
|
0x30].addP7Checksum()), //Extended (EX)
|
|
|
|
/* Create an Extended packet
|
|
* Return the packet */
|
|
extendedPacket: (type, subtype, dataField) =>
|
|
([type,
|
|
...subtype.hexToAscii(2),
|
|
0x31,
|
|
...(dataField = dataField.encodeDataField()).length.hexToAscii(4),
|
|
...dataField].addP7Checksum()),
|
|
|
|
/* Create a buffer containing the Data (D) field of a command packet
|
|
* Return the buffer */
|
|
commandPacketDataField: (datatype, fileSize, commandArguments) =>
|
|
([0x30, 0x30, //Overwrite (OW)
|
|
...datatype.hexToAscii(2), //Data type (DT) ??
|
|
...fileSize.hexToAscii(8), //File size (FS)
|
|
...commandArguments.flatMap((element) => element.length.hexToAscii(2)), //Size of Data {1..6} (SD{1..6})
|
|
...commandArguments.join('').toAscii()]), //Data {1..6} (D{1..6})
|
|
|
|
/* Create a buffer containing the Data (D) field of a data packet
|
|
* Return the buffer */
|
|
dataPacketDataField: (totalNumber, currentNumber, data) =>
|
|
([...totalNumber.hexToAscii(4), //Total number (TN) subfield
|
|
...currentNumber.hexToAscii(4), //Current number (CN) subfield
|
|
...data]), //Data (DD) subfield
|
|
|
|
};
|
|
|
|
/* ---------------------Packet receiving--------------------- */
|
|
|
|
p7.receive = {
|
|
packet: function () {
|
|
console.log("%cReceiving...", "color: orange");
|
|
|
|
var packetInfo = {};
|
|
|
|
return p7.device.transferIn(2, 64)
|
|
.then(function receive(transferInResult) {
|
|
if (!transferInResult.data.byteLength) {
|
|
console.log('buffer was empty, retrying');
|
|
return p7.device.transferIn(2, 64).then(receive);
|
|
}
|
|
|
|
packetInfo.receiveBuffer = Array.from(new Uint8Array(transferInResult.data.buffer));
|
|
|
|
packetInfo.length = 6; //Type (T), Subtype (S), Extended (EX) and Checksum (CS) fields
|
|
|
|
//Set Type (T) field
|
|
packetInfo.type = packetInfo.receiveBuffer[0];
|
|
|
|
//Set Subtype (ST) field
|
|
packetInfo.subtype = packetInfo.receiveBuffer.slice(1, 2).asciiToHex();
|
|
|
|
//Set Extended (EX) field
|
|
if ((packetInfo.extended = (packetInfo.receiveBuffer[3] === 0x31))) {
|
|
console.log('packet is extended');
|
|
//Set Data size (DS) field
|
|
packetInfo.dataSize = packetInfo.receiveBuffer.slice(4, 8).asciiToHex();
|
|
|
|
packetInfo.length += packetInfo.dataSize + 4; //Data size field
|
|
|
|
if (64 < packetInfo.length)
|
|
return p7.device.transferIn(2, packetInfo.length - 64)
|
|
.then((transferInResult) => packetInfo.receiveBuffer.push(...(new Uint8Array(transferInResult.data.buffer))));
|
|
}
|
|
}).then(() => {
|
|
if (packetInfo.extended)
|
|
packetInfo.data = packetInfo.receiveBuffer.slice(8, packetInfo.receiveBuffer.length - 2).decodeDataField();
|
|
|
|
//Compute checksum
|
|
let checksumError = ((packetInfo.checksum = packetInfo.receiveBuffer.slice(packetInfo.length - 2, packetInfo.length).asciiToHex()) !== packetInfo.receiveBuffer.slice(1, packetInfo.length - 2).p7Checksum());
|
|
|
|
return packetInfo;
|
|
}).catch((err) => {
|
|
err.message = "Couldn't receive the packet: " + err.message;
|
|
throw err;
|
|
});
|
|
},
|
|
|
|
data: function (responsePacketInfo) {
|
|
var data = [];
|
|
|
|
return p7.send.packet(p7.make.basicPacket(p7PacketType.ack, ackSubtype.default))
|
|
.then(function receiveData(responsePacketInfo) {
|
|
if (responsePacketInfo.type !== p7PacketType.data)
|
|
return [data.flat(), responsePacketInfo];
|
|
|
|
data.push(responsePacketInfo.data.dataPacketDataFieldGetData());
|
|
return p7.send.packet(p7.make.basicPacket(p7PacketType.ack, ackSubtype.default)).then(receiveData);
|
|
});
|
|
}
|
|
};
|
|
|
|
|
|
/* ---------------------Packet sending--------------------- */
|
|
|
|
p7.send = {
|
|
packet: function (buffer) {
|
|
console.log("%cSending packet...", "color: green");
|
|
return p7.device.transferOut(1, Uint8Array.from(buffer))
|
|
.catch((err) => {
|
|
err.message = "Couldn't send the packet: " + err.message;
|
|
throw err;
|
|
})
|
|
.then((transferOutResult) => p7.receive.packet())
|
|
.catch((err) => {
|
|
err.message = "Couldn't receive the response packet: " + err.message;
|
|
throw err;
|
|
});
|
|
},
|
|
|
|
/* Send a single command
|
|
* Return the informations about the response ack packet */
|
|
singleCommand: (subtype, datatype, fileSize, commandArguments) =>
|
|
p7.send.packet(p7.make.extendedPacket(p7PacketType.command, subtype, p7.make.commandPacketDataField(datatype, fileSize, commandArguments)))
|
|
.then((responsePacketInfo) => {
|
|
if (!(responsePacketInfo.type === p7PacketType.ack && responsePacketInfo.subtype === ackSubtype.default))
|
|
throw new Error("The calculator didn't send the expected ack packet!:" +
|
|
"\t{Type: " + responsePacketInfo.type +
|
|
"\tSubtype: " + responsePacketInfo.subtype + "}");
|
|
|
|
return responsePacketInfo;
|
|
}),
|
|
|
|
/* Send a single command request
|
|
* Return an array containing the filtered (with `callbackFunction`) Data (D) field of each response command packet */
|
|
singleCommandRoleswap: function (subtype, datatype, fileSize, commandArguments, callbackFunction) {
|
|
var filteredData = [];
|
|
|
|
return p7.send.singleCommand(subtype, datatype, fileSize, commandArguments)
|
|
.then(() => p7.send.packet(p7.make.basicPacket(p7PacketType.roleswap, roleswapSubtype.default)))
|
|
.then(function receiveRequestedCommand(responsePacketInfo) {
|
|
if (responsePacketInfo.type !== p7PacketType.command)
|
|
return filteredData;
|
|
|
|
filteredData.push(callbackFunction(responsePacketInfo.receiveBuffer));
|
|
return p7.send.packet(p7.make.basicPacket(p7PacketType.ack, ackSubtype.default)).then(receiveRequestedCommand);
|
|
});
|
|
},
|
|
|
|
dataCommand: function (subtype, datatype, fileSize, commandArguments, data) {
|
|
var currentPacketNumber = 0;
|
|
var lastPacketSize = data.length & 0xFF; //Equivalent to data.length % 256, but way faster !
|
|
var totalPacketNumber = (data.length >> 8) + (lastPacketSize !== 0); //Equivalent to data.length / 256, but way way waaaaaay faster, and return an integer quotient, not a decimal one !!
|
|
|
|
return p7.send.singleCommand(subtype, datatype, fileSize, commandArguments)
|
|
.then(function sendDataPackets(result) {
|
|
if ((currentPacketNumber += 1) === totalPacketNumber)
|
|
return p7.send.packet(p7.make.extendedPacket(p7PacketType.data, subtype, p7.make.dataPacketDataField(totalPacketNumber, currentPacketNumber, data.slice(data.length - lastPacketSize, data.length))))
|
|
|
|
return p7.send.packet(p7.make.extendedPacket(p7PacketType.data, subtype, p7.make.dataPacketDataField(totalPacketNumber, currentPacketNumber, data.slice(((currentPacketNumber - 1) << 8), (currentPacketNumber << 8))))).then(sendDataPackets);
|
|
});
|
|
},
|
|
|
|
dataCommandRoleswap: async function (subtype, datatype, fileSize, commandArguments, callbackFunction) {
|
|
var filteredData = [];
|
|
|
|
return p7.send.singleCommand(subtype, datatype, fileSize, commandArguments)
|
|
.then(() => p7.send.packet(p7.make.basicPacket(p7PacketType.roleswap, roleswapSubtype.default)))
|
|
.then(function receiveRequestedData(responsePacketInfo) {
|
|
if (responsePacketInfo.type === p7PacketType.roleswap)
|
|
return filteredData;
|
|
|
|
let command = responsePacketInfo.receiveBuffer;
|
|
return p7.receive.data()
|
|
.then((dataResponse) => {
|
|
filteredData.push(callbackFunction(command, dataResponse[0]));
|
|
return receiveRequestedData(dataResponse[1]);
|
|
});
|
|
});
|
|
}
|
|
};
|
|
|
|
/* ---------------------Initialization and exiting--------------------- */
|
|
|
|
/* Connect to the calculator */
|
|
p7.connect = () =>
|
|
navigator.usb.requestDevice({filters:[
|
|
{'vendorId': 0x07cf , 'productId': 0x6101}, //fx-9750gII
|
|
{'vendorId': 0x07cf , 'productId': 0x6102}] //fx-CP400
|
|
}).then((device) => {
|
|
p7.device = device
|
|
return p7.device.open();
|
|
}).then(() => {
|
|
if (p7.device.configuration === null)
|
|
return p7.device.selectConfiguration(1); //Only existing one so it should be selected by default, just checking
|
|
}).then(() => {
|
|
if (p7.device.configuration.interfaces[0].claimed === false)
|
|
return p7.device.claimInterface(0); //Same as for the configuration
|
|
});
|
|
|
|
/* Receive and send some usb control message, as defined in fxReverse documentation
|
|
*
|
|
* Adapted version (some parameters changed since fxReverse's writing) of usb_control_msg() function's protoype
|
|
* from linux-manual : https://manpages.debian.org/jessie-backports/linux-manual-4.8/usb_control_msg.9.en.html
|
|
*
|
|
* int usb_control_msg(struct usb_device * dev,
|
|
* uint8_t requesttype,
|
|
* uint8_t request,
|
|
* uint16_t value,
|
|
* uint16_t index,
|
|
* void * data,
|
|
* uint16_t size,
|
|
* int timeout);
|
|
*
|
|
* fxReverse2:13:
|
|
*
|
|
* int init_connection() {
|
|
* char *buffer = calloc(0x29, sizeof(char));
|
|
*
|
|
* //Receive 0x12 bytes of data
|
|
* usb_control_message(usb_handle,
|
|
* 0x80, = 0b10000000
|
|
* - D7 = 1 -> Data transfer direction: Device-to-host
|
|
* - D6...D5 = 0 -> Type: Standard
|
|
* - D4...D0 = 0 -> Recipient: Device
|
|
* 0x6,
|
|
* 0x0100,
|
|
* 0x0,
|
|
* buffer,
|
|
* 0x12,
|
|
* 200);
|
|
*
|
|
* //Same arguments (except timeout), but value is 0x200 and it receives 0x29 bytes of data
|
|
* usb_control_message(usb_handle, 0x80, 0x6, 0x200, 0, buffer, 0x29, 250);
|
|
*
|
|
*
|
|
* usb_control_message(usb_handle,
|
|
* 0x41, = 0b01000001
|
|
* - D7 = 0 -> Data transfer direction: Host-to-device
|
|
* - D6...D5 = 2 -> Type: Vendor
|
|
* - D4...D0 = 1 -> Interface: Interface
|
|
* 0x1,
|
|
* 0x0,
|
|
* 0,
|
|
* buffer,
|
|
* 0x0,
|
|
* 250);
|
|
*
|
|
* free(buffer);
|
|
* return 0;
|
|
* }
|
|
****************************************************************
|
|
|
|
let transferInResult = undefined;
|
|
let controlData = undefined;
|
|
|
|
try {
|
|
transferInResult = await p7.device.controlTransferIn({
|
|
requestType: 'standard',
|
|
recipient: 'device',
|
|
request: 0x06, // GET_DESCRIPTOR
|
|
value: 0x0100, // Descriptor Type and Descriptor Index
|
|
index: 0x0000
|
|
}, 0x12); // Length
|
|
} catch (err) {
|
|
console.log(err);
|
|
}
|
|
|
|
controlData = new Uint8Array(transferInResult.data.buffer);
|
|
|
|
console.log('vendor id : 0x' + controlData[9].toString(16).padStart(2, 0) + controlData[8].toString(16).padStart(2,0));
|
|
console.log('product id : 0x' + controlData[11].toString(16).padStart(2, 0) + controlData[10].toString(16).padStart(2,0));
|
|
|
|
try {
|
|
transferInResult = await p7.device.controlTransferIn({
|
|
requestType: 'standard',
|
|
recipient: 'device',
|
|
request: 0x06, // GET_DESCRIPTOR
|
|
value: 0x0200, // Descriptor Type and Descriptor Index
|
|
index: 0x0000
|
|
}, 0x29); // Length
|
|
} catch (err) {
|
|
console.log(err);
|
|
}
|
|
|
|
controlData = new Uint8Array(transferInResult.data.buffer);
|
|
console.log(controlData);
|
|
|
|
try {
|
|
await p7.device.controlTransferOut({
|
|
requestType: 'vendor',
|
|
recipient: 'interface',
|
|
request: 0x01,
|
|
value: 0x0000,
|
|
index: 0x0000
|
|
}, controlData);
|
|
} catch (err) {
|
|
console.log(err);
|
|
} */
|
|
|
|
/* Initialize the connection with the calculator */
|
|
p7.init = () =>
|
|
p7.connect()
|
|
.catch(() => {
|
|
throw new Error("Couldn't connect to the calculator!");
|
|
}).then(() => p7.send.packet(p7.make.basicPacket(p7PacketType.check, checkSubtype.initialization))
|
|
.catch(() => {
|
|
throw new Error("Couldn't send the initialisation packet!");
|
|
}).then(() => p7.send.packet(p7.make.basicPacket(p7PacketType.command, sysCommandSubtype.getDeviceInfo))
|
|
.catch(() => {
|
|
throw new Error("Couldn't ask for the device infos!");
|
|
}).then((responsePacketInfo) => responsePacketInfo.receiveBuffer.extendedAckPacket())));
|
|
|
|
/* End the connexion with the calculator */
|
|
p7.exit = function () {
|
|
|
|
}
|
|
})();
|