461 lines
14 KiB
Java
461 lines
14 KiB
Java
package fabrik.simulator.pic16f84;
|
|
|
|
public class Commands {
|
|
private static int wRegister = 0;
|
|
|
|
public static int get_wRegister() {
|
|
return wRegister;
|
|
}
|
|
|
|
public static void decode(int instruction){
|
|
final int jumpaddr = 0x7FF;
|
|
final int fileregaddr = 0x7F;
|
|
final int constant = 0xFF;
|
|
final int bitaddr = 0x380;
|
|
final int destinationbit = 0x80;
|
|
|
|
int d = (instruction & destinationbit) >> 7;
|
|
int f = instruction & fileregaddr;
|
|
int k = instruction & constant;
|
|
int b = (instruction & bitaddr) >> 7;
|
|
int j = instruction & jumpaddr;
|
|
|
|
switch (instruction & 0x3800){
|
|
case 0b10000000000000:
|
|
System.out.println("CALL: " + j);
|
|
CALL (j);
|
|
return;
|
|
case 0b10100000000000:
|
|
System.out.println("GOTO: " + j);
|
|
GOTO (j);
|
|
return;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
switch (instruction & 0x3C00){
|
|
case 0b01000000000000:
|
|
System.out.println("BCF: " + f + " " + b);
|
|
DataRegister.clearBit(f, b);
|
|
return;
|
|
case 0b01010000000000:
|
|
System.out.println("BSF: " + f + " " + b);
|
|
DataRegister.setBit(f, b);
|
|
return;
|
|
case 0b01100000000000:
|
|
System.out.println("BTFSC: " + f + " " + b);
|
|
BTFSC(f, b);
|
|
return;
|
|
case 0b01110000000000:
|
|
System.out.println("BTFSS: " + f + " " + b);
|
|
BTFSS(f, b);
|
|
return;
|
|
case 0b11000000000000:
|
|
System.out.println("MOVLW: " + k);
|
|
MOVLW (k);
|
|
return;
|
|
case 0b11010000000000:
|
|
System.out.println("RETLW: " + k);
|
|
RETLW (k);
|
|
return;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
switch (instruction & 0x3E00){
|
|
case 0b11111000000000:
|
|
System.out.println("ADDLW: " + k);
|
|
ADDLW (k);
|
|
return;
|
|
case 0b11110000000000:
|
|
System.out.println("SUBLW: " + k);
|
|
SUBLW (k);
|
|
return;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
switch (instruction & 0x3F00){
|
|
case 0b00011100000000:
|
|
System.out.println("ADDWF: " + f + " " + d);
|
|
ADDWF (f, d);
|
|
return;
|
|
case 0b00010100000000:
|
|
System.out.println("ANDWF: " + f + " " + d);
|
|
ANDWF (f, d);
|
|
return;
|
|
case 0b00100100000000:
|
|
System.out.println("COMF: " + f + " " + d);
|
|
COMF (f, d);
|
|
return;
|
|
case 0b00001100000000:
|
|
System.out.println("DECF: " + f + " " + d);
|
|
DECF (f, d);
|
|
return;
|
|
case 0b00101100000000:
|
|
System.out.println("DECFSZ: " + f + " " + d);
|
|
DECFSZ (f, d);
|
|
return;
|
|
case 0b00101000000000:
|
|
System.out.println("INCF: " + f + " " + d);
|
|
INCF (f, d);
|
|
return;
|
|
case 0b00111100000000:
|
|
System.out.println("INCFSZ: " + f + " " + d);
|
|
INCFSZ (f, d);
|
|
return;
|
|
case 0b00010000000000:
|
|
System.out.println("IORWF: " + f + " " + d);
|
|
IORWF (f, d);
|
|
return;
|
|
case 0b00100000000000:
|
|
System.out.println("MOVF: " + f + " " + d);
|
|
MOVF (f, d);
|
|
return;
|
|
case 0b00110100000000:
|
|
System.out.println("RLF: " + f + " " + d);
|
|
RLF (f, d);
|
|
return;
|
|
case 0b00110000000000:
|
|
System.out.println("RRF: " + f + " " + d);
|
|
RRF (f, d);
|
|
return;
|
|
case 0b00001000000000:
|
|
System.out.println("SUBWF: " + f + " " + d);
|
|
SUBWF (f, d);
|
|
return;
|
|
case 0b00111000000000:
|
|
System.out.println("SWAPF: " + f + " " + d);
|
|
SWAPF (f, d);
|
|
return;
|
|
case 0b00011000000000:
|
|
System.out.println("XORWF: " + f + " " + d);
|
|
XORWF (f, d);
|
|
return;
|
|
case 0b11100100000000:
|
|
System.out.println("ANDLW: " + k);
|
|
ANDLW (k);
|
|
return;
|
|
case 0b11101000000000:
|
|
System.out.println("XORLW: " + k);
|
|
XORLW (k);
|
|
return;
|
|
case 0b11100000000000:
|
|
System.out.println("IORLW: " + k);
|
|
IORLW (k);
|
|
return;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
switch (instruction & 0x3F80){
|
|
case 0b00000110000000:
|
|
System.out.println("CLRF: " + f);
|
|
CLRF (f);
|
|
return;
|
|
case 0b00000100000000:
|
|
System.out.println("CLRW");
|
|
CLRW ();
|
|
return;
|
|
case 0b00000010000000:
|
|
System.out.println("MOVWF: " + f);
|
|
MOVWF (f);
|
|
return;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
switch (instruction){
|
|
case 0b01100100:
|
|
System.out.println("CLRWDT");
|
|
//TODO
|
|
return;
|
|
case 0b1001:
|
|
System.out.println("RETFIE");
|
|
//TODO
|
|
return;
|
|
case 0b1000:
|
|
System.out.println("RETURN");
|
|
//TODO
|
|
return;
|
|
case 0b01100011:
|
|
System.out.println("SLEEP");
|
|
//TODO
|
|
return;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
if (instruction == 0 || instruction == 0b0110000 || instruction == 0b01000000 || instruction == 0b00100000){
|
|
System.out.println("NOP");
|
|
}
|
|
else{
|
|
System.out.println("Nicht gefunden!");
|
|
}
|
|
|
|
|
|
}
|
|
|
|
public static void GOTO(int jump) {
|
|
DataRegister.setPC(jump-1);
|
|
}
|
|
|
|
public static void CALL(int jump) {
|
|
//TODO
|
|
}
|
|
|
|
public static void MOVWF(int file) {
|
|
DataRegister.setRegister(file, wRegister);
|
|
}
|
|
|
|
public static void CLRW() {
|
|
wRegister = 0;
|
|
DataRegister.determineZeroFlag(wRegister);
|
|
}
|
|
|
|
public static void CLRF(int file) {
|
|
DataRegister.setRegister(file, 0);
|
|
DataRegister.determineZeroFlag(DataRegister.getRegister(file));
|
|
}
|
|
|
|
public static void IORLW(int literal) {
|
|
wRegister |= literal;
|
|
DataRegister.determineZeroFlag(wRegister);
|
|
}
|
|
|
|
public static void XORLW(int literal) {
|
|
wRegister ^= literal;
|
|
DataRegister.determineZeroFlag(wRegister);
|
|
}
|
|
|
|
public static void ANDLW(int literal) {
|
|
wRegister &= literal;
|
|
DataRegister.determineZeroFlag(wRegister);
|
|
}
|
|
|
|
public static void XORWF(int file, int destination) {
|
|
int result = wRegister ^ DataRegister.getRegister(file);
|
|
if (destination == 0){
|
|
wRegister = result;
|
|
}
|
|
else {
|
|
DataRegister.setRegister(file, result);
|
|
}
|
|
DataRegister.determineZeroFlag(result);
|
|
}
|
|
|
|
public static void SWAPF(int file, int destination) {
|
|
int content = DataRegister.getRegister(file);
|
|
int result = (content & 0x0F) << 4 | (content & 0xF0) >> 4;
|
|
if (destination == 0){
|
|
wRegister = result;
|
|
}
|
|
else {
|
|
DataRegister.setRegister(file, result);
|
|
}
|
|
}
|
|
|
|
public static void SUBWF(int file, int destination) {
|
|
int result = (DataRegister.getRegister(file) - wRegister) ;
|
|
if (wRegister == 0 || result >= 0){
|
|
DataRegister.setCarryFlag(1);
|
|
DataRegister.setDigitCarryFlag(1);
|
|
}
|
|
else {
|
|
DataRegister.setCarryFlag(0);
|
|
DataRegister.setDigitCarryFlag(0);
|
|
}
|
|
if (destination == 0){
|
|
wRegister = result & 0xFF;
|
|
}
|
|
else {
|
|
DataRegister.setRegister(file, result & 0xFF);
|
|
}
|
|
DataRegister.determineZeroFlag(result);
|
|
}
|
|
|
|
public static void RLF(int file, int destination) {
|
|
int fcontent = DataRegister.getRegister(file);
|
|
int carry = DataRegister.getCarryFlag();
|
|
int result = (fcontent << 1) | carry;
|
|
DataRegister.determineCarryFlag(result);
|
|
if (destination == 0){
|
|
wRegister = result & 0xFF;
|
|
}
|
|
else {
|
|
DataRegister.setRegister(file, result & 0xFF);
|
|
}
|
|
}
|
|
|
|
public static void RRF(int file, int destination) {
|
|
int fcontent = DataRegister.getRegister(file);
|
|
int carry = DataRegister.getCarryFlag() << 7;
|
|
int contentlow = fcontent & 0b1;
|
|
int result = fcontent >> 1 | carry;
|
|
DataRegister.setCarryFlag(contentlow);
|
|
if (destination == 0){
|
|
wRegister = result & 0xFF;
|
|
}
|
|
else {
|
|
DataRegister.setRegister(file, result & 0xFF);
|
|
}
|
|
}
|
|
|
|
public static void MOVF(int file, int destination) {
|
|
int content = DataRegister.getRegister(file);
|
|
if (destination == 0){
|
|
wRegister = content;
|
|
}
|
|
else {
|
|
DataRegister.setRegister(file, content);
|
|
}
|
|
DataRegister.determineZeroFlag(content);
|
|
}
|
|
|
|
public static void IORWF(int file, int destination) {
|
|
int result = wRegister | DataRegister.getRegister(file);
|
|
if (destination == 0){
|
|
wRegister = result;
|
|
}
|
|
else {
|
|
DataRegister.setRegister(file, result);
|
|
}
|
|
DataRegister.determineZeroFlag(result);
|
|
}
|
|
|
|
public static void INCFSZ(int file, int destination) {
|
|
int result = (DataRegister.getRegister(file) + 1) & 0xFF;
|
|
if (destination == 0){
|
|
wRegister = result;
|
|
}
|
|
else {
|
|
DataRegister.setRegister(file, result);
|
|
}
|
|
if (result == 0) {
|
|
DataRegister.increasePC();
|
|
}
|
|
}
|
|
|
|
public static void INCF(int file, int destination) {
|
|
int result = (DataRegister.getRegister(file) + 1) & 0xFF;
|
|
if (destination == 0){
|
|
wRegister = result;
|
|
}
|
|
else {
|
|
DataRegister.setRegister(file, result);
|
|
}
|
|
DataRegister.determineZeroFlag(result);
|
|
}
|
|
|
|
public static void DECFSZ(int file, int destination) {
|
|
int result = (DataRegister.getRegister(file) -1) & 0xFF;
|
|
if (destination == 0){
|
|
wRegister = result;
|
|
}
|
|
else {
|
|
DataRegister.setRegister(file, result);
|
|
}
|
|
if (result == 0){
|
|
DataRegister.increasePC();
|
|
}
|
|
}
|
|
|
|
public static void DECF(int file, int destination) {
|
|
int result = (DataRegister.getRegister(file) -1) & 0xFF;
|
|
if (destination == 0){
|
|
wRegister = result;
|
|
}
|
|
else {
|
|
DataRegister.setRegister(file, result);
|
|
}
|
|
DataRegister.determineZeroFlag(result);
|
|
}
|
|
|
|
private static void COMF(int file, int destination) {
|
|
int result = (~ DataRegister.getRegister(file)) & 0xFF;
|
|
if (destination == 0){
|
|
wRegister = result;
|
|
}
|
|
else {
|
|
DataRegister.setRegister(file, result);
|
|
}
|
|
DataRegister.determineZeroFlag(result);
|
|
}
|
|
|
|
public static void ANDWF(int file, int destination) {
|
|
int result = wRegister & DataRegister.getRegister(file);
|
|
if (destination == 0){
|
|
wRegister = result & 0xFF;
|
|
}
|
|
else {
|
|
DataRegister.setRegister(file, result & 0xFF);
|
|
}
|
|
DataRegister.determineZeroFlag(result);
|
|
DataRegister.determineCarryFlag(result);
|
|
DataRegister.determineDigitCarryFlag(result);
|
|
}
|
|
|
|
public static void ADDWF(int file, int destination) {
|
|
int result = wRegister + DataRegister.getRegister(file);
|
|
if (wRegister == 0 || DataRegister.getRegister(file) == 0){
|
|
DataRegister.setCarryFlag(0);
|
|
DataRegister.setDigitCarryFlag(0);
|
|
}
|
|
else {
|
|
DataRegister.determineCarryFlag(result);
|
|
DataRegister.determineDigitCarryFlag(result);
|
|
}
|
|
if (destination == 0) {
|
|
wRegister = result & 0xFF;
|
|
}
|
|
else {
|
|
DataRegister.setRegister(file, result & 0xFF);
|
|
}
|
|
DataRegister.determineZeroFlag(result);
|
|
}
|
|
|
|
public static void SUBLW(int literal) {
|
|
int result = literal - wRegister;
|
|
if (wRegister == 0 || result >= 0){
|
|
DataRegister.setCarryFlag(1);
|
|
DataRegister.setDigitCarryFlag(1);
|
|
}
|
|
else {
|
|
|
|
DataRegister.setCarryFlag(0);
|
|
DataRegister.setDigitCarryFlag(0);
|
|
}
|
|
wRegister = result & 0xFF;
|
|
DataRegister.determineZeroFlag(result);
|
|
}
|
|
|
|
public static void ADDLW(int literal) {
|
|
int result = wRegister + literal;
|
|
wRegister = result & 0xFF;
|
|
DataRegister.determineZeroFlag(result);
|
|
DataRegister.determineCarryFlag(result);
|
|
DataRegister.determineDigitCarryFlag(result);
|
|
}
|
|
|
|
public static void RETLW(int literal) {
|
|
wRegister = literal;
|
|
//TODO: PC vom Stack holen und laden
|
|
}
|
|
|
|
public static void MOVLW(int literal) {
|
|
wRegister = literal;
|
|
}
|
|
|
|
public static void BTFSC(int address, int bit) {
|
|
if (DataRegister.getBit(address, bit) == 0){
|
|
DataRegister.increasePC();
|
|
}
|
|
}
|
|
|
|
public static void BTFSS(int address, int bit) {
|
|
if (DataRegister.getBit(address, bit) == 1){
|
|
DataRegister.increasePC();
|
|
}
|
|
}
|
|
}
|