Initial commit

.gitignore

@@ -0,0 +1,52 @@
+
+.metadata
+bin/
+target/
+tmp/
+*.tmp
+*.bak
+*.swp
+*~.nib
+local.properties
+.settings/
+.loadpath
+.recommenders
+
+# Eclipse Core
+.project
+
+# External tool builders
+.externalToolBuilders/
+
+# Locally stored "Eclipse launch configurations"
+*.launch
+
+# PyDev specific (Python IDE for Eclipse)
+*.pydevproject
+
+# CDT-specific (C/C++ Development Tooling)
+.cproject
+
+# JDT-specific (Eclipse Java Development Tools)
+.classpath
+
+# Java annotation processor (APT)
+.factorypath
+
+# PDT-specific (PHP Development Tools)
+.buildpath
+
+# sbteclipse plugin
+.target
+
+# Tern plugin
+.tern-project
+
+# TeXlipse plugin
+.texlipse
+
+# STS (Spring Tool Suite)
+.springBeans
+
+# Code Recommenders
+.recommenders/

data/in.ta

@@ -0,0 +1,15 @@
+LDA $10:14
+ADD $10:15
+OUT
+HLT
+$10:0
+$10:0
+$10:0
+$10:0
+$10:0
+$10:0
+$10:0
+$10:0
+$10:0
+$10:23
+$10:43

pom.xml

@@ -0,0 +1,58 @@
+
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+	<modelVersion>4.0.0</modelVersion>
+
+	<groupId>eu.tankernn.assembly.compiler</groupId>
+	<version>1.0</version>
+	<packaging>jar</packaging>
+
+	<url>http://tankernn.eu</url>
+	<name>Tankernn Assembly Compiler</name>
+
+	<dependencies>
+		<dependency>
+		    <groupId>com.pi4j</groupId>
+		    <artifactId>pi4j-core</artifactId>
+		   <version>1.0</version>
+		</dependency>
+	</dependencies>
+
+	<build>
+		<plugins>
+			<plugin>
+				<artifactId>maven-assembly-plugin</artifactId>
+				<executions>
+					<execution>
+						<phase>package</phase>
+						<goals>
+							<goal>single</goal>
+						</goals>
+						<configuration>
+							<archive>
+								<manifest>
+									<addClasspath>true</addClasspath>
+									<mainClass>eu.tankernn.assembly.compiler.Assemble</mainClass>
+								</manifest>
+							</archive>
+							<!-- The filename of the assembled distribution file defualt ${project.build.finalName} -->
+							<finalName>${project.build.finalName}</finalName>
+							<appendAssemblyId>false</appendAssemblyId>
+						</configuration>
+					</execution>
+				</executions>
+				<configuration>
+					<descriptorRefs>
+						<descriptorRef>jar-with-dependencies</descriptorRef>
+					</descriptorRefs>
+				</configuration>
+			</plugin>
+		</plugins>
+	</build>
+
+	<properties>
+		<maven.compiler.source>1.8</maven.compiler.source>
+		<maven.compiler.target>1.8</maven.compiler.target>
+	</properties>
+	<artifactId>tankernn-assembly-compiler</artifactId>
+</project>

src/main/java/eu/tankernn/assembly/compiler/Assemble.java

