Add EEPROM stress testing scripts.

usb/eeprom-stress-test-wrapper.sh

@@ -0,0 +1,3 @@
+#!/bin/sh
+
+sh ./eeprom-stress-test.sh 2>&1 | tee eeprom-stress-test.log

usb/eeprom-stress-test.sh

@@ -0,0 +1,27 @@
+#!/bin/sh
+set -e # fail on the first error
+set -x # show expanded variables
+
+userConfigSize=`./get-config-size.js`
+hardwareConfigSize=`./get-config-size.js h`
+
+iter=1
+while true; do
+    echo iter $iter
+
+    dd if=/dev/urandom of=hardware-config.write bs=1 count=$hardwareConfigSize
+    ./write-config.js h
+    ./eeprom.js writeHardwareConfig
+    ./eeprom.js readHardwareConfig
+    ./read-config.js h
+    diff hardware-config.read hardware-config.write
+
+    dd if=/dev/urandom of=user-config.write bs=1 count=$userConfigSize
+    ./write-config.js
+    ./eeprom.js writeUserConfig
+    ./eeprom.js readUserConfig
+    ./read-config.js
+    diff user-config.read user-config.write
+
+    iter=$((iter+1))
+done

usb/eeprom.js

@@ -0,0 +1,32 @@
+#!/usr/bin/env node
+let fs = require('fs');
+let uhk = require('./uhk');
+
+let eepromTransferType = process.argv[2];
+let eepromTransferId = uhk.eepromTransfer[eepromTransferType];
+
+if (eepromTransferId === undefined) {
+    console.error(`Gotta provide one of ${Object.keys(uhk.eepromTransfer).join(', ')}`);
+    process.exit(1);
+}
+
+let isFirstSend = true;
+let isFirstReceive = true;
+let isEepromBusy = true;
+
+uhk.sendUsbPacketsByCallback(() => {
+    if (isFirstSend) {
+        isFirstSend = false;
+        return new Buffer([uhk.usbCommands.launchEepromTransfer, eepromTransferId]);
+    } else {
+        return isEepromBusy ? new Buffer([uhk.usbCommands.getKeyboardState]) : null;
+    }
+});
+
+uhk.registerReceiveCallback((buffer) => {
+    if (isFirstReceive) {
+        isFirstReceive = false;
+    } else {
+        isEepromBusy = buffer[1] === 1;
+    }
+});

usb/get-config-size.js

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+let uhk = require('./uhk');
+let process = require('process');
+
+uhk.silent = true;
+let isHardwareConfig = process.argv[2] === 'h';
+let configTypeString = isHardwareConfig ? 'hardware' : 'user';
+
+uhk.sendUsbPacketsByCallback(() => {
+    return new Buffer([uhk.usbCommands.getProperty, isHardwareConfig ? uhk.systemPropertyIds.hardwareConfigSize : uhk.systemPropertyIds.userConfigSize]);
+});
+
+uhk.registerReceiveCallback((buffer) => {
+    configSize = buffer[1] + (buffer[2]<<8);
+    console.log(configSize);
+    process.exit(0);
+});

usb/read-config.js

@@ -10,7 +10,7 @@ let isFirstSend = true;
 let isFirstReceive = true;
 let configSize;
 let offset = 0;
