Comparator

Een comparator is eigenlijk een vergelijker. In de naam comparator zit comparare (latijn voor: vergelijken). Zowel in analoge als digitale schakelingen wordt deze component gebruikt.

Een digitale 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.

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

Digitale Comparator voor 2 1-bit woorden

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

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.

Digitale comparator voor 2 4-bit woorden

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

Nut

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.

Zie de categorie Comparators van Wikimedia Commons voor mediabestanden over dit onderwerp.