API tools faq
paste
prjbrook

CDP1802e7.ino cosmacuino now has disassembler but too big

prjbrook
Apr 25th, 2020
179
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 37.91 KB | None | 0 0
raw download clone embed print report
  1. /**e7 2
  2. Fri Apr 24 13:13:07 NZST 2020. Now want to time instructions per second using millis, run and stop (single stepping = stop)
  3. Fri Apr 24 11:12:12 NZST 2020. Still tidying up printLevel3.Done
  4. Thu Apr 23 11:39:37 NZST 2020. Working on disassembler's output. Thinking of 4 levels: Lev0 = print_nothing to Lev3 print_heaps_diagnostics
  5. ..NB space: "Global variables use 2902 bytes (35%) of dynamic memory, leaving 5290 bytes for local variables. Maximum is 8192 bytes."
  6. ..Too much RAM for nano. Might have to use progmem etc.
  7. Tue Apr 21 20:12:55 NZST 2020. Disassember going. Some problems with many switch statements so changed to if,if,if,.
  8. Needs to be tidied up and slimmed down.Starting now in ...e4.
  9. Sun Apr 19 11:02:16 NZST 2020. Extending disassem. but ram memory too high for nano.
  10. Sat Apr 18 12:50:37 NZST 2020. Cosmacuino version 0.2 Now starting on disassembler.
  11. Fri Apr 17 16:53:23 NZST 2020. ..e1 works well. Final step would be a disassembler but need to think about space on nano.
  12. ..all below has been on mega.
  13. Fri Apr 17 12:43:54 NZST 2020.C:\Users\Dell\Documents\Arduino\PB_SketchApril12\CDP1802e0\CDP1802e0.ino. Trying report of all useful vars.
  14. Fri Apr 17 11:41:53 NZST 2020. Going to look at DElay changes and report.
  15. Thu Apr 16 14:26:37 NZST 2020. Sorted, I think, break points, opcode stopping with seial commands. Next:speed changes.
  16. Thu Apr 16 12:25:37 NZST 2020. Working well. Now get break points going in real time...
  17. Tue Apr 14 19:59:13 NZST 202. All code tidied up. Old routines deleted. Next: single stepping.
  18. Tue Apr 14 15:35:00 NZST 2020. Going OK. Just deleting a whole lot of rubbish and carefully retesting.
  19. Tue Apr 14 13:02:36 NZST 2020. Tidy up time, and simplify main loop into easy subroutines.
  20. Mon Apr 13 14:50:01 NZST 2020. version 1802d2.ino now working well. Norway routines have been replaced.
  21. ...by bulletproof ones. Want to make better output each line of code.
  22. ..To form like 0123: F8 F,R,cycles, clocks
  23. Mon Apr 13 13:24:55 NZST 2020. Getting rid of Norwat commands and integrating checkForCommands()
  24. * Sun Apr 12 15:40:21 NZST 2020. Got better serial command routines from bulletProofSerialI. Integrate them.
  25. * Mon Mar 30 15:05:50 NZDT 2020 ..c8. Got long branches, lbr, into page three going OK.
  26. * .. also got sep to work in same way. Jumped in and out of code by changing prog ctr with sep.
  27. * .. next. Try that SCART method of using subroutines on 1802
  28. * Sun Mar 29 14:26:46 NZDT 2020 ..c7. Have big 1024 vRam[] buffer but can't use it yet.
  29. * ..Need TPA time to record Hi adr byte.
  30. * Sorted vRAM[] up to 1024 bytes and got new comand dumpVariableVer(int) to give 256 0r 1024 dumps.
  31. * Sun Mar 29 13:49:17 NZDT 2020 ..c6. Now want to exgtend vRAM[] frolm 256 to 1024 bytes. Fake memory.
  32. * Sat Mar 28 16:23:44 NZDT 2020. This is ...c5. Now going to try fastest baudrate 115200 and fastest DELAY =1.
  33. * All worked. Fast enough for time being. Next increase vRAM[] to 1024 bytes and check Hi address byte on
  34. * ..TPA.
  35. * Sat Mar 28 16:23:44 NZDT 2020 still...c4. Got baudrate up to 57600 and DELAY down to 2. Allworking.
  36. * Sat Mar 28 14:13:16 NZDT 2020 CDP1802c4. Going to try DELAY=4, and baudrate is 38.4K. Works OK but
  37. * ..is too fast in terminal so only print every 10th TPB going-high count. (clocks/8)
  38. * Sat Mar 28 13:37:04 NZDT 2020 CDP1802c3. Going to increase speed all round. First DELAY to 16. Baud to 19.2K Both OK
  39. * Now going to try DELAY =8 and baud = 28.8K. Both worked.
  40. * Sat Mar 28 13:14:18 NZDT 2020 CDP1802c2. Need to speed up a bit. Reg dumping works but is slow.
  41. * so going to change DELAY from 50 to 32 then keep halving. Worked OK also shortened message to terminal.
  42. * Also increased serial speed to 14.4K. Working OK. Next continue speed of clock and baudrate.
  43. * The version below is about right for reading programs into mega to act like ROM for 1802.
  44. * Only hesitation is the norway commands where serial strings seem a bit error prone.
  45. *
  46. * Thu Mar 26 14:09:30 NZDT 2020 CDP1802c1. Some problems with Norway commands as serial chars still available from prevuious actions.
  47. * ..Solution might be to flush Rx buffer after each command.
  48. * Wed Mar 25 16:40:32 NZDT 2020 CDP1802c0. Now going to add in serial read into vRAM[] from bin file generated
  49. * ..by a18 assembler. Uses Bray++ terminal to send file. Norway command is "gf" for getfile. Has to be 256 bytes.
  50. * Wed Mar 25 16:01:41 NZDT 2020 CDP1802b9. All working except for TPA signal and MWR* pin turning on writeStrobe but being tirned off by TPA.
  51. * * Tue Mar 24 13:09:41 NZDT 2020. All below works. Just a bit worried writeStrobe might turn on after being..
  52. * ..dealt with during TPB. Might get TPA to turn off writeStrobe so any subsequent LOWs of MWR* before TPB time are valid only
  53. * Tue Mar 24 10:20:46 NZDT 2020 CDP18028.Playing with MWR*
  54. * CDP1802b7 works. See 1802 blog. Next version: look at MWR.
  55. * CDP1802b6 21/3/203:47 Issues woth serial.available slowing down reads of 1802 data. Trying new Norwegian code.
  56. * 3:57, works witrh dummy commands.
  57. * . Start of array use for instructions
  58. Had big problems with first TPB cycle. Seemed to get old address outp[ut on address bus low when
  59. ..it should have been zero after reset. Round about the 4th clock after reset, adress goes to old value before reset.
  60. ..Settles down into next cycles with consistent addresses 1,2,3,4. But adr=0 remains a problem. The read line doesn't seem to be
  61. ..activated on first cycle so maybe just nop in zero position and move on?
  62. ..Next, connect up BUS pins to C port on mega. Initially just output nops, then when needed by instruction fetch, then chnage
  63. .. to little program that plays with Q and does loop involving nops too. This program has too many diagnostic entries so will tidy up
  64. .. before trying next version.
  65. Tidied up and working with resistors connecting data bus to $C4 pattern = nop.
  66. Now going to send constant $C4 via PORTC of Mega2650 to breadboard containing 1802. PORTC-->BUS 1802 all the time. Should be the
  67. ..same as resistor to rail $C4 above. Worked 10:07
  68. Now try sending $c4 only when clk goes low and TPB is high.Worked 10:19.
  69. Now try sending nop from mega to 1802 bus only when 1) clock goes low,2) TPB is high and 3) read is low. Worked 10:24
  70. Now going to select nop from an array of nops. Worked with just one element of arry of instructions called vRAM[]. Do several next.
  71. Key change was [ byte vRAM[5] = {0xc4, 0xc4, 0xc4, 0xc4, 0x00}; ] Next add instructions to turn on and off Q flag.
  72. Now going to put in little sequence of instructions. Key change is: [ byte vRAM[5] = {0xc4, 0x7b, 0xc4, 0x7a, 0x00};
  73. //ie nop,seq,nop,req,idl ] Worked and got Q flag going on and off with this; [byte vRAM[5] = {0x7b, 0x7b, 0x7a, 0x7b, 0x00}; ]
  74. Now gpoing to turn Q on and off but with branch back to start. Worked OK.
  75. 11:27am 20/3/20. Adding in dump of vertual ram array as well as issuing commands from serial terminal.
  76. ..Practiced some of the routines in dumper3.
  77. Going well, apart from serial read issues, but basic 1820 stuff going well. Try new serial read instruction code.
  78. */
  79.  
  80. //1802 talks to Arduino Mega
  81. #define clockPin 13
  82. #define clearPin 12
  83. #define intPin 11
  84. #define TPBpin A1
  85. #define TPApin A0
  86. #define readPin A15 //the *MRD of 1802
  87. #define writePin A14 //the MWR* of 1802
  88. #define SC0pin A12 //When SC0=LOW it's a fetch, when HI it's executing
  89. #define TPBDivisor 1 //50 //1 // 100 //50 //10 //if ten, shows every tenth output line, otherwise too fast to see and act in terminal.
  90. //#define DELAY 50 //16 //1 // 2 //4 //8 //16 //32 //50
  91. byte DELAY=30; //default. Can be changes via terminal command.
  92.  
  93. int val = 0; int bufBytes;
  94. unsigned int adrByte=0;
  95. unsigned int adrByteHi =0;
  96. unsigned int currentAdr;
  97. unsigned long time =0;
  98. boolean writeStrobe = false; //should really get TBA to turn this off too; Just in case.
  99. const byte numChars = 32;
  100. char receivedChars[numChars];
  101. byte receivedBytes[numChars];
  102. //char data[32] ;
  103. //char data[32] ;
  104. char data[200];
  105. unsigned int breakPointAdr=0,opCode,stopCode;
  106. unsigned long fetchCtr=0;
  107. unsigned long t0,clkCtr=0,TPBCtr= 0, clockRate=0,t1=0; //used in millis timing.
  108. char fetchOrExecuteCh;
  109. char readOrWriteCh;
  110. char * blankStr ="";
  111. int printLevel=1; //how much detail do you want in serial output for disassembler
  112. char instructionBytes = 1; //some instructions have 1 eg c4 = nop, some have 3 eg lsk 12 34
  113. //byte opCode;
  114. boolean newData = false;
  115. boolean showExecutes = true;
  116. boolean TPADone = false, TPBDone=true;
  117. boolean singleStepping = false, stepMe=false;
  118. boolean showCommands=true;
  119. boolean doOpStops = false; //breakpoint if opCode=stopCode;
  120.  
  121.  
  122. //byte vRAM[5] = {0x7b, 0x7b, 0x7a, 0x7b, 0x00}; //ie nop,seq,nop,req,idl
  123. //byte vRAM[256] = {0x7b, 0x7a, 0x7b, 0x7a, 0x30, 0x00,0x00}; //ie seq,seq,req,seq,br start, idl
  124. //byte vRAM[256] = {0x7b, 0x7a, 0x7b, 0xf8,0x00,0xb7,0xf8,0x98,0xa7,0xf8,0x6A,0x57, 0x30, 0x09,0x00};
  125. byte vRAM[1024] = {0x7b, 0x7a, 0x7b, 0xf8,0x00,0xb7,0xf8,0x98,0xa7,0xf8,0x7D,0x57,0xc4, 0x30, 0x09,0x00};
  126. //byte vRAM[512] = {0x7b, 0x7a, 0x7b, 0xf8,0x00,0xb7,0xf8,0x98,0xa7,0xf8,0x7D,0x57,0xc4, 0x30, 0x09,0x00}; //memory short on nano
  127. void setup() {
  128.  
  129. pinMode(clockPin, OUTPUT);
  130. pinMode(clearPin, OUTPUT);
  131. pinMode(intPin,OUTPUT);
  132. pinMode(TPApin,INPUT);
  133. pinMode(TPBpin,INPUT);
  134. pinMode(readPin,INPUT);
  135. pinMode(writePin,INPUT);
  136. pinMode(SC0pin,INPUT);
  137. DDRA=0x00; //DDRA reads Adress port of 1802. All inputs.
  138. DDRC=0x00; //PORTC connects to 1802 data BUS.
  139. Serial.begin(9600); //(115200); //(57600); //38400); //(28800); //(19200); //(14400); //(9600); // // open the serial port at 9600 bps:
  140. serialFlush();
  141. delay(1000); //time to sort out Bray++
  142. Serial.flush();
  143. Serial.println("Arduino talks to 1802. CDP1802c1. Pb 2020");
  144. delay(500);
  145. doReset();
  146. // dumpVariableVert(256);
  147. // doReport();
  148. //experiment0();
  149. //experiment1();
  150. //while(1) { };
  151. printLevel=1; //printlevel = 1 is default. Can be changed via terminal commands.
  152. //experiment1();
  153. //millisExperiment0();
  154. }
  155.  
  156. //--------------------------------------------------------------------------------------
  157. void loop() {
  158. checkForCommands(); //Still a bit clumsy with Serial lib.
  159. doClockCycle();
  160. }//*******************************************
  161.  
  162. void doClockCycle() {
  163. digitalWrite(clockPin, HIGH); // turn the LED on (HIGH is the voltage level)
  164. if(digitalRead(TPApin) ==HIGH) {
  165. doTPAStuff();
  166. }
  167. if (digitalRead(writePin)==LOW){
  168. doWriteStuff();
  169. }
  170. delay(DELAY); // wait. DELAY is a variable, can be 0
  171. digitalWrite(clockPin, LOW); // turn the LED off by making the voltage LOW
  172. DDRC=0x00; //DDRC usually input except when sending instruction
  173. clkCtr++; //how many clocks after reset?
  174.  
  175. if (digitalRead(TPBpin) ==HIGH) {
  176. doTPBWork();
  177. }
  178. delay(DELAY); // wait
  179. }
  180. //*************************************************
  181. void doTPBWork(void) {
  182. TPBCtr++;
  183. adrByte = PINA;
  184. if (writeStrobe== true) {
  185. writeStrobe = false;
  186. vRAM[adrByte+adrByteHi*256]=PINC; //adrByteHi comes from read of PORTC during TPA
  187. readOrWriteCh='W';
  188. }
  189. else {
  190. readOrWriteCh='R';
  191. }
  192.  
  193.  
  194. if(digitalRead(SC0pin)==LOW) {
  195. fetchOrExecuteCh='F';
  196. fetchCtr++;
  197. //print1TPBResults1();
  198. }
  199. else {
  200. fetchOrExecuteCh='E';
  201. }
  202.  
  203. if (digitalRead(readPin)==LOW) {
  204. DDRC = 0xff; //just for this version. Send nop when clockk goes 1 to 0, TPB =1, MRD=0
  205. currentAdr = adrByte+adrByteHi*256;
  206. PORTC = vRAM[adrByte+adrByteHi*256] ; // read byte from virtual
  207. opCode=vRAM[adrByte+adrByteHi*256];
  208. }
  209. TPBDone=true;
  210. //print1TPBResults1();
  211. //printTPBResults2();
  212. if(printLevel!=0) {
  213. printTPBResults3();
  214. }
  215. if((currentAdr==breakPointAdr) && (breakPointAdr>0)) {
  216. Serial.println("Breakpoint address .....");
  217. singleStepping=true;
  218. }
  219. if((doOpStops==true) && (opCode == stopCode)){
  220. Serial.println("Op code stop .....");
  221. singleStepping=true;
  222. }
  223. if(singleStepping==true){
  224. Serial.print("*");
  225. stepMe=false;
  226. while(stepMe==false){
  227. checkForCommands();
  228. }
  229. }
  230. }
  231. void doReset(void){
  232. digitalWrite(intPin,HIGH); //no interrupts yet
  233. digitalWrite(clearPin,LOW); //bring CLEAR low for about 10 clocks to reset 1802
  234. for(int i =0;i<=10;i++) {
  235. digitalWrite(clockPin, HIGH);
  236. delay(DELAY); // wait
  237. digitalWrite(clockPin, LOW);
  238. delay(DELAY);
  239. }// 10 clocks low should reset 1802
  240. digitalWrite(clearPin,HIGH); //bring back to RUN mode
  241. }
  242.  
  243. void serialFlush(void){
  244. while(Serial.available() > 0) { //while there are characters in the serial buffer, because
  245. char t = Serial.read(); // get one character
  246. }
  247. }
  248. void doWriteStuff(void) {
  249. // Serial.print("@W"); //usually happens twice in cycle when
  250. writeStrobe=true;
  251. }
  252. void doTPAStuff(void) {
  253. writeStrobe = false; //before new low-going *MWR causes writeStrobe to go true. Safe.
  254. adrByteHi = PINA; //will be used at TPB time later.
  255. TPADone=true;
  256. }
  257.  
  258. void getFile() { // go to File Send part of Bray++ terminal and put bin file into vRAM[]
  259. int inCtr=0;
  260. byte byteIn=65;
  261. while(inCtr<1024){
  262. if(Serial.available()){
  263. byteIn = Serial.read();
  264. vRAM[inCtr]=byteIn;
  265. inCtr++;
  266. }
  267. }
  268. Serial.print("Got 1024");
  269. }
  270.  
  271. void dumpVariableVert(int sizeToDump) { //new version of dumpVert(). Different sizes.
  272. //char data[100];
  273. Serial.print("Col: ");
  274. for(int i=0;i<16;i++) {
  275. sprintf(data, "%02x ",i);
  276. Serial.print(data);
  277. if(i==7) Serial.print(" ");
  278. }
  279. for (int i=0;i<sizeToDump;i++){
  280. if (i%16 == 0){
  281. Serial.println ("");
  282. sprintf(data, "%02x ",i);
  283. Serial.print(data);
  284. }
  285. if(i%8==0) { Serial.print("|"); }
  286. sprintf(data, " %02x ",vRAM[i]);
  287. Serial.print(data);
  288. }
  289. Serial.println(" ");
  290. }
  291. int hexCharToInt2(byte by){ //pb version
  292. int d,r;
  293. d=by-'0';
  294. if(d>=0 && d<=9) {r=d;}
  295. else{
  296. d=by-55; //is it A,B...F?
  297. if (d>=10 && d<=15) {r=d;}
  298. else{
  299. r=by-87; //must be a,b...f. NB No error checking.
  300. }
  301. }
  302. return r;
  303. }
  304.  
  305. void doBreakPoint2(){
  306. int d;
  307. int ctr=0;
  308. unsigned int hexVal[8];
  309. hexVal[2]=hexCharToInt2(receivedBytes[2])*4096;
  310. hexVal[3]=hexCharToInt2(receivedBytes[3])*256;
  311. hexVal[4]=hexCharToInt2(receivedBytes[4])*16;
  312. hexVal[5]=hexCharToInt2(receivedBytes[5])*1;
  313. breakPointAdr=hexVal[2]+hexVal[3]+hexVal[4]+hexVal[5]; //important
  314. Serial.print("Break point adress is : ");
  315. Serial.print(breakPointAdr);
  316. Serial.print(", in hex : 0x");
  317. Serial.println(breakPointAdr,HEX);
  318. }
  319. void doOpStop2(){
  320. // int d;
  321. unsigned int hexVal[8];
  322. hexVal[2]=hexCharToInt2(receivedBytes[2])*16;
  323. hexVal[3]=hexCharToInt2(receivedBytes[3])*1;
  324. stopCode=hexVal[2]+hexVal[3];
  325. Serial.print("Op stop is : ");
  326. Serial.print(stopCode);
  327. Serial.print(", in hex : 0x");
  328. Serial.println(stopCode,HEX);
  329. }
  330. void doDelay() {
  331. unsigned int hexVal[8];
  332. hexVal[2]=hexCharToInt2(receivedBytes[2])*16;
  333. hexVal[3]=hexCharToInt2(receivedBytes[3])*1;
  334. DELAY=hexVal[2]+hexVal[3];
  335. Serial.print("DELAY now is : ");
  336. Serial.print(DELAY);
  337. Serial.print(", in hex : 0x");
  338. Serial.println(DELAY,HEX);
  339. }
  340. void interpretCommand() {
  341. String Command(receivedChars); //**important
  342. if(Command.equals("gf")){
  343. Serial.print("Getting File");
  344. getFile();
  345. serialFlush();
  346. Serial.println("**done gf flush** Now resetting");
  347. doReset();
  348. }
  349.  
  350. if(Command.equals("dk")){
  351. dumpVariableVert(1024);
  352. serialFlush();
  353. Serial.println("**done dkflush**");
  354. }
  355. if(Command.equals("du")){
  356. dumpVariableVert(256);
  357. serialFlush();
  358. Serial.println("**done duflush**");
  359. }
  360. if(Command.equals("re")){
  361. doReset();
  362. TPBCtr=0; clkCtr = 0;
  363. serialFlush();
  364. Serial.println("**did reset flush**");
  365. }
  366.  
  367. if((receivedBytes[0]==0x62)&&(receivedBytes[1]==0x70)) doBreakPoint2(); //<bpxxxx>
  368. if((receivedBytes[0]==0x6f)&&(receivedBytes[1]==0x70)) doOpStop2(); //<opxx>
  369. if((receivedBytes[0]==0x64)&&(receivedBytes[1]==0x65)) doDelay(); //<dexx>.
  370.  
  371. if(Command.equals("singleStep")) {
  372.  
  373. singleStepping=true; t1=millis()-time; Serial.print("--> ");Serial.print(t1);
  374. clockRate = (clkCtr*1000)/t1; Serial.print("=&& "); Serial.print(clockRate);
  375. } //go into single stepping but stop clock; presume <run> just finished.
  376. if(Command.equals("stepMe")) stepMe=true;
  377. if (Command.equals("report")) doReport();
  378. if(Command.equals("toggleCommandShow")){
  379. if(showCommands==true) showCommands=false;
  380. else showCommands=true;
  381. }
  382. if(Command.equals("toggleShowExecutes")){
  383. if(showExecutes==true) showExecutes=false;
  384. else showExecutes=true;
  385. }
  386. if(Command.equals("toggleOpStopping")){
  387. if(doOpStops==true) doOpStops=false;
  388. else doOpStops=true;
  389. }
  390. if(Command.equals("run")){
  391.  
  392. singleStepping=false;
  393. stepMe=true;
  394. Serial.println("Sing step = false");
  395. clkCtr=0; TPBCtr=0; fetchCtr=0; //after "run" we're timing clks/sec
  396. time=millis();
  397. //Serial.print("<> "); Serial.print(time); //start timer. Stopped by going into single stepping.
  398.  
  399. }
  400. if(Command.equals("pl0")) printLevel=0;
  401. if(Command.equals("pl1")) printLevel=1;
  402. if(Command.equals("pl2")) printLevel=2;
  403. if(Command.equals("pl3")) printLevel=3;
  404.  
  405.  
  406. }
  407.  
  408. void checkForCommands(){ //if any inputs from keyboard, push them into buffer and see what command it is.
  409. recvWithStartEndMarkers();
  410. showAndInterpret();
  411. }
  412.  
  413. void recvWithStartEndMarkers() { ////https://forum.arduino.cc/index.php?topic=396450
  414. static boolean recvInProgress = false;
  415. static byte ndx = 0;
  416. char startMarker = '<';
  417. char endMarker = '>';
  418. char rc;
  419. while (Serial.available() > 0 && newData == false) {
  420. rc = Serial.read();
  421.  
  422. if (recvInProgress == true) {
  423. if (rc != endMarker) {
  424. receivedChars[ndx] = rc;
  425. receivedBytes[ndx]=(byte)rc; //PB added this
  426. ndx++;
  427. if (ndx >= numChars) {
  428. ndx = numChars - 1;
  429. }
  430. }
  431. else {
  432. receivedChars[ndx] = '\0'; // terminate the string
  433. recvInProgress = false;
  434. ndx = 0;
  435. newData = true;
  436. }
  437. }
  438.  
  439. else if (rc == startMarker) {
  440. recvInProgress = true;
  441. }
  442. }
  443. }
  444.  
  445. void showAndInterpret() {
  446. if (newData == true) {
  447. if(showCommands==true){
  448. Serial.print("Command received is : ");
  449. Serial.println(receivedChars);
  450. }
  451. else {serialFlush();} //get rid of commands in input buffer
  452. interpretCommand();
  453. newData = false;
  454. }
  455. }
  456. void print1TPBResults1(void) {//print disassembled opcode with address: optional
  457. sprintf(data,"Adr1] %02x%02x : ",adrByteHi,adrByte);
  458. Serial.print(data);
  459. doDisAsm(opCode); //new
  460. }
  461. void printTPBResults2() { //output adr and opcode and clockc et for each line...
  462. //showExecutes=true;
  463. ///temp!!!
  464. //doReport();
  465. if (fetchOrExecuteCh=='F') {
  466. // sprintf(data,"Adr: %02x%02x : %02x %u, %u %c %c",adrByteHi,adrByte,opCode, TPBCtr,clkCtr, fetchOrExecuteCh,readOrWriteCh);
  467.  
  468. sprintf(data,"Adr) %02x%02x : %02x ",adrByteHi,adrByte,opCode);
  469.  
  470. Serial.print(data);
  471. doDisAsm(opCode); //best place?
  472.  
  473.  
  474.  
  475.  
  476. }
  477. else{
  478. if(showExecutes){
  479. sprintf(data," Adr2: %x%x : %02x %lu<, %lu> %c %c",adrByteHi,adrByte,opCode,TPBCtr,clkCtr, fetchOrExecuteCh,readOrWriteCh);
  480. Serial.println(data);
  481.  
  482. }
  483. }
  484. }
  485. void doReport() { //show all useful variables.
  486. sprintf(data, "delay = %02x, op Stop code = %02x, breakpoint = %04x, current address = %04x, op code = %02x", DELAY,stopCode,breakPointAdr,currentAdr,opCode);
  487. Serial.println(data);
  488. sprintf(data, "TPBCtr = %lu, clkCtr= %lu, readOrWriteCh = %c, fetchOrExecuteCh = %c, showExecutes = %d, doOpStops=%d ", TPBCtr,clkCtr,readOrWriteCh,fetchOrExecuteCh,showExecutes, doOpStops);
  489. Serial.println(data);
  490. sprintf(data, "TPADone = %d, TPBDone= %d, singleStepping = %d, stepMe = %d, showCommands = %d, instuction fetches=%lu ", TPADone,TPBDone,singleStepping,stepMe,showCommands,fetchCtr);
  491. Serial.println(data);
  492. sprintf(data,"Print Level %d",printLevel);
  493. Serial.print(data);
  494. }
  495. void doDisAsm(byte bopCode) { //look at op code and disassemble insgtruction. May require reading further bytes
  496. byte LSNib, MSNib;
  497. MSNib = bopCode/16;
  498. LSNib = bopCode%16;
  499. //sprintf(data,"Op code is %x and MSNib is %x and LSNib is %x", bopCode, MSNib, LSNib); //take out later
  500. //Serial.println(data);
  501. instructionBytes = 1; //default for eg nop, phi, inc. Can be changed at relevant instruction subroutine
  502. switch(MSNib) {
  503. case 0:
  504. if(LSNib==0) sprintf(data,"idl %s",blankStr);
  505. else sprintf(data,"ldn %x",LSNib); break;
  506. case 1:
  507. sprintf(data,"inc %x",LSNib);
  508. break;
  509. case 2:
  510. sprintf(data,"dec %x",LSNib);
  511. break;
  512. case 3:
  513. //sprintf(data,"Tricky branches");
  514. instructionBytes=2;
  515. doHiNib3(LSNib);
  516. break;
  517. case 4:
  518. sprintf(data,"lda %x",LSNib);
  519. break;
  520. case 5:
  521. sprintf(data,"str %x",LSNib);
  522. break;
  523. case 6:
  524. //sprintf(data,"Tricky I/O");
  525. //sprintf(data,"Case 6");
  526. //instructionBytes = 2;
  527. doHiNib6(LSNib);
  528. break;
  529. case 7:
  530. //sprintf(data,"Tricky Hi nib 7");
  531. //doHiNib7(LSNib);
  532. //doHiNib7A(LSNib);
  533. doHiNib7B(LSNib);
  534. break;
  535. case 8:
  536. sprintf(data,"glo %x",LSNib);
  537. break;
  538. case 9:
  539. sprintf(data,"ghi %x",LSNib);
  540. break;
  541. case 0xa:
  542. sprintf(data,"plo %x",LSNib);
  543. break;
  544. case 0xb:
  545. sprintf(data,"phi %x",LSNib);
  546. break;
  547. case 0xc:
  548. instructionBytes=3;
  549. doHiNibcB(LSNib); //long branches and skips :0xc..
  550. break;
  551. case 0xd:
  552. sprintf(data,"sep %x",LSNib);
  553. break;
  554. case 0xe:
  555. sprintf(data,"sex %x",LSNib);
  556. break;
  557. case 0xf:
  558. doHiNibfA(LSNib); //arith logic etc
  559. break;
  560. default:
  561. sprintf(data," not disassenble %x %x",MSNib,LSNib); break; //took "could" out
  562. }
  563. //showData();
  564. Serial.print(data);
  565. //Serial.print("-");
  566. //Serial.print(bopCode,HEX); //output disassembled bopCode,no..maybe only at certain levels
  567. //Serial.println(bopCode,HEX);
  568. //serialFlush();
  569. }
  570. void experiment0() {
  571. doDisAsm(0x00);
  572. doDisAsm(0x05);
  573. doDisAsm(0x15);
  574. doDisAsm(0x25);
  575. doDisAsm(0x30);
  576. doDisAsm(0x31);
  577. //doDisAsm(0x31);
  578. doDisAsm(0x32);
  579. doDisAsm(0x33);
  580. doDisAsm(0x34);
  581. //doDisAsm(0x35);
  582. doDisAsm(0x35);
  583. doDisAsm(0x36);
  584. doDisAsm(0x37);
  585. //doDisAsm(0x38);
  586. doDisAsm(0x38);
  587. doDisAsm(0x39);
  588. doDisAsm(0x3a);
  589. doDisAsm(0x3b);
  590. doDisAsm(0x3c);
  591. doDisAsm(0x3d);
  592. doDisAsm(0x3e);
  593. doDisAsm(0x3f);
  594. doDisAsm(0x45);
  595. doDisAsm(0x55);
  596. //doDisAsm(0x60);
  597. doDisAsm(0x60);
  598. doDisAsm(0x61);
  599. doDisAsm(0x68);
  600. doDisAsm(0x69);
  601. doDisAsm(0x6d);
  602. doDisAsm(0x6d);
  603. //doDisAsm(0x70);
  604. doDisAsm(0x3f);
  605. doDisAsm(0x38);
  606. doDisAsm(0x3f);
  607. doDisAsm(0x3f);
  608. doDisAsm(0x60);//
  609. doDisAsm(0x61);
  610. doDisAsm(0x68);
  611. doDisAsm(0x69);
  612. doDisAsm(0x6d);
  613. doDisAsm(0x6d);
  614. doDisAsm(0x60);
  615. doDisAsm(0x60);//------------
  616. doDisAsm(0x6d);
  617. doDisAsm(0x6d);
  618. doDisAsm(0x60);
  619. doDisAsm(0x60);//==========2==
  620. doDisAsm(0x30);
  621. doDisAsm(0x70);//==3==
  622. doDisAsm(0x71);
  623. doDisAsm(0x72);
  624. doDisAsm(0x73);
  625. doDisAsm(0x74);
  626. doDisAsm(0x75);
  627. doDisAsm(0x76);
  628. doDisAsm(0x77);
  629. doDisAsm(0x78);
  630. doDisAsm(0x79);
  631. doDisAsm(0x7a);
  632. doDisAsm(0x7b);
  633. doDisAsm(0x7c);
  634. doDisAsm(0x7d);
  635. doDisAsm(0x7e);
  636. doDisAsm(0x7f);
  637. doDisAsm(0xc0);
  638. doDisAsm(0xc1);
  639. doDisAsm(0xc2);
  640. doDisAsm(0xc3);
  641. doDisAsm(0xc4);
  642. doDisAsm(0xc5);
  643. doDisAsm(0xc6);
  644. doDisAsm(0xc7);
  645. doDisAsm(0xc8);
  646. doDisAsm(0xc9);
  647. doDisAsm(0xca);
  648. doDisAsm(0xcb);
  649. doDisAsm(0xcc);
  650. doDisAsm(0xcd);
  651. doDisAsm(0xce);
  652. doDisAsm(0xcf);
  653. doDisAsm(0xf0);
  654. doDisAsm(0xf1);
  655. doDisAsm(0xf2);
  656. doDisAsm(0xf3);
  657. doDisAsm(0xf4);
  658. doDisAsm(0xf5);
  659. doDisAsm(0xf6);
  660. doDisAsm(0xf7);
  661. doDisAsm(0xf8);
  662. doDisAsm(0xf9);
  663. doDisAsm(0xfa);
  664. doDisAsm(0xfb);
  665. doDisAsm(0xfc);
  666. doDisAsm(0xfd);
  667. doDisAsm(0xfe);
  668. doDisAsm(0xff);
  669.  
  670.  
  671.  
  672.  
  673.  
  674. //doDisAsm(0x71);
  675. /*doDisAsm(0x72);
  676. doDisAsm(0x73);
  677. doDisAsm(0x74);
  678. doDisAsm(0x76);
  679. doDisAsm(0x77);
  680. doDisAsm(0x85);
  681. doDisAsm(0x95);
  682. doDisAsm(0xa5);
  683. doDisAsm(0xb5);
  684. doDisAsm(0xc5);
  685. doDisAsm(0xd5);
  686. doDisAsm(0xe5);
  687. doDisAsm(0xf5);*/
  688. }
  689. void doHiNib3(byte secondByte) {
  690. //sprintf(data,"Doing it in subroutine..,,,,Tricky Hi nib 3. Tricky branches");
  691. byte nextByte = vRAM[currentAdr+1]; //eg br 40 will have codes 30 40 and 40 is "nextByte"
  692. //instructionBytes=2;
  693. switch(secondByte) {
  694. case 0:
  695. sprintf(data,"br %02x",nextByte); break;
  696.  
  697. case 1:
  698. sprintf(data,"bq %0x",nextByte); break; //!!todo: fix %x to %0x
  699. case 2:
  700. sprintf(data,"bz %x",nextByte); break;
  701. case 3:
  702. sprintf(data,"bdf %x",nextByte); break;
  703. case 4:
  704. sprintf(data,"b1 %x",nextByte); break;
  705. case 5:
  706. sprintf(data,"b2 %x",nextByte); break;
  707. case 6:
  708. sprintf(data,"b3 %x",nextByte); break;
  709. case 7:
  710. sprintf(data,"b4 %x",nextByte); break;
  711. case 8:
  712. sprintf(data,"skp %x",nextByte); break;
  713. case 9:
  714. sprintf(data,"bnq %x",nextByte); break;
  715. case 0xa:
  716. sprintf(data,"bnz %x",nextByte); break;
  717. case 0xb:
  718. sprintf(data,"bnf %x",nextByte); break;
  719. case 0xc:
  720. sprintf(data,"bn1 %x",nextByte); break;
  721. case 0xd:
  722. sprintf(data,"bn2 %x",nextByte); break;
  723. case 0xe:
  724. sprintf(data,"bn3 %x",nextByte); break;
  725. case 0xf:
  726. sprintf(data,"bn4 %x",nextByte); break;
  727. default:
  728. sprintf(data,"--prob-- 0x3 %x",secondByte); break;
  729. }
  730. }
  731. void doHiNib6(byte secondByte) {
  732. //sprintf(data,"Doing it in subroutine..,,,,Tricky Hi nib 7");
  733. if (secondByte==0) sprintf(data,"irx %s",blankStr);
  734. else{
  735. if((secondByte<=7) && (secondByte>0)) sprintf(data,"out %x",secondByte);
  736. else sprintf(data,"inp %x",(secondByte-8));
  737. }
  738. //NB can't have 68
  739. }
  740. void doHiNib7(byte secondByte) {
  741. //sprintf(data,"7xxx");
  742. //Serial.print("hn7");
  743. if (secondByte==1)sprintf(data,"dis %s",blankStr);
  744. else sprintf(data,"Not 1 %s",blankStr);
  745. byte nextByte = vRAM[currentAdr+1]; //eg br 40 will have codes 30 40 and 40 is "nextByte"
  746. /*switch(secondByte) {
  747. case 0:
  748. sprintf(data,"br %x",nextByte); break;
  749. //sprintf(data,"ret %s",blankStr); break;
  750. case 1:
  751. sprintf(data,"dis %s",blankStr); break;
  752. case 2:
  753. sprintf(data,"ldxa " ); break;
  754. case 3:
  755. sprintf(data,"stxd " ); break;
  756. case 4:
  757. sprintf(data,"adc " ); break;
  758. case 5:
  759. sprintf(data,"sdb " ); break;
  760. case 6:
  761. sprintf(data,"shrc " ); break;
  762. case 7:
  763. sprintf(data,"smb " ); break;
  764. case 8:
  765. sprintf(data,"sav " ); break;
  766. case 9:
  767. sprintf(data,"mark " ); break;
  768. case 0xa:
  769. sprintf(data,"seq " ); break;
  770. case 0xb:
  771. sprintf(data,"req " ); break;
  772. case 0xc:
  773. sprintf(data,"addi %x",nextByte); break;
  774. case 0xd:
  775. sprintf(data,"sdbi %x",nextByte); break;
  776. case 0xe:
  777. sprintf(data,"shlc"); break;
  778. case 0xf:
  779. sprintf(data,"smbi %x",nextByte); break;
  780. default:
  781. sprintf(data,"--prob-- 0x7 %x",secondByte); break;
  782. }
  783. */
  784. }
  785. void doHiNibc() {
  786. sprintf(data,"Doing it in subroutine..,,,,hi nib c; branches and skips");
  787. }
  788. void doHiNibf() {
  789. sprintf(data,"Doing it in subroutine..,,,,hi nib f;arith logic etc");
  790. }
  791. void showData() {
  792. for (int i=0;i<10;i++) {
  793. Serial.print(data[i]);
  794. }
  795. }
  796. void experiment1(void) {
  797. doDisAsm(0x00);
  798. doDisAsm(0x05);
  799. doDisAsm(0x15);
  800. doDisAsm(0x25);
  801. doDisAsm(0x30);
  802. doDisAsm(0x00);
  803. doDisAsm(0x05);
  804. doDisAsm(0x15);
  805. doDisAsm(0x25);
  806. doDisAsm(0x30);
  807. doDisAsm(0x00);
  808. doDisAsm(0x05);
  809. doDisAsm(0x15);
  810. doDisAsm(0x25);
  811. doDisAsm(0x30);
  812. doDisAsm(0x00);
  813. doDisAsm(0x05);
  814. doDisAsm(0x15);
  815. doDisAsm(0x25);
  816. doDisAsm(0x30);
  817. doDisAsm(0x00);
  818. doDisAsm(0x05);
  819. doDisAsm(0x15);
  820. doDisAsm(0x25);
  821. doDisAsm(0x30);
  822. doDisAsm(0x00);
  823. doDisAsm(0x05);
  824. doDisAsm(0x15);
  825. doDisAsm(0x25);
  826. doDisAsm(0x30);
  827. doDisAsm(0x00);
  828. doDisAsm(0x05);
  829. doDisAsm(0x15);
  830. doDisAsm(0x25);
  831. doDisAsm(0x30);
  832. doDisAsm(0x00);
  833. doDisAsm(0x05);
  834. doDisAsm(0x15);
  835. doDisAsm(0x25);
  836. doDisAsm(0x30);
  837. doDisAsm(0x00);
  838. doDisAsm(0x05);
  839. doDisAsm(0x15);
  840. doDisAsm(0x25);
  841. doDisAsm(0x30);
  842. doDisAsm(0x00);
  843. doDisAsm(0x05);
  844. doDisAsm(0x15);
  845. doDisAsm(0x25);
  846. doDisAsm(0x30);
  847. doDisAsm(0x00);
  848. doDisAsm(0x05);
  849. doDisAsm(0x15);
  850. doDisAsm(0x25);
  851. doDisAsm(0x30);
  852. doDisAsm(0x00);
  853. doDisAsm(0x05);
  854. doDisAsm(0x15);
  855. doDisAsm(0x25);
  856. doDisAsm(0x30);
  857. doDisAsm(0x00);
  858. doDisAsm(0x05);
  859. doDisAsm(0x15);
  860. doDisAsm(0x25);
  861. doDisAsm(0x30);
  862. doDisAsm(0x00);
  863. doDisAsm(0x05);
  864. doDisAsm(0x15);
  865. doDisAsm(0x25);
  866. doDisAsm(0x30);
  867. doDisAsm(0x00);
  868. doDisAsm(0x05);
  869. doDisAsm(0x15);
  870. doDisAsm(0x25);
  871. doDisAsm(0x30);
  872. doDisAsm(0x00);
  873. doDisAsm(0x05);
  874. doDisAsm(0x15);
  875. doDisAsm(0x25);
  876. doDisAsm(0x30);
  877. }
  878. void doHiNib7A(byte secondByte) {
  879. //sprintf(data,"7xxx");
  880. //Serial.print("hn7");
  881. //if (secondByte==1)sprintf(data,"dis %s",blankStr);
  882. //else sprintf(data,"Not 1 %s",blankStr);
  883. byte nextByte = vRAM[currentAdr+1]; //eg br 40 will have codes 30 40 and 40 is "nextByte"
  884. switch(secondByte) {
  885. case 0:
  886. //sprintf(data,"br %x",nextByte); break;
  887. sprintf(data,"ret %s",blankStr); break;
  888. case 1:
  889. sprintf(data,"dis %s",blankStr); break;
  890.  
  891. case 2:
  892. sprintf(data,"ldxa %s",blankStr ); break;
  893. case 3:
  894. sprintf(data,"stxd %s",blankStr ); break;
  895. case 4:
  896. sprintf(data,"adc %s",blankStr ); break;
  897. case 5:
  898. sprintf(data,"sdb %s",blankStr ); break;
  899. case 6:
  900. sprintf(data,"shrc %s",blankStr ); break;
  901. /* case 7:
  902. sprintf(data,"smb %s",blankStr ); break;
  903. /* case 8:
  904. sprintf(data,"sav " ); break;
  905. case 9:
  906. sprintf(data,"mark " ); break;
  907. case 0xa:
  908. sprintf(data,"seq " ); break;
  909. case 0xb:
  910. sprintf(data,"req " ); break;
  911. case 0xc:
  912. sprintf(data,"addi %x",nextByte); break;
  913. case 0xd:
  914. sprintf(data,"sdbi %x",nextByte); break;
  915. case 0xe:
  916. sprintf(data,"shlc"); break;
  917. case 0xf:
  918. sprintf(data,"smbi %x",nextByte); break;*/
  919. default:
  920. sprintf(data,"--prob0x07 %x",secondByte); break;
  921. }
  922. }
  923. void doHiNib7B(byte secondByte1) {
  924. // cpould not get the switch method to work for this one.
  925. byte nextByte = vRAM[currentAdr+1]; //eg br 40 will have codes 30 40 and 40 is "nextByte"
  926.  
  927. if (secondByte1==0) sprintf(data,"ret %s",blankStr);
  928. if (secondByte1==1) sprintf(data,"dis %s",blankStr);
  929. if (secondByte1==2) sprintf(data,"ldxa %s",blankStr);
  930. if (secondByte1==3) sprintf(data,"stxd %s",blankStr);
  931. if (secondByte1==4) sprintf(data,"adc %s",blankStr);
  932. if (secondByte1==5) sprintf(data,"sdb %s",blankStr);
  933. if (secondByte1==6) sprintf(data,"shrc %s",blankStr);
  934. if (secondByte1==7) sprintf(data,"smb %s",blankStr);
  935. if (secondByte1==8) sprintf(data,"sav %s",blankStr);
  936. if (secondByte1==9) sprintf(data,"mark %s",blankStr);
  937. if (secondByte1==0x0a) sprintf(data,"req %s",blankStr);
  938. if (secondByte1==0x0b) sprintf(data,"seq %s",blankStr);
  939. if (secondByte1==0x0c) {
  940. sprintf(data,"adci %0x",nextByte);instructionBytes=2; }
  941. if (secondByte1==0x0d) {
  942. sprintf(data,"sdbi %0x",nextByte);instructionBytes=2; }
  943. if (secondByte1==0x0e) sprintf(data,"shlc %0x",nextByte);
  944. if (secondByte1==0x0f) {
  945. sprintf(data,"smbi %0x",nextByte);instructionBytes=2; }
  946.  
  947. }
  948. void doHiNibcA(byte secondByte2) { //long branches etc
  949. //sprintf(data,"Doing it in subroutine..,,,,Tricky Hi nib 3. Tricky branches");
  950. byte nextByte = vRAM[currentAdr+1]; //eg br 40 will have codes 30 40 and 40 is "nextByte"
  951. byte thirdByte = vRAM[currentAdr+2];
  952. switch(secondByte2) {
  953. case 0:
  954. sprintf(data,"lbr %x %x",nextByte,thirdByte); break;
  955. // sprintf(data,"ret %s",blankStr); break; //!!
  956. case 1:
  957. sprintf(data,"bq %x%x",nextByte,thirdByte); break;
  958. case 2:
  959. sprintf(data,"bz %x",nextByte); break;
  960. case 3:
  961. sprintf(data,"bdf %x",nextByte); break;
  962. case 4:
  963. sprintf(data,"b1 %x",nextByte); break;
  964. case 5:
  965. sprintf(data,"b2 %x",nextByte); break;
  966. case 6:
  967. sprintf(data,"b3 %x",nextByte); break;
  968. case 7:
  969. sprintf(data,"b4 %x",nextByte); break;
  970. case 8:
  971. sprintf(data,"skp %x",nextByte); break;
  972. case 9:
  973. sprintf(data,"bnq %x",nextByte); break;
  974. case 0xa:
  975. sprintf(data,"bnz %x",nextByte); break;
  976. case 0xb:
  977. sprintf(data,"bnf %x",nextByte); break;
  978. case 0xc:
  979. sprintf(data,"bn1 %x",nextByte); break;
  980. case 0xd:
  981. sprintf(data,"bn2 %x",nextByte); break;
  982. case 0xe:
  983. sprintf(data,"bn3 %x",nextByte); break;
  984. case 0xf:
  985. sprintf(data,"bn4 %x",nextByte); break;
  986. default:
  987. sprintf(data,"--prob-- 0x3 %x",secondByte2); break;
  988. }
  989. }
  990. void doHiNibcB(byte secondByte2) { //long branches etc
  991. //sprintf(data,"Doing it in subroutine..,,,,Tricky Hi nib 3. Tricky branches");
  992. byte nextByte = vRAM[currentAdr+1]; //eg br 40 will have codes 30 40 and 40 is "nextByte"
  993. byte thirdByte = vRAM[currentAdr+2];
  994. if (secondByte2==0) sprintf(data,"lbr %0x%0x",nextByte,thirdByte);
  995. if (secondByte2==1) sprintf(data,"lbq %0x%0x",nextByte,thirdByte);
  996. if (secondByte2==2) sprintf(data,"lbz %0x %0x",nextByte,thirdByte);
  997. if (secondByte2==3) sprintf(data,"lbdf %0x %0x",nextByte,thirdByte);
  998. if (secondByte2==4){
  999. sprintf(data,"nop %s",blankStr); instructionBytes=1; }
  1000. if (secondByte2==5) sprintf(data,"lsnq %0x%0x",nextByte,thirdByte);
  1001. if (secondByte2==6) sprintf(data,"lsnz %0x %0x",nextByte,thirdByte);
  1002. if (secondByte2==7) sprintf(data,"lsnf %0x %0x",nextByte,thirdByte);
  1003. if (secondByte2==8) sprintf(data,"lskp %0x %0x",nextByte,thirdByte);
  1004. if (secondByte2==9) sprintf(data,"lbnq %0x %0x",nextByte,thirdByte);
  1005. if (secondByte2==0xa) sprintf(data,"lbnz %0x %0x",nextByte,thirdByte);
  1006. if (secondByte2==0xb) sprintf(data,"lbnf %0x %0x",nextByte,thirdByte);
  1007. if (secondByte2==0xc) sprintf(data,"lsie %0x %0x",nextByte,thirdByte);
  1008. if (secondByte2==0xd) sprintf(data,"lsq %0x %0x",nextByte,thirdByte);
  1009. if (secondByte2==0xe) sprintf(data,"lsz %0x %0x",nextByte,thirdByte);
  1010. if (secondByte2==0xf) sprintf(data,"lsdf %0x %0x",nextByte,thirdByte);
  1011.  
  1012.  
  1013. //else sprintf(data,"not yet %s",blankStr);
  1014. /*
  1015. switch(secondByte2) {
  1016. case 0:
  1017. sprintf(data,"lbr %x %x",nextByte,thirdByte); break;
  1018. // sprintf(data,"ret %s",blankStr); break; //!!
  1019. case 1:
  1020. sprintf(data,"bq %x%x",nextByte,thirdByte); break;
  1021. case 2:
  1022. sprintf(data,"bz %x",nextByte); break;
  1023. case 3:
  1024. sprintf(data,"bdf %x",nextByte); break;
  1025. case 4:
  1026. sprintf(data,"b1 %x",nextByte); break;
  1027. case 5:
  1028. sprintf(data,"b2 %x",nextByte); break;
  1029. case 6:
  1030. sprintf(data,"b3 %x",nextByte); break;
  1031. case 7:
  1032. sprintf(data,"b4 %x",nextByte); break;
  1033. case 8:
  1034. sprintf(data,"skp %x",nextByte); break;
  1035. case 9:
  1036. sprintf(data,"bnq %x",nextByte); break;
  1037. case 0xa:
  1038. sprintf(data,"bnz %x",nextByte); break;
  1039. case 0xb:
  1040. sprintf(data,"bnf %x",nextByte); break;
  1041. case 0xc:
  1042. sprintf(data,"bn1 %x",nextByte); break;
  1043. case 0xd:
  1044. sprintf(data,"bn2 %x",nextByte); break;
  1045. case 0xe:
  1046. sprintf(data,"bn3 %x",nextByte); break;
  1047. case 0xf:
  1048. sprintf(data,"bn4 %x",nextByte); break;
  1049. default:
  1050. sprintf(data,"--prob-- 0x3 %x",secondByte2); break;
  1051. }*/
  1052. }
  1053. void doHiNibfA(byte secondByte1) {
  1054. // could not get the switch method to work for this one.
  1055. byte nextByte = vRAM[currentAdr+1]; //eg br 40 will have codes 30 40 and 40 is "nextByte"
  1056. if (secondByte1>=8) instructionBytes=2; //otherwise stays at 1
  1057.  
  1058. if (secondByte1==0) sprintf(data,"ldx %s",blankStr);
  1059. if (secondByte1==1) sprintf(data,"or %s",blankStr);
  1060. if (secondByte1==2) sprintf(data,"and %s",blankStr);
  1061. if (secondByte1==3) sprintf(data,"xor %s",blankStr);
  1062. if (secondByte1==4) sprintf(data,"add %s",blankStr);
  1063. if (secondByte1==5) sprintf(data,"sd %s",blankStr);
  1064. if (secondByte1==6) sprintf(data,"shr %s",blankStr);
  1065. if (secondByte1==7) sprintf(data,"sm %s",blankStr);
  1066. //if (secondByte>=8) instructionBytes=2;
  1067. if (secondByte1==8) sprintf(data,"ldi %02x",nextByte);
  1068. if (secondByte1==9) sprintf(data,"ori %02x",nextByte);
  1069. if (secondByte1==0x0a) sprintf(data,"ani %02x",nextByte);
  1070. if (secondByte1==0x0b) sprintf(data,"xri %02x",nextByte);
  1071. if (secondByte1==0x0c) sprintf(data,"adi %02x",nextByte);
  1072. if (secondByte1==0x0d) sprintf(data,"sdi %02x",nextByte);
  1073. if (secondByte1==0x0e) { sprintf(data,"shl %s",blankStr); instructionBytes=1; }
  1074. if (secondByte1==0x0f) sprintf(data,"smi %02x",nextByte);
  1075.  
  1076. }
  1077. void printTPBResults3(void) {
  1078. Serial.print("[");
  1079. if (fetchOrExecuteCh=='F'){
  1080. sprintf(data,"Adr1 %02x%02x : ",adrByteHi,adrByte);
  1081. Serial.print(data);
  1082. doDisAsm(opCode); //new
  1083. if (printLevel==1) {
  1084. Serial.println("]"); //if level1 finish here with CR.
  1085. }
  1086. if(printLevel>=2) {
  1087. sprintf(data," --%2x ",opCode);
  1088. if (instructionBytes ==1) Serial.println(data);
  1089. if (instructionBytes==2) {
  1090. Serial.print(data);
  1091. Serial.println(vRAM[currentAdr+1],HEX);
  1092. }
  1093. if (instructionBytes==3) {
  1094. Serial.print(data);
  1095. Serial.print(vRAM[currentAdr+1],HEX);
  1096. Serial.println(vRAM[currentAdr+2],HEX);
  1097. }
  1098. }
  1099. }
  1100. else { // ie it's not 'F', it's an execute line:
  1101. if(printLevel==3) {
  1102. sprintf(data," Adr: %x%x : %02x Ck=%lu, Cy=%lu, In=%lu ; ( %c %c ) M%lu Cr%lu",adrByteHi,adrByte,opCode,clkCtr,TPBCtr,fetchCtr, fetchOrExecuteCh,readOrWriteCh,t1,clockRate);
  1103. //sprintf(data,"Adr: %x%x : %02x %u, %u ,%u ; %c %c",adrByteHi,adrByte,opCode,TPBCtr,clkCtr,fetchCtr, fetchOrExecuteCh,readOrWriteCh);
  1104. //sprintf(data," Adr: %x%x : %02x %u, %u %c %c",adrByteHi,adrByte,opCode,TPBCtr,clkCtr, fetchOrExecuteCh,readOrWriteCh);
  1105. Serial.println(data);
  1106. }
  1107. }
  1108. }
  1109. void millisExperiment0(void){
  1110. unsigned long time;
  1111.  
  1112. for (int i=0;i<10;i++) {
  1113. //Serial.println(millis());
  1114.  
  1115.  
  1116. Serial.print("Time: ");
  1117. time = millis();
  1118.  
  1119. Serial.println(time); //prints time since program started
  1120. delay(1000); // wait a second so as not to send massive amounts of data
  1121. }
  1122. //Notes and Warnings
  1123. }
Advertisement
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!