[feature] - Add multiplexer

Author: robwilson1

.gitignore

@@ -6,6 +6,9 @@ npm-debug.log*
 yarn-debug.log*
 yarn-error.log*
 
+# Test coverage
+/coverage/
+
 # Optional npm cache directory
 .npm
 
@@ -88,4 +91,4 @@ $RECYCLE.BIN/
 .TemporaryItems
 .Trashes
 .VolumeIcon.icns
-.com.apple.timemachine.donotpresent
+.com.apple.timemachine.donotpresent

package.json

@@ -8,7 +8,7 @@
 		"build": "rollup -c",
 		"dev": "rollup -c -w",
 		"start": "sirv public",
-		"test:unit": "jest"
+		"test:unit": "jest --collectCoverage"
 	},
 	"devDependencies": {
 		"@babel/core": "^7.9.0",

src/components/adders/tests/full-adder.test.js

@@ -1,6 +1,13 @@
 import { fullAdder } from "..";
 
 describe("Adders - Full Adder", () => {
+	test("default to output { sum: 0, carry: 0 }", () => {
+		expect(fullAdder()).toStrictEqual({
+			sum: 0b0,
+			carry: 0b0,
+		});
+	});
+
 	test("0 0 0 to output { sum: 0, carry: 0 }", () => {
 		expect(fullAdder(0b0, 0b0, 0b0)).toStrictEqual({
 			sum: 0b0,

src/components/adders/tests/half-adder.test.js

@@ -1,6 +1,13 @@
 import { halfAdder } from "..";
 
 describe("Adders - Half Adder", () => {
+	test("default to output { sum: 0, carry: 0 }", () => {
+		expect(halfAdder()).toStrictEqual({
+			sum: 0b0,
+			carry: 0b0,
+		});
+	});
+
 	test("0 0 to output { sum: 0, carry: 0 }", () => {
 		expect(halfAdder(0b0, 0b0)).toStrictEqual({
 			sum: 0b0,

src/components/adders/tests/ripple-carry-adder.test.js

@@ -2,6 +2,13 @@ import { defaultByte } from "../../../util/defaults";
 import { rippleCarryAdder } from "..";
 
 describe("Adders - Ripple Carry Adder", () => {
+	test("default to output { sum: 00000000, carry: 0 }", () => {
+		expect(rippleCarryAdder()).toStrictEqual({
+			sum: defaultByte,
+			carry: 0b0,
+		});
+	});
+
 	test("00000000 + 00000000 to output { sum: 00000000, carry: 0 }", () => {
 		expect(rippleCarryAdder(defaultByte, defaultByte)).toStrictEqual({
 			sum: defaultByte,

src/components/gates/tests/and-gate.test.js

@@ -1,15 +1,22 @@
 import { andGate } from "..";
 
 describe("Gates - AND", () => {
+	test("defaults to 0", () => {
+		expect(andGate()).toBe(0b0);
+	});
+
 	test("0 AND 0 to be 0", () => {
 		expect(andGate(0b0, 0b0)).toBe(0b0);
 	});
+
 	test("0 AND 1 to be 0", () => {
 		expect(andGate(0b0, 0b1)).toBe(0b0);
 	});
+
 	test("1 AND 0 to be 0", () => {
 		expect(andGate(0b1, 0b0)).toBe(0b0);
 	});
+
 	test("1 AND 1 to be 1", () => {
 		expect(andGate(0b1, 0b1)).toBe(0b1);
 	});

src/components/gates/tests/not-gate.test.js

@@ -1,9 +1,14 @@
 import { notGate } from "..";
 
 describe("Gates - NOT", () => {
+	test("defaults to 1", () => {
+		expect(notGate()).toBe(0b1);
+	});
+
 	test("0 to become 1", () => {
 		expect(notGate(0b0)).toBe(0b1);
 	});
+
 	test("1 to become 0", () => {
 		expect(notGate(0b1)).toBe(0b0);
 	});

src/components/gates/tests/or-gate.test.js

@@ -1,15 +1,22 @@
 import { orGate } from "..";
 
 describe("Gates - OR", () => {
+	test("defaults to 0", () => {
+		expect(orGate()).toBe(0b0);
+	});
+
 	test("0 OR 0 to be 0", () => {
 		expect(orGate(0b0, 0b0)).toBe(0b0);
 	});
+
 	test("0 OR 1 to be 1", () => {
 		expect(orGate(0b0, 0b1)).toBe(0b1);
 	});
+
 	test("1 OR 0 to be 1", () => {
 		expect(orGate(0b1, 0b0)).toBe(0b1);
 	});
+
 	test("1 OR 1 to be 1", () => {
 		expect(orGate(0b1, 0b1)).toBe(0b1);
 	});

src/components/gates/tests/xor-gate.test.js

@@ -1,15 +1,22 @@
 import { xorGate } from "..";
 
 describe("Gates - XOR", () => {
+	test("defaults to 0", () => {
+		expect(xorGate()).toBe(0b0);
+	});
+
 	test("0 XOR 0 to be 0", () => {
 		expect(xorGate(0b0, 0b0)).toBe(0b0);
 	});
+
 	test("0 XOR 1 to be 1", () => {
 		expect(xorGate(0b0, 0b1)).toBe(0b1);
 	});
+
 	test("1 XOR 0 to be 1", () => {
 		expect(xorGate(0b1, 0b0)).toBe(0b1);
 	});
+
 	test("1 XOR 1 to be 0", () => {
 		expect(xorGate(0b1, 0b1)).toBe(0b0);
 	});

src/components/latches/tests/and-or-latch.test.js

@@ -6,6 +6,12 @@ describe("Latches - AndOrLatch", () => {
 		expect(latch.output).toBe(0b0);
 	});
 
+	test("default trigger outputs 0", () => {
+		const latch = new AndOrLatch();
+		latch.trigger();
+		expect(latch.output).toBe(0b0);
+	});
+
 	test("Setting input to 1 outputs 1", () => {
 		const latch = new AndOrLatch();
 		latch.trigger(0b1, 0b0);

src/components/latches/tests/gated-latch.test.js

@@ -6,6 +6,12 @@ describe("Latches - GatedLatch", () => {
 		expect(latch.output).toBe(0b0);
 	});
 
+	test("default trigger outputs 0", () => {
+		const latch = new GatedLatch();
+		latch.trigger();
+		expect(latch.output).toBe(0b0);
+	});
+
 	test("Setting input to 1 outputs 0", () => {
 		const latch = new GatedLatch();
 		latch.trigger(0b1, 0b0);

src/components/registers/index.js

@@ -1 +1,2 @@
 export { EightBitRegister } from "./eight-bit-register";
+export { MultiPlexer } from "./multiplexer";

src/components/registers/multiplexer.js

@@ -0,0 +1,44 @@
+import "../../util/types";
+import { defaultByte, defaultBit } from "../../util/defaults";
+import { binaryArrayToDecimal } from "../../util/convert";
+import { GatedLatch } from "../latches";
+
+const MatrixFactory = (rows, cols) => {
+	return [...Array(rows)].map(() => Array(cols).fill(new GatedLatch()));
+};
+
+export class MultiPlexer {
+	constructor(rows = 16, cols = 16) {
+		/** @type {GatedLatch[][]} */
+		this.matrix = MatrixFactory(rows, cols);
+	}
+
+	/**
+	 * Simulates an active intersection wire
+	 * @param {byte} address - The address of the latch to enable
+	 * @param {bit} data - The input/output data bit
+	 * @param {bit} writeEnabled - The shared writeEnabled bit
+	 * @param {bit} readEnabled - The shared readEnabled bit
+	 */
+	trigger(
+		address = defaultByte,
+		data = defaultBit,
+		writeEnabled = defaultBit,
+		readEnabled = defaultBit
+	) {
+		const [c3, c2, c1, c0, r3, r2, r1, r0] = address;
+		const colAddress = binaryArrayToDecimal([c3, c2, c1, c0]);
+		const rowAddress = binaryArrayToDecimal([r3, r2, r1, r0]);
+		this.activeLatch = this.matrix[colAddress][rowAddress];
+
+		// In reality this would use an AND gate
+		if (writeEnabled) {
+			this.activeLatch.trigger(data, writeEnabled);
+		}
+
+		// In reality this would use an AND gate
+		if (readEnabled) {
+			return this.activeLatch.output;
+		}
+	}
+}

src/components/registers/tests/multiplexer.test.js

@@ -0,0 +1,36 @@
+import { MultiPlexer } from "..";
+
+describe("Registers - Multiplexer", () => {
+	test("new multiplexeris 16x16 matrix", () => {
+		const multiplexer = new MultiPlexer();
+		expect(multiplexer.matrix).toHaveLength(16);
+		expect(multiplexer.matrix[0]).toHaveLength(16);
+		expect(multiplexer.matrix[1]).toHaveLength(16);
+		expect(multiplexer.matrix[15]).toHaveLength(16);
+	});
+
+	test("The trigger can read/write to specific latches", () => {
+		const multiplexer = new MultiPlexer();
+		const address1 = [0b0, 0b0, 0b1, 0b0, 0b0, 0b1, 0b1, 0b1]; // col 2, row 7
+		const address2 = [0b0, 0b1, 0b1, 0b0, 0b0, 0b0, 0b1, 0b1]; // col 5, row 3
+
+		const read = (addr) => {
+			return multiplexer.trigger(addr, 0b0, 0b0, 0b1);
+		};
+
+		const write = (addr, dataIn) => {
+			multiplexer.trigger(addr, dataIn, 0b1, 0b0);
+		};
+
+		// 1) can read address
+		expect(read(address1)).toBe(0b0);
+
+		// 2) can write 1 to address
+		write(address1, 0b1);
+		expect(read(address1)).toBe(0b1);
+
+		// 3) Can remember values in different addresses
+		expect(read(address2)).toBe(0b0);
+		expect(read(address1)).toBe(0b1);
+	});
+});

src/util/convert.js

@@ -0,0 +1,9 @@
+import "./types";
+
+/**
+ * Converts a byte to decimal
+ * @param {byte | nibble} input
+ */
+export function binaryArrayToDecimal(input) {
+	return parseInt(input.join(""), 2);
+}

src/util/defaults.js

@@ -1,7 +1,7 @@
 import "./types";
 
-/** @type {byte} */
+/** @type {0b0} */
 export const defaultBit = 0b0;
 
-/** @type {byte} */
+/** @type {[0b0, 0b0, 0b0, 0b0, 0b0, 0b0, 0b0, 0b0]} */
 export const defaultByte = [0b0, 0b0, 0b0, 0b0, 0b0, 0b0, 0b0, 0b0];

src/util/tests/convert.test.js

@@ -0,0 +1,41 @@
+import { binaryArrayToDecimal } from "../convert";
+
+describe("Util - Convert", () => {
+	describe("binaryArrayToDecimal method", () => {
+		test("converts a byte successfully (00000000)", () => {
+			const input = [0b0, 0b0, 0b0, 0b0, 0b0, 0b0, 0b0, 0b0];
+			const result = binaryArrayToDecimal(input);
+			expect(result).toBe(0);
+		});
+
+		test("converts a byte successfully (11111111)", () => {
+			const input = [0b1, 0b1, 0b1, 0b1, 0b1, 0b1, 0b1, 0b1];
+			const result = binaryArrayToDecimal(input);
+			expect(result).toBe(255);
+		});
+
+		test("converts a byte successfully (10101010)", () => {
+			const input = [0b1, 0b0, 0b1, 0b0, 0b1, 0b0, 0b1, 0b0];
+			const result = binaryArrayToDecimal(input);
+			expect(result).toBe(170);
+		});
+
+		test("converts a byte successfully (01010101)", () => {
+			const input = [0b0, 0b1, 0b0, 0b1, 0b0, 0b1, 0b0, 0b1];
+			const result = binaryArrayToDecimal(input);
+			expect(result).toBe(85);
+		});
+
+		test("converts a nibble successfully (0100)", () => {
+			const input = [0b0, 0b1, 0b0, 0b0];
+			const result = binaryArrayToDecimal(input);
+			expect(result).toBe(4);
+		});
+
+		test("converts a nibble successfully (1100)", () => {
+			const input = [0b1, 0b1, 0b0, 0b0];
+			const result = binaryArrayToDecimal(input);
+			expect(result).toBe(12);
+		});
+	});
+});