src/edu/berkeley/obits/AtmelSerial.java

   1 package edu.berkeley.obits;
   2
   3 import static edu.berkeley.obits.device.atmel.AtmelDevice.Constants.*;
   4 import edu.berkeley.obits.device.atmel.*;
   5 import java.awt.*;
   6 import java.awt.event.*;
   7 import java.awt.color.*;
   8 import org.ibex.util.*;
   9 import java.io.*;
  10 import java.util.*;
  11 import gnu.io.*;
  12
  13 public class AtmelSerial {
  14
  15     public static SerialPort detectObitsPort() throws Exception {
  16         Enumeration e = CommPortIdentifier.getPortIdentifiers();
  17         while(e.hasMoreElements()) {
  18             CommPortIdentifier cpi = (CommPortIdentifier)e.nextElement();
  19             Log.info(AtmelSerial.class, "trying " + cpi.getName());
  20             if (cpi.getName().startsWith("/dev/cu.usbserial-")) return new RXTXPort(cpi.getName());
  21             if (cpi.getName().startsWith("/dev/ttyS0")) return new RXTXPort(cpi.getName());
  22         }
  23         Log.info(AtmelSerial.class, "returning null...");
  24         return null;
  25     }
  26     public static int PIPELEN=20;
  27     public static void main(String[] s) throws Exception {
  28         AvrDrone device = new AvrDrone(detectObitsPort());
  29         At40k at40k = new At40k.At40k10(device);
  30         int count = 0;
  31         try {
  32             long begin = System.currentTimeMillis();
  33             BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
  34             for(String str = br.readLine(); str != null; str = br.readLine()) {
  35                 long foo = Long.parseLong(str, 16);
  36                 device.mode4((int)(foo >> 24), (int)(foo >> 16), (int)(foo >>  8), (int)(foo >>  0));
  37                 count++;
  38                 if (count % 100 == 0) Log.info(AtmelSerial.class, "wrote " + count + " configuration octets");
  39             }
  40             device.flush();
  41             long end = System.currentTimeMillis();
  42             Log.info(AtmelSerial.class, "finished in " + ((end-begin)/1000) + "s");
  43             Thread.sleep(1000);
  44             Log.info(AtmelSerial.class, "issuing command");
  45
  46             //at40k.iob_top(2, true).oe(false);
  47             //at40k.iob_top(2, false).oe(false);
  48             //at40k.iob_top(1, true).oe(false);
  49
  50             // this command confirmed to turn *on* led0
  51             //at40k.iob_top(1, false).output(0);
  52             /*
  53             for(int i=0; i<20; i++) {
  54                 at40k.iob_bot(i, false).output(0);
  55                 at40k.iob_bot(i, true).output(0);
  56             }
  57             */
  58
  59             //System.out.println("tick");
  60                 //Thread.sleep(3000);
  61                 //System.out.println("tick");
  62                 //at40k.cell(0x01, 0x17).xlut((byte)0x);
  63
  64             /*
  65             System.out.println(Integer.toString(0xff & at40k.cell(0x01, 0x17).xlut(), 16));
  66             System.out.println(Integer.toString(0xff & at40k.cell(0x01, 0x17).ylut(), 16));
  67             at40k.cell(0x01, 0x17).ylut((byte)0xff);
  68             */
  69
  70             //at40k.cell(0x01, 0x17).wi(L1);
  71             /*
  72             System.out.println("a: " + at40k.new SectorWire(true, 0, 4, 0x17).driverRight());
  73             System.out.println("b: " + at40k.new SectorWire(true, 1, 4, 0x17).driverRight());
  74             At40k.SectorWire h0p0 = at40k.new SectorWire(true, 0, 0, 0x17);
  75             At40k.SectorWire h0p1 = at40k.new SectorWire(true, 1, 0, 0x17);
  76             At40k.SectorWire h0p2 = at40k.new SectorWire(true, 2, 0, 0x17);
  77             At40k.SectorWire h4p0 = at40k.new SectorWire(true, 0, 4, 0x17);
  78             At40k.SectorWire h4p1 = at40k.new SectorWire(true, 1, 4, 0x17);
  79             At40k.SectorWire h4p2 = at40k.new SectorWire(true, 2, 4, 0x17);
  80
  81             //h4p1.drives(h0p1, false);
  82             //at40k.cell(0x04, 0x17).out(L1, false);
  83             //at40k.cell(0x04, 0x17).h(L0, false);
  84
  85             for(int plane=0; plane<5; plane++) {
  86                 at40k.new SectorWire(true, plane,     4, 0x17).drives(at40k.new SectorWire(true, plane,     0, 0x17), false);
  87                 at40k.cell(0x04, 0x17).out(plane, false);
  88                 at40k.cell(0x04, 0x17).h(plane, false);
  89                 at40k.cell(0x01, 0x17).h(plane, false);
  90             }
  91             try { Thread.sleep(2000); } catch (Exception e) { }
  92
  93             int plane=0;
  94             at40k.new SectorWire(true, plane, 4, 0x17).drives(at40k.new SectorWire(true, plane, 0, 0x17), true);
  95             at40k.cell(0x04, 0x17).out(plane, true);
  96             at40k.cell(0x04, 0x17).h(plane, true);
  97             at40k.cell(0x01, 0x17).h(plane, true);
  98             at40k.cell(0x01, 0x17).wi(plane);
  99
 100             */
 101
 102             /*
 103             System.out.println("xlut is " + hex(at40k.cell(0x04, 0x17).xlut()));
 104             System.out.println("ylut is " + hex(at40k.cell(0x04, 0x17).ylut()));
 105             At40k.Cell cell = at40k.cell(0x04, 0x17);
 106             //cell.xlut(0xff);
 107             //cell.f(false);
 108             System.out.println(cell.c());
 109             cell.c(YLUT);
 110             cell.ylut(0x4D);
 111             cell.xlut(0x00);
 112
 113             cell.b(false);
 114             cell.f(false);
 115             //cell.t(false, false, true);
 116             cell.t(false, true, false);
 117             cell.out(L3, true);
 118             cell.wi(L3);
 119
 120             cell.yo(false);
 121             cell.h(L0, false);
 122             cell.h(L1, false);
 123             cell.h(L2, false);
 124             cell.h(L3, false);
 125             cell.h(L4, false);
 126
 127             for(int i=3; i>=1; i--) {
 128                 at40k.cell(i, 0x17).yi(EAST);
 129                 at40k.cell(i, 0x17).ylut(0x55);
 130                 at40k.cell(i, 0x17).yo(false);
 131             }
 132             */
 133
 134             //System.out.println("reading port status: " + Integer.toString(device.readBus() & 0xff, 16));
 135
 136
 137             // blank these out
 138             /*
 139             at40k.cell(23, 8).ylut(0xff);
 140             at40k.cell(23, 11).ylut(0xff);
 141             at40k.iob_right(8, true).enableOutput();
 142             at40k.iob_right(11, true).enableOutput();
 143             */
 144             //for(int x=4;  x<=22; x++) swap(at40k.cell(x, 22), NW, NORTH);
 145
 146
 147             // entry cell: just copy X->X Y->Y
 148             //at40k.cell(4,23).b(false);
 149             //at40k.cell(4,23).yo(false);
 150             //at40k.cell(4,23).ylut(at40k.cell(4,23).xlut());
 151             //at40k.cell(4,23).xo(false);
 152             /*
 153             at40k.cell(4,23).xlut(0x55);
 154             at40k.cell(4,23).ylut(0x55);
 155             */
 156             /*
 157             at40k.cell(4,23).xlut(0x71);
 158             at40k.cell(4,23).ylut(0x44);
 159             at40k.cell(4,23).c(YLUT);
 160             at40k.cell(4,23).f(false);
 161             at40k.cell(4,23).t(false, false, true);
 162             */
 163
 164             //for(int x=6;  x<=23; x++) copy(at40k.cell(x, 23), NW, WEST);  // top row copies to the right
 165             /*
 166             copy(at40k.cell(5, 22), NW, NORTH);
 167             for(int x=6;  x<=22; x++) copy(at40k.cell(x, 22), NW, WEST);  // second top row copies to the right
 168             //for(int y=22; y>=10; y--) copy(at40k.cell(23, y), NW, NORTH); // right edge copies down
 169             for(int y=21; y>=9;  y--) copy(at40k.cell(22, y), NW, NORTH); // second right edge copies down
 170             copy(at40k.cell(23, 9), NW, WEST);                            // second output
 171             */
 172             /*
 173             handshaker(at40k.cell(4,23));
 174             at40k.cell(4,23).xi(NW);
 175             at40k.cell(4,23).yi(SOUTH);
 176
 177             //handshaker(at40k.cell(5,23));
 178             //at40k.cell(5,23).yi(NORTH);
 179
 180             at40k.cell(5,23).yi(NORTH);
 181             at40k.cell(5,23).xlut(0x55);
 182             at40k.cell(5,23).xi(SW);
 183             at40k.cell(5,23).ylut(0x55);
 184             at40k.cell(5,22).yi(NORTH);
 185             at40k.cell(5,22).xlut(0x55);
 186
 187             bounce(at40k.cell(4,22));
 188
 189             // cell southeast of entry cell
 190             at40k.cell(3,22).xi(NE);      // NW->xin
 191             at40k.cell(3,22).ylut(0x33);  // xin->y
 192             at40k.cell(3,22).yo(false);   // y->yout
 193             copy(at40k.cell(3, 21), NW, NORTH);  // second top row copies to the right
 194             copy(at40k.cell(4, 21), NW, EAST);  // second top row copies to the right
 195             copy(at40k.cell(5, 21), NW, EAST);  // second top row copies to the right
 196             copy(at40k.cell(6, 21), NW, EAST);  // second top row copies to the right
 197             copy(at40k.cell(6, 22), NW, SOUTH);  // second top row copies to the right
 198             */
 199             /*
 200             at40k.cell(05,22).xlut(0xff);
 201             at40k.cell(05,22).ylut(0xff);
 202             at40k.cell(05,22).c(XLUT);
 203             at40k.cell(05,22).f(false);
 204             at40k.cell(05,22).b(false);
 205             at40k.cell(05,22).oe(NONE);
 206             at40k.cell(05,22).v(L3, true);
 207             at40k.cell(05,22).out(L3, true);
 208             */
 209             at40k.cell(4,23).ylut(~0xCC);
 210             at40k.cell(4,23).xlut(~0xAA);
 211             at40k.cell(5,23).ylut(~0xAA);
 212             at40k.cell(5,23).xlut(~0xAA);
 213             for(int i=6; i<PIPELEN+2; i++) {
 214                 at40k.cell(i, 23).ylut(0xAA);
 215                 at40k.cell(i, 23).xlut(0xCC);
 216                 at40k.cell(i, 23).yi(WEST);
 217             }
 218             for(int i=4; i<PIPELEN+2; i++) bounce(at40k.cell(i, 21));
 219
 220
 221             at40k.cell(4,22).ylut(0xB2);
 222             //at40k.cell(5,22).xlut(0x44);
 223             at40k.cell(4,22).xi(SE);
 224             at40k.cell(4,22).yi(NORTH);
 225             at40k.cell(4,22).c(YLUT);
 226             at40k.cell(4,22).f(false);
 227             at40k.cell(4,22).t(false, false, true);
 228             at40k.cell(4,22).yo(false);
 229             at40k.cell(4,22).xo(false);
 230
 231             for(int x=5; x<PIPELEN; x++) {
 232                 at40k.cell(x,22).ylut(0xB2);
 233                 //at40k.cell(x,22).xlut(0x44);
 234                 at40k.cell(x,22).c(YLUT);
 235                 at40k.cell(x,22).f(false);
 236                 at40k.cell(x,22).t(false, false, true);
 237                 at40k.cell(x,22).xi(SE);
 238                 at40k.cell(x,22).yi(WEST);
 239                 at40k.cell(x,22).yo(false);
 240                 at40k.cell(x,22).xo(false);
 241             }
 242             //at40k.cell(5,22).yi(WEST);
 243             at40k.cell(4,22).yi(NORTH);
 244             at40k.cell(4,22).ylut(0xAA);
 245
 246             at40k.cell(PIPELEN,22).c(YLUT);
 247             at40k.cell(PIPELEN,22).ylut(0xB2);
 248             //at40k.cell(PIPELEN,22).xlut(0x44);
 249             at40k.cell(PIPELEN,22).xi(NE);
 250             at40k.cell(PIPELEN,22).yi(WEST);
 251             at40k.cell(PIPELEN,22).yo(false);
 252             at40k.cell(PIPELEN,22).xo(false);
 253             at40k.cell(PIPELEN,22).f(false);
 254             at40k.cell(PIPELEN,22).t(false, false, true);
 255
 256             at40k.cell(21,15).yi(WEST);
 257             at40k.cell(21,15).ylut(0xAA);
 258             at40k.cell(22,15).yi(WEST);
 259             at40k.cell(22,15).ylut(0xAA);
 260             at40k.cell(23,15).h(3, true);
 261             at40k.cell(23,15).yi(L3);
 262             at40k.cell(23,15).ylut(0xAA);
 263             at40k.iob_right(15, true).enableOutput(WEST);
 264             /*
 265             at40k.cell(22,11).ylut(0xff);
 266             at40k.cell(23,11).yi(L3);
 267             //at40k.cell(23,11).yi(WEST);
 268             //at40k.cell(23,11).xi(L1);
 269             at40k.cell(23,11).ylut(0xAA);
 270             at40k.iob_right(11, true).enableOutput(WEST);
 271             at40k.cell(23,11).v(L3, true);
 272             at40k.cell(23,11).yo(false);
 273             //at40k.flush();
 274             */
 275             int vx=04;
 276             int vv=23;
 277             /*
 278             System.out.println("correct: " + at40k.cell(19,15).hwire(L3) + " drives " + at40k.cell(20,15).hwire(L3));
 279             System.out.println("correct: " + at40k.cell(15,15).hwire(L3) + " drives " + at40k.cell(19,15).hwire(L3));
 280             System.out.println("correct: " + at40k.cell(11,15).hwire(L3) + " drives " + at40k.cell(15,15).hwire(L3));
 281             System.out.println("correct: " + at40k.cell(07,15).hwire(L3) + " drives " + at40k.cell(11,15).hwire(L3));
 282
 283             at40k.cell(19,15).hwire(L3).drives(at40k.cell(20,15).hwire(L3), true);
 284             at40k.cell(15,15).hwire(L3).drives(at40k.cell(19,15).hwire(L3), true);
 285             at40k.cell(11,15).hwire(L3).drives(at40k.cell(15,15).hwire(L3), true);
 286             at40k.cell(07,15).hwire(L3).drives(at40k.cell(11,15).hwire(L3), true);
 287             */
 288             //at40k.cell(05,vv).xlut(0xff);
 289             //at40k.cell(05,vv).ylut(0xff);
 290             /*
 291             at40k.cell(vx,vv).c(YLUT);
 292             at40k.cell(vx,vv).f(false);
 293             at40k.cell(vx,vv).b(false);
 294             at40k.cell(vx,vv).oe(NONE);
 295             at40k.cell(vx,vv).v(L3, true);
 296             at40k.cell(vx,vv).out(L3, true);
 297             */
 298             /*
 299             at40k.cell(vx,15).v(L3, true);
 300             at40k.cell(vx,15).h(L3, true);
 301             at40k.cell(vx,19).vwire(L3).drives(at40k.cell(vx,15).vwire(L3), true);
 302             at40k.cell(vx,23).vwire(L3).drives(at40k.cell(vx,19).vwire(L3), true);
 303             */
 304
 305             //at40k.cell(5,23).ylut(0x00);
 306             //at40k.cell(6,22).ylut(0xff);
 307             //at40k.cell(22,11).ylut(0xff);
 308             /*
 309             At40k.Cell cell = at40k.cell(4, 16);
 310             cell.xlut(0xff);
 311             cell.ylut(0xff);
 312             cell.b(false);
 313             cell.f(false);
 314             cell.c(XLUT);
 315             cell.h(L3, true);
 316             cell.v(L3, true);
 317             cell.out(L3, true);
 318             cell.oe(NONE);
 319             */
 320             //scan(at40k, cell, YLUT, true);
 321             //scan(at40k, cell, YLUT, false);
 322
 323             device.scanFPGA();
 324             Visualizer v = new Visualizer(at40k, device);
 325             v.show();
 326             v.setSize(1380, 1080);
 327             At40k.Cell cell = at40k.cell(4, 23);
 328             Image img = v.createImage(v.getWidth(), v.getHeight());
 329             /*
 330             int x = 1;
 331             int y = 14;
 332             cell = at40k.cell(x,y);
 333             scan(at40k, cell, YLUT, true);
 334             cell.c(YLUT);
 335             cell.b(false);
 336             cell.f(false);
 337             cell.oe(NONE);
 338             cell.ylut(0xff);
 339             */
 340             //int x = 5;
 341             //int y = 11;
 342
 343             //selfTest(device, at40k, v);
 344
 345             for(int i=0; i<10000; i++) {
 346                 v.refresh();
 347                 try { Thread.sleep(100); } catch (Exception e) { }
 348             }
 349             //cell.ylut(0x09);
 350
 351             //at40k.cell(0x01, 0x17).h(0, false);
 352             //at40k.cell(0x01, 0x17).xi(NE);
 353             //at40k.cell(0x01, 0x17).ylut((byte)0x55);
 354
 355             //at40k.cell(0x04, 0x17).xlut((byte)0x10);
 356             //at40k.cell(0x04, 0x17).ylut((byte)0x10);
 357             //at40k.cell(0x04, 0x17).yo(false);
 358             //at40k.cell(0x04, 0x17).xo();
 359
 360             /*
 361             at40k.cell(0x01, 0x17).xi(L0);
 362             at40k.cell(0x01, 0x17).h(L0, true);
 363             */
 364             /*
 365             at40k.cell(0x03, 0x17).xlut((byte)0x55);
 366             at40k.cell(0x03, 0x17).ylut((byte)0x55);
 367             at40k.cell(0x03, 0x17).yi(EAST);
 368             at40k.cell(0x03, 0x17).ylut((byte)0x55);
 369             at40k.cell(0x03, 0x17).yo(true);
 370
 371             at40k.cell(0x03, 0x17).f(false);
 372             at40k.cell(0x03, 0x17).c(XLUT);
 373             at40k.cell(0x03, 0x17).oe(NONE);
 374             at40k.cell(0x03, 0x17).out(L0, true);
 375
 376             at40k.cell(0x02, 0x17).yi(EAST);
 377             at40k.cell(0x02, 0x17).ylut((byte)0x55);
 378             at40k.cell(0x02, 0x17).yo(false);
 379
 380             at40k.cell(0x01, 0x17).yi(EAST);
 381             at40k.cell(0x01, 0x17).ylut((byte)0x55);
 382             at40k.cell(0x01, 0x17).yo(false);
 383
 384             at40k.cell(0x01, 0x17).h(L0, true);
 385             at40k.cell(0x01, 0x17).v(L0, false);
 386             */
 387             //at40k.cell(0x01, 0x17).yi(L0);
 388             //at40k.cell(0x01, 0x17).xi(L0);
 389             //at40k.cell(0x01, 0x17).ylut((byte)0x33);
 390
 391             /*
 392             at40k.cell(0x03, 0x17).h(L0, true);
 393             at40k.cell(0x03, 0x17).out(L0, true);
 394             at40k.cell(0x03, 0x17).c(XLUT);
 395             at40k.cell(0x03, 0x17).f(false);
 396             */
 397             /*
 398             at40k.cell(0x01, 0x17).xin(4);
 399             at40k.cell(0x01, 0x17).yin(4);
 400             at40k.cell(0x01, 0x16).ylut((byte)0x00);
 401             device.mode4(2, 0x17, 0x01, 0);
 402
 403             for(int i=0; i<10; i++) {
 404                 Thread.sleep(3000);
 405                 System.out.println("tick");
 406                 //at40k.cell(0x01, 0x17).xlut((byte)0xFF);
 407                 at40k.cell(0x00, 0x17).ylut((byte)0x00);
 408                 device.flush();
 409                 Thread.sleep(3000);
 410                 System.out.println("tick");
 411                 //at40k.cell(0x01, 0x17).xlut((byte)0x00);
 412                 at40k.cell(0x00, 0x17).ylut((byte)0xFF);
 413                 device.flush();
 414             }
 415             */
 416
 417
 418             /*
 419             at40k.iob_top(0, true).output(0);
 420             at40k.iob_top(0, true).oe(false);
 421             at40k.iob_top(0, true).pullup();
 422             device.flush();
 423             Thread.sleep(3000);
 424
 425             Log.info(AtmelSerial.class, "issuing command");
 426             at40k.iob_top(1, true).pulldown();
 427             device.flush();
 428             */
 429             Log.info(AtmelSerial.class, "done");
 430             System.exit(0);
 431         } catch (Exception e) { e.printStackTrace(); }
 432     }
 433
 434     public static void scan(At40k dev, At40k.Cell cell, int source, boolean setup) {
 435         if (setup) {
 436             if (source != NONE) cell.c(source);
 437             cell.b(false);
 438             cell.f(false);
 439             cell.out(L3, true);
 440         }
 441         cell.v(L3, setup);
 442
 443         At40k.SectorWire sw = cell.vwire(L3);
 444         //System.out.println("wire is: " + sw);
 445         while(sw.row > (12 & ~0x3) && sw.south() != null) {
 446             //System.out.println(sw + " -> " + sw.south());
 447             sw.drives(sw.south(), setup);
 448             sw = sw.south();
 449         }
 450         while(sw.row < (12 & ~0x3) && sw.north() != null) {
 451             //System.out.println(sw + " -> " + sw.north());
 452             sw.drives(sw.north(), setup);
 453             sw = sw.north();
 454         }
 455         //cell = dev.cell(19, 15);
 456         cell = dev.cell(cell.col, 15);
 457         /*
 458         System.out.println("cell is " + cell);
 459         cell.xlut(0xff);
 460         cell.ylut(0xff);
 461         cell.b(false);
 462         cell.f(false);
 463         cell.c(XLUT);
 464         cell.out(L3, true);
 465         cell.oe(NONE);
 466         */
 467         cell.h(L3, setup);
 468         cell.v(L3, setup);
 469         sw = cell.hwire(L3);
 470         while(sw.east() != null) {
 471             //System.out.println(sw + " -> " + sw.east());
 472             sw.drives(sw.east(), setup);
 473             sw = sw.east();
 474         }
 475     }
 476
 477     public static void copy(At40k.Cell cell, int xdir, int ydir) {
 478         cell.xlut((byte)0x33);
 479         cell.ylut((byte)0x55);
 480         cell.xi(xdir);
 481         cell.yi(ydir);
 482         cell.xo(false);
 483         cell.yo(false);
 484     }
 485     public static String hex(int x) {
 486         return Long.toString(x & 0xffffffffL, 16);
 487     }
 488
 489     public static void bounce(At40k.Cell cell) {
 490         cell.xlut((byte)0xCC);
 491         cell.ylut((byte)0xCC);
 492         cell.xi(NE);
 493         cell.yi(NORTH);
 494         cell.xo(false);
 495         cell.yo(false);
 496     }
 497     public static void handshaker(At40k.Cell cell) {
 498         cell.xlut(0x22);
 499         cell.ylut(0x71);
 500         cell.c(XLUT);
 501         cell.f(false);
 502         cell.t(false, false, true);
 503     }
 504
 505     public static class Visualizer extends Frame implements KeyListener, MouseMotionListener, MouseListener {
 506         public static final int WIDTH = 40;
 507         public static final int HEIGHT = 40;
 508         public static final int LW = 15;
 509         public static final int LH = 15;
 510         public static final Color RED  = new Color(0xaa, 0x55, 0x55);
 511         public static final Color BLUE = new Color(0x55, 0x55, 0xaa);
 512         private final At40k dev;
 513         private final AvrDrone drone;
 514         int selx = -1;
 515         int sely = -1;
 516         public Visualizer(final At40k dev, final AvrDrone drone) {
 517             this.dev = dev;
 518             this.drone = drone;
 519             show();
 520             addMouseMotionListener(this);
 521             addMouseListener(this);
 522             addKeyListener(this);
 523             new Thread() {
 524                 public void run() {
 525                     try {
 526                         while(true) {
 527                             Thread.sleep(500);
 528                             if (!enabled) continue;
 529                             keyPressed(null);
 530                         }
 531                     } catch (Exception e) {
 532                         e.printStackTrace();
 533                     }
 534                 }
 535             }.start();
 536         }
 537         public boolean enabled = false;
 538         public void mouseClicked(MouseEvent e) { }
 539         public void mouseEntered(MouseEvent e) { }
 540         public void mouseExited(MouseEvent e) { }
 541         public void mouseReleased(MouseEvent e) {
 542         }
 543         public void keyTyped(KeyEvent k) {
 544         }
 545         public void keyReleased(KeyEvent k) {
 546         }
 547         public void keyPressed(KeyEvent k) {
 548             switch(k==null ? '_' : k.getKeyChar()) {
 549                 case '1': {
 550                     if (selx==-1 || sely==-1) break;
 551                     At40k.Cell cell = dev.cell(selx, sely);
 552                     cell.xlut(0xff);
 553                     cell.ylut(0xff);
 554                     drawCell(getGraphics(), selx, sely);
 555                     break;
 556                 }
 557                 case ' ': {
 558                     enabled = !enabled;
 559                 }
 560                 case 'C': {
 561                     if (selx==-1 || sely==-1) break;
 562                     At40k.Cell cell = dev.cell(selx, sely);
 563                     cell.ylut(0xB2);
 564                     drawCell(getGraphics(), selx, sely);
 565                     break;
 566                 }
 567                 case '0': {
 568                     if (selx==-1 || sely==-1) break;
 569                     At40k.Cell cell = dev.cell(selx, sely);
 570                     cell.xlut(0x00);
 571                     cell.ylut(0x00);
 572                     drawCell(getGraphics(), selx, sely);
 573                     break;
 574                 }
 575             }
 576             for(int x=5; x<=PIPELEN; x++) {
 577                 At40k.Cell cell = dev.cell(x, 22);
 578                 scan(dev, cell, YLUT, true);
 579                 boolean y = (drone.readBus() & 0x80) != 0;
 580                 scan(dev, cell, YLUT, false);
 581
 582                 Graphics g = getGraphics();
 583                 g.setFont(new Font("sansserif", Font.BOLD, 24));
 584                 g.setColor(Color.white);
 585                 g.drawString("0", left(cell) + 12, top(cell) + 30);
 586                 g.drawString("1", left(cell) + 12, top(cell) + 30);
 587                 //g.setColor(RED);
 588                 //g.drawString("X="+(x?"1":"0"), left(cell) + 10, top(cell) + 20);
 589
 590                 //g.drawString((y?"1":"0"), left(cell) + 12, top(cell) + 30);
 591                 drawCell(g, x, 22, y?new Color(0xff, 0x99, 0x99):new Color(0x99, 0xff, 0x99));
 592             }
 593         }
 594         public void mousePressed(MouseEvent e) {
 595                             At40k.Cell cell = dev.cell(selx, sely);
 596                             if (cell==null) return;
 597                             int old = cell.c();
 598                             scan(dev, cell, YLUT, true);
 599                             boolean y = (drone.readBus() & 0x80) != 0;
 600                             //scan(dev, cell, XLUT, true);
 601                             //boolean x = (drone.readBus() & 0x80) != 0;
 602                             scan(dev, cell, YLUT, false);
 603                             cell.c(old);
 604                             Graphics g = getGraphics();
 605                             g.setFont(new Font("sansserif", Font.BOLD, 14));
 606                             g.setColor(Color.white);
 607                             //g.drawString("X=0", left(cell) + 10, top(cell) + 20);
 608                             //g.drawString("X=1", left(cell) + 10, top(cell) + 20);
 609                             /*
 610                             g.setColor(Color.white);
 611                             g.drawString("Y=0", left(cell) + 8, top(cell) + 35);
 612                             g.drawString("Y=1", left(cell) + 8, top(cell) + 35);
 613                             */
 614                             //g.setColor(RED);
 615                             //g.drawString("X="+(x?"1":"0"), left(cell) + 10, top(cell) + 20);
 616                             g.setColor(BLUE);
 617                             g.drawString("Y="+(y?"1":"0"), left(cell) + 8, top(cell) + 35);
 618         }
 619
 620         public void mouseMoved(MouseEvent e) {
 621             int x = e.getX();
 622             int y = e.getY();
 623             if (selx >= 0 && selx < 24 && sely >= 0 && sely < 24) {
 624                 int cx = selx;
 625                 int cy = sely;
 626                 At40k.Cell cell = dev.cell(cx, cy);
 627                 selx = -1;
 628                 sely = -1;
 629                 drawCell(getGraphics(), cx, cy);
 630                 drawSector(getGraphics(), dev.cell(cx, cy).sector());
 631             }
 632             selx = (x-20)/(WIDTH+2);
 633             sely = (23 - (y-20)/(HEIGHT+2))+1;
 634             At40k.Cell cell = dev.cell(selx, sely);
 635             if (selx >= 0 && selx < 24 && sely >= 0 && sely < 24) {
 636                 drawCell(getGraphics(), selx, sely);
 637                 drawSector(getGraphics(), dev.cell(selx, sely).sector());
 638             }
 639         }
 640         public void mouseDragged(MouseEvent e) { mousePressed(e); }
 641         public void paint(Graphics g) {
 642             g.setColor(Color.white);
 643             g.fillRect(0, 0, getWidth(), getHeight());
 644             for(int x=0; x<24; x++)
 645                 for(int y=0; y<24; y++)
 646                     drawCell(g,x,y);
 647             for(int x=0; x<=23; x+=4)
 648                 for(int y=23; y>=0; y-=4)
 649                     drawSector(g, dev.cell(x, y).sector());
 650             g.setColor(BLUE);
 651             g.drawString("Ready", (5*(WIDTH+2))+20, 40);
 652             g.setColor(RED);
 653             g.drawString("Send",  (3*(WIDTH+2))+20, 40);
 654             g.setColor(BLUE);
 655             refresh();
 656         }
 657         public void refresh() {
 658             Graphics g = getGraphics();
 659             int data = drone.readBus() & 0xff;
 660             for(int i=0; i<8; i++) {
 661                 g.setColor((data & (1<<i))==0 ? Color.black : Color.green);
 662                 g.drawString("D"+i,  (24*(WIDTH+2))+20, ((23-(i+7))*(HEIGHT+2))+60-HEIGHT/2);
 663             }
 664         }
 665         public static int left(At40k.Cell cell) { return (cell.col)   *(WIDTH+2)+20; }
 666         public static int top(At40k.Cell cell)  { return (23-cell.row)*(HEIGHT+2)+60; }
 667         public void drawSector(Graphics g, At40k.Sector sector) {
 668             g.setColor(Color.gray);
 669             ((Graphics2D)g).setStroke(new BasicStroke(1));
 670             int px = ((sector.col)*(WIDTH+2))+20-1;
 671             int py = ((23-(sector.row+3))*(HEIGHT+2))+60-1;
 672             g.drawRect(px, py, (WIDTH+2)*4+2, (HEIGHT+2)*4+2);
 673             for(int dir=0; dir<2; dir++) {
 674                 boolean h = dir==0;
 675                 for(int y=h?sector.row:sector.col; y<(h?sector.row+4:sector.col+4); y++)
 676                     for(int plane=0; plane<=4; plane++) {
 677                         At40k.Cell cell      = h ? dev.cell(sector.col,   y) : dev.cell(y, sector.row);
 678                         At40k.Cell cell_east = h ? dev.cell(sector.col-1, y) : dev.cell(y, sector.row-1);
 679                         At40k.Cell cell_west = h ? dev.cell(sector.col+4, y) : dev.cell(y, sector.row+4);
 680                         boolean draw = false;
 681                         if (h) {
 682                             if (cell_east!=null &&
 683                                 (cell_east.hwire(plane).drives(cell.hwire(plane)) ||
 684                                  cell_east.hwire(plane).drives(cell.hwire(plane))))
 685                                 draw = true;
 686                             if (cell_west!=null &&
 687                                 (cell_west.hwire(plane).drives(cell.hwire(plane)) ||
 688                                  cell_west.hwire(plane).drives(cell.hwire(plane))))
 689                                 draw = true;
 690                         } else {
 691                             if (cell_east!=null &&
 692                                 (cell_east.vwire(plane).drives(cell.vwire(plane)) ||
 693                                  cell_east.vwire(plane).drives(cell.vwire(plane))))
 694                                 draw = true;
 695                             if (cell_west!=null &&
 696                                 (cell_west.vwire(plane).drives(cell.vwire(plane)) ||
 697                                  cell_west.vwire(plane).drives(cell.vwire(plane))))
 698                                 draw = true;
 699                         }
 700                         if (!draw)
 701                             for(int x=h?sector.col:sector.row; x<(h?sector.col+4:sector.row+4); x++)
 702                                 if (((h ? dev.cell(x,y).hx(plane) : dev.cell(y,x).vx(plane))) ||
 703                                     (h?dev.cell(x,y).out(plane):dev.cell(y,x).out(plane)))
 704                                     draw = true;
 705                         if (draw) {
 706                             g.setColor(new Color(0xff, 0x00, 0xff));
 707                             if (h) {
 708                                 g.drawLine(left(cell),
 709                                            top(cell)+3,
 710                                            left(cell) + 4*(WIDTH+2),
 711                                            top(cell)+3
 712                                            );
 713                             } else {
 714                                 g.drawLine(left(cell)+3,
 715                                            top(cell) + (HEIGHT+2),
 716                                            left(cell)+3,
 717                                            top(cell) - 3*(HEIGHT+2)
 718                                            );
 719                             }
 720                         }
 721                     }
 722             }
 723         }
 724         public void drawCell(Graphics g, int cx, int cy) { drawCell(g, cx, cy, Color.white); }
 725         public void drawCell(Graphics g, int cx, int cy, Color bg) {
 726             int x = (cx*(WIDTH+2))+20;
 727             int y = ((23-cy)*(HEIGHT+2))+60;
 728             if (g.getClipBounds() != null && !g.getClipBounds().intersects(new Rectangle(x, y, x+WIDTH, y+HEIGHT))) return;
 729
 730             System.out.println("drawcell " + cx + "," + cy);
 731             At40k.Cell cell = dev.cell(cx, cy);
 732             g.setColor(bg);
 733             g.fillRect(x, y, WIDTH, HEIGHT);
 734
 735             g.setColor((selx==cx && sely==cy) ? Color.red : Color.black);
 736             g.drawRect(x, y, WIDTH, HEIGHT);
 737
 738             //g.setColor((selx==cx && sely==cy) ? Color.red : Color.gray);
 739             //g.drawRect(x+(WIDTH-(LW*2))/2-1,    y+(HEIGHT-LW)/2-1, LW*2+1, LH+1);
 740
 741             g.setColor(RED);
 742             //g.fillRect(x+(WIDTH-(LW*2))/2,    y+(HEIGHT-LW)/2, LW,   LH);
 743             g.setColor(Color.white);
 744             //g.drawString("1", x+(WIDTH-(LW*2))/2,    y+(HEIGHT-LW)/2);
 745
 746             g.setColor(BLUE);
 747             //g.fillRect(x+(WIDTH-(LW*2))/2+LW, y+(HEIGHT-LW)/2, LW,   LH);
 748             g.setColor(Color.white);
 749             //g.drawString("0", x+(WIDTH-(LW*2))/2+LW,    y+(HEIGHT-LW)/2);
 750
 751             /*
 752               g.setColor(BLUE);
 753             ((Graphics2D)g).setStroke(new BasicStroke((float)1));
 754             switch(cell.yi()) {
 755                 case NORTH: g.drawLine(x+WIDTH/2+5,  y-10,        x+WIDTH/2+5, y+HEIGHT/2); break;
 756                 case SOUTH: g.drawLine(x+WIDTH/2-5,  y+HEIGHT+10, x+WIDTH/2-5, y+HEIGHT/2); break;
 757                 case EAST:  g.drawLine(x+WIDTH+10, y+HEIGHT/2+5,  x+WIDTH/2, y+HEIGHT/2+5); break;
 758                 case WEST:  g.drawLine(x-10,       y+HEIGHT/2-5,  x+WIDTH/2, y+HEIGHT/2-5); break;
 759                 case NONE:  break;
 760             }
 761             g.setColor(RED);
 762             ((Graphics2D)g).setStroke(new BasicStroke((float)1));
 763             switch(cell.xi()) {
 764                 case NW: g.drawLine(x-10+3,       y-10,        x+WIDTH/2+3, y+HEIGHT/2); break;
 765                 case SW: g.drawLine(x-10-3,       y+HEIGHT+10, x+WIDTH/2-3, y+HEIGHT/2); break;
 766                 case NE: g.drawLine(x+WIDTH+10+3, y-10,        x+WIDTH/2+3, y+HEIGHT/2); break;
 767                 case SE: g.drawLine(x+WIDTH+10-3, y+HEIGHT+10, x+WIDTH/2-3, y+HEIGHT/2); break;
 768                 case NONE:  break;
 769             }
 770             ((Graphics2D)g).setStroke(new BasicStroke(1));
 771             */
 772
 773             if (selx==cx && sely==cy) {
 774                 int xp = 23 * (WIDTH+2) + 100;
 775                 int yp = 100;
 776                 g.setColor(Color.white);
 777                 g.fillRect(xp, yp, 300, 1000);
 778                 g.setColor(Color.black);
 779                 g.drawString("Cell " + cx + "," + cy,       xp, (yp+=15));
 780                 //g.drawString("X-Lut: " + bin8(cell.xlut()), xp, (yp+=15));
 781                 g.drawString("X-Lut: " + cell.printXLut(), xp, (yp+=15));
 782                 //g.drawString("Y-Lut: " + bin8(cell.ylut()), xp, (yp+=15));
 783                 g.drawString("Y-Lut: " + cell.printYLutX(), xp, (yp+=15));
 784             }
 785
 786             if ((cell.ylut()&0xff)==0xff && (cell.xlut()&0xff)==0xff) {
 787                 g.setFont(new Font("sansserif", Font.BOLD, 24));
 788                 g.setColor(Color.white);
 789                 g.drawString("0", left(cell) + 12, top(cell) + 30);
 790                 g.drawString("1", left(cell) + 12, top(cell) + 30);
 791                 //g.setColor(RED);
 792                 //g.drawString("X="+(x?"1":"0"), left(cell) + 10, top(cell) + 20);
 793                 g.setColor(new Color(0x00, 0x00, 0xff));
 794                 g.drawString("1", left(cell) + 12, top(cell) + 30);
 795             }
 796             if ((cell.ylut()&0xff)==0x00 && (cell.xlut()&0xff)==0x00) {
 797                 g.setFont(new Font("sansserif", Font.BOLD, 24));
 798                 g.setColor(Color.white);
 799                 g.drawString("0", left(cell) + 12, top(cell) + 30);
 800                 g.drawString("1", left(cell) + 12, top(cell) + 30);
 801                 //g.setColor(RED);
 802                 //g.drawString("X="+(x?"1":"0"), left(cell) + 10, top(cell) + 20);
 803                 g.setColor(new Color(0x00, 0x00, 0xff));
 804                 g.drawString("0", left(cell) + 12, top(cell) + 30);
 805             }
 806             if ((cell.ylut()&0xff)==0xB2) {
 807                 System.out.println("muller @ " + cell);
 808                 g.setFont(new Font("sansserif", Font.BOLD, 24));
 809                 g.setColor(Color.white);
 810                 g.drawString("0", left(cell) + 12, top(cell) + 30);
 811                 g.drawString("1", left(cell) + 12, top(cell) + 30);
 812                 //g.setColor(RED);
 813                 //g.drawString("X="+(x?"1":"0"), left(cell) + 10, top(cell) + 20);
 814                 g.setColor(new Color(0x00, 0xaa, 0x00));
 815                 g.drawString("C", left(cell) + 12, top(cell) + 30);
 816             }
 817         }
 818     }
 819
 820     private static String pad(int i, String s) { if (s.length()>i) return s; return "0"+pad((i-1),s); }
 821     private static String bin8(byte b) {
 822         int n = b & 0xff;
 823         String ret = "";
 824         for(int i=7; i>=0; i--)
 825             ret += (n & (1<<i))==0 ? "0" : "1";
 826         return ret;
 827     }
 828
 829     public static void selfTest(AvrDrone device, At40k at40k, Visualizer v) {
 830             int fail = 0;
 831             long now = System.currentTimeMillis();
 832             for(int x=0; x<24; x++)
 833                 for(int y=0; y<24; y++) {
 834                     At40k.Cell cell = at40k.cell(x,y);
 835                     scan(at40k, cell, YLUT, true);
 836                     //v.paint(img.getGraphics());
 837                     //v.getGraphics().drawImage(img, 0, 0, null);
 838                     cell.ylut(0xff);
 839                     boolean a = (device.readBus() & 0x80)!=0;
 840                     cell.ylut(0x00);
 841                     boolean b = (device.readBus() & 0x80)!=0;
 842                     if (a & !b) {
 843                         //System.out.println("pass " + x+","+y);
 844                         Graphics g = v.getGraphics();
 845                         g.setColor(Color.green);
 846                         g.drawString("pass", v.left(cell) + 10, v.top(cell) + 20);
 847                     } else {
 848                         System.out.println("FAIL!!!! " + x+","+y+" => " + a + " " + b);
 849                         fail++;
 850                         Graphics g = v.getGraphics();
 851                         g.setColor(Color.red);
 852                         g.drawString("FAIL", v.left(cell) + 10, v.top(cell) + 20);
 853                     }
 854                     scan(at40k, cell, YLUT, false);
 855                 }
 856
 857             System.out.println("failures: " + fail);
 858             System.out.println("scan time: " + (System.currentTimeMillis()-now) + "ms");
 859     }
 860
 861 }