Aktív témák

• #21 t3rm1nat0r csendes tag

  2009-12-30 12:36:40 #21

  Ö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

  Mivel egy c program lesz ami majd emulálja a hardver működését, ezért kicsit a programozás rejtelmeiben is elmerülök. Ezért került ide ez a topik.

  Ha megnézzük, hogy egy D flip-flop mennyi kapuból áll, és egy kapu mennyi tranzisztorból, elsőre elég elrettentőnek látszik a feladat.
  Itt jön a képbe a programozás igazi lényege. Mert nem az a lényeg, hogy az összes c nyelvjárás szintaktikai külömbségeit fejből fujja az ember. Azt egy ovodás is kiguglizza.

  A feladat felbontása kisebb részfeladatokra. Ez az, amit /még/ nem tudnak a gépek.

  Mivel a c nyelv egy logikai kapu működését egyszerűen utánnozza, ezért ez lesz az alapszint. Erre épül fel majd minden. Mivel látványos programot akarok, ezért a tranzisztorok állapotát is meg lehet majd jeleníteni a kapu állapotának ismeretében.
  Igazából egy processzort nem kapuszinten terveznek, hanem nagyobb egységekből rakják össze. Ez programozásnál is egy bevált módszer. Ha már tesztelt, és biztosan jól működő részegységekből építkezünk, akkor az új rendszer gyorsabban áll össze, és kisebb a hibalehetőség.

  A nemrég belinkelt Dflipflop-nak ennyi a kódja.Ez egyszerűen megmonja, hogy egy sorXsor-os NAND tömbben melyik kapu melyik két másikhoz kapcsolódjon.

  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);
  }

  Innentől egy 8 bites számlálónak már csak ennyi a kódja.Ez megadja, hogy két soronként legyen lefele egy-egy Dflipflop, és mindig az előző kimenetére csatlakozzon.

  //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;

  Definiálni kellene a define_links() függvényt. Mondjuk legyen ilyen.

  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;
  }

  Ebből már sejthető, hogy az alapstruktúrának valami hasonlónak kell lennie.

  struct struct_nand
  {
  int in1,in2,out;
  int link[2];
  int xykoord[3][2];
  }nand[2000];

  Lesz egy kapunak két bemenete és egy kimenete. Hogy honnan szedje az értéket a bemenet, ezt adja meg a link[]. Ezt definiáltam az előbb.

  A kapuk szimulációja sem sokkal bonyolultabb.

  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
  }

  A kapu lehet az 5V-ra vagy a földre kötve, de kaphatja a bemenetét egy másik kapuról. Ha ezt beállitottuk, akkor már csak a NAND művelet elvégzése van hátra.

  Igazából ez már így működik, de senki nem kiváncsi egyesek meg nullák ugrálására a képernyőn.
  Na ez a rész már kissé bonyolultabb lesz, de nem vészes.

Aktív témák