Aktív témák

• #22 t3rm1nat0r csendes tag

  2009-12-30 12:42:37 #22

  Összes hozzászólása itt Válaszok az összes hozzászólására itt Válaszok erre a hozzászólásra

  Privát üzenet küldése

  

  t3rm1nat0r

  csendes tag

  Elég a mellébeszélésből, lássuk a lényeget.

  #include <stdio.h>
  #include <stdlib.h>
  #include <math.h>
  
  
  #include <X11/Xlib.h>
  #include <assert.h>
  #include <unistd.h>
  
  
  Display *disp;
  Window win;
  GC gc;
  
  
  void pixel(int x,int y,int color)
  {
  XSetForeground(disp,gc,color);
  XDrawPoint(disp, win, gc, x,y);
  }
  void draw_line(int x1,int y1,int x2,int y2,int color)
  {
  XSetForeground(disp,gc,color);
  XDrawLine(disp, win, gc, x1,y1,x2,y2);
  }
  void initialize()
  {
  disp = XOpenDisplay((0));
  win = XCreateSimpleWindow(disp, DefaultRootWindow(disp), 0,0, 1200, 850, 0,0,0);
  
  XSelectInput(disp, win, StructureNotifyMask);
  XMapWindow(disp, win);
  
  gc = XCreateGC(disp, win, 0, (0));
  XSetForeground(disp,gc,0);
  
  while(1)
  {
  XEvent event;
  XNextEvent(disp, &event);
  if (event.type == MapNotify)break;
  }
  }
  
  
  
  
  
  
  //#define random_nand
  
  struct struct_nand
  {
  int in1,in2,out;
  int link[2];
  int xykoord[3][2];
  }nand[2000];
  
  
  
  int szinek[]={0x777700,0xffff00};
  int xykoord[10][2];
  
  const int link_0V =-3;
  const int link_5V =-2;
  const int link_none=-1;
  
  
  
  const int sor=32;
  const int ketsor=32*2;
  
  
  
  
  
  
  void draw_tranz(int x,int y,int l1,int l2,int l3,int n)
  {
  draw_line(x,y,x,y+8,0xff0000);
  draw_line(x+2,y,x+2,y+8,0xff0000);
  
  xykoord[n][0]=x-4;//in
  xykoord[n][1]=y+4;
  draw_line(x-4,y+4,x-1,y+4,szinek[l1]);
  
  draw_line(x+3,y+2,x+6,y+2,szinek[l2]);
  draw_line(x+3,y+6,x+6,y+6,szinek[l3]);
  
  draw_line(x+6,y-2,x+6,y+2,szinek[l2]);
  draw_line(x+6,y+9,x+6,y+6,szinek[l3]);
  
  if(n==1)
  {
  xykoord[4][0]=x+6;//out
  xykoord[4][1]=y+9;
  }
  if(n==0)
  {
  xykoord[5][0]=x+6;//0.tr out
  xykoord[5][1]=y+9;
  }
  }
  void draw_nand(int j)
  {
  if(nand[j].link[0]==link_none)
  if(nand[j].link[1]==link_none) return;
  
  int x=j%sor;
  int y=j/sor;
  x*=30;
  y*=40;
  
  draw_tranz(x+12,y+12,nand[j].in1,1,!nand[j].in1,0);//1 bal
  draw_tranz(x+24,y+12,nand[j].in2,1,!nand[j].in2,1);//3 db jobb lefele
  draw_tranz(x+24,y+24,nand[j].in1, !nand[j].in1,0,2);
  draw_tranz(x+24,y+36,nand[j].in2, !nand[j].in2,0,3);
  
  int q=0,w=2;//in
  draw_line(xykoord[q][0],xykoord[q][1],xykoord[q][0],xykoord[w][1],szinek[nand[j].in1]);
  draw_line(xykoord[w][0],xykoord[w][1],xykoord[q][0],xykoord[w][1],szinek[nand[j].in1]);
  
  q=1;w=3;
  draw_line(xykoord[q][0],xykoord[q][1],xykoord[q][0],xykoord[w][1],szinek[nand[j].in2]);
  draw_line(xykoord[w][0],xykoord[w][1],xykoord[q][0],xykoord[w][1],szinek[nand[j].in2]);
  
  w=4;
  draw_line(xykoord[w][0],xykoord[w][1],xykoord[w][0]+3,xykoord[w][1],szinek[nand[j].out]);//out
  nand[j].xykoord[0][0]=xykoord[w][0]+3;
  nand[j].xykoord[0][1]=xykoord[w][1];
  
  w=0;
  draw_line(xykoord[w][0],xykoord[w][1],xykoord[w][0]-3,xykoord[w][1],szinek[nand[j].in1]);//in1
  draw_line(xykoord[w][0]+12,xykoord[w][1]+15,xykoord[w][0]-3,xykoord[w][1]+15,szinek[nand[j].in2]);//int2
  nand[j].xykoord[1][0]=xykoord[w][0]-3;
  nand[j].xykoord[1][1]=xykoord[w][1];
  nand[j].xykoord[2][0]=xykoord[w][0]-3;
  nand[j].xykoord[2][1]=xykoord[w][1]+15;
  
  w=5;
  draw_line(xykoord[w][0],xykoord[w][1],xykoord[w][0]+12,xykoord[w][1],szinek[!nand[j].in1]);//in1
  }
  void draw_connect(int j,int link,int s,int dx,int col)
  {
  if(link<0) return;
  
  int x=nand[j].xykoord[s][0];
  int y=nand[j].xykoord[s][1];
  int x3=nand[link].xykoord[0][0];
  int y3=nand[link].xykoord[0][1];
  int x2,y2;
  
  x2=x;
  y2=y+dx;
  draw_line(x,y,x2,y2,col);x=x2;y=y2;
  
  x2=x3;
  y2=y;
  draw_line(x,y,x2,y2,col);x=x2;y=y2;
  
  x2=x3+dx;
  y2=y;
  draw_line(x,y,x2,y2,col);x=x2;y=y2;
  
  x2=x3+dx;
  y2=y3;
  draw_line(x,y,x2,y2,col);x=x2;y=y2;
  
  x2=x3;
  y2=y3;
  draw_line(x,y,x2,y2,col);x=x2;y=y2;
  }
  void draw_layer()
  {
  int j;
  
  for(j=0;j<1000;j+=40) draw_line(0,j+9,1000,j+9,0xffff00);//tap vezetekek
  for(j=0;j<1000;j+=40) draw_line(0,j+6,1000,j+6,0x777700);
  
  
  for(j=0;j<sor*sor;j++) draw_nand(j);
  
  for(j=0;j<sor*sor;j++)
  {
  int dx=2+(j%8)*2;
  draw_connect(j,nand[j].link[0],1,dx,szinek[nand[j].in1]);
  draw_connect(j,nand[j].link[1],2,dx,szinek[nand[j].in2]);
  }
  }
  
  
  
  
  
  
  void define_links(int t,int l1,int l2,int default_out)
  {
  nand[t].link[0]=l1;
  nand[t].link[1]=l2;
  nand[t].out=default_out;
  }
  
  void define_adder(int t,int l1,int l2,int l3)
  {
  int tr[]={
  t+0, t+1, t+2, t+3, t+4,
  t+sor+0, t+sor+1, t+sor+2, t+sor+3, 0};//5-8
  
  define_links(tr[0],l1,l2,0); define_links(tr[1],l1,tr[0],0);
  define_links(tr[2],tr[5],tr[1],0); define_links(tr[3],tr[2],l3,0);
  define_links(tr[4],tr[3],tr[2],0);
  
  define_links(tr[5],tr[0],l2,0); define_links(tr[6],tr[3],l3,0);
  define_links(tr[7],tr[4],tr[6],0); define_links(tr[8],tr[0],tr[3],0);
  }
  
  void define_dflip(int t,int l1)
  {
  int tr[]={
  t+0, t+1, t+2, t+3, t+4,
  t+sor+0, t+sor+1, t+sor+2, t+sor+3, t+sor+4,0};//5-9
  
  
  define_links(tr[0],link_5V,l1,0); //inverter
  define_links(tr[5],link_5V,tr[4],1);
  
  define_links(tr[1],l1,tr[5],0); define_links(tr[2],tr[7],tr[1],1);
  define_links(tr[6],l1,tr[4],1); define_links(tr[7],tr[2],tr[6],0);
  
  define_links(tr[3],tr[0],tr[2],1); define_links(tr[4],tr[9],tr[3],0);
  define_links(tr[8],tr[0],tr[7],1); define_links(tr[9],tr[4],tr[8],1);
  
  }
  void define_decoder(int tr3,int tr4,int mask)
  {
  int dx[]={sor,sor,sor,sor};//invertalva egy ketsorral lejjebb
  
  if(mask&1) dx[0]=0;
  if(mask&2) dx[1]=0;
  if(mask&4) dx[2]=0;
  if(mask&8) dx[3]=0;
  
  define_links(tr3 ,tr4+dx[0] ,tr4+ketsor+dx[1],0);
  define_links(tr3+1,tr3,link_5V,0); //inverter
  
  define_links(tr3+2,tr4+ketsor*2+dx[2],tr4+ketsor*3+dx[3],0);
  define_links(tr3+3,tr3+2,link_5V,0);//inverter
  
  define_links(tr3+4,tr3+1,tr3+3,0);
  define_links(tr3+5,tr3+4,link_5V,0);//inverter
  }
  void nand_gates()
  {
  int i,j,y;
  
  nand[0].out=1;
  nand[sor].out=1;
  
  
  
  
  
  for(j=0;j<sor*sor;j++)
  {
  nand[j].in1=1;
  nand[j].in2=1;
  
  nand[j].link[0]=link_none;
  nand[j].link[1]=link_none;
  #ifdef random_nand
  nand[j].link[0]=j + (rand()%4) + (rand()%4)*sor;
  nand[j].link[1]=j + (rand()%4) + (rand()%4)*sor;
  #endif
  }
  
  
  
  
  
  //counter
  int counter_bazis=2,counter_out_offset=4;
  int tr=counter_bazis;
  define_dflip(tr,0); tr+=ketsor;
  define_dflip(tr,tr+counter_out_offset-ketsor); tr+=ketsor;
  define_dflip(tr,tr+counter_out_offset-ketsor); tr+=ketsor;
  define_dflip(tr,tr+counter_out_offset-ketsor); tr+=ketsor;
  define_dflip(tr,tr+counter_out_offset-ketsor); tr+=ketsor;
  define_dflip(tr,tr+counter_out_offset-ketsor); tr+=ketsor;
  define_dflip(tr,tr+counter_out_offset-ketsor); tr+=ketsor;
  define_dflip(tr,tr+counter_out_offset-ketsor); tr+=ketsor;
  
  
  //address decoder
  int tr3=20,tr4=counter_bazis + counter_out_offset, addr=0;
  define_decoder(tr3,tr4,addr++); tr3+=sor;
  define_decoder(tr3,tr4,addr++); tr3+=sor;
  define_decoder(tr3,tr4,addr++); tr3+=sor;
  define_decoder(tr3,tr4,addr++); tr3+=sor;
  define_decoder(tr3,tr4,addr++); tr3+=sor;
  define_decoder(tr3,tr4,addr++); tr3+=sor;
  define_decoder(tr3,tr4,addr++); tr3+=sor;
  define_decoder(tr3,tr4,addr++); tr3+=sor;
  define_decoder(tr3,tr4,addr++); tr3+=sor;
  define_decoder(tr3,tr4,addr++); tr3+=sor;
  define_decoder(tr3,tr4,addr++); tr3+=sor;
  define_decoder(tr3,tr4,addr++); tr3+=sor;
  define_decoder(tr3,tr4,addr++); tr3+=sor;
  define_decoder(tr3,tr4,addr++); tr3+=sor;
  define_decoder(tr3,tr4,addr++); tr3+=sor;
  define_decoder(tr3,tr4,addr++); tr3+=sor;
  
  
  //adder
  int adder_bazis=9,adder_out_offset=34;
  int tr1=adder_bazis,tr_out1=counter_bazis+counter_out_offset,tr_out_carry=link_0V;
  define_adder(tr1,link_0V,tr_out1,tr_out_carry); tr1+=ketsor; tr_out1+=ketsor;
  
  tr_out_carry=adder_bazis + adder_out_offset + 1;
  define_adder(tr1, link_5V, tr_out1, tr_out_carry); tr1+=ketsor; tr_out1+=ketsor; tr_out_carry+=ketsor;
  define_adder(tr1, link_0V, tr_out1, tr_out_carry); tr1+=ketsor; tr_out1+=ketsor; tr_out_carry+=ketsor;
  define_adder(tr1, link_5V, tr_out1, tr_out_carry); tr1+=ketsor; tr_out1+=ketsor; tr_out_carry+=ketsor;
  define_adder(tr1, link_0V, tr_out1, tr_out_carry); tr1+=ketsor; tr_out1+=ketsor; tr_out_carry+=ketsor;
  define_adder(tr1, link_0V, tr_out1, tr_out_carry); tr1+=ketsor; tr_out1+=ketsor; tr_out_carry+=ketsor;
  define_adder(tr1, link_0V, tr_out1, tr_out_carry); tr1+=ketsor; tr_out1+=ketsor; tr_out_carry+=ketsor;
  define_adder(tr1, link_0V, tr_out1, tr_out_carry); tr1+=ketsor; tr_out1+=ketsor; tr_out_carry+=ketsor;
  
  
  
  
  
  
  while(1)
  {
  //printf("%d.. %d %d \n",k,nand[0].out,nand[sor].out);
  
  
  
  draw_layer();
  
  for(i=0;i<100;i++)
  {
  //draw_layer();//ido kell mig minden beall, kirajzolhato a koztes allapot
  
  for(j=0;j<sor*sor;j++)
  if((j%sor))//elso sor nem kell
  {
  int link1=nand[j].link[0];
  int link2=nand[j].link[1];
  
  if(link1==link_5V) nand[j].in1=1;//fix input
  if(link2==link_5V) nand[j].in2=1;
  if(link1==link_0V) nand[j].in1=0;
  if(link2==link_0V) nand[j].in2=0;
  
  if(link1>=0) nand[j].in1=nand[link1].out;//out -> in1,2
  if(link2>=0) nand[j].in2=nand[link2].out;
  }
  for(j=0;j<sor*sor;j++)
  if((j%sor))//elso sor nem kell
  {
  nand[j].out=!(nand[j].in1 & nand[j].in2);//NAND muvelet
  }
  
  }
  
  int s=1,a=0;
  for(y=0;y<16;y+=2)
  {
  // for(x=0;x<6;x++) printf("%d ",nand[x+sor*y].out);
  
  int e=nand[counter_bazis + counter_out_offset + sor*y].out;//counter kimenet
  if(e) a+=s;
  s<<=1;
  
  printf("%d ",e);
  }
  printf(" = %d \n",a);
  
  a=0;s=1;
  for(y=0;y<16;y+=2)
  {
  int e=nand[adder_bazis + sor*y + adder_out_offset].out;//adder kimenet
  
  if(e) a+=s;
  s<<=1;
  
  printf("%d ",e);
  }
  printf(" = %d \n",a);
  
  
  
  
  nand[0].out^=1;
  
  printf("\n");
  // getchar();
  }
  }
  
  
  
  
  
  int main()
  {
  initialize();
  nand_gates();
  XFlush(disp);
  getchar();
  return 0;
  }

Aktív témák