356 lines
10 KiB
Java
356 lines
10 KiB
Java
package fabrik.simulator.pic16f84;
|
|
|
|
import fabrik.simulator.pic16f84.interfaces.DataRegisterInterface;
|
|
import fabrik.simulator.pic16f84.interfaces.EEPROMInterface;
|
|
import fabrik.simulator.pic16f84.interfaces.IOPortInterface;
|
|
|
|
import java.util.Arrays;
|
|
|
|
public class DataRegister extends PICComponent implements DataRegisterInterface {
|
|
private final int INDF = 0x0;
|
|
private final int PCL = 0x2;
|
|
private final int STATUS = 0x3;
|
|
private final int FSR = 0x4;
|
|
private final int PORTA = 0x5;
|
|
private final int PORTB = 0x6;
|
|
private final int PCLATH = 0xA;
|
|
private final int INTCON = 0xB;
|
|
|
|
private final int EEDATA = 0x08;
|
|
private final int EEADR = 0x09;
|
|
private final int EECON1 = 0x88;
|
|
private final int EECON2 = 0x89;
|
|
|
|
private final int TRISA = 0x85;
|
|
private final int TRISB = 0x86;
|
|
|
|
private final int C = 0x0;
|
|
private final int DC = 0x1;
|
|
private final int Z = 0x2;
|
|
private final int RP0 = 0x5;
|
|
|
|
|
|
private final int [] dataRegister = new int[0xFF];
|
|
private final int [] syncedRegisters = {INDF, PCL, STATUS, FSR, PCLATH, INTCON};
|
|
private final int [] eepromRegisters = {EEDATA, EEADR, EECON1, EECON2};
|
|
public final int [] ioRegisters = {PORTA, PORTB, TRISA, TRISB};
|
|
|
|
|
|
public DataRegister () {
|
|
super();
|
|
}
|
|
|
|
@Override
|
|
public void initialize(PICComponents picComponents) {
|
|
super.initialize(picComponents);
|
|
System.out.println("DataRegister.\n");
|
|
initOrReset();
|
|
}
|
|
|
|
private void initOrReset () {
|
|
dataRegister[PCL] = 0b0;
|
|
dataRegister[STATUS] = 0b00011000;
|
|
dataRegister[PCLATH] = 0b0;
|
|
dataRegister[INTCON] = 0b0;
|
|
dataRegister[0x81] = 0b11111111;
|
|
dataRegister[0x80 + PCL] = dataRegister[PCL];
|
|
dataRegister[0x80 + STATUS] = dataRegister[STATUS];
|
|
dataRegister[TRISA] = 0b11111111;
|
|
dataRegister[TRISB] = 0b11111111;
|
|
dataRegister[0x80 + PCLATH] = dataRegister[PCLATH];
|
|
dataRegister[0x80 + INTCON] = dataRegister[INTCON];
|
|
carryFlag = 0;
|
|
zeroFlag = 0;
|
|
digitCarryFlag = 0;
|
|
super.ioPorts.resetTRIS();
|
|
System.out.println(Arrays.toString(dataRegister));
|
|
}
|
|
|
|
public void initDataRegister() {
|
|
initOrReset();
|
|
}
|
|
|
|
private boolean isSyncedRegister (int address){
|
|
for (int register : syncedRegisters){
|
|
if (address == register || address == 0x80 + register){
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public int[] getDataRegister() {
|
|
return dataRegister;
|
|
}
|
|
|
|
private int determineIndirectAndChange (int address){
|
|
if (address == INDF || address == 0x80 + INDF) {
|
|
return dataRegister[FSR];
|
|
}
|
|
else
|
|
return address;
|
|
}
|
|
|
|
public int getFSR (){
|
|
return dataRegister[FSR];
|
|
}
|
|
|
|
private int bank() {
|
|
return ((dataRegister[STATUS] >> RP0) & 1) * 0x80;
|
|
}
|
|
|
|
public int getRegister(int fileAddress){
|
|
int address = determineIndirectAndChange (fileAddress);
|
|
if (bank () + address == EECON2)
|
|
return 0;
|
|
return dataRegister[bank() + address];
|
|
}
|
|
|
|
public void setRegister(int fileAddress, int content){
|
|
int address = determineIndirectAndChange (fileAddress);
|
|
if (Arrays.stream(ioRegisters).anyMatch(i -> i == address)){
|
|
ioPorts.setRegister(bank() + address, content);
|
|
return;
|
|
}
|
|
if (Arrays.stream(eepromRegisters).anyMatch(i -> i == address)){
|
|
eeprom.parse(bank() + address, content, 0b11);
|
|
return;
|
|
}
|
|
if (fileAddress == PCL || fileAddress == 0x80 + PCL){
|
|
programCounter = content + (dataRegister[PCLATH] << 8);
|
|
}
|
|
if (!isSyncedRegister(address))
|
|
dataRegister[bank() + address] = content;
|
|
else {
|
|
dataRegister[address] = content;
|
|
dataRegister[0x80 + address] = content;
|
|
if (address == STATUS){
|
|
setFlags();
|
|
}
|
|
}
|
|
if (address == 1)
|
|
preScaler.resetFromRegister();
|
|
}
|
|
|
|
public int getBit(int fileAddress, int bit) {
|
|
int address = determineIndirectAndChange (fileAddress);
|
|
if (bank() + address == EECON2)
|
|
return 0;
|
|
return (dataRegister[bank() + address] >> bit) & 1;
|
|
}
|
|
|
|
public int getDirectBit(int address, int bit){
|
|
return (dataRegister[address] >> bit) & 1;
|
|
}
|
|
|
|
public void clearBit(int fileAddress, int bit) {
|
|
int address = determineIndirectAndChange (fileAddress);
|
|
if (Arrays.stream(ioRegisters).anyMatch(i -> i == address)){
|
|
ioPorts.clearBit(bank() + address, bit);
|
|
return;
|
|
}
|
|
if (Arrays.stream(eepromRegisters).anyMatch(i -> i == address)){
|
|
eeprom.parse(bank () + address, bit, 0b00);
|
|
return;
|
|
}
|
|
if (!isSyncedRegister(address)) {
|
|
if (getBit(address, bit) == 1) {
|
|
dataRegister[bank() + address] -= (int) Math.pow(2, bit);
|
|
}
|
|
}
|
|
else {
|
|
if (getBit(address, bit) == 1) {
|
|
dataRegister[address] -= (int) Math.pow(2, bit);
|
|
dataRegister[0x80 + address] = dataRegister[address];
|
|
if (address == STATUS){
|
|
setFlags();
|
|
}
|
|
}
|
|
}
|
|
if (address == 1)
|
|
preScaler.resetFromRegister();
|
|
}
|
|
|
|
public void setBit(int fileAddress, int bit) {
|
|
int address = determineIndirectAndChange (fileAddress);
|
|
if (Arrays.stream(ioRegisters).anyMatch(i -> i == address)){
|
|
ioPorts.setBit(bank() + address, bit);
|
|
return;
|
|
}
|
|
if (Arrays.stream(eepromRegisters).anyMatch(i -> i == address)){
|
|
eeprom.parse(bank () + address, bit, 0b10);
|
|
return;
|
|
}
|
|
if (!isSyncedRegister(address)) {
|
|
if (getBit(address, bit) == 0) {
|
|
dataRegister[bank() + address] += (int) Math.pow(2, bit);
|
|
}
|
|
}
|
|
else {
|
|
if (getBit(address, bit) == 0) {
|
|
dataRegister[address] += (int) Math.pow(2, bit);
|
|
dataRegister[0x80 + address] = dataRegister[address];
|
|
if (address == STATUS){
|
|
setFlags();
|
|
}
|
|
}
|
|
}
|
|
if (address == 1)
|
|
preScaler.resetFromRegister();
|
|
}
|
|
|
|
public void setDirectBit (int fileAddress, int bit, int value){
|
|
if (getDirectBit(fileAddress, bit) == 0 && value == 1){
|
|
dataRegister[fileAddress] += (int) Math.pow(2, bit);
|
|
} else if (getDirectBit(fileAddress, bit) == 1 && value == 0){
|
|
dataRegister[fileAddress] -= (int) Math.pow(2, bit);
|
|
}
|
|
}
|
|
|
|
private int programCounter = 0;
|
|
|
|
private void writeToPCL(){
|
|
dataRegister[PCL] = programCounter & 0xFF;
|
|
dataRegister[0x80 + PCL] = dataRegister[PCL];
|
|
}
|
|
|
|
public void increasePC (){
|
|
if (programCounter != 0x3FF) {
|
|
programCounter++;
|
|
}
|
|
else {
|
|
programCounter = 0;
|
|
}
|
|
writeToPCL();
|
|
}
|
|
|
|
public void setPC (int value){
|
|
programCounter = value + ((getRegister(PCLATH) & 0b11000) << 8);
|
|
writeToPCL();
|
|
}
|
|
|
|
public void resetPC () {
|
|
programCounter = 0;
|
|
}
|
|
|
|
public int getPC(){
|
|
return programCounter;
|
|
}
|
|
|
|
private void setFlags() {
|
|
carryFlag = getDirectBit(STATUS, C);
|
|
digitCarryFlag = getDirectBit(STATUS, DC);
|
|
zeroFlag = getDirectBit(STATUS, Z);
|
|
}
|
|
|
|
private int zeroFlag = 0;
|
|
|
|
public void determineZeroFlag(int result){
|
|
if (result == 0){
|
|
zeroFlag = 1;
|
|
if (getBit(STATUS, Z) == 0){
|
|
dataRegister[STATUS] += 0b100;
|
|
dataRegister[0x80 + STATUS] = dataRegister[STATUS];
|
|
}
|
|
}
|
|
else {
|
|
zeroFlag = 0;
|
|
if (getBit(STATUS, Z) == 1){
|
|
dataRegister[STATUS] -= 0b100;
|
|
dataRegister[0x80 + STATUS] = dataRegister[STATUS];
|
|
}
|
|
}
|
|
}
|
|
|
|
public int getZeroFlag(){
|
|
return zeroFlag;
|
|
}
|
|
|
|
private int carryFlag = 0;
|
|
|
|
public void setCarryFlag(int value){
|
|
carryFlag = value;
|
|
if (value == 1){
|
|
if (getBit(STATUS, C) == 0){
|
|
dataRegister[STATUS] += 0b1;
|
|
dataRegister[0x80 + STATUS] = dataRegister[STATUS];
|
|
}
|
|
}
|
|
else {
|
|
if (getBit(STATUS, C) == 1){
|
|
dataRegister[STATUS] -= 0b1;
|
|
dataRegister[0x80 + STATUS] = dataRegister[STATUS];
|
|
}
|
|
}
|
|
}
|
|
|
|
public void determineCarryFlag (int result){
|
|
if (result > 0xFF){
|
|
setCarryFlag(1);
|
|
}
|
|
else {
|
|
setCarryFlag(0);
|
|
}
|
|
}
|
|
|
|
public int getCarryFlag (){
|
|
return carryFlag;
|
|
}
|
|
|
|
private int digitCarryFlag = 0;
|
|
|
|
public void setDigitCarryFlag(int value){
|
|
digitCarryFlag = value;
|
|
if (value == 1){
|
|
if (getBit(STATUS, DC) == 0){
|
|
dataRegister[STATUS] += 0b10;
|
|
dataRegister[0x80 + STATUS] = dataRegister[STATUS];
|
|
}
|
|
}
|
|
else {
|
|
if (getBit(STATUS, DC) == 1){
|
|
dataRegister[STATUS] -= 0b10;
|
|
dataRegister[0x80 + STATUS] = dataRegister[STATUS];
|
|
}
|
|
}
|
|
}
|
|
|
|
public void determineDigitCarryFlag(int result){
|
|
if (result >> 4 == 1){
|
|
setDigitCarryFlag(1);
|
|
}
|
|
else {
|
|
setDigitCarryFlag(0);
|
|
}
|
|
}
|
|
|
|
public int getDigitCarryFlag(){
|
|
return digitCarryFlag;
|
|
}
|
|
|
|
public void setDirectRegister(int fileAddress, int content) {
|
|
dataRegister[fileAddress] = content;
|
|
}
|
|
|
|
|
|
public int getPCL() {
|
|
return PCL;
|
|
}
|
|
public int getSTATUS() {
|
|
return STATUS;
|
|
}
|
|
|
|
public int getPCLATH() {
|
|
return PCLATH;
|
|
}
|
|
public int getINTCON() {
|
|
return INTCON;
|
|
}
|
|
|
|
public int getDirectRegister(int address) {
|
|
return dataRegister[address];
|
|
}
|
|
}
|
|
|
|
|