આ લોજિક ગેટ્સ એ ડિજિટલ ઇલેક્ટ્રોનિક્સનો આધાર છે. આ કારણોસર, તેઓ ખૂબ જ મહત્વપૂર્ણ છે, અને જો તમે તેમની સાથે કામ કરવાનું શરૂ કરવા માંગતા હો, તો તમારે જાણવું જોઈએ કે તેઓ શું છે, તેઓ કેવી રીતે રચાય છે અને તેમનું કાર્ય. તેથી તમે બજારમાં અસ્તિત્વમાં રહેલી ચિપ્સની શ્રેણીનો ઉપયોગ કરી શકો છો જેમાં આ પ્રકારના દરવાજા હોય છે જેથી તમે આ તર્ક સાથે કામ કરીને તમારા પોતાના પ્રોજેક્ટ બનાવવાનું શરૂ કરી શકો.
આ દરવાજા, અન્ય સાથે જોડાઈ ઇલેક્ટ્રોનિક ઘટકો, અને તે પણ પ્લેટો જેવી Arduino, તેઓ નિર્માતાઓને ઘણું નાટક આપી શકે છે જેમ તમે તમારા માટે જોઈ શકો છો.
લોજિક ગેટ શું છે?
આ તર્ક દરવાજા તે ડિજિટલ ઇલેક્ટ્રોનિક સર્કિટના અમલીકરણ માટે ડિજિટલ તર્કના મૂળભૂત ઘટકો છે. આ દરવાજાઓ તેમના ઇનપુટ્સની સ્થિતિના આધારે તેમના આઉટપુટ પર નીચા (0) અથવા ઉચ્ચ (1) વોલ્ટેજ સિગ્નલો પ્રદાન કરે છે. તેમની પાસે સામાન્ય રીતે એક બહાર નીકળો અને બે પ્રવેશદ્વાર હોય છે, પરંતુ 2 થી વધુ પ્રવેશદ્વારો સાથે દરવાજા હોઈ શકે છે. વધુમાં, ત્યાં ખાસિયતો છે જેમ કે ઇનવર્ટિંગ ગેટ કે નહીં, તેમાં માત્ર એક ઇનપુટ અને એક આઉટપુટ છે.
આ બુલિયન ઇનપુટ્સ અને આઉટપુટ માટે આભાર તમે મેળવી શકો છો પ્રાથમિક દ્વિસંગી તર્ક કામગીરી, જેમ કે સરવાળો, ગુણાકાર, નકારાત્મકતા, વગેરે.
તેઓ કેવી રીતે અમલમાં આવે છે?
લોજિક ગેટ્સ માત્ર એક રીતે અમલમાં મૂકી શકાતા નથી. હકીકતમાં, તેથી જ ત્યાં વિવિધ છે તાર્કિક પરિવારો. આમાંના દરેક પરિવારો વિવિધ ઇલેક્ટ્રોનિક ઘટકોનો ઉપયોગ કરીને એક રીતે ગેટનો અમલ કરશે.
પોર ઇઝેમ્પ્લોજો TTL નો ઉપયોગ ચિપ માટે કરવામાં આવે છે, તો દરવાજા બાયપોલર ટ્રાન્ઝિસ્ટરથી બનેલા હશે, જ્યારે CMOS લોજિક ફક્ત MOSFET ટ્રાન્ઝિસ્ટર પર આધારિત છે. આ બે પરિવારો ઉપરાંત, જે સામાન્ય રીતે સૌથી વધુ લોકપ્રિય છે, ત્યાં અન્ય પણ છે જેમ કે BiCMOS (દ્વિધ્રુવી અને CMOS ટ્રાન્ઝિસ્ટરને જોડે છે), RTL (રેઝિસ્ટર અને બાયપોલર ટ્રાન્ઝિસ્ટર), DTL (ડાયોડ્સ અને ટ્રાન્ઝિસ્ટર), ECL, IIL, વગેરે.
ત્યાં એક કુટુંબ બીજા કરતા વધુ સારું નથી, તે એપ્લિકેશન પર નિર્ભર રહેશે. પરંતુ તેમ છતાં, CMOS તે CPU, MCU, GPU, મેમરી વગેરે જેવા અદ્યતન સર્કિટમાં સૌથી વધુ ઉપયોગમાં લેવાતું એક છે. અન્ય સરળ સર્કિટ માટે TTL શોધવાનું પણ સામાન્ય છે.
ઍપ્લિકેશન
આ લોજિક ગેટ્સની એપ્લિકેશન્સ અનંત છે. આ આવશ્યક "ઇંટો" સાથે તમે બનાવી શકો છો ડિજિટલ સર્કિટનો સમૂહ. એક સરળ એડરથી, જટિલ CPU સુધી, તમે કલ્પના કરી શકો તેવા અન્ય ઘણા સર્કિટ દ્વારા. વાસ્તવમાં, તમે દરરોજ ઉપયોગ કરો છો તે ઘણી સિસ્ટમો, જેમ કે તમારું પીસી, તમારું ટીવી, મોબાઈલ વગેરે, અબજો લોજિક ગેટ ધરાવે છે.
Un વ્યવહારુ ઉદાહરણ લોજિક ગેટ્સની એપ્લિકેશન આ સરળ એડર હશે જે તમે ઉપરની છબીમાં જોઈ શકો છો. તે એક ખૂબ જ સરળ સર્કિટ છે, જે સરવાળા પરિણામ આપવા માટે તેના ઇનપુટ્સમાં બે બિટ્સ (A અને B) ઉમેરવા સક્ષમ છે, અને કેરી પણ, એટલે કે, તમે જે લઈ જાઓ છો... તમે તેના પરિણામો જોઈ શકો છો. નીચેના કોષ્ટકમાં આપો:
A | B | રકમ | કેરી | દ્વિસંગી પરિણામ |
---|---|---|---|---|
0 | 0 | 0 | 0 | 00 |
0 | 1 | 1 | 0 | 01 |
1 | 0 | 1 | 0 | 01 |
1 | 1 | 0 | 1 | 10 |
જો તમે આ કોષ્ટક જુઓ, જો તમે બાઈનરીમાં 0 + 0 ઉમેરશો તો તે તમને 0 આપશે, જો તમે 1 + 0 ઉમેરશો તો તે 1 છે, પરંતુ જો તમે 1 + 1 ઉમેરો છો તો તે 2 આપશે, જે દ્વિસંગી સિસ્ટમમાં 10 ને અનુરૂપ છે.
લોજિક ગેટ્સના પ્રકાર
આ માટે લોજિક ગેટ્સના પ્રકાર, તમારી પાસે તેમાંથી સારી સંખ્યા છે, જો કે સૌથી વધુ ઉપયોગમાં લેવાતા નીચેના છે (તેમના સત્ય કોષ્ટકો સાથે):
- બફર (હા): તેને બફર અથવા ડાયરેક્ટ ગેટ તરીકે ઓળખવામાં આવે છે, કારણ કે તેના આઉટપુટની સ્થિતિ તેના ઇનપુટ જેવી જ હશે. જો કે તે નકામું લાગે છે, ઘણા લોજિક સર્કિટ્સમાં તેનો વારંવાર વર્તમાન એમ્પ્લીફાયર અથવા વોલ્ટેજ અનુયાયી તરીકે ઉપયોગ થાય છે.
એન્ટ્રડા | બહાર નીકળો |
---|---|
0 | 0 |
1 | 1 |
- નહીં (ઇનવર્ટર): લોજિકલ નેગેશન (¬o'), એટલે કે, તે તેના આઉટપુટ પર બીટને ઉલટાવે છે.
એન્ટ્રડા | બહાર નીકળો |
---|---|
0 | 1 |
1 | 0 |
- અને (Y): આ અન્ય ગેટ તેના ઇનપુટના દ્વિસંગી બિટ્સનું ઉત્પાદન કાર્ય (·) કરે છે. એટલે કે, તે A અને B નો ગુણાકાર કરવા જેવું હશે. તેથી, શૂન્ય વડે કંઈપણ શૂન્ય છે, તે તેના આઉટપુટને માત્ર એક જ આપશે જો બંને ઇનપુટ 1 હોય. તેથી તેનું નામ 1 અને 1.
A | B | S |
---|---|---|
0 | 0 | 0 |
0 | 1 | 0 |
1 | 0 | 0 |
1 | 1 | 1 |
- સોનું): આ બીજો દરવાજો તાર્કિક ઉમેરણ કામગીરી (+) કરે છે. એટલે કે, તેના આઉટપુટમાંથી એક અથવા બીજું, અથવા તેનું આઉટપુટ 1 થવા માટે બંને 1 પર હોવા જોઈએ. જ્યારે બંને 0 હોય, ત્યારે આઉટપુટ પણ 0 હોય.
A | B | S |
---|---|---|
0 | 0 | 0 |
0 | 1 | 1 |
1 | 0 | 1 |
1 | 1 | 1 |
- XOR (અથવા વિશિષ્ટ): આ વિશિષ્ટ OR બુલિયન કાર્ય A'B + AB ' કરે છે, અને તેનું પ્રતીક છે . આ કિસ્સામાં, જો તેના બે ઇનપુટ સમાન હોય, તો આઉટપુટ 0 છે. જો તે અલગ હોય, તો તે 1 હશે.
A | B | S |
---|---|---|
0 | 0 | 0 |
0 | 1 | 1 |
1 | 0 | 1 |
1 | 1 | 0 |
- NAND (Y નકારેલ): નકારેલ તાર્કિક ઉત્પાદન છે, એટલે કે, AND નો વ્યસ્ત. તે આઉટપુટ બિટ્સને ઊંધું કરવા માટે AND આઉટપુટ પર NOT નો ઉપયોગ કરવા જેવું છે. તેથી, પરિણામો છે:
A | B | S |
---|---|---|
0 | 0 | 1 |
0 | 1 | 1 |
1 | 0 | 1 |
1 | 1 | 0 |
- NOR (અથવા નકારેલ): નકારાત્મક તાર્કિક સરવાળો, અથવા સમાન શું છે, એક OR તેના નકારાત્મક આઉટપુટ સાથે, પરિણામે OR ના વિપરિત થાય છે.
A | B | S |
---|---|---|
0 | 0 | 1 |
0 | 1 | 0 |
1 | 0 | 0 |
1 | 1 | 0 |
- XNOR (વિશિષ્ટ NOR): તે XOR ગેટ પર દ્વિસંગી પૂરક લાગુ કરવા જેવું છે. એટલે કે, AB + A'B' ઓપરેશન કરો. A ગુણ્યા B માં A ગુણ્યા B નકાર્યા. તેથી, આઉટપુટ ઇનવર્ટેડ XOR જેવા હશે:
A | B | S |
---|---|---|
0 | 0 | 1 |
0 | 1 | 0 |
1 | 0 | 0 |
1 | 1 | 1 |
NOR અને NAND એ બે સૌથી રસપ્રદ દરવાજા છે, કારણ કે તેઓ તરીકે ઓળખાય છે યુનિવર્સલ લોજિક ગેટ્સ. એટલે કે, તમે અન્ય કોઈપણ પ્રકારના લોજિક ગેટને રજૂ કરવા માટે માત્ર તેમની સાથે સર્કિટ બનાવી શકો છો. આ મહત્વપૂર્ણ છે, કારણ કે જો તમે આ દરવાજા સાથે ચિપ્સ ખરીદો છો, તો તમારી પાસે તમામ કાર્યો હોઈ શકે છે. ઉદાહરણ તરીકે, જો NOR ના બે ઇનપુટ્સ બ્રિજ કરેલા હોય અથવા NAND એ NOT ના સમકક્ષ હોય. તમારી પાસે અહીં વધુ સમકક્ષ છે:
Te હું સલાહ આપું છુંવધુ જાણવા માટે, Google કોઈપણ દરવાજા સાથે એક સરળ સર્કિટ. અને તે શું કરે છે તે જાણવા માટે, એક પ્રકારનું "રિવર્સ એન્જિનિયરિંગ" કરો, ઇનપુટ્સ અને આઉટપુટની લાઇનને અનુસરો અને આઉટપુટને આપવામાં આવેલા ઇનપુટ્સ અનુસાર દરેક લાઇનની સ્થિતિ જુઓ.
પોર ઇઝેમ્પ્લોજો તમે ઉપરની ઇમેજ જુઓ, NAND ગેટ સાથે OR ની સમકક્ષતા રેખાકૃતિ, તો તમે જોશો કે તેમાં બે NAND ગેટ હોય છે અને તેમના આઉટપુટ બ્રિજ સાથે હોય છે અને બંને આઉટપુટ બીજા NAND પર જાય છે. નીચેનાને ધ્યાનમાં રાખો:
- જો તમે NAND સત્ય કોષ્ટક પર જશો, તો તમે જોશો કે જ્યારે તેના બે ઇનપુટ 0 હોય ત્યારે આઉટપુટ 1 હોય અને જ્યારે તેના બે ઇનપુટ 1 હોય ત્યારે આઉટપુટ 0 હોય.
- જેમ જેમ તેઓ બ્રીજ કરે છે, જો ઇનપુટ 1 છે (એક બંનેમાં પ્રવેશે છે), તો પરિણામ 0 છે. અને જ્યારે ઇનપુટ 0 (બંને શૂન્ય) હશે, તો આઉટપુટ 1 હશે, જે NOT ની સમકક્ષ છે.
- તેથી, અમારી પાસે બિટ્સ A અને B માટે બે NOT છે. તેમના આઉટપુટ પર અમારી પાસે A 'અને B' હશે.
- તે બે નકારાત્મકતા છેલ્લા NANDમાં જાય છે, જે તે બે બિટ્સનું વ્યસ્ત તાર્કિક ઉત્પાદન કરશે.
- તર્કશાસ્ત્રના નિયમો અનુસાર, આ સીધી રકમની બરાબર છે, એટલે કે, A + B. તેથી, અંતિમ પરિણામ એવું હશે કે તે એક OR...
લોજિક ગેટ ચિપ શ્રેણી - ક્યાંથી ખરીદવું
ઇલેક્ટ્રોનિક્સમાં વિશિષ્ટ સ્ટોર્સમાં તમે કરી શકો છો સસ્તી ચિપ્સ ખરીદો તમારા પ્રોજેક્ટ્સમાં ઉપયોગ શરૂ કરવા માટે લોજિક ગેટ સાથે. આ ચિપ્સ એકલ લોજિક ગેટ નથી, પરંતુ તે તમને તેમાંના ઘણા રાખવાની મંજૂરી આપે છે જેથી કરીને તમે તેમના ઇનપુટ્સ અને આઉટપુટને તમને જરૂર મુજબ લિંક કરી શકો. ઉદાહરણ તરીકે, ઉપરની ઇમેજમાંના ડાયાગ્રામમાં તમે 4 NAND ગેટ સાથે DIP ચિપનું લાક્ષણિક પિનઆઉટ જોઈ શકો છો. વધુમાં, તેમાં પાવર માટે બે પિન પણ છે (Vcc અને GND).
અહીં કેટલાક છે ખરીદી ભલામણો:
- કોઈ ઉત્પાદનો મળ્યાં નથી..
- હુઆબન: સાર્વત્રિક NAND ગેટ સાથે 30-ચિપ કિટ.
- ઝેબુલોન: 120 CMOS ચિપ કીટ.
અન્ય સંસાધનો
આ દરવાજાઓને કેવી રીતે અમલમાં મૂકવું અને તેમની સાથે સર્કિટ કેવી રીતે બનાવવાનું શરૂ કરવું તે વિશે વધુ જાણવા માટે, તમે આનો ઉપયોગ કરી શકો છો અન્ય સંસાધનો હું શું ભલામણ કરું છું:
- SimulIDE સોફ્ટવેર દરવાજા સાથે આ સર્કિટની કામગીરીનું અનુકરણ કરવામાં સક્ષમ થવા માટે. તે મફત, ઓપન સોર્સ અને ક્રોસ-પ્લેટફોર્મ છે.
- ઑનલાઇન બાઈનરી કેલ્ક્યુલેટર (તમે તમારી ઓપરેટિંગ સિસ્ટમના કેલ્ક્યુલેટરને બાઈનરી મોડમાં પણ વાપરી શકો છો).
- કોઈ ઉત્પાદનો મળ્યાં નથી..
- ડિજિટલ લોજિક સર્કિટ્સ બુક: ડિઝાઇનથી પ્રયોગ સુધી.
Arduino સાથે ડિજિટલ તર્ક
અન્ય સંસાધન જો તમારી પાસે પહેલેથી જ હોય તો તમારા હાથમાં શું છે એક પ્લેટ Arduino UNO તમારા હાથમાં છે સ્કેચ બનાવવા માટે Arduino IDE નો ઉપયોગ કરો જે આ તર્ક કાર્યોનું અનુકરણ કરે છે, ઉદાહરણ તરીકે, દરવાજાના આઉટપુટનું અનુકરણ કરતા LED વડે પરિણામને વધુ વિઝ્યુઅલ રીતે જુઓ. ઉદાહરણ તરીકે, પિન 7 પર એલઇડી મૂકવું અને 8 અને 9 નો ઇનપુટ A અને B તરીકે ઉપયોગ કરવો:
int pinOut = 7; int pinA = 8; int pinB = 9; void setup() { pinMode(pinOut, OUTPUT); pinMode(pinA, INPUT); pinMode(pinB, INPUT); } void loop() { boolean pinAState = digitalRead(pinA); boolean pinBState = digitalRead(pinB); boolean pinOutState; //AND pinOutState =pinAState & pinBState; digitalWrite(pinOut, pinOutState); }
અહીં AND (&) ફંક્શનનો ઉપયોગ કરવામાં આવ્યો છે, જેમ તમે જોઈ શકો છો, પરંતુ તમે કોડની તે લાઇનને // AND લાઇન હેઠળ અન્ય લોકો સાથે બદલી શકો છો. અન્ય તર્ક કાર્યો:
//OR pinOutState = pinAState | pinBState; //NOT pinOutState = !pinAState; //XOR pinOutState = pinAState ^ pinBState; //NAND pinOutState = !(pinAState & pinBState); //NOR pinOutState = !(pinAState | pinBState); //XNOR pinOutState = !(pinAState ^ pinBState);