ArSid - Arduino Sid Synthesizer

Thu 23-May-19
21:22:14




Latches

Datum: Sat 14 May 2016
Samenvatting: De aanstuur-registers die de bediening in de bovenplaat met de Arduino gaat verbinden.
 Soort Artikel: Electro
Status: Afgerond



[Tekst] [Afbeeldingen] [Aansluitingen] [Broncodes]
latches_01-schema.jpg
1/15: latches_01-schema.jpg.
latches_02-printontwerp.jpg
2/15: latches_02-printontwerp.jpg.
latches_03-printcut.jpg
3/15: latches_03-printcut.jpg.
latches_04-printopbouw.jpg
4/15: latches_04-printopbouw.jpg.
latches_05-meten.jpg
5/15: latches_05-meten.jpg.
latches_06-inbouw.jpg
6/15: latches_06-inbouw.jpg.
Meer
[Tekst] [Afbeeldingen] [Aansluitingen] [Broncodes]

De Latches-print zorgt dat de vele schakelaars, de Ledrij (via de Aansturingsprint) en het Lcd-Display via de Databus structuur aangestuurd kunnen worden door de Arduino Mega.

Een Latch (dit is Engels voor "Grendel") is een 1-bit onthouder (te vergelijken met "Memory"), die een signaal op zijn (data)ingang "D", vasthoudt en continue laat zien op zijn eigen (data)uitgang "Q". Het onthouden gebeurt op commando van een zogenaamde "Clock-signaal". Er zijn vele type van dit soort elementen, met elk zijn eigen IC-nummer. De hier gekozen type (nummer 74hct574) heeft 8 van zulke latches die met 1 clock signaal 8 bits (oftewel 1 byte) onthouden. Dit IC heeft bovendien de ingangen en uitgangen netjes op een rij.

Nu kunnen alle ingangen van deze IC's aan de Databus worden verbonden. De Clock-ingang van elk IC bepaalt door wel IC de data van de databus wordt onthouden en continue wordt doorgegeven. Met de uitgangen van de diverse IC's kunnen andere elementen worden aangestuurd, zoals Leds of een schakelaar-aansturing (of andere taken).

Het Schema.

Het idee achter het schema is eenvoudig: de bedienings-elementen in de bovenplaat zijn verdeeld in 3 hoofddelen. Elk deel krijgt zijn eigen groep geheugen-IC's die onthouden hoe het betreffende hoofddeel (op bit niveau) wordt aangestuurd.

De drie hoofddelen, die hieronder afzonderlijk worden besproken, zijn:

  1. Led: De Led-Rij - de Latches sturen de ingangen van de Aansturing aan en laten zo de juiste Led(s) branden.
  2. Lcd: Het Lcd-Display - de Latches stuurt de informatie door en regelt de besturings-draadjes van het display (hier de register-select en de Enable).
  3. Schakelaar: De schakelaars - De Latches sturen de schakelaar-rij aan via een decoder.

Duidelijk is de dikke blauwe lijn in het schema te zien. Dit is de Databus, waarlangs de Arduino Mega zijn informatie doorstuurt naar de geheugen-IC's. Net als bij de schakelaars lijkt deze print een ingewikkeld iets te worden. Maar door elk hoofddeel goed gescheiden te behandelen, valt de complexiteit van deze print best mee.

Led Latch.

De Led-Latch bestaat uit 2 Latch-IC's (IC1 en IC2) en een decoder (IC7) (74hct138). IC1 en de (lage) helft van IC2 sturen de kleuren van de Led-Rij aan. Elk groepje van 3 kleur-lijntjes (want RGB) wordt aangestuurd door 4 bitjes - waarvan de hoogste bit van elk groepje van 4 niet wordt gebruikt.

De andere (hoge) helft van IC2 stuurt een 3-8 decoder aan om de Led-Nummer te bepalen. Dit verzekert ons dat er slechts 1 Led-nummer wordt geaktiveerd, wat resulteert in een lagere totale stroom, wanneer er (maximaal) 9 Led's branden.

Gezamelijk gaan de Led-Kleuren en led-Nummers naar de Aansturingsprint, die de Led's in de Led-Rij uiteindelijk aansturen.

De Clock-ingangen die deze Latch aansturen heten hier "Leds Col" en "Leds ColNr".

Lcd Latch.

Het Lcd-Display vraagt een andere aanpak. Het display kent 8 databits en 3 control-aansluitingen. IC3 (Latch) zullen de 8 databits aansturen, IC4 (Latch) nemen twee control-aansluitingen voor zijn rekeningen. Er blijven 6 uitgangen van IC4 ongebruikt. Een consequentie van een overzichtelijk schema en aansturing door programmatuur (en dus snelle aansturing) willen hebben.

De derde control-aansluiting is een Read/Write aansluiting van het Lcd-Display (pen 5). Het Display heeft de mogelijkheid om zich te laten uitlezen (Read). En via de hier gebruikte ontwerp structuur voor de Latch-print zou dit ook hier gebruikt kunnen worden. Het kost echter wel 1 IC extra - en dus ook extra ruimte op de print. Veel ontwerpen gebruiken het Lcd-Display alleen in de Write-mode. En dus wordt deze aansluting continue op Write gehouden.

Het Lcd-Display heeft ook een aansluiting om de contrast in te kunnen instellen. Hier is dit mogelijk via een (liggende) instelbare potmeter (P1 - Lcd Contrast). In de ArSid is deze potmeter bereikbaar via een gaatje in de bodem.

De Clock-ingangen die deze Latch aansturen heten hier "Lcd Data" en "Lcd Ctrl".

Het Lcd-Display heeft een RGB-achtergrond verlichting. Er was oorspronkelijk gepland dat deze direct door de Arduino Mega wordt aangestuurd. Later is besloten om de aansluiting via de Latches-print (Lb, Lg, Lr, L+) te laten gaan, om uiteindelijk toch nog bij de Arduino mega uit te laten komen.

Schakelaar Latch

Het schakelaar matrix heeft weer zijn eigen aanpak. Naast een Latch is er iets nodig om informatie van de schakelaar-standen weer naar de databus terug te kunnen sturen. Ook hiervoor zijn er diverse IC's beschikbaar.