@@ -0,0 +1,112 @@
+package eu.tankernn.assembly.compiler;
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.FileReader;
+import java.io.IOException;
+import java.io.PrintStream;
+import java.util.HashMap;
+
+import eu.tankernn.assembly.output.GPIOHandler;
+import eu.tankernn.assembly.output.ParallelOutput;
+
+public class Assemble {
+	static PrintStream out;
+	static BufferedReader in;
+
+	static HashMap<String, Byte> labels = new HashMap<String, Byte>();
+	static HashMap<String, Byte> variables = new HashMap<String, Byte>();
+	static byte currentAddress = 0;
+	
+	static boolean outputToGPIO = false;
+	static boolean bigEndianData = true;
+	static boolean bigEndianAddress = true;
+
+	public static void main(String[] args) {
+		if (outputToGPIO)
+			GPIOHandler.init(new ParallelOutput());
+		
+		File fileIn;
+
+		if (args.length > 0) {
+			fileIn = new File(args[0]);
+		} else {
+			fileIn = new File("data/in.ta");
+		}
+
+		try {
+			in = new BufferedReader(new FileReader(fileIn));
+		} catch (FileNotFoundException e) {
+			log("Could not find file " + fileIn.getAbsolutePath());
+			return;
+		}
+
+		if (args.length > 1) {
+			File fileOut = new File(args[1]);
+			if (fileOut.exists()) {
+				log("File " + fileOut.getAbsolutePath() + " already exists, aborting.");
+				return;
+			} else {
+				try {
+					fileOut.createNewFile();
+					out = new PrintStream(new FileOutputStream(fileOut));
+				} catch (IOException e) {
+					System.err.println("Error creating/opening file " + fileOut.getAbsolutePath());
+					e.printStackTrace();
+				}
+			}
+		} else {
+			out = System.out;
+		}
+
+		try {
+			startCompile();
+		} catch (IOException ex) {
+			log("The compiler encountered an error: ");
+			ex.printStackTrace();
+		}
+	}
+
+	public static void startCompile() throws IOException {
+		String line;
+		int index = 0;
+		while ((line = in.readLine()) != null) {
+			try {
+				output(new LineParser(line, index++).parse());
+			} catch (SyntaxErrorException e) {
+				e.printStackTrace();
+				System.exit(1);
+			}
+		}
+	}
+
+	public static void addLabel(String label) {
+		labels.put(label, (byte) currentAddress);
+	}
+
+	public static void log(String str) {
+		System.out.println(str);
+	}
+
+	public static void output(Byte[] bytes) throws IOException {
+		for (int i = 0; i < bytes.length; i++)
+			currentAddress++;
+
+		if (outputToGPIO)
+			GPIOHandler.writeData(bytes);
+		else
+			for (Byte b : bytes)
+				out.println(byteToBinaryString(currentAddress, 4, bigEndianAddress) + " : " + byteToBinaryString(b, 8, false));
+	}
+	
+	private static String byteToBinaryString(int b, int wordLength, boolean reverse) {
+		int template = (int) Math.pow(2, wordLength) - 1;
+		StringBuilder result = new StringBuilder();
+		result.append(Integer.toBinaryString((b & template) + template + 0x1).substring(1));
+		if (reverse)
+			result.reverse();
+		return result.toString();
+	}
+}

src/main/java/eu/tankernn/assembly/compiler/LineParser.java

