------------ Woord vooraf ------------------------------------------------------------------------------------------------- Onderstaande methode tot uitbreiding van de LPT-poort is niet de enige (en volgens sommigen ook niet de makkelijkste) manier om meer uit je parallelle poort te halen. Er leiden meestal meerdere wegen naar Rome: zo ook in dit geval. Het idee is alsvolgt ontstaan: ik wilde een heleboel LEDjes (200+) om beurten laten flitsen. Aangezien de LPT-poort qua programmeren een vrij eenvoudige zaak is, besloot ik om dat via die poort te doen. Maar ja, die heeft maar 8 uitgangen ... Ik moest die poort dus uitbreiden, maar dan op zo'n manier dat ik hele snelle pulsen kon geven. Met in mijn achterhoofd de mogelijkheid om het later met een microcontroller te kunnen doen. Shift-registers hebben het nadeel dat alle bits achter elkaar hangen. Je moet alle bits opnieuw erin stoppen als je ook maar 1 bit wilt veranderen. Dat komt de snelheid niet ten goede. Daarom heb ik het anders aangepakt. Ik heb een aantal 74HCT4514 en 74HCT4515 IC's gebruikt om via het dataregister van de LPT-poort 256 uitgangen te creeren. Die 256 uitgangen kon ik allemaal om beurten hoog maken en ook nog zeer snel. ( Wat je eigenlijk doet, is het vertakken van een signaal uit je stuurregister. ) ( Welke tak je ingaat, bepaal je door het "adres" in het dataregister. ) Toen dat werkte, bedacht ik me, dat ik met al die signalen ook motortjes en zo zou kunnen aansturen. Maar dan moest ik die signalen wel vast kunnen houden. Tot nu toe had ik "vluchtige" signalen: als je het "adres" veranderde, dan ging het ene LEDje uit en het andere LEDje aan. Er moesten dus buffers komen om de signalen stabiel te maken. Daar heb ik de 74HCT573 voor gebruikt. Aangezien deze IC's uit 8 flipflop's bestaan, kon ik een byte in het dataregister zo overnemen in een 74HCT573. Aan deze 74HCT573 IC's heb ik LEDjes gehangen om het systeem te testen, en daar was 'ie dan: de lichtkrant. In het kort is het idee dus alsvolgt: Je hebt (maximaal) 256 IC's die ieder 8 in- en uitgangen hebben: de latches. De ingangen worden gevoed door het dataregister van de LPT-poort. Normaal gesproken doen deze IC's niets: d.w.z. de uitgangen zijn stabiel. Met een puls uit je stuurregister kun je 1 IC de opdracht geven om de data aan de ingangen op te slaan. Die puls uit je stuurregister wordt eerst vertakt, zodat iedere latch zijn eigen signaal heeft (een eigen "adres"). Nogmaals: deze methode is niet heilig, er bestaan ook andere. Ik vond het echter qua programmeren vrij eenvoudig. Ook heeft het de volgende voordelen: - als je PC vastloopt, blijven de uitgangen van de latches stabiel - je spreekt alleen maar de lachtes aan die je nodig hebt (gaat dus vrij snel) Veel plezier ermee. ------------ Uitbreiden parallelle poort ---------------------------------------------------------------------------------- Een parallelle poort van een PC heeft 3 registers: dataregister, statusregister en stuurregister. De adressen in een PC liggen in deze volgorde. Een bekend adres voor de 1e parallelle poort (LPT1) is 378h. In dat geval is adres 378h het dataregister, 379h het statusregister en 37Ah het stuurregister. Het dataregister is bidirectioneel; het stuurregister ook. Via deze registers kun je gegevens versturen maar ook inlezen. Het statusregister is unidirectioneel. Via dit register kun je alleen gegevens inlezen. Vroeger werden (bij het aansturen van printers) het data- en stuurregister alleen als uitgangen gebruikt. Dan heb je dus 12 uitgangen en 5 ingangen. (datareg.: 8 pinnen, stuurreg.: 4 pinnen, statusreg.: 5 pinnen) Op de volgende manier kun je het aantal uitgangen van een parallelle poort uitbreiden. (met wat aanpassingen is het ook mogelijk om ingangen te maken) ------------ De theorie --------------------------------------------------------------------------------------------------- Eigenlijk heel simpel: je bootst een klein beetje een PC na. Een PC werkt o.a. met een adresbus, een stuurbus en een databus. Je maakt van het dataregister van de parallelle poort zowel een "adresbus" als een "databus". Je gebruikt 2 bits van je stuurregister als stuursignalen, een soort kleine "stuurbus" dus. In je software doe je het volgende: * 1 - je schrijft een "adres" in het dataregister * 2 - je geeft de opdracht "adres opslaan" (d.m.v. een bit in het stuurregister) * 3 - je schrijft "data" in het dataregister * 4 - je geeft de opdracht "data opslaan" (d.m.v. een ander bit in het stuurregister) Dit herhaal je (meestal met oplopende adressen) zo vaak als nodig. Dat betekent dat de IC's die je gebruikt het adres intern moeten kunnen opslaan. ------------ De IC's ------------------------------------------------------------------------------------------------------ De 74HCT4514 en 74HCT4515 worden gebruikt om het adres in op te slaan en dit adres op het juiste moment vrij te geven waardoor de data opgeslagen kan worden. (komt later aan de orde) De 74HCT4514 en 74HCT4515 zijn zogenaamde "4 to 16 decoders". Dat betekent dat ze 4 inputs hebben (A0,A1,A2 en A3) die een binaire waarde vertegenwoordigen. 0000 = 0 0001 = 1 0010 = 2 0011 = 3 0100 = 4 0101 = 5 0110 = 6 0111 = 7 1000 = 8 1001 = 9 1010 = 10 1011 = 11 1100 = 12 1101 = 13 1110 = 14 1111 = 15 In totaal dus 16 mogelijkheden (0 t/m 15). Deze IC's hebben dan ook 16 uitgangen. Precies 1 van deze 16 uitgangen wijkt af van de overige 15, afhankelijk van de waarde op de A0-A3 inputs. Het leuke van deze IC's is, dat ze een ingebouwde latch hebben die de waarde op de Adres-inputs (A0-A3) vast kan houden. Daartoe hebben ze een LE-input (Latch Enable), waarmee je aan kan geven dat het adres op A0-A3 opgeslagen moet worden. Dat is dus * 1 en * 2 van wat je in je software doet. Je zet een "adres" in het dataregister van je parallelle poort en je geeft de opdracht om dat adres op te slaan. Dat betekent dat je de LE-input van deze IC's heel even hoog en vervolgens weer laag maakt. Als je dat doet, slaan deze IC's de waarden aan de A0-A3 inputs intern op. Het "adres" ligt dan vast. Deze IC's hebben ook nog een input waarmee je kunt bepalen of het gedecodeerde adres (dat intern is opgeslagen) op de outputs zichtbaar moet zijn of niet. Dit wordt de Enable-input genoemd. Voor de 4514 geldt: als de Enable-input laag is, dan is 1 van de 16 outputs hoog, de rest laag. Voor de 4515 geldt: als de Enable-input laag is, dan is 1 van de 16 outputs laag, de rest hoog. Precies het omgekeerde dus. Is de Enable-input hoog, dan zijn alle outputs hetzelfde: voor de 4514 allemaal laag, voor de 4515 allemaal hoog. Zo meteen kom ik terug op deze IC's, nu eerst naar een ander IC dat je nodig hebt. De 74HCT573 wordt gebruikt als "datacel". De uitgangen van dit IC gebruik je b.v. om zaken als motortjes aan/uit te zetten of om LED's te laten branden. De 74HCT573 is een octal D-type flipflop. Dit IC heeft 8 data-inputs en 8 data-outputs die 1 op 1 zijn gekoppeld. (bij iedere input hoort 1 output) Ook dit IC heeft een LE-input (Latch Enable) dat (net zoals bij die vorige IC's) active low is. Dat betekent dat als er een "0" (oftewel laag signaal) op de LE-input staat, de outputs stabiel zijn. Dit IC reageert dan niet op wat er aan de inputs gebeurt. Als de LE-input "1" is (oftewel hoog), dan reageert dit IC wel op de 8 inputs. Men zegt ook wel: de outputs volgen de inputs. (dit wordt ook wel "transparant"-modus genoemd) Dat is dus * 3 en * 4 van wat je in je software doet. Je zet "data" in het dataregister van je parallelle poort en je geeft de opdracht om die data op te slaan. Dat betekent dat je de LE-input van een van deze IC's heel even hoog en vervolgens weer laag maakt. Als je dat doet, slaat dit IC de waarden aan de 8 inputs intern op en deze waarden zijn op de outputs te zien. De "data" ligt dan vast. De 74HCT573 heeft ook nog een OE-input (Output Enable), maar die gebruiken we hier niet. Leg deze input vast aan 0 Volt. Nu combineren we deze IC's. De 74HCT4515 en 74HCT4514 worden gebruikt om een hele rits 74HCT573 IC's aan te sturen. De 74HCT4515 noem ik de master, omdat die een aantal 4514 IC's onder zich heeft en aanstuurt. De 74HCT4514 noem ik een slave, omdat die een 4515 boven zich heeft. De 74HCT 573 noem ik een datacel, omdat die de bits vasthoudt waar je uiteindelijk mee werkt. Je verbindt deze IC's alsvolgt met elkaar: - De LE-input van een datacel wordt verbonden met een slave-output, m.a.w. iedere slave-output stuurt een datacel aan. - De LE-input van de master en van alle slaves wordt verbonden met een lijn van je stuurregister. Vanuit je programma geef je dus de master en alle slaves gelijktijdig de opdracht "adres opslaan". (de master slaat het hoge nibble op en de slaves slaan het lage nibble op: komt straks nog aan de orde) - De Enable-input van de master wordt verbonden met een andere lijn van je stuurregister en de Enable-input van alle slaves wordt verbonden met een master-output, m.a.w. iedere master-output stuurt een slave aan. Vanuit je programma geef je dus alleen de master de opdracht "data opslaan". De master geeft dit signaal door aan de juiste slave, die op zijn beurt de juiste datacel aanstuurt. ------------ De schema's -------------------------------------------------------------------------------------------------- Het eerste deel van het schema ziet er nu alsvolgt uit. Alle inputs, outputs en register bits zijn genummerd van 0 t/m 7. (bit 0 is dus het 1e bit, bit 1 is het 2e bit, enz...) St.1 = Stuurregister bit 1 -> opdracht "data opslaan" (dit is dus het 2e bit van je stuurregister) Met dit signaal wordt de master aangestuurd, die op zijn beurt de juiste slave aanstuurt. Dit signaal wordt dus eigenlijk "vertakt" en komt er bij een slave-uitgang weer uit. St.2 = Stuurregister bit 2 -> opdracht "adres opslaan" (dit is dus het 3e bit van je stuurregister) Alle Enable-inputs van de master en de slaves worden met St.2 verbonden. St.1 ------------ | St.2 ----- | | | |LE |Enable ------------------- A0 ---| |--- output 0 ----------- | |--- output 1 -------- | A1 ---| |--- output 2 ----- | | | 74 HCT 4515 | | | | A2 ---| | ... | | | | Master | ... | | | A3 ---| | ... | | | | | ... | | | | | ... | | | | | | | | | |--- output 15- | | | ------------------- | | | | | | | | | | | ----------------- | | | | | | | | | | | St.2 ---- | | | | | | | | | |LE |Enable | | | ------------------- | | | A0 ---| |--- output 0 | | | | |--- output 1 | | | A1 ---| |--- output 2 | | | | 74 HCT 4514 |--- output 3 | | | A2 ---| | | | | | Slave 0 | ... | | | A3 ---| | ... | | | | | ... | | | | | ... | | | | | | | | | |--- output 15 | | | ------------------- | | | | | | | | -------------------- | | | | | St.2 ---- | | | | | | | |LE |Enable | | ------------------- | | A0 ---| |--- output 0 | | | |--- output 1 | | A1 ---| |--- output 2 | | | 74 HCT 4514 |--- output 3 | | A2 ---| | | | | Slave 1 | ... | | A3 ---| | ... | | | | ... | | | | ... | | | | | | | |--- output 15 | | ------------------- | | | | | ----------------------- | | | | | St.2 ---- | | | | | |LE |Enable | ------------------- | A0 ---| |--- output 0 | | |--- output 1 | A1 ---| |--- output 2 | | 74 HCT 4514 |--- output 3 | A2 ---| | | | Slave 2 | ... | A3 ---| | ... | | | ... | | | ... | | | | | |--- output 15 | ------------------- | | | ........... | | ........... | | ........... | | --------------------------- | | St.2 ---- | | | |LE |Enable ------------------- A0 ---| |--- output 0 | |--- output 1 A1 ---| |--- output 2 | 74 HCT 4514 |--- output 3 A2 ---| | | Slave 15 | ... A3 ---| | ... | | ... | | ... | | | |--- output 15 ------------------- Je ziet dat je op deze manier maximaal 16 slaves aan de master kunt hangen. M.a.w.: iedere master-output (0 t/m 15) kan een slave aansturen (slave 0 t/m slave 15). Het aansluiten van het dataregister van je parallelle poort op de master en slaves doe je alsvolgt: A0 t/m A3 van de slaves sluit je aan op het lage nibble (de 4 laagste bits) van je dataregister. A0 t/m A3 van de master sluit je aan op het hoge nibble (de 4 hoogste bits) van je dataregister. ---- | | --------------------- | |---- output 0 -------------------------- A0 ---| | d | | | a |---- output 1 -------------------------- A1 ---| 74 HCT 4514 | t | | | a |---- output 2 -------------------------- A2 ---| Slave 0 | | | t/m | |---- output 3 -------------------------- A3 ---| Slave x | r | | | e |---- output 4 ------------. | g | | | i |---- output 5 ----------. | | s | | | | t |---- output 6 --------. | | | e | | | | | r |---- output 7 ------. | | | | | | | | | ---- | | | | | | | | | | | | --------------------- | | | '------------- A0 ---| | | | | | | '--------------- A1 ---| 74 HCT 4515 | | | | '----------------- A2 ---| MAster | | '------------------- A3 ---| | Iedere slave-output wordt doorverbonden met de LE-input van een datacel. Als je 1 slave bekijkt met z'n onderliggende 16 datacellen, dan heb je de volgende verbindingen: From master ----- | St.2 ----- | | | |LE |Enable ------------------- A0 ---| |--- output 0 --------------------------------------------------------------------- | |--- output 1 ---------------------------------------------- | A1 ---| |--- output 2 ----------------------- | | | 74 HCT 4514 | | | | A2 ---| | ... | | | | Slave x | ... | | | A3 ---| | ... | | | | | ... | | | | | ... | | | | | | | | | |--- output 15---- | | | ------------------- | | | | | | | | | | | | ----------------------------- | | | | | | | | | | | |LE |LE |LE |LE ----- ----- ----- ----- | | | | | | | | D0 --| |-- Q0 D0 --| |-- Q0 D0 --| |-- Q0 D0 --| |-- Q0 | | | | | | | | D1 --| |-- Q1 D1 --| |-- Q1 D1 --| |-- Q1 D1 --| |-- Q1 | | | | | | | | D2 --| |-- Q2 D2 --| |-- Q2 D2 --| |-- Q2 D2 --| |-- Q2 | | | | | | | | D3 --| |-- Q3 D3 --| |-- Q3 D3 --| |-- Q3 D3 --| |-- Q3 | | ... ... ... ... | | | | | | D4 --| |-- Q4 D4 --| |-- Q4 D4 --| |-- Q4 D4 --| |-- Q4 | | | | | | | | D5 --| |-- Q5 D5 --| |-- Q5 D5 --| |-- Q5 D5 --| |-- Q5 | | | | | | | | D6 --| |-- Q6 D6 --| |-- Q6 D6 --| |-- Q6 D6 --| |-- Q6 | | | | | | | | D7 --| |-- Q7 D7 --| |-- Q7 D7 --| |-- Q7 D7 --| |-- Q7 | | | | | | | | ----- ----- ----- ----- Datacel: 15 2 1 0 De ingangen van alle datacellen (D0 t/m D7) sluit je aan op het dataregister van je parallelle poort (bit 0 t/m bit 7). De uitgangen van alle datacellen (Q0 t/m Q7) kun je aansluiten op wat je maar wilt. Dit zijn je uiteindelijke uitgangen. Ik heb "Q0" t/m "Q7" gebruikt, omdat dit in de datasheet van de 74HCT573 ook zo genoemd wordt. Als je nu alle outputs van alle slaves doornummerd, kom je op 256 signaallijnen. slave 0 - 0 t/m 15 slave 1 - 16 t/m 31 slave 2 - 32 t/m 47 slave 3 - 48 t/m 63 slave 4 - 64 t/m 79 slave 5 - 80 t/m 95 slave 6 - 96 t/m 111 slave 7 - 112 t/m 127 slave 8 - 128 t/m 143 slave 9 - 144 t/m 159 slave 10 - 160 t/m 175 slave 11 - 176 t/m 191 slave 12 - 192 t/m 207 slave 13 - 208 t/m 223 slave 14 - 224 t/m 239 slave 15 - 240 t/m 255 Deze outputs worden allemaal (als je ze allemaal zou gebruiken tenminste) doorverbonden met de LE-input van een datacel. Als je dit schema volledig zou maken, zou je dus 256 datacellen hebben met ieder 8 outputs. Je zou dan in totaal 256 x 8 = 2048 uitgangen hebben die je onafhankelijk van elkaar hoog of laag kan maken. ------ 1 x Master |Master| | | ------ ||...| || ---------------------------------------- || | | ----------------- | | | | ------ ------ ------ 16 x Slave |Slave | |Slave | |Slave | (0 t/m 15) | 0 | | 1 | ... ... ... | 15 | ------ ------ ------ ||...| ||...| ||...| || ------ || ------ || ------ | -- | | -- | | -- | | | | | | | | | | _ _ _ _ _ _ _ _ _ 256 x Datacel | | | | | | | | | | | | | | | | | | (0 t/m 255) | | | | ... | | | | | | ... | | | | | | | | |_| |_| |_| |_| |_| |_| |_| |_| |_| 0 1 15 0 1 15 0 1 15 Doorgenummerd: 0 1 ... 15 16 17 ... 31 ... ... 240 241 ... 255 -> 256 x 8 outputs = 2048 outputs Data Adres: register: MSbit bit 7 0 0 0 0 0 0 1 1 1 \ A0 bit 6 0 0 0 0 0 0 1 1 1 \ A1 bit 5 0 0 0 0 0 0 1 1 1 / A2 bit 4 0 0 0 1 1 1 1 1 1 / A3 van de Master . . . . . . . . . bit 3 0 0 1 0 0 1 0 0 1 \ A0 bit 2 0 0 1 0 0 1 0 0 1 \ A1 bit 1 0 0 1 0 0 1 0 0 1 / A2 LSbit bit 0 0 1 1 0 1 1 0 1 1 / A3 van alle Slaves ------------ Een voorbeeld ------------------------------------------------------------------------------------------------ We houden het eenvoudig (en klein) en gaan uit van 32 datacellen. (32 x 8 bits = 256 uitgangen) We hebben hiervoor maar 2 slave's nodig. (2 x 16 outputs = 32 aanstuursignalen) Het complete schema komt er dan alsvolgt uit te zien: --------- |-- 0 stuur |-- 1 -------------------------------------. register |-- 2 -----------------------------------) | (---------+--------------. |-- 3 | | | --------- | | | | | | --------- | | | |-- 0 \ |Enable |LE | |-- 1 \ (hoge nibble) --------------- | |-- 2 \ datareg. 4 /A0 --| | | data |-- 3 \_____________________5__/ A1 --| 74 HCT 4515 | | register |-- 4 / | 6 \ A2 --| | | |-- 5 / | datareg. 7 \A3 --| Master | | |-- 6 / | | | | |-- 7 / | --------------- | --------- | |0 |1 ... | | | | | | | | | ____________________| | | | | .--------------------' '--------------------) | (---. | | | | | .----) | (---------------------------------------------o | | | | | | | | | | | | |LE |Enable |LE |Enable | (lage nibble) --------------- (lage nibble) --------------- | datareg. 0 /A0 --| | / datareg. 0 /A0 --| | |___________1_/ A1 --| 74 HCT 4514 | /_______________________1_/ A1 --| 74 HCT 4514 | | 2 \ A2 --| | \ 2 \ A2 --| | | datareg. 3 \A3 --| Slave 0 | \ datareg. 3 \A3 --| Slave 1 | | | | | | | --------------- --------------- | |0 ... ... |15 |0 ... ... |15 | | | | | | | | | | | .--------' '--------. .--------' '--------. | | | | | | | | | | | (data) |LE (data) |LE (data) |LE (data) |LE | ( in ) --- ( in ) --- ( in ) --- ( in ) --- | /D0 -| |- Q0 = 0 D0 -| |- Q0 = 120 D0 -| |- Q0 = 128 D0 -| |- Q0 = 248 | / D1 -| |- Q1 = 1 D1 -| |- Q1 = 121 D1 -| |- Q1 = 129 D1 -| |- Q1 = 249 | / D2 -| |- Q2 = 2 D2 -| |- Q2 = 122 D2 -| |- Q2 = 130 D2 -| |- Q2 = 250 |___/ D3 -| |- Q3 = 3 ... ... D3 -| |- Q3 = 123 D3 -| |- Q3 = 131 ... ... D3 -| |- Q3 = 251 \ D4 -| |- Q4 = 4 D4 -| |- Q4 = 124 D4 -| |- Q4 = 132 D4 -| |- Q4 = 252 \ D5 -| |- Q5 = 5 D5 -| |- Q5 = 125 D5 -| |- Q5 = 133 D5 -| |- Q5 = 253 \ D6 -| |- Q6 = 6 D6 -| |- Q6 = 126 D6 -| |- Q6 = 134 D6 -| |- Q6 = 254 \D7 -| |- Q7 = 7 D7 -| |- Q7 = 127 D7 -| |- Q7 = 135 D7 -| |- Q7 = 255 --- --- --- --- Datacel: 0 15 16 31 (Datacellen: 16 x 74HCT573) Als je meer uitgangen wilt hebben, koppel je gewoon een nieuwe slave met 16 datacellen aan output 2 van de master. Dan heb je er weer 128 uitgangen bij. Wil je nog meer uitgangen, dan koppel je wederom een slave met 16 datacellen aan de master, maar nu aan output 3. Enz, enz, enz, tot een maximum van 16 slave's. Dit schema is dus gemakkelijk uit te breiden. Als je heel veel uitgangen wilt, is het aan te bevelen om een buffer direct achter je parallelle poort te hangen. Ik weet niet precies hoeveel IC's zo'n poort tegelijk aan kan sturen, maar als het er heeeeel veel worden, kon dat wel eens niet goed gaan. Ik denk niet dat je LPT-poort eronder zal lijden, maar misschien dat de data niet meer goed gelezen wordt. Je kunt als buffer een 74HCT573 gebruiken. (die gebruik je tenslotte toch al) Leg in dat geval de LE-input vast aan 0 Volt, zodat het IC in transparant-modus werkt, en de OE-input ook aan 0 Volt. ------------ Aansturing --------------------------------------------------------------------------------------------------- De reden dat je de stuurregister-bits 1 en 2 gebruikt is de volgende: Normaal is het zo dat als je in je software een bit "0" maakt, dat de outputpin dan laag wordt (0 Volt), en als je een bit "1" maakt, dat de outputpin dan hoog wordt (5 Volt). Maar: sommige outputs van je stuurregister zijn wat men noemt "inverted". Bit 0, 1 en 3 zijn de inverted bits. Dat betekent dat als je zo'n bit "0" maakt, dat de uitgang dan hoog wordt en omgekeerd. Gewoonlijk hou je de bits in je stuurregister (die met dit schema verbonden zijn) laag. Als je een opdracht wilt geven ("adres opslaan" of "data opslaan"), dan maak je een bit "1" en direct weer "0". We noemen dit een opdracht-pulse. Bit 2 is het niet-inverted bit van je stuurregister. Dit bit hou je op "0" in je software. Op de outputpin staat dan een laag signaal (0 Volt). Bit 2 is verbonden met de LE-input van de master en alle slaves. Die LE-inputs zijn dus normaal gesproken "0". Dat klopt: als de LE-input "0" is, dan houden de IC's hun adres intern vast. Als je een opdracht-pulse geeft ("1" en weer "0"), dan slaan de IC's het adres aan de A0-A3 inputs op. Maar bij bit 1 werkt 't aan de uitgang net andersom. Dit bit hou je in software op "0" (net als bit 2), maar aan de uitgang staat dan een hoog signaal. (inverted dus) Dat klopt, want de Enable-input van de master moet normaliter hoog zijn opdat hij het gedecodeerde adres niet laat zien. Pas als je de opdracht-pulse "data opslaan" geeft ("1" en weer "0"), dan maakt de master heel even 1 van zijn outputs laag. De slave die aangesproken wordt, maakt vervolgens 1 van zijn outputs hoog en activeert daarmee de juiste datacel. Die datacel zal vervolgens de data aan zijn inputs intern latchen en de opdracht "data opslaan" is daarmee voltooid. ------------ Tot besluit -------------------------------------------------------------------------------------------------- Wees je ervan bewust dat deze schakeling perfect werkt op een DOS-machine waar je alle hardware vrij kunt benaderen (zoals 't hoort), maar dat Windows niet echt meewerkt als 't gaat om benadering van hardware-poorten. Als het onder Windows niet meteen werkt of als je vreemde toestanden aan je uitgangen krijgt, dan ligt dat niet aan deze schakeling, als je begrijpt wat ik bedoel. ;-) Ik hoop dat deze uitleg uitgebreid en vooral volledig genoeg is. Succes. -------------------------------------------------------- Overzicht van de aansluitpinnen van de parallelle poort. De *'s worden in dit schema gebruikt. Pen Register Bit Naam (voor printers) 1 stuur 0 Strobe (inverted) * 2 data 0 * 3 data 1 * 4 data 2 * 5 data 3 * 6 data 4 * 7 data 5 * 8 data 6 * 9 data 7 10 status 6 Acknowledge 11 status 7 Busy (inverted) 12 status 5 PE (Paper End) 13 status 4 OffOn * 14 stuur 1 ALF (Automatic Line Feed) (inverted) 15 status 3 Err (Error) * 16 stuur 2 Init 17 stuur 3 DSL (Device Select) (inverted) 18 t/m 25 massa (0 Volt) LPT1: 378 379 37A ---------- ---------- ---------- | | | | | | | bit 0 |<===> pin 2 * | s bit 0 | | bit 0 |<===> pin 1 (inv.) | d | | t | | s | | a bit 1 |<===> pin 3 * | a bit 1 | | t bit 1 |<===> pin 14 * (inv.) | t | | t | | u | | a bit 2 |<===> pin 4 * | u bit 2 | | u bit 2 |<===> pin 16 * | | | s | | r | | bit 3 |<===> pin 5 * | bit 3 |<==== pin 15 | bit 3 |<===> pin 17 (inv.) | r | | r | | r | | e bit 4 |<===> pin 6 * | e bit 4 |<==== pin 13 | e bit 4 | | g | | g | | g | | i bit 5 |<===> pin 7 * | i bit 5 |<==== pin 12 | i bit 5 | | s | | s | | s | | t bit 6 |<===> pin 8 * | t bit 6 |<==== pin 10 | t bit 6 | | e | | e | | e | | r bit 7 |<===> pin 9 * | r bit 7 |<==== pin 11 (inv.) | r bit 7 | | | | | | | ---------- ---------- ----------