Hier heb ik gekozen voor een bi-directionele tri-state data-buffer IC (74hct245) (IC6). Net als bij de Latch-IC's liggen hier de ingangen en uitgangen netjes naast elkaar. Normaliter kunnen digitale IC-uitgangen maar 2 standen aannemen. Laag (0V) en Hoog (+5V) - waardes (en namen) die ook bekend zijn bij het programmeren van de Arduino. Dit buffer-IC kent ook nog een derde toestand, namelijk: hoge impedantie. Dit is te beschouwen dat de uitgang geheel wordt "losgekoppeld" en de aansluiting totaal geen invloed heeft op de rest die op deze uitgang is verbonden.

Met zo'n 3-state buffer is het dus mogelijk om data terug te sturen naar de (blauwe) Databus en dus door de Arduino Mega te laten inlezen. De Arduino zelf zal dan eerst de betreffende aansluitingen op "Ingang" mogen zetten, voordat het de data kan teruglezen.

De Latch-IC zelf (IC 5) stuurt met de 4 laagste bitjes 2 decoder-IC's aan (74hct138 - een 3-8 decoder) (IC8 en IC9). Het hoogste bitje hiervan bepaald welk IC aktief wordt. De decoder-IC's bepalen welke schakelaar rij wordt geaktiveerd.

Wanneer er dan een schakelaar op AAN wordt gezet, zal het aktieve signaal (via de schakelaar-diode(s)) worden teruggestuurd naar de data-buffer-IC (IC6).

Zoals eerder is geschreven is de data-buffer er 1 van het type "bi-directioneel". Of te wel, er kan data de ene kant op EN de andere kant op (echter niet tegelijk). Er is een aansluiting op dit IC (pen 1) die bepaalt welke kant de data op mag gaan. Hier op de Latch-print mag de data alleen van rechts (poort B) naar links (poort A) gaan. Daarvoor moet pen 1 Laag worden gehouden.

Een "Enable" signaal (pen 19) zet de poort dan open, zodat de data daadwerkelijk van poort B naar poort A kan gaan (en dus richting de Arduino).

Wat bij de data-buffer ook nodig is, is dat de ingangen een vaste waarde krijgen, zelfs als geen enkele schakelaar op "Aan" staat. Het weerstand netwerk R2 zorgt ervoor dat de ingangen van de data-buffer continue met de +5V is verbonden en dat de ingangen een HOOG te zien krijgen als een enkele schakelaar (van een rij) op Aan staat.

De Clock-ingangen die deze Latch aansturen heten hier "Schakelaars In" en "Schakelaars Out" - met de opmerking dat "Schakelaars In" in feite geen Clock-ingang is maar een Enable-ingang.

Het print ontwerp.

Wat aan de print opvalt is de hoek die er links-onder uitgehaald is. In deze hoek zit het afschermschot van de trafo en deze ruimte kan dus niet worden gebruikt om elektronica op te solderen.

Wat ook opvalt is de vele aansluitringen: Links naar de Arduino Mega en het Lcd-Display; rechts naar de Led Aansturing; boven naar de schakelaars. De aanslutingen moeten ook op deze plekken zitten, want op de plaats waar nu de IC's zitten, daarboven komt de print van de Led Aansturing - er is daar dus geen enkele ruimte voor draden en aansluitingen.

Het print ontwerp vergde nog behoorlijk wat puzzle en schuifwerk om het geheel nog enigzins compakt te krijgen.

De plus (+5V) en de min (0V) zijn duidelijk aangegeven met resp. de kleuren rood en zwart. De andere draadjes zijn wel aangegeven, maar doordat er diversen recht boven elkaar lopen is het schema nodig om te zien welk draadje nu welke pennen met elkaar verbindt.

De gehele (dikke blauwe) Databus is in het print ontwerp aangegeven door een rijtje van 8 soldeer-punten. Bij de feitelijke print is hier een kabelboompje te zien van groen/wit en groen/zwart draad. Net als bij de schakelaars geldt hier: het solderen van draadje voor draadje, bitlijn voor bitlijn vergemakkelijkt het behouden van het overzicht. Want met alle draadjes zo bij elkaar is er achteraf geen touw meer aan vast te knopen.

Op de print zijn ook de blauwe ontkoppel condensatoren (IC1 .. IC7 - de blauwe druppeltjes) zijn duidelijk te zien.

Het testen.

Nog voordat er een IC in de voetjes is geprikt, is als eerste getest of de plus (+5V) en de min (0V) daar aangesloten zijn, waar ze zijn gepland. Daarna is met de Ohm-meter doorgemeten of de diverse aansluitingen correct zijn en of er geen kortsluitingen zijn.

Als volgende test is het Lcd-Display aangesloten. Het Blink-programma is geladen en de achtergrondverlichting blinkte er vrolijk op los. Ook is de Lcd Contrast getest, op de foto te zien als 2 groene balkjes, waar de tekens op zullen verschijnen.

De Latches-print is aangesloten op de Arduino Mega en daarna is het een questie van de IC's er 1 voor 1 in prikken om elk hoofddeel op juiste werking te testen.

Maar eerst enkele opmerkingen over het test programma. Wat meteen opvalt aan de laatste algemene funkties zijn het direkt aansturen van de Arduino-poorten met de variabelen DDRx en PORTx (met op de plaats van de x de letter van de betreffende poort).

Eerst is er een eerste test programma gemaakt met gebruik makend van de standaard Arduino funkties "pinMode()" en "digitalWrite()". Op zich werkt dat wel op bitjes-niveau. Maar op byte-niveau is er 8 keer een IF-ELSE-statement nodig om een complete byte weg te kunnen schrijven. Met een databus en adresbus structuur wordt er al gauw met bytes gewerkt, in plaats van losse bitjes. We hebben het hier niet over een regel-toestel met allemaal losse I/O elementen, c.q. sensorren, maar over een computer-achtig iets, waarbij de Arduino als CPU wordt "mis"bruikt.