-let configBuffer;
+let configBuffer = new Buffer(0);
 let chunkSizeToRead;
 
 uhk.sendUsbPacketsByCallback(() => {
@@ -19,10 +19,11 @@ uhk.sendUsbPacketsByCallback(() => {
         return new Buffer([uhk.usbCommands.getProperty, isHardwareConfig ? uhk.systemPropertyIds.hardwareConfigSize : uhk.systemPropertyIds.userConfigSize]);
     } else {
         chunkSizeToRead = Math.min(chunkSize, configSize - offset)
-        let buffer = Buffer([uhk.usbCommands.readUserConfig, chunkSizeToRead, offset & 0xff, offset >> 8]);
+        let usbCommand = isHardwareConfig ? uhk.usbCommands.readHardwareConfig : uhk.usbCommands.readUserConfig;
+        let buffer = Buffer([usbCommand, chunkSizeToRead, offset & 0xff, offset >> 8]);
         let bufferOrNull = offset >= configSize ? null : buffer;
         if (!bufferOrNull) {
-            fs.writeFileSync(`${configTypeString}-config.out`, configBuffer, 'binary');
+            fs.writeFileSync(`${configTypeString}-config.read`, configBuffer);
         }
         offset += chunkSizeToRead;
         return bufferOrNull;
@@ -34,7 +35,6 @@ uhk.registerReceiveCallback((buffer) => {
         isFirstReceive = false;
         configSize = buffer[1] + (buffer[2]<<8);
         console.log(`${configTypeString}configSize:`, configSize);
-        configBuffer = new Buffer(0);
     } else {
         configBuffer = Buffer.concat([configBuffer, new Buffer(buffer.slice(1, chunkSizeToRead+1))]);
     }

usb/uhk.js

@@ -66,7 +66,9 @@ function sendUsbPacketsByCallback(packetProvider, options={}) {
         return;
     }
 
-    console.log('Sending: ', bufferToString(packet));
+    if (!moduleExports.silent) {
+        console.log('Sending: ', bufferToString(packet));
+    }
 
     let [endpointIn, endpointOut] = usbEndpoints || getUsbEndpoints();
     endpointOut.transfer(packet, function(err) {
@@ -83,7 +85,9 @@ function sendUsbPacketsByCallback(packetProvider, options={}) {
                     console.error("USB error: %s", err2);
                     process.exit(2);
                 }
-                console.log('Received:', bufferToString(receivedBuffer));
+                if (!moduleExports.silent) {
+                    console.log('Received:', bufferToString(receivedBuffer));
+                }
                 (receiveCallback || (()=>{}))(receivedBuffer);
                 sendUsbPacketsByCallback(packetProvider);
             })
@@ -102,7 +106,7 @@ function sendUsbPackets(packets, options={}) {
     }, options)
 }
 
-exports = module.exports = {
+exports = module.exports = moduleExports = {
     DelayMs,
     bufferToString,
     getUhkDevice,
@@ -140,6 +144,12 @@ exports = module.exports = {
         hardwareConfigSize: 4,
         userConfigSize: 5,
     },
+    eepromTransfer: {
+        readHardwareConfig: 0,
+        writeHardwareConfig: 1,
+        readUserConfig: 2,
+        writeUserConfig: 3,
+    },
     leftLedDriverAddress: 0b1110100,
     rightLedDriverAddress: 0b1110111
 }

usb/write-config.js

@@ -0,0 +1,39 @@
+#!/usr/bin/env node
+let fs = require('fs');
+let uhk = require('./uhk');
+
+const chunkSize = 60;
+
+let isHardwareConfig = process.argv[2] === 'h';
+let configTypeString = isHardwareConfig ? 'hardware' : 'user';
+let isFirstSend = true;
+let isFirstReceive = true;
+let configSize;
+let offset = 0;
+let configBuffer = fs.readFileSync(`${configTypeString}-config.write`);
+let chunkSizeToRead;
+
+uhk.sendUsbPacketsByCallback(() => {
+    if (isFirstSend) {
+        isFirstSend = false;
+        return new Buffer([uhk.usbCommands.getProperty, isHardwareConfig ? uhk.systemPropertyIds.hardwareConfigSize : uhk.systemPropertyIds.userConfigSize]);
+    } else {
+        chunkSizeToRead = Math.min(chunkSize, configSize - offset)
+        let usbCommand = isHardwareConfig ? uhk.usbCommands.writeHardwareConfig : uhk.usbCommands.writeUserConfig;
+        let buffer = Buffer.concat([
+            new Buffer([usbCommand, chunkSizeToRead, offset & 0xff, offset >> 8]),
+            configBuffer.slice(offset, offset+chunkSizeToRead)
+        ]);
+        let bufferOrNull = offset >= configSize ? null : buffer;
+        offset += chunkSizeToRead;
+        return bufferOrNull;
+    }
+});
+
+uhk.registerReceiveCallback((buffer) => {
+    if (isFirstReceive) {
+        isFirstReceive = false;
+        configSize = buffer[1] + (buffer[2]<<8);
+        console.log(`${configTypeString}configSize:`, configSize);
+    }
+});