@@ -0,0 +1,139 @@
+package eu.tankernn.assembly.compiler;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class LineParser {
+
+	public static class OPCodes {
+		public static final byte NOP = 0x0, LDA = 0x1, ADD = 0x2, SUB = 0x3, AND = 0x4, OR = 0x5, NOT_B = 0x6,
+				STO = 0x7, OUT = 0x8, JMP = 0x9, HLT = 0xA;
+	}
+
+	String line;
+	int lineIndex;
+	ArrayList<Byte> list = new ArrayList<Byte>();
+	String[] instruction;
+	int pos = 0;
+
+	public LineParser(String line, int lineIndex) {
+		this.line = line;
+		this.lineIndex = lineIndex;
+		instruction = line.split("\\s+");
+	}
+
+	public Byte[] parse() throws SyntaxErrorException {
+
+		// Comment
+		if (line.startsWith(";")) {
+			return null;
+		}
+
+		// Add a label
+		if (instruction[0].endsWith(":")) {
+			Assemble.addLabel(instruction[0].substring(0, instruction[0].length() - 2));
+			pos++;
+		}
+
+		// Add a literal byte
+		if (instruction[pos].startsWith("$"))
+			try {
+				byte b = parseToByte(instruction[pos]);
+				list.add(b);
+				return listToByteArray(list);
+			} catch (NumberFormatException ex) {
+
+			}
+
+		String command = instruction[pos].toUpperCase();
+
+		switch (command) {
+		case "NOP":
+			addWithoutAddress(OPCodes.NOP);
+			break;
+		case "LDA":
+			addWithAddress(OPCodes.LDA);
+			break;
+		case "ADD":
+			addWithAddress(OPCodes.ADD);
+			break;
+		case "SUB":
+			addWithAddress(OPCodes.SUB);
+			break;
+		case "AND":
+			addWithAddress(OPCodes.AND);
+			break;
+		case "OR":
+			addWithAddress(OPCodes.OR);
+			break;
+		case "NOT":
+		case "NOTB":
+			addWithAddress(OPCodes.NOT_B);
+			break;
+		case "STO":
+			addWithoutAddress(OPCodes.STO);
+			break;
+		case "OUT":
+			addWithoutAddress(OPCodes.OUT);
+			break;
+		case "JMP":
+			pos++;
+			switch (instruction[pos]) {
+			case "":
+
+			}
+			addWithoutAddress(OPCodes.JMP);
+			break;
+		case "HLT":
+			addWithoutAddress(OPCodes.HLT);
+			break;
+		default:
+			throw new SyntaxErrorException("Commmand not found: " + command + " At line: " + lineIndex);
+		}
+
+		return listToByteArray(list);
+	}
+
+	private static Byte[] listToByteArray(List<Byte> list) {
+		return list.toArray(new Byte[list.size()]);
+	}
+
+	/**
+	 * Converts a string representation of a byte value into a byte.
+	 * 
+	 * @param s
+	 *            A string with the format <code>$base:value</code>
+	 * @return The byte value represented by the string
+	 */
+	private Byte parseToByte(String s) {
+		String[] sArr = instruction[pos].replace("$", "").split(":");
+		byte b = (byte) Integer.parseInt(sArr[1], Integer.parseInt(sArr[0]));
+		
+		return Assemble.bigEndianData ? reverseByte(b) : b;
+	}
+
+	private byte reverseByte(byte x) {
+		int intSize = 8;
+		byte y = 0;
+		for (int position = intSize - 1; position > 0; position--) {
+			y += ((x & 1) << position);
+			x >>= 1;
+		}
+		return y;
+	}
+
+	private void addWithAddress(byte OPCode) throws SyntaxErrorException {
+		pos++;
+		byte address;
+		try {
+			address = parseToByte(instruction[pos]);
+		} catch (IndexOutOfBoundsException ex) {
+			throw new SyntaxErrorException("Missing address." + " At line: " + lineIndex);
+		}
+		list.add((byte) ((OPCode << 0x4) | address));
+	}
+
+	private void addWithoutAddress(byte OPCode) {
+		list.add((byte) ((OPCode << 0x4)));
+	}
+}

src/main/java/eu/tankernn/assembly/compiler/SyntaxErrorException.java

@@ -0,0 +1,14 @@
+package eu.tankernn.assembly.compiler;
+
+public class SyntaxErrorException extends Exception {
+
+	public SyntaxErrorException(String messsage) {
+		super(messsage);
+	}
+
+	/**
+	 * 
+	 */
+	private static final long serialVersionUID = 9188486217457093809L;
+
+}

src/main/java/eu/tankernn/assembly/output/DataOutputMethod.java

@@ -0,0 +1,9 @@
+package eu.tankernn.assembly.output;
+
+import com.pi4j.io.gpio.GpioController;
+
+public interface DataOutputMethod {
+	public void init(GpioController GPIO);
+
+	public void output(byte b);
+}

src/main/java/eu/tankernn/assembly/output/GPIOHandler.java