Daarnaast zijn er eenvoudige funkties nodig om bytes weg te schrijven naar de databus en op te nemen in een bepaalde Latch-register. De registers hebben hier nog geen eigen adres, elke clock wordt apart aangestuurd. De Decoder-eenheid moet elke aparte clock verbinden met de adresbus-structuur. Ook is elke Clock-ingang flank gevoelig, zodat de registers alleen data in zich opnemen wanneer de Clock gaat van LAAG naar HOOG.

De eenvoudige funkties hebben namen als:

  1. Write_Ledback() => Schrijft de aarde in LL naar de Lcd Backlight Leds in een bitjes formaat als %0000 0RGB, met elke kleur 1 bitje. De functie doet wat controle werk, schuift de bitjes op naar de hoogste 3 posities en schrijft het weg naar poort B (bit 5..7).
  2. Set_Adres_Out() => Zet alle pennen van port C op uitgang (deze funktie wordt hier eigenlijk nergens gebruikt).
  3. Write_Adres() => Schrijft een byte-waarde naar de adres-poort, poort C, nadat (alweer) alle poort-pennen als uitgang zijn ingesteld. Dit is feitelijk een overbodige aktie, maar wordt hier als zekerheid gebruikt.
  4. Set_Data_In() => Zet alle uitgangen van port A op ingang (deze funktie wordt hier eigenlijk nergens gebruikt).
  5. Set_Data_Out() => Zet alle uitgangen van port A op uitgang (deze funktie wordt hier eigenlijk nergens gebruikt).
  6. write_data() => Deze funktie zet een byte-waarde DD op het aangegevens adres AA. Het adres wordt geaktiveerd en daarna meteen weer op NUL gezet. Ook hier worden alle poort-pennen eerst als uitgang zijn ingesteld. Hier is het geen overbodige aktie, omdat er van de databus ook gelezen moet kunnen worden. De naam van deze funktie gaat veranderd worden in de naam POKE, vergelijkbaar met het Basic-Commando POKE Adres,Data
  7. read_data() => Deze funktie leest een byte-waarde DD van het aangegevens adres AA. Ook hier worden alle poort-pennen eerst als uitgang ingesteld. Hier is het geen overbodige aktie, omdat er van de databus ook gelezen moet kunnen worden. De naam van deze funktie gaat veranderd worden in de naam PEEK, vergelijkbaar met de Basic-Funktie Data=PEEK(Adres)

Kanttekening: Bij de eerste test worden bij zowel write_data() als read_data() de waarde AA (een getal van 0 tot en met 7) eerst omgezet in het aktief maken van het juiste bit-nummer (met behulp van de constante array "BITJES"). Uiteindelijk wordt de adres AA rechtstreeks op de Adresbus gezet.

Led Latches

Zoals de foto's laat zien geeft het testen een chaos in de ArSid. De reden hiervoor is dat voor de LedRij de Aansturing erbij nodig is. Maar deze print kan nog niet op zijn plaats worden gemonteerd, omdat de Latches hieronder zitten. Een opgevouwen A4 moet voor de nodige isolatie zorgen.

Bij het maken van het test-programma blijkt weer dat ik de digitale aansluitingen van de Arduino Mega nog steeds erg onlogisch vind, niet alleen zijn de poort-pinnen "gebroken" verdeeld, ook staan de volgorde niet consequent op de pinnen 22 tot en met 53. Begint de Poort A met het hoogste bitje (nr 7), Poort C en Poort L (en de andere poorten) beginnen met het laagste bitje (nr 0).

Na wat looplicht-effecten, loops en FOR-lussen, is een test-programma gemaakt waarbij 4 potmeters bepalen welke Leds branden en in welke kleur. De LedRij is verdeeld in 3 groepen, elke groep krijgt dus een kleur-potmeter. De kleur instellen gaat hier eenvoudig door de Rode, Groene en Blauwe Led(s) aan of uit te zetten. Het nummer in de groep gaat met de vierde potmeter, lopend vanaf 0 tot en met 7. Hiermee worden de Lednummers van alle groepen beïnvloedt

Na wat draaien aan de potmeters is de conclusie dat dit deel van de Latches werkt. Met dit deel is meteen een potmeter-test gedaan op zowel de Control-potentiometers als de Audio-Potmeters.

De funktie Write_Led() regelt dat de 2 Led-registers worden gevuld met de 4 (overzichtelijkere) parameters.

Lcd Latches.

Het testen van de Lcd Latches gaf minder moeilijkheden. Een tekst, als "ABCDE", is zonder problemen naar het display geschreven. Daarna is er de tekst "ArSid Latch Check" van gemaakt.

Toen kwam het idee om de potentiometer waardes naar de Lcd toe te schrijven. De potentiometers geven een waarde van 0 t/m 1023 (decimaal). Een eenvoudige deling maakt hier een getal van $0 t/m $F van. Met de nodige spaties ertussen passen de 16 cijfers keurig op de 20 posities.

De volgende Lcd Funkties zijn erbij gekomen:

  • Lcd_Out() => Deze funktie schrijft gegevens naar de Lcd. Een 1 schrijft gegevens naar het Instructie Register van de Lcd. Een 0 (NUL) schrijft gegevens naar het Data Register van de Lcd. Een extra Delay(42) zorgt voor de benodigde wachttijd. In de uiteindelijke ArSid programmatuur moet hier een andere oplossing voor worden gevonden. Deze wachttijd is te lang, zodat er Midi-gebeurtenissen gemist kunnen worden.
  • Lcd_Init() => Deze funktie initialiseert de Lcd, volgens de voorgeschreven procedure. De "0" van Instructie Register is hier duidelijk te zien.
  • Lcd_LatchTest_Text() => Deze funktie schrijft de tekst "ArSid Latch Check". De "1" van Data Register is hier duidelijk te zien.

Daarnaast zijn er de volgende Funkties:

  • Post_On_Lcd() => Deze funktie schrijft alle potentiometer waardes naar het display, inclusief de benodigde spaties ertussen.

Wat behouden is, is het wegschrijven van de potentiometer-waardes naar de LedRij (P0, P1, P2 & P8) en de Lcd Backlight (P9).

