Comparator

Uit Wikipedia, de vrije encyclopedie
Ga naar: navigatie, zoeken

Een comparator is eigenlijk een vergelijker. In de naam comparator zit comparare (latijn voor: vergelijken). Een comparator is een schakeling die twee n-bit woorden met elkaar vergelijkt. De uitgang van de schakeling wordt hoog als de bits van woord A gelijk zijn aan de bits van woord B. De comparator is een van de meest gebruikte componenten in de elektronica.

Zowel in analoge als digitale schakelingen wordt deze component gebruikt.

Er zijn verschillende comparatoren, een klein voorbeeld hiervan is de magnitude comparator. Deze comparator heeft 3 uitgangen, die hoog worden naargelang het resultaat van de vergelijking. De resultaten op een magnitude comparator zijn:

  • woord A > woord B.
  • woord A < woord B.
  • woord A = woord B.

Ontwerp[bewerken]

Comparator voor 2 1-bit woorden[bewerken]

Inputs Outputs
A B A<B A=B A>B
0 0 0 1 0
0 1 1 0 0
1 0 0 0 1
1 1 0 1 0
Schema 1-bit comparator

Dit is de eenvoudigste comparator, waar 2 woorden van elk 1 bit met elkaar vergeleken worden. In bijstaande figuur zie je de waarheidstabel van deze comparator.

Als we nu besluiten dat, G = (A > B), K = (A < B) en E = (A = B), dan kunnen we de logische vergelijkingen afleiden vanuit een waarheidstabel of via een KV-diagram.

De logische vergelijkingen voor deze comparator zijn als volgt:

  • G = A B(niet)
  • K = A(niet) B
  • E = A(niet) B(niet) OF A B

Nu we deze vergelijkingen weten kunnen we een mogelijke praktische realisatie van de schakeling maken. Het schema van de comparator voor 2 woorden van 1 bit, vind je in bijstaande figuur.

Een comparator voor 2 woorden van elk 1 bit, zul je echter niet gauw tegenkomen in de praktijk. In praktijk zal de eenvoudigste comparator 2 woorden van elk 4 bits vergelijken.

Comparator voor 2 4-bit woorden[bewerken]

Een voorbeeld van een comparator voor 2 woorden van elk 4 bits is de 74LS85, een 4-bit magnitude comparator. In onderstaande figuur vind je de waarheidstabel voor deze IC.

Inputs Cascade Inputs Outputs
A_3, B_3 A_2, B_2 A_1, B_1 A_0, B_0 A<B A=B A>B A<B A=B A>B
A > B x x x x x x 0 0 1
A < B x x x x x x 1 0 0
A = B A > B x x x x x 0 0 1
A = B A < B x x x x x 1 0 0
A = B A = B A > B x x x x 0 0 1
A = B A = B A < B x x x x 1 0 0
A = B A = B A = B A > B x x x 0 0 1
A = B A = B A = B A < B x x x 1 0 0
A = B A = B A = B A = B 0 0 1 0 0 1
A = B A = B A = B A = B 1 0 0 1 0 0
A = B A = B A = B A = B 0 1 0 0 1 0

De 74LS85 vergelijkt 2 4-bit ingangen en zegt of ze groter dan, kleiner dan of gelijk aan elkaar zijn. Er zijn ook nog 3 cascade ingangen voorzien om de 4-bit comparator uit te breiden naar een 8, 12, 16,…-bit comparator. Deze worden met de corresponderende cascade ingangen van de volgende comparator verbonden. De laagste orde comparator heeft een hoog signaal aan de A = B input en lage signalen aan de A < B en A > B inputs.

In bijstaande figuur zie je het schema van de 74LS85, waar de cascade-schakeling duidelijk te zien is.

Je kan deze comparator ook gebruiken in een VHDL-code voor Xilinx, dat zie je in de code hieronder.

library ieee; 
use ieee.std_logic_1164.all;

entity four_bit_comparator is 
   port ( 
      A,B : in std_logic_vector(3 downto 0); 
      AgB_in , AsB_in, AeB_in: in std_logic; 
      AgB_out, AsB_out, AeB_out: out std_logic 
   ); 
end entity four_bit_comparator; 
architecture beschrijving of four_bit_comparator is 
   signal sane: bit; 
begin 
process (A,B,sane,AgB_in,AeB_in,AsB_in) begin 
   if( 
      (AgB_in='1' or AgB_in='0') 
      and 
      (AeB_in='1' or AeB_in='0') 
      and 
      (AsB_in='1' or AsB_in='0') 
      and 
      (A(0)='1' or A(0)='0') and (A(1)='1' or A(1)='0') 
      and 
      (A(2)='1' or A(2)='0') and (A(0)='1' or A(3)='0') 
      and 
      (B(0)='1' or B(0)='0') and (B(1)='1' or B(1)='0') 
      and 
      (B(2)='1' or B(2)='0') and (B(0)='1' or B(3)='0') 
   ) 
   then sane<='1'; else sane<='0'; end if; 
   if sane='0' then 
      AsB_out <= 'X'; AgB_out <= 'X'; AeB_out <= 'X'; 
   else 
      if A=B then 
         if 
            AgB_in='1' and AsB_in='0' and AeB_in='0' then 
            AgB_out<='1'; AsB_out<='0'; AeB_out<='0';   end if; 
         if 
            AgB_in='0' and AsB_in='1' and AeB_in='0' then 
            AgB_out<='0'; AsB_out<='1'; AeB_out<='0';   end if; 
         if 
            AeB_in='1' then 
            AgB_out<='0'; AsB_out<='0'; AeB_out<='1';   end if; 
         if 
            AgB_in='1' and AsB_in='1' and AeB_in='0' then 
            AgB_out<='0'; AsB_out<='0'; AeB_out<='1';   end if; 
         if 
            AgB_in='0' and AsB_in='0' and AeB_in='0' then 
            AgB_out<='1'; AsB_out<='1'; AeB_out<='0';   end if; 
      end if; 
      if A>B then 
         AgB_out <= '1'; AsB_out<='0'; AeB_out<='0'; 
      end if; 
      if A<B then 
         AsB_out <= '1'; AgB_out<='0'; AeB_out<='0'; 
      end if; 
   end if; 
end process; 
end architecture beschijving;

Nut[bewerken]

Magnitude comparatoren en andere comparatoren zijn nuttig in schakelingen waarin binaire getallen verschillende fysische grootheden voorstellen en vergeleken worden met vaste ingestelde referentiegrootheden. De uitgangen sturen de fysische grootheid bij tot de gewenste (referentiegrootheid) bereikt wordt.

Deze fysische grootheden kunnen grootheden zijn zoals; een bepaalde hoeveelheid, een snelheid, een temperatuur….

Een voorbeeld waarin een magnitude comparator gebruikt wordt is de telcontrole in een kopieermachine.