@@ -0,0 +1,49 @@
+package eu.tankernn.assembly.output;
+
+import com.pi4j.io.gpio.GpioController;
+import com.pi4j.io.gpio.GpioFactory;
+import com.pi4j.io.gpio.GpioPinDigitalOutput;
+import com.pi4j.io.gpio.Pin;
+import com.pi4j.io.gpio.PinState;
+import com.pi4j.io.gpio.RaspiPin;
+
+public class GPIOHandler {
+
+	static final Pin[] ADDRESS_PINS = { RaspiPin.GPIO_22, RaspiPin.GPIO_23, RaspiPin.GPIO_24, RaspiPin.GPIO_25 };
+	static final Pin WRITE_PIN = RaspiPin.GPIO_26;
+	private static DataOutputMethod dom;
+
+	static GpioPinDigitalOutput[] addressOutputPins = new GpioPinDigitalOutput[8];
+	static GpioPinDigitalOutput writePin;
+
+	// create GPIO controller instance
+	static final GpioController GPIO = GpioFactory.getInstance();
+
+	static byte currentAddress;
+
+	public static void init(DataOutputMethod method) {
+		dom = method;
+		dom.init(GPIO);
+
+		for (int i = 0; i < addressOutputPins.length; i++)
+			addressOutputPins[i] = GPIO.provisionDigitalOutputPin(ADDRESS_PINS[i], "Address pin " + i, PinState.LOW);
+
+		writePin = GPIO.provisionDigitalOutputPin(WRITE_PIN, "Write pin", PinState.HIGH);
+	}
+
+	public static void writeData(Byte[] bytes) {
+		for (byte b : bytes) {
+			// Output address
+			for (int i = 0; i < addressOutputPins.length; i++) {
+				addressOutputPins[i].setState((currentAddress & 1 << i) == 1);
+			}
+			currentAddress++;
+
+			// Output data
+			dom.output(b);
+
+			// Pulse write pin
+			writePin.pulse(10);
+		}
+	}
+}

src/main/java/eu/tankernn/assembly/output/ParallelOutput.java

@@ -0,0 +1,27 @@
+package eu.tankernn.assembly.output;
+
+import com.pi4j.io.gpio.GpioController;
+import com.pi4j.io.gpio.GpioPinDigitalOutput;
+import com.pi4j.io.gpio.Pin;
+import com.pi4j.io.gpio.PinState;
+import static com.pi4j.io.gpio.RaspiPin.*;
+
+public class ParallelOutput implements DataOutputMethod {
+
+	private static final Pin[] DATA_PINS = { GPIO_07, GPIO_00, GPIO_01, GPIO_02, GPIO_03, GPIO_04, GPIO_05, GPIO_06 };
+
+	private GpioPinDigitalOutput[] dataOutputPins = new GpioPinDigitalOutput[8];
+
+	@Override
+	public void init(GpioController GPIO) {
+		for (int i = 0; i < dataOutputPins.length; i++)
+			dataOutputPins[i] = GPIO.provisionDigitalOutputPin(DATA_PINS[i], "Data pin " + i, PinState.LOW);
+	}
+
+	@Override
+	public void output(byte b) {
+		for (int i = 0; i < 8; i++)
+			dataOutputPins[i].setState((b & 1 << i) == 1);
+	}
+
+}

src/main/java/eu/tankernn/assembly/output/SerialOutput.java

@@ -0,0 +1,29 @@
+package eu.tankernn.assembly.output;
+
+import com.pi4j.io.gpio.GpioController;
+import com.pi4j.io.gpio.GpioPinDigitalOutput;
+import com.pi4j.io.gpio.Pin;
+import com.pi4j.io.gpio.PinState;
+import com.pi4j.io.gpio.RaspiPin;
+
+public class SerialOutput implements DataOutputMethod {
+	private static final Pin DATA_PIN = RaspiPin.GPIO_01;
+	private static final Pin DATA_CLOCK_PIN = RaspiPin.GPIO_02;
+	private GpioPinDigitalOutput dataOutputPin;
+	private GpioPinDigitalOutput dataClockPin;
+	
+	@Override
+	public void init(GpioController GPIO) {
+		dataOutputPin = GPIO.provisionDigitalOutputPin(DATA_PIN, "Data pin", PinState.LOW);
+		dataClockPin = GPIO.provisionDigitalOutputPin(DATA_CLOCK_PIN, "Data clock pin", PinState.LOW);
+	}
+
+	@Override
+	public void output(byte b) {
+		for (int i = 0; i < 8; i++) {
+			dataOutputPin.setState((b & 1 << i) == 1);
+			dataClockPin.pulse(10);
+		}
+	}
+
+}