Schakelaar Latches.

De schakelaar Latches heeft iets meer moeite gekost om te testen. De uitgangs-decoder (2 * 74hct138) heeft het meteen gedaan, zoals gepland. Maar het weer inlezen heeft meer tijd gekost. Hier waren 2 oorzaken.

  1. In de Arduino is er een direkte methode om te schrijven naar uitgangspinnen, namelijk via de variabele PORTx. Het inlezen van de ingangspinnen werkt echter niet door het lezen vanuit deze variabele PORTx, maar door het lezen van de variabele PINx. Door het lezen van PORTx krijgt men namelijk de waarde terug, die men er het laatst heen geschreven heeft.

    En ik ben niet de enige die hiermee geconfronteerd werd, getuige de volgende link: http://forum.arduino.cc/index.php?topic=79803.0

  2. Het uitlezen, zodra de ingangsbuffer (74hct245) is geselecteerd, resulteerde in onjuiste waardes. Een osciloscoop liet wel duidelijk pulsen liet zien aan Pin 19 van de ingangsbuffer (74hct245). Een extra Delay() (van 1 microseconde) na het selecteren van de ingangbuffer (de 74hct245) en voor het uitlezen ervan heeft dit opgelost.

Na deze oplossingen is het testprogramma uitgebreid dat alle schakelaar standen ook op de Lcd worden getoond. Twee regels geven alle mogelijke schakelaars (meervoud) standen in. Elke schakelaar rij heeft in principe 2 cijfertjes (elk van $0 t/m $F) nodig - tenminste als het normale on-off schakelaars waren geweest. Nu nemen de (on-off-on) schakelaars (per rij) 2 uitgangen in, dus zijn er 4 cijfertjes nodig. De derde regel (gemerkt met "e') geeft alle laagste 4-bits weer, de vierde regel (gemerkt met "o") geeft alle hoogste bits weer. Daarna zijn de cijfertjes precies op volgorde (met spaties na elke 4 cijfertjes), zoals te verwachten is, dus schakelaar uitgang "0123 4567 89AB CDEF".

Het aflezen van het display geeft nu precies aan, zoals de schakelaars aangeven. En er kan nu meteen getest worden dat elke schakelaar maar 1 bitje omlegt, in plaats van meerdere bitjes door verborgen sluitingen.

De volgende funkties verzorgen het schakelaar gebeuren.

  • Read_Schak() => Deze funktie zorgt dat de schakelaar-posities van SchakNr wordt uitgelezen en terug gegeven aan de funktie oproep. Hierbij wordt de variabele SchakNr eerst naar de Schakelaar Out register geschreven. 2 decoder-IC's (74hct138) decoderen dit getal hardware matig naar 1 van de 16 mogelijke schakelaar lijnen ($0 t/m $F). Deze lijn wordt LAAG gemaakt. Zijn er schakelaars "aan"gezet, dan wordt de betreffende LAAG-lijn via de diodes naar de ingangen van de ingangsbuffer (74hct245) doorgegeven. Deze hardware-matige aktie kost geen enkele programma-tijd (maar des ondanks kost het wel enige tijd). Daarna worden alle 8-bits van het ingangsregister weer ingelezen. Dus gewoon recht-toe recht-aan: Schakelaar Out wegschrijven - Schakelaar In inlezen.
  • Schaks_On_Lcd() => Deze funktie zorgt dat de schakelaar-posities, die in de variabele Schak zit, wordt getoond op de Lcd. De variabele SchakNr is nodig om de waarde op de juiste plaats op de Lcd te zetten.

Het einde van de Latches Test.

Nu alle (hardware-matige) funkties van de Latches uitgebreid is getest, is er nu iets om verder mee te "spelen" en te experimenteren.

Een aanvulling is om van het Lcd Display het "Enable"-draadje ook terug te voeren naar een plaatsje naast de Latches-Ingang (die 6 polige "connector"), zodat er hardware-matig de benodigde verwerkingstijd van 40usec "afgeteld" kan worden, in plaats van een software-matige delay waarin het ArSid programma geen andere dingen kan doen.

Dan is de Latches-print getest, goed bevonden en gereed verklaard. Op naar de volgende fase, de Decoder. 


[Tekst] [Afbeeldingen] [Aansluitingen] [Broncodes]

Afbeeldingen

latches_01-schema.jpg
1/15: latches_01-schema.jpg.
latches_02-printontwerp.jpg
2/15: latches_02-printontwerp.jpg.
latches_03-printcut.jpg
3/15: latches_03-printcut.jpg.
latches_04-printopbouw.jpg
4/15: latches_04-printopbouw.jpg.
latches_05-meten.jpg
5/15: latches_05-meten.jpg.
latches_06-inbouw.jpg
6/15: latches_06-inbouw.jpg.
latches_07-lcdtest.jpg
7/15: latches_07-lcdtest.jpg.
latches_08-aansluiten.jpg
8/15: latches_08-aansluiten.jpg.
latches_09-ledrijtest.jpg
9/15: latches_09-ledrijtest.jpg.
latches_10-lcdtest.jpg
10/15: latches_10-lcdtest.jpg.
latches_11-lcdtest.jpg
11/15: latches_11-lcdtest.jpg.
latches_12-schakelaartest.jpg
12/15: latches_12-schakelaartest.jpg.
latches_13-schakelaartest_lcd.jpg
13/15: latches_13-schakelaartest_lcd.jpg.
latches_14-gemonteerd.jpg
14/15: latches_14-gemonteerd.jpg.
latches_15-gemonteerd.jpg
15/15: latches_15-gemonteerd.jpg.

[Tekst] [Afbeeldingen] [Aansluitingen] [Broncodes]

De aansluitingen van Latches

Diverse tests van de Latches-print

Arduino Mega

Pwr USB ?
 
?
aref
gnd Gnd's
? d13 Lr = Backlight Blauw
ioreff d12 Lg = Backlight Groen
Reset reset d11 Lb = Backlight Rood
+3.3v d10
+5V L+ = LCDBacklight +5v d9
Gnd's gnd d8
Gnd's gnd
Vin d7
d6
Potmeter 0 a0 d5
Potmeter 1 a1 d4
Potmeter 2 a2 d3
Potmeter 3 a3 d2
Potmeter 4 a4 d1
Potmeter 5 a5 d0
Potmeter 6 a6
Potmeter 7 a7 d14
d15
Potmeter 8 a8 d16
Potmeter 9 a9 d17
Potmeter A a10 d18 Tx1 = Midi Out
Potmeter B a11 d19 Rx1 = Midi In
Potmeter C a12 d20
Potmeter D a13 d21
Potmeter E a14 /~\
Potmeter F a15 \_/
Onderconnector
D0 = Data 0 d22 | d23 D1 = Data 1
D2 = Data 2 d24 | d25 D3 = Data 3
D4 = Data 4 d26 | d27 D5 = Data 5
D6 = Data 6 d28 | d29 D7 = Data 7
 | 
d30 | d31
L5 = Schak Out d32 | d33 L4 = Schak In
L3 = Lcd Ctrl d34 | d35 L2 = Lcd Data
L1 = Leds ColNr d36 | d37 L0 = Leds Cols
 | 
d38 | d39
d40 | d41
 | 
d42 | d43
d44 | d45
d46 | d47
d48 | d49
 | 
d50 | d51
d52 | d53


[Tekst] [Afbeeldingen] [Aansluitingen] [Broncodes]
Broncode: [1: De Led Latches] [2: De Lcd Latches] [3: De Schakelaar Latches]

1: De broncode van De Led Latches

(Sat 14 May 2016) Het testen van de LedRij (met de potmeters). Hierbij is de Aansturing nodig.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
/****************************************************************************
    ArSid Latches Test LedRij

    Latches Print test Programma.
    Nodig: Control-Potmeters
           Aansturing ledRij

*****************************************************************************/


const byte bitje[8] = {1,2,4,8,16,32,64,128};

void setup()
{ Set_Adres_Out();
  Write_Data (0, 0xFE);
  Write_Data (1, 0x0F);

  Write_Lcdback(0x02);   delay(250);
  Write_Lcdback(0x01);   delay(250);
  Write_Lcdback(0x02);

}

void loop()
{ // put your main code here, to run repeatedly:
  for (word qq=0; qq<=255; qq=qq+1)
      { byte ql= qq &0x0F;
        Write_Lcdback(ql);
        for (word ww=0; ww<=255; ww=ww+1)
            { Write_Led (ww, ql, ql, ql);
              delay(  5);                // wait some time
            }
      }
}


// ===================================================================

void Write_Led(byte nr, byte L1, byte L2, byte L3)
{
  nr = nr & 0x0F;
  L1 = L1 & 0x0F;
  L2 = L2 & 0x0F;
  L3 = L3 & 0x0F;
  Write_Data (0, (L2 << 4) + L1);
  Write_Data (1, (nr << 4) + L3);
}

// ===================================================================
// ===================================================================
// ===================================================================

void Write_Lcdback(byte LL)
{ // Write byte naar Lcd Backlight
  LL = LL & 0b00000111;
  LL = LL ^ 0x07;
  DDRB = DDRB | 0b11100000;
  PORTB = (PORTB & 0x1F) | ( LL << 5);
}

void Set_Adres_Out()
{ // Set de Adres op Output
  DDRC = 0xFF;
}

void Write_Adres(byte aa)
{ // Write byte naar Adresbus
  DDRC = 0xFF;
  PORTC = aa;
}

void Set_Data_Out()
{ // Set de Databus op Output
  DDRA = 0xFF;
}

void Set_Data_In()
{ // Set de Databus op Int
  DDRA = 0x00;
}

void Write_Data(byte aa, byte dd)
{ // Write byte naar Databus
  DDRC = 0xFF;
  DDRA = 0xFF;
  PORTA = dd;
  aa = bitje[aa & 0b00000111];      // <=====================
  PORTC = aa;
//  delayMicroseconds(5);
  PORTC = 0b00000000;
//  delayMicroseconds(5);
}


Broncode: [1: De Led Latches] [2: De Lcd Latches] [3: De Schakelaar Latches]

2: De broncode van De Lcd Latches

(Sat 14 May 2016) Het testen van de Lcd (met de potmeters). Hierbij is de LedRij (en de Aansturing) gebruikt.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
/****************************************************************************
    ArSid Latches Test Lcd

    Latches Print test Programma.
    Nodig: Control-Potmeters
           Lcd (Rgb Backlight)
           Aansturing ledRij

*****************************************************************************/


const byte bitje[8] = {1,2,4,8,16,32,64,128};

word P0 = 0;
word P1 = 0;
word P2 = 0;
word P3 = 0;
word P4 = 0;
word P5 = 0;
word P6 = 0;
word P7 = 0;
word P8 = 0;
word P9 = 0;
word PA = 0;
word PB = 0;
word PC = 0;
word PD = 0;
word PE = 0;
word PF = 0;

void setup()
{ Set_Adres_Out();
  Write_Data (0, 0xFE); // Init LedRij Col
  Write_Data (1, 0x0F); // Init LedRij ColNr

  Write_Lcdback(0x02);

  Lcd_Init();
}

void loop()
{ // put your main code here, to run repeatedly:
  P0 = analogRead( 0) / 64;
  P1 = analogRead( 1) / 64;
  P2 = analogRead( 2) / 64;
  P3 = analogRead( 3) / 64;
  P4 = analogRead( 4) / 64;
  P5 = analogRead( 5) / 64;
  P6 = analogRead( 6) / 64;
  P7 = analogRead( 7) / 64;
  P8 = analogRead( 8) / 64;
  P9 = analogRead( 9) / 64;
  PA = analogRead(10) / 64;
  PB = analogRead(11) / 64;
  PC = analogRead(12) / 64;
  PD = analogRead(13) / 64;
  PE = analogRead(14) / 64;
  PF = analogRead(15) / 64;

  Write_Led(P8,P0,P1,P2);
  Write_Lcdback(P9);

  Pots_On_Lcd();
}

void Pots_On_Lcd()
{ // Write Alle Potmeter Waardes
  Lcd_Out(0,0b11000000);    // GotoXY(0,1)
  Lcd_Out(1,Byte2Hexchar(P0));
  Lcd_Out(1,Byte2Hexchar(P1));
  Lcd_Out(1,Byte2Hexchar(P2));
  Lcd_Out(1,Byte2Hexchar(P3));
  Lcd_Out(1,' ');
  Lcd_Out(1,Byte2Hexchar(P4));
  Lcd_Out(1,Byte2Hexchar(P5));
  Lcd_Out(1,Byte2Hexchar(P6));
  Lcd_Out(1,Byte2Hexchar(P7));
  Lcd_Out(1,' ');
  Lcd_Out(1,Byte2Hexchar(P8));
  Lcd_Out(1,Byte2Hexchar(P9));
  Lcd_Out(1,Byte2Hexchar(PA));
  Lcd_Out(1,Byte2Hexchar(PB));
  Lcd_Out(1,' ');
  Lcd_Out(1,Byte2Hexchar(PC));
  Lcd_Out(1,Byte2Hexchar(PD));
  Lcd_Out(1,Byte2Hexchar(PE));
  Lcd_Out(1,Byte2Hexchar(PF));
  delay(100);
}

byte Byte2Hexchar(byte bb)
{ if (bb < 0x0A)
     { return bb+'0';
     }
  else
     { return bb+('A'-0x0A);
     }
}

// ===================================================================

void Write_Led(byte nr, byte L1, byte L2, byte L3)
{
  nr = nr & 0x0F;
  L1 = (L1 & 0x0F) ^ 0x0F;
  L2 = (L2 & 0x0F) ^ 0x0F;
  L3 = (L3 & 0x0F) ^ 0x0F;
  Write_Data (0, (L2 << 4) + L1);
  Write_Data (1, (nr << 4) + L3);
}

void Lcd_Init()
{ delay(20);                          // Wait while the LCD-unit itself is initialized
  // Sent Lcd Initialisation, 3 times (as described in the datasheet).
  Lcd_Out(0,0b00111000); delay(5);   // 1st LCD write (set 8bits interface)
  Lcd_Out(0,0b00111000); delay(1);   // 2nd LCD write (set 8bits interface)
  Lcd_Out(0,0b00111000); delay(1);   // 3rd LCD write (set 8bits interface)
  // Sent Lcd Instructions
  Lcd_Out(0,0b00111000);    // Function-Set 8-bits, 2-lines, 5x8-font, <none>, <none>
  Lcd_Out(0,0b00001000);    // Set Display On/Off Control: Cursor, Blinking
  Lcd_Out(0,0b00001100);    // Set Display On/Off Control: Cursor, Blinking
  Lcd_Out(0,0b00010100);    // Set Cursor/ Display Shift: Shift/Cursor, Right/Left, <none>, <none>
  Lcd_Out(0,0b00000110);    // Entry Mode Set: Inc/Dec, DisplShift
  Lcd_Out(0,0b00000001);    // Clear Display
  delay(2);
  Lcd_Out(0,0b10000001);    // GotoXY(1,0)
  Write_Lcd_LatchTest_Text();
}

void Write_Lcd_LatchTest_Text()
{ // Sent Characters
  Lcd_Out(1,'A');
  Lcd_Out(1,'r');
  Lcd_Out(1,'S');
  Lcd_Out(1,'i');
  Lcd_Out(1,'d');
  Lcd_Out(1,' ');
  Lcd_Out(1,'L');
  Lcd_Out(1,'a');
  Lcd_Out(1,'t');
  Lcd_Out(1,'c');
  Lcd_Out(1,'h');
  Lcd_Out(1,' ');
  Lcd_Out(1,'C');
  Lcd_Out(1,'h');
  Lcd_Out(1,'e');
  Lcd_Out(1,'c');
  Lcd_Out(1,'k');
}

void Lcd_Out(byte rr, byte bb)
{ // Rs  0  %00000000 = Instruction Register
  // Rs  1  %00000001 = Data Register
  // En  0  %00000000 = Enable     (Falling Edge)
  // En  1  %00001000 = Not Enable (Raising Edge)

  rr=rr & 0b00000001;

  Write_Data(3,0b00001000 | rr);
  Write_Data(2,bb);
  delayMicroseconds(42);
  Write_Data(3,0b00000000 | rr);
}

// ===================================================================
// ===================================================================
// ===================================================================

void Write_Lcdback(byte LL)
{ // Write byte naar Lcd Backlight
  LL = LL & 0b00000111;
  LL = LL ^ 0x07;
  DDRB = DDRB | 0b11100000;
  PORTB = (PORTB & 0x1F) | ( LL << 5);
}

void Set_Adres_Out()
{ // Set de Adres op Output
  DDRC = 0xFF;
}

void Write_Adres(byte aa)
{ // Write byte naar Adresbus
  DDRC = 0xFF;
  PORTC = aa;
}

void Set_Data_Out()
{ // Set de Databus op Output
  DDRA = 0xFF;
}

void Set_Data_In()
{ // Set de Databus op Int
  DDRA = 0x00;
}

void Write_Data(byte aa, byte dd)
{ // Write byte naar Databus
  if (aa != 0x04)
     { DDRC = 0xFF;        // Adresbus
       DDRA = 0xFF;        // Databus Output
       PORTA = dd;         // Databus Write Byte
       aa = bitje[aa & 0b00000111];  // <==== Maak van het adres-nummer een bitje
       aa = ~ aa;                    // <==== Bitje Inverteren.
       PORTC = aa;         // Adresbus
       delayMicroseconds(1);
       PORTC = 0b11111111; // Adresbus
     }
}

byte Read_Data(byte aa)
{ // Read byte van Databus
  byte dd = 0x00;
  if (aa == 0x04)
     { DDRC = 0xFF;        // Adresbus
       DDRA = 0x00;        // Databus Input
       aa = bitje[aa & 0b00000111];  // <==== Maak van het adres-nummer een bitje
       aa = ~ aa;                    // <==== Bitje Inverteren.
       PORTC = 0b11101111; // Adresbus
       delayMicroseconds(1);
       dd = PINA;         // Databus Read Byte
       PORTC = 0b11111111; // Adresbus
     }
   return dd;
}


Broncode: [1: De Led Latches] [2: De Lcd Latches] [3: De Schakelaar Latches]

3: De broncode van De Schakelaar Latches

(Sat 14 May 2016) Het testen van de Schakelaars. Hierbij is de Lcd nodig en zijn de Potmeters en de LedRij (en de Aansturing) gebruikt.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
/****************************************************************************
    ArSid Latches Test Schakelaars

    Latches Print test Programma.
    Nodig: Schakelaars
           Lcd (Rgb Backlight)
           Control-Potmeters
           Aansturing ledRij

*****************************************************************************/


const byte bitje[8] = {1,2,4,8,16,32,64,128};

word P0 = 0;
word P1 = 0;
word P2 = 0;
word P3 = 0;
word P4 = 0;
word P5 = 0;
word P6 = 0;
word P7 = 0;
word P8 = 0;
word P9 = 0;
word PA = 0;
word PB = 0;
word PC = 0;
word PD = 0;
word PE = 0;
word PF = 0;
byte Schak = 0;

void setup()
{ Set_Adres_Out();
  Write_Data (0, 0xFE); // Init LedRij Col
  Write_Data (1, 0x0F); // Init LedRij ColNr

  Write_Lcdback(0x02);

  Lcd_Init();
}

void loop()
{ // Lees Potmeters
  P0 = analogRead( 0) / 64;
  P1 = analogRead( 1) / 64;
  P2 = analogRead( 2) / 64;
  P3 = analogRead( 3) / 64;
  P4 = analogRead( 4) / 64;
  P5 = analogRead( 5) / 64;
  P6 = analogRead( 6) / 64;
  P7 = analogRead( 7) / 64;
  P8 = analogRead( 8) / 64;
  P9 = analogRead( 9) / 64;
  PA = analogRead(10) / 64;
  PB = analogRead(11) / 64;
  PC = analogRead(12) / 64;
  PD = analogRead(13) / 64;
  PE = analogRead(14) / 64;
  PF = analogRead(15) / 64;

  // Doe Potmeters naar LedRij Kleur en Nr
  Write_Led(P8,P0,P1,P2);

  // Doe Potmeters naar Lcd BackLight Kleur
  Write_Lcdback(P9);

  // Lees en Schrijf Schakelaars
  Schaks_On_Lcd(0xFF,00);
  Schak=Read_Schak(0x00);    Schaks_On_Lcd(0x00,Schak);
  Schak=Read_Schak(0x01);    Schaks_On_Lcd(0x01,Schak);
  Schak=Read_Schak(0x02);    Schaks_On_Lcd(0x02,Schak);
  Schak=Read_Schak(0x03);    Schaks_On_Lcd(0x03,Schak);

  Schak=Read_Schak(0x04);    Schaks_On_Lcd(0x04,Schak);
  Schak=Read_Schak(0x05);    Schaks_On_Lcd(0x05,Schak);
  Schak=Read_Schak(0x06);    Schaks_On_Lcd(0x06,Schak);
  Schak=Read_Schak(0x07);    Schaks_On_Lcd(0x07,Schak);

  Schak=Read_Schak(0x08);    Schaks_On_Lcd(0x08,Schak);
  Schak=Read_Schak(0x09);    Schaks_On_Lcd(0x09,Schak);
  Schak=Read_Schak(0x0A);    Schaks_On_Lcd(0x0A,Schak);
  Schak=Read_Schak(0x0B);    Schaks_On_Lcd(0x0B,Schak);

  Schak=Read_Schak(0x0C);    Schaks_On_Lcd(0x0C,Schak);
  Schak=Read_Schak(0x0D);    Schaks_On_Lcd(0x0D,Schak);
  Schak=Read_Schak(0x0E);    Schaks_On_Lcd(0x0E,Schak);
  Schak=Read_Schak(0x0F);    Schaks_On_Lcd(0x0F,Schak);
  Pots_On_Lcd();
}

void Schaks_On_Lcd(byte SchakNr, byte Schak)
{ // Write Schakelaar Waardes
  if (SchakNr >= 0x10)
     { // Schrijf "e" (Eerste Schakelaar Bits) en "o" ( hOogste Schakelaar Bits)
       Lcd_Out(0,0b10000000 | 20 | 0b00000000);    // GotoXY(0,2)
       Lcd_Out(1,'e');
       Lcd_Out(0,0b10000000 | 20 | 0b01000000);    // GotoXY(0,3)
       Lcd_Out(1,'o');
     }
  else
     { // Schrijf Schakelaar Stand
       if (SchakNr >= 0x0C) { SchakNr = SchakNr + 1; }
       if (SchakNr >= 0x08) { SchakNr = SchakNr + 1; }
       if (SchakNr >= 0x04) { SchakNr = SchakNr + 1; }
       Lcd_Out(0,0b10000000 | 21+SchakNr | 0b00000000);    // GotoXY(0,2)
       Lcd_Out(1,Byte2Hexchar(Schak & 0x0F));
       Lcd_Out(0,0b10000000 | 21+SchakNr | 0b01000000);    // GotoXY(0,3)
       Lcd_Out(1,Byte2Hexchar(Schak >> 4));
     }
}

void Pots_On_Lcd()
{ // Schrijf "p" (Potmeters)
  Lcd_Out(0,0b11000000);    // GotoXY(0,1)
  Lcd_Out(1,'p');
  // Schrijf Alle Potmeter Waardes
  Lcd_Out(1,Byte2Hexchar(P0));
  Lcd_Out(1,Byte2Hexchar(P1));
  Lcd_Out(1,Byte2Hexchar(P2));
  Lcd_Out(1,Byte2Hexchar(P3));
  Lcd_Out(1,' ');
  Lcd_Out(1,Byte2Hexchar(P4));
  Lcd_Out(1,Byte2Hexchar(P5));
  Lcd_Out(1,Byte2Hexchar(P6));
  Lcd_Out(1,Byte2Hexchar(P7));
  Lcd_Out(1,' ');
  Lcd_Out(1,Byte2Hexchar(P8));
  Lcd_Out(1,Byte2Hexchar(P9));
  Lcd_Out(1,Byte2Hexchar(PA));
  Lcd_Out(1,Byte2Hexchar(PB));
  Lcd_Out(1,' ');
  Lcd_Out(1,Byte2Hexchar(PC));
  Lcd_Out(1,Byte2Hexchar(PD));
  Lcd_Out(1,Byte2Hexchar(PE));
  Lcd_Out(1,Byte2Hexchar(PF));
  delay(100);
}

byte Byte2Hexchar(byte bb)
{ if (bb < 0x0A)
     { return bb+'0';
     }
  else
     { return bb+('A'-0x0A);
     }
}

// ===================================================================

void Write_Led(byte nr, byte L1, byte L2, byte L3)
{
  nr = nr & 0x0F;
  L1 = (L1 & 0x0F) ^ 0x0F;
  L2 = (L2 & 0x0F) ^ 0x0F;
  L3 = (L3 & 0x0F) ^ 0x0F;
  Write_Data (0, (L2 << 4) + L1);
  Write_Data (1, (nr << 4) + L3);
}

void Lcd_Init()
{ delay(20);                          // Wait while the LCD-unit itself is initialized
  // Sent Lcd Initialisation, 3 times (as described in the datasheet).
  Lcd_Out(0,0b00111000); delay(5);   // 1st LCD write (set 8bits interface)
  Lcd_Out(0,0b00111000); delay(1);   // 2nd LCD write (set 8bits interface)
  Lcd_Out(0,0b00111000); delay(1);   // 3rd LCD write (set 8bits interface)
  // Sent Lcd Instructions
  Lcd_Out(0,0b00111000);    // Function-Set 8-bits, 2-lines, 5x8-font, <none>, <none>
  Lcd_Out(0,0b00001000);    // Set Display On/Off Control: Cursor, Blinking
  Lcd_Out(0,0b00001100);    // Set Display On/Off Control: Cursor, Blinking
  Lcd_Out(0,0b00010100);    // Set Cursor/ Display Shift: Shift/Cursor, Right/Left, <none>, <none>
  Lcd_Out(0,0b00000110);    // Entry Mode Set: Inc/Dec, DisplShift
  Lcd_Out(0,0b00000001);    // Clear Display
  delay(2);
  Lcd_Out(0,0b10000010);    // GotoXY(1,0)
  Write_Lcd_LatchTest_Text();
}

void Write_Lcd_LatchTest_Text()
{ // Sent Characters
  Lcd_Out(1,'A');
  Lcd_Out(1,'r');
  Lcd_Out(1,'S');
  Lcd_Out(1,'i');
  Lcd_Out(1,'d');
  Lcd_Out(1,' ');
  Lcd_Out(1,'L');
  Lcd_Out(1,'a');
  Lcd_Out(1,'t');
  Lcd_Out(1,'c');
  Lcd_Out(1,'h');
  Lcd_Out(1,' ');
  Lcd_Out(1,'C');
  Lcd_Out(1,'h');
  Lcd_Out(1,'e');
  Lcd_Out(1,'c');
  Lcd_Out(1,'k');
}

void Lcd_Out(byte rr, byte bb)
{ // Rs  0  %00000000 = Instruction Register
  // Rs  1  %00000001 = Data Register
  // En  0  %00000000 = Enable     (Falling Edge)
  // En  1  %00001000 = Not Enable (Raising Edge)

  rr=rr & 0b00000001;

  Write_Data(3,0b00001000 | rr);
  Write_Data(2,bb);
  delayMicroseconds(42);
  Write_Data(3,0b00000000 | rr);
}

byte Read_Schak(byte SchakNr)
{ byte ss = 0;
  SchakNr = SchakNr & 0x0F;
  Write_Data(5,SchakNr);     // Write Schakelaars Out
  ss = ~ Read_Data(4);       // Read  Schakelaars In
  return ss;
}

// ===================================================================
// ===================================================================
// ===================================================================

void Write_Lcdback(byte LL)
{ // Write byte naar Lcd Backlight
  LL = LL & 0b00000111;
  LL = LL ^ 0x07;
  DDRB = DDRB | 0b11100000;
  PORTB = (PORTB & 0x1F) | ( LL << 5);
}

void Set_Adres_Out()
{ // Set de Adres op Output
  DDRC = 0xFF;
}

void Write_Adres(byte aa)
{ // Write byte naar Adresbus
  DDRC = 0xFF;
  PORTC = aa;
}

void Set_Data_Out()
{ // Set de Databus op Output
  DDRA = 0xFF;
}

void Set_Data_In()
{ // Set de Databus op Int
  DDRA = 0x00;
}

void Write_Data(byte aa, byte dd)
{ // Write byte naar Databus
  if (aa != 0x04)
     { DDRC = 0xFF;        // Adresbus
       DDRA = 0xFF;        // Databus Output
       PORTA = dd;         // Databus Write Byte
       aa = bitje[aa & 0b00000111];  // <==== Maak van het adres-nummer een bitje
       aa = ~ aa;                    // <==== Bitje Inverteren.
       PORTC = aa;         // Adresbus
       delayMicroseconds(1);
       PORTC = 0b11111111; // Adresbus
     }
}

byte Read_Data(byte aa)
{ // Read byte van Databus
  byte dd = 0x00;
  if (aa == 0x04)
     { DDRC = 0xFF;        // Adresbus
       DDRA = 0x00;        // Databus Input
       aa = bitje[aa & 0b00000111];  // <==== Maak van het adres-nummer een bitje
       aa = ~ aa;                    // <==== Bitje Inverteren.
       PORTC = 0b11101111; // Adresbus
       delayMicroseconds(1);
       dd = PINA;         // Databus Read Byte
//       delayMicroseconds(1);
       PORTC = 0b11111111; // Adresbus
     }
   return dd;
}



Broncode: [1: De Led Latches] [2: De Lcd Latches] [3: De Schakelaar Latches]
[Tekst] [Afbeeldingen] [Aansluitingen] [Broncodes]