ArSid - Arduino Sid Synthesizer

Fri 18-Oct-19
21:15:57




Sids

Datum: Thu 30 November 2017
Samenvatting: De Sids is de print waar 4 Sid-IC's op gemonteerd zijn. Er moeten zowel oude versies (6581), als nieuwe versies (8580) op kunnen zitten.
 Soort Artikel: Electro
Status: Afgerond



[Tekst] [Afbeeldingen] [Aansluitingen] [Broncodes]
sids_01-schema.jpg
1/32: sids_01-schema.jpg.
sids_02-blokschema.jpg
2/32: sids_02-blokschema.jpg.
sids_03-aansluitschema.jpg
3/32: sids_03-aansluitschema.jpg.
sids_04-printontwerp.jpg
4/32: sids_04-printontwerp.jpg.
sids_05-printcut.jpg
5/32: sids_05-printcut.jpg.
sids_06-print-foutontwerp.jpg
6/32: sids_06-print-foutontwerp.jpg.
Meer
[Tekst] [Afbeeldingen] [Aansluitingen] [Broncodes]

Ruim een jaar geleden is het schema al ontworpen (zie de datum op het schema), alsmede de print-opbouw. Echter tijdens het solderen van de print kwam ik er (toen al) al achter dat dit bij deze print één van de saaiste klussen is.

8 datalijnen, 5 adreslijnen, plus de controllijnen (R/W en Phi2 signalen) hebben elk 6 losse draadjes (4 Sids en 2 print aansluitingen) nodig. Vermenigvuldigd met 16 geeft al 80 losse draadjes, die ook nog netjes gelegd moeten worden.

Er moet worden voorzien om er een tweede print bovenop te zetten. Hiervoor zijn diverse aansluitingen dubbel uitgevoerd, zoals de voedingsspanningen, de data-, adres- en control-bus. Bij de bovenste print moeten hoekjes eruit worden gezaagd, zodat de connectoren met de onderste print naar de rest van de ArSid niet in de weg komen te zitten. Vanaf het begin was het plan al om 8 Sids te kunnen aansturen, tevens is de Decoder ontworpen om 8 Sids te kunnen decoderen.

Meestal wijst een eerste printontwerp in de juiste richting, maar dit gaat niet altijd meteen goed, getuige de foto's. Hier ligt een groot probleem bij het bevestigingsgat rechtsboven. In de behuizing zit op deze plaats juist een voet en een montage-schroef dwars door de voet heen geeft geen betrouwbare bevestiging. Daarom is het ontwerp gewijzigd, zijn de audio-connectoren (bovenaan) langer gemaakt. Tevens zijn er twee rode (spannings)Leds vervangen door groene Leds (omdat deze spanningen geen +5V zijn, maar +9V en +12V). In het printontwerp zijn naast de Sids diverse condensatoren te zien. Deze zijn op de print echter tussen de IC-voeten gesoldeerd en zitten ze dus onder de Sid-IC's zelf. Elke Sid heeft ook nog twee speciale "filter"-condensatoren nodig om het filter juist te laten werken, deze worden wel naast de IC-voet (en dus naast de Sid) gesoldeerd.

Oude versie Sid vs nieuwe versie Sid.

Er zijn (globaal) twee versies van de Sid uitgebracht. De oude versie, de oer-Sid, is de oorspronkelijke versie en draagt nummer 6581. Men zegt dat deze iets rouwer klinkt. Ook bevat deze versie enkele onvolkomenheden, zoals dat de volume regeling een gelijkspanning (een DC) niet helemaal wegkreeg. Het signaal bevatte dus een DC-component. Deze eigenschap werd uitgebuit om 4-bits samples te laten horen.

De nieuwe versie draagt nummer 8580. Hierin zijn enkele onzorgvuldigheden uit de oer-Sid verbeterd. Dit resulteerde dat het samplen niet werkt. Er is geen DC-component meer aanwezig om het sample-afspelen te kunnen realiseren.

Er zijn op electronica niveau ook verschillen tussen deze twee versies, namelijk de voedingsspanning (12V of 9V) en de filter-condensatoren (2200pF of 6800pF) (pinnen 1 t/m 4). Alle aansluitpinnen zijn wel hetzelfde gebleven.

In dit schema is gekozen dat de Sids in paren op de print gezet moeten worden. Bij elk paar is de beslissing of ik er twee oude of twee nieuwe versies in zet. Elk paar heeft ook zijn eigen (groene) spanningsLed.

Op het moment van ontwerpen, heb ik één Cbm64 liggen en nog 1 Sid 6581 (al ongeveer 30 jaar) in een onderdelenbak. Ik heb nog 4 Sids kunnen bestellen, namelijk 2 Sids 6581 en 2 Sids 8580. Vanuit dit aantal is het ontwerp ontstaan. Voor de rest blijkt de Sid-markt enorm schaars geworden te zijn. Zoals het er uitziet begin ik met twee oude en twee nieuwe versies op één print. Links twee oer-Sids (6581 als Sid0 en Sid1) en rechts twee nieuwe Sids (8580 als Sid6 en Sid7).

Filter-condensatoren.

Het zoeken naar de filter-condensatoren was al een zoektocht op zich. Deze moeten gemaakt zijn van PolyStyrene (zie het aansluitschema "Typical 6581 Sid Application" uit de Datasheet van de Sid), een materiaal dat over de tijd weinig verloopt. In de jaren 1980 kwamen deze nog veel voor. Maar anno 2016 zijn ze zeldzaam en dat is ook te merken aan de prijs ervan.

Een electronica-winkel in Den Helder had ze gelukkig nog liggen. Een keramische, of een gewone ontkoppel-condensator kost nu dan enkele dubbeltjes, de polystyrene condensatoren kosten al meer dan 7,00euro per stuk. Voor dit projekt ga ik voor een zo stabiel mogelijke werking, dus vind ik dit wel de moeite waard. Ik had er dan van elke waarde 10 stuks genomen, enkelen in voorraad leek mij wel handig. Wat opvalt is dat ze ook een stuk groter zijn (zie foto's).

Solderingen testen.

Na al het saaie solderen van de data-bus (groen/wit en groen/zwart), adres- (geel/zwart) en control-bus (geel/wit en groen als reset) zijn alle verbindingen hardware-matig getest op een juiste verbinding tussen alle overeenkomende pinnen en dat er geen kortsluiting is tussen de vele draadjes. Dit testen gebeurt eenvoudig met een multi-meter in de stand weerstand en moet worden gedaan voordat de kostbare Sids erop worden geprikt.

Tussen de Sids en de bus-connectoren lopen nu zoveel draadjes dat dit misschien nog problemen oplevert bij het erin prikken van de Sids, of de bus-aansluitingen.

Een andere zorg zijn de polystyrene condensatoren van 6800pF. Zij zijn zo hoog, dat er wellicht geen tweede print bovenop kan worden geprikt. Maar met (voorlopig) maar 4 Sids moet het voorlopig gaan voldoen.

Elektrische test.

Eerst moeten er nog verbindingen van de Databus en die tussen de Decoder en de Sids worden gesoldeert. Het valt op dat er vier draden (nog) niet aangesloten zijn op de Sids. Dit zijn de Enable-draden voor de Sids 2 (rood), 3 (oranje), 4 (geel) en 5 (groen) - ik heb immers gekozen om eerst de Sids 0, 1, 6 en 7 te gebruiken.

De voeding is aangesloten en aangezet. En meteen lichten de drie Leds op de Sids-print op. De rode voor de 5V en twee groene voor de 12V (Sid 0 en 1) en de 9V (Sid 6 en 7). Nameten met de multi-meter bevestigt dat de voedingsspanningen keurig aanwezig zijn op de voedingspennen van de Sid IC-voeten.

Testen van de Adresbus en Databus.

De volgende teststap is om (nog zonder Sids) te kijken of alle Data en Adres signalen van de Arduino doorkomen op de Sids-print en dat ze elkaar niet (ver)storen. Eerst is er een Logic-Analyser op de adresbus aangesloten en wordt door de Arduino alle adreslijnen 1 voor 1 hoog gemaakt. Op de Logic-Analyser moet dan op de afzonderlijke adreslijnen een Hoge puls zichtbaar worden, die als een soort treintje naar een hogere adreslijn gaat.

Na de adresbus is het zelfde gedaan met de Databus. Vervolgens is de combinatie van de Adresbus met de Databus getest. Alle treintjes zijn keurig in beeld gekomen, zonder dat ze elkaar storen ... op 1 dingetje na.

Het blijkt dat de adres-enable (Op de Arduino is dit Pin 42, Port L, bit 7 - te zien als de hoogste adres-lijn) meer rotzooi op de Databus laat gooien, dan verwacht.

Het heeft ook wat tijd gekost om dit probleem te analyseren en te beredeneren. Ook omdat de rotzooi alleen op de Datalijnen kwam en altijd op een vast tijdstip na het treintje verscheen. Blijkbaar heb ik de Adresbus en Databus moeten testen zonder de Latches-print en Decoder-print aangesloten (deze had ik dus aangesloten gelaten). Er moet vanaf de Latches valse data op de Databus gekomen zijn, doordat de R/~W niet meegenomen is in deze test. Die valse data moet afkomstig zijn van de enige Read-"Register" op de Latches, namelijk dat register dat de schakelaar-standen inleest.

Bij het niet meenemen van de adres-enable (of te wel met de 'botte bijl' de betreffende Pin 42 als ingang houden), tonen de datalijnen keurig het treintje met hoge pulsen, gepauseerd door 16 lage dalen (de Arduino is dan de adreslijnen aan het toggelen).

Bij de Logic-Analyser foto's is onderaan een gedecodeerd resultaat getoond, keurig in de volgorde van $01, $02, $04 tot en met $80. Een teken dat alle bitjes 1 voor 1 aankomen. Een meettijd op de bovense datalijn toont keurig dat een puls 5msec duurt, de tijd die in het programma is opgegeven. Tussen twee pulsen is de tijd 115msec, wat overeenkomt met 7*5msec (= 35msec) dat de datalijn laag is, PLUS 16*5msec (= 80msec) dat de adreslijnen wordt getoggeld.

Bij een test waarbij het oscilloscoopbeeld getriggerd wordt met ~CS0 (ChipSelect van Sid 0 - deze is Low-Active), is de lijn Adres-Enable toch weer nodig. De Pin 42 van de Arduino is weer op Uitgang gezet. Echter nu wordt de R/~W (Pin 40) Laag gehouden, zodat er "continue geschreven" wordt. Nu blijkt dat het pulsentreintje op de Databus geen verstoring meer heeft. Ook de ChipSelect0 wordt keurig weergegeven op het bovenste helft van het oscilloscoop-beeld. De ChipSelect0 komt rechtstreeks vanaf IC1 op de Decoder-print.

'Poke'n en 'Peek'en.

Bij de Sids is een belangrijke naamswijziging doorgevoerd in twee IO-funkties, namelijk die met de namen WRITE_DATA() en READ_DATA(). Deze zijn hernaamd naar POKE() en PEEK(). Deze namen komen rechtstreeks uit de programmeertaal BASIC, de standaard taal waarmee men de Cbm64 kon programmeren. Wilde men op de Cbm64 geluid hebben, dan waren er diverse POKE-commando's nodig om de Sid te programmeren.

  • POKE(): Het gebruik in Basic was: "POKE Adres,Data" en dit resulteerde dat de Data rechtstreeks op geheugenplaats Adres werd weggeschreven ... Als er een IO-register (Vid, Sid, Cia, Processor-register) op dat adres was, dan werd de data in het betreffende register geschreven - Hier heet de funktie Poke(Adres,Data) en doet hetzelfde.

  • PEEK(): Het gebruik in Basic was: "Data=PEEK(Adres)" (een echte funktie in Basic) en dit resulteerde dat er Data rechtstreeks vanuit een geheugenplaats op dat Adres werd uitgelezen ... Als er een IO-register (Vid, Sid, Cia, Processor-register) op dat adres was, dan werd de data uit het betreffende register gelezen - Hier heet de funktie Data=Peek(Adres) en doet hetzelfde.

    In dit projekt vind ik Poke en Peek duidelijker op zijn plaats dan Write_Data en Read_Data, juist vanwege de geschiedenis vanuit de Cbm64.

    Controleren van de Timing.

    Met de Logic Analizer is ook de Timing gecontroleerd van de adreslijnen die naar de Sid gaan. Ik ben niet de eerste die een Sid wil aansturen met een "vreemde" processor. Het blijkt dat de Sid 6581 niet zo moeilijk is om aan te sturen, dat de timing ervan niet zo'n probleem is. Het blijkt dat het andere Sid-type, de 8580 veel strenger is. Dat deze de data niet accepteerd als de timing niet correct is.

    Wat ook een rol speelt is dat de 1MHz oscillator (de clock die de Φ2 bepaalt) op de Decoder-print en de Clock op de Arduino op geen enkele manier gekoppeld zijn. Ook al draait de Arduino Mega op 16MHz, als hier een clock van 1MHz gehaald wordt, zal deze clock langzaam verlopen met die van de Decoder-print. Dit is ook de reden dat het Φ2 signaal (Phi2) niet alleen naar de Sids gaat voor de frequentie-basis en daarmee alle toonhoogtes bepaal, maar deze timing is ook de reden dat de Φ2 ook teruggaat naar de Arduino - een punt dat ik al vroeg in het totaal ontwerp heb zitten.

    Voor de timing is teruggegrepen naar het timing-diagram van de 6502 (of eigenlijk van de 6510, de processor die in de CBM64 zit - deze staat gewoon in de CBM64 Programmers Reference Guide). Belangrijk is dat de Adres en Data op tijd op de bussen staan, als de R/~W signaal eraan komt. En de R/~W moet op tijd gestabiliseerd zijn als de Φ2 omlaag gaat (zie de blauwe pijl op de foto's). De timing-diagrammen van onder andere de 6581 en andere 65xx IO-IC's bevestigen dit (ook deze timing-diagrammen staan in de CBM64 Programmers Reference Guide).

    Het eerste ontwerp voor de Poke-Funktie was recht-toe recht-aan geprogrammeerd, zonder te kijken naar het Φ2-signaal. Enkele regels waren dubbel uitgevoerd om voor een kleine vertraging te zorgen die de Latches blijkaar nodig had. Na het aansluiten van de adres-bus van de Sids (A0 .. A4) op een Logic Analyzer, samen met de ~CS, de R/~W en de Φ2, blijkt dat de timing best veel verloopt. Er moest nog wat gesleuteld worden aan deze funktie.

    In de Poke-Funktie zijn enkele WHILE-lussen toegevoegd, die kijken naar de Φ2 ["while ( (PING & phi2_mask) != / == 0) { Do_Nothing }"]. Eerst worden de Adres en Data op de bussen gezet. Na het Laag maken van de R/~W wordt er gewacht tot de Φ2 Hoog is en daarna wordt er gewacht tot de Φ2 weer laag is - het moment dat een Sid de data echt inleest. Vervolgens wordt de R/~W weer "Laag" gemaakt - dit veroorzaakt een extra korte vertraging, iets korter dan de standaard funktie DelayMicroSecons() kan realiseren. Daarna wordt de Adres ge-disable-d, gevolgd door het weer Hoog maken van de R/~W. Dit is het einde van de Poke-Funktie.

    Het beeld van de Logic Analyzer (zie foto's) laat nu zien dat, zodra de ~CS Laag is, er keurig gewacht wordt op de Φ2. En zodra de Φ2 weer Laag is (bij de blauwe vertikale lijnen), dan duurt het een korte tijd voordat de ~CS weer Hoog wordt, een teken dat de Sid geen data meer opneemt.

    Een Sid plaatsen.

    Nu eerst de Polystyrene Condensatoren op de Sids-print solderen en dan komt uiteindelijk het spannendste moment aan. Namelijk het erin prikken van één Sid (6581) en met de oscilloscoop controleren of er een audio-signaal uit komt.

    Een testprogramma is dan snel gemaakt. Aanzetten en dan ... geen resultaat. Geen beeld op de oscilloscoop op de Audio-Uitgang. Wat op de oscilloscoop wel opvalt is een 1MHz signaal op de audio-uitgang. Ik weet van vroeger ook dat het audio-signaal uit de CBM64 ook niet brandschoon was, dus dit is geen verontrusting. En ook warmte-produktie van de Sid. Volgens de Datasheet mag de Sid een temperatuur hebben van 0C tot 70C, echter ik kon hem nog steeds met een vinger aanraken. Dan wordt het verder foutzoeken in de elektronica. En blijkt er gewoon niets verkeerds te zitten. De timing is nog verder ge-fine-tuned, maar nog steeds geen resultaat. Zelfs een tweede exemplaar (6581) gaf geen enkel audio-signaal.

    Dan is het (enigzins paniekerig denken): "Wat nu." De eerste gedachte is om de Sid uit mijn eigen Commodore64 te trekken ... ware het niet dat die er al uit is gehaald (met geen idee wanneer dat was, want het was de tweede al die ik in mijn CBM64 gedaan had). Dan wordt het tijd om toch de enige 6581 uit mijn eigen onderdelenbak gebruiken. Ik wist met grote zekerheid dat het een goede zou zijn, ondanks dat deze meer dan 30 jaar in mijn onderdelenbak heeft gelegen.

    Aanzetten en kijken naar het beeld van de oscilloscoop. Weer geen signaal, totdat ... na enige tijd (en na het verzetten van de trigger-time instellingen) er toch iets van driehoekjes te zien zijn op het beeld. Driehoekjes die in frequentie lijken te varieren ... lijken? Ze varieren ook echt in frequentie (zoals het eerste testprogramma (hier niet weergegeven) geprogrammeerd was). Jubel, juich, juich. Enerzijds omdat ik uiteindelijk toch geluid heb, anderzijds omdat dit een bevestiging is dat de aansturing ervoor gewoon werkt, zoals ingedachte is.

    Met een frequentie van 1.53kHz zijn de 4 mogelijke golfvormen (1:driehoek; 2:zaagtand; 4:pulse; 8:ruis) uitgeprobeerd en is het op oscilloscoop-beeld vastgelegd (zie foto's). In vertikale richting is echter ook een 1MHz signaal van de clock Φ2 te zien als een brede band. Iets dat er op de versterker-printen uit gefilterd moet worden.

    Deze frequentie van 1.53kHz komt hier toevallig uit de ge-poke-de waarde van 101 in zowel de Lage-byte als de Hoge-byte voor de frequentie-registers [0,1].

    Er is een mini-printje gemaakt met maar 3 komponenten erop, 1) een ontkoppel-elko (zoals het aansluit-schema al aangeeft), 2) een (blauw) volume-knopje en 3) een extra uitgang waar de oscilloscoop op aangesloten kan worden. Een paar mini speakertjes (met ingebouwde versterker op batterijen) is erop aangesloten en het geluid is nu ook hoorbaar.

    Sweep-programma.

    De zaagtand is weer ingesteld en de ADSR van de Sid heeft een paar leuke waardes gekregen. Dit programma is hier wel weergegeven. Deze sweep (van 001 .. 251) is opgenomen en zowel in een foto als in een MP3 geplaatst.

    Een blik in het LOOP-deel van het programma geeft toch weer iets vertrouwds, al die Pokes onder elkaar.

    Poke(Sid_Adr+24, 15); // Volume
    Poke(Sid_Adr+ 0, 0); // Freq Lo
    Poke(Sid_Adr+ 1, 200); // Freq Hi
    Poke(Sid_Adr+ 2,0x88); // PulsWid Lo
    Poke(Sid_Adr+ 3,0x88); // PulsWid Hi
    Poke(Sid_Adr+ 5,0x66); // AD
    Poke(Sid_Adr+ 6,0xF6); // SR
    Poke(Sid_Adr+ 4,wave1+1); // Control (SoundWave)

    Op de CBM64 was het in Basic niets anders dan een partij Pokes om de Sid te programmeren (zie foto's - de hier gegeven foto is alleen een voorbeeld hoe een CBM64 programma er uit kan zien. Het voorbeeld heeft inhoudelijk totaal niets te maken met de Sids-print).

    Nawoord Sids.

    Tijdens het maken van het ArSid-programma (het programma dat de ArSid gaat besturen), heb ik één van de bestelde Sids 6581 erbij geprikt (gewoon kijken wat hij doet), blijkt deze toch te werken. Een snel doorlopen van enkele register-waardes, blijkt deze Sid goed te werken, betreffende de voices. Van het filter-deel twijfel ik nog. Dit zal ik later nog moeten uitzoeken, wanneer de Versterkers klaar zijn. Zag het er eerst wat somber uit, omdat ik sommige idee-en niet uit zou kunnen voeren, nu blijkt dat ik toch ver ga komen in mijn ideeën.

    Ik heb ook twee nieuwere Sids 8580 er in geprikt - ook deze werken, qua voices. Het simuleren van de 65xx-bussen door de Arduino Mega werkt uitstekend. Ik twijfel bij mijn 8580-Sids ook over het filter, ook dit is een punt voor later. Maar met dit al als eindresultaat is de Sid-print voorlopig voltooid en afgerond. Al met al ziet het er machtig uit, 4 Sids op een rijtje (zie foto).

    Tijdens het testen en programmeren blijken de Sids erg warm te worden. Door het monteren van een koellichaam op de Sids kan er geen tweede Sid-print bovenop de eerste geplaatst worden, hoewel er met het ontwerpen van de Sid-print wel rekening mee is gehouden.

    Een troost is dat ik niet meer Sid-chips heb, zodat dit laatste geen noemenwaardig probleem voor mij zal zijn ... en er dus prioriteit gegeven kan worden aan het extra koelen van de Sid-chips.


    Audio voorbeelden.

  • Sweep met zaagtand, 001 .. 251.


    

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

    Afbeeldingen

    sids_01-schema.jpg
    1/32: sids_01-schema.jpg.
    sids_02-blokschema.jpg
    2/32: sids_02-blokschema.jpg.
    sids_03-aansluitschema.jpg
    3/32: sids_03-aansluitschema.jpg.
    sids_04-printontwerp.jpg
    4/32: sids_04-printontwerp.jpg.
    sids_05-printcut.jpg
    5/32: sids_05-printcut.jpg.
    sids_06-print-foutontwerp.jpg
    6/32: sids_06-print-foutontwerp.jpg.
    sids_07-printhalf.jpg
    7/32: sids_07-printhalf.jpg.
    sids_08-condensators.jpg
    8/32: sids_08-condensators.jpg.
    sids_09-printbijna.jpg
    9/32: sids_09-printbijna.jpg.
    sids_10-klaar.jpg
    10/32: sids_10-klaar.jpg.
    sids_11-tussenkabel.jpg
    11/32: sids_11-tussenkabel.jpg.
    sids_12-voedingtest.jpg
    12/32: sids_12-voedingtest.jpg.
    sids_13-adresbus.jpg
    13/32: sids_13-adresbus.jpg.
    sids_14-databus.jpg
    14/32: sids_14-databus.jpg.
    sids_15-scoop_cs.jpg
    15/32: sids_15-scoop_cs.jpg.
    sids_16-databus-and-cs0.jpg
    16/32: sids_16-databus-and-cs0.jpg.
    sids_17-timing6502.jpg
    17/32: sids_17-timing6502.jpg.
    sids_18_poketiming.jpg
    18/32: sids_18_poketiming.jpg.
    sids_19-sid-op-print.jpg
    19/32: sids_19-sid-op-print.jpg.
    sids_20-sid-op-print.jpg
    20/32: sids_20-sid-op-print.jpg.
    sids_21-volume-speaker.jpg
    21/32: sids_21-volume-speaker.jpg.
    sids_22-0clocknoise.jpg
    22/32: sids_22-0clocknoise.jpg.
    sids_23-1triange.jpg
    23/32: sids_23-1triange.jpg.
    sids_24-2saw.jpg
    24/32: sids_24-2saw.jpg.
    sids_25-4pulse.jpg
    25/32: sids_25-4pulse.jpg.
    sids_26-8noise.jpg
    26/32: sids_26-8noise.jpg.
    sids_27-soundsweep.jpg
    27/32: sids_27-soundsweep.jpg.
    sids_28-sweep_saw_001-251.jpg
    28/32: sids_28-sweep_saw_001-251.jpg.
    sids_29-registers.jpg
    29/32: sids_29-registers.jpg.
    sids_30-cbm64prog.jpg
    30/32: sids_30-cbm64prog.jpg.
    sids_31-lcd-werkende-sid.jpg
    31/32: sids_31-lcd-werkende-sid.jpg.
    sids_32_allesgevuld.jpg
    32/32: sids_32_allesgevuld.jpg.

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

    De aansluitingen van Sids

    Diverse tests van de Sids

    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
     | 
    A7 = Adres 7 d30 | d31 A6 = Adres 6
    A5 = Adres 5 d32 | d33 A4 = Adres 4
    A3 = Adres 3 d34 | d35 A2 = Adres 2
    A1 = Adres 1 d36 | d37 A0 = Adres 0
     | 
    ~Reset d38 | d39 Lcd (hier niet nodig)
    R/~W d40 | d41 phi2
     | 
    ~Enable Adres d42 | d43
    d44 | d45
    d46 | d47
    d48 | d49 A8 = Adres 8
     | 
    d50 | d51
    d52 | d53

    

    [Tekst] [Afbeeldingen] [Aansluitingen] [Broncodes]
    Broncode: [1: Sids Adresbus Test] [2: Sids Adresbus & DatabusTest] [3: Sids Adresbus, Databus en ChipSelect0 Test] [4: Sids Poke Timing]
    [5: Sids Sound Sweep]

    1: De broncode van Sids Adresbus Test

    (Sat 23 December 2017) Het testen van de Adresbus op de Sids-print.

    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
    /****************************************************************************
        ArSid Sids Test Adres

        Sids Print test Programma.

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


    void setup()
    {
      // put your setup code here, to run once:
      Set_Busses_Out();
    }

    const int pause=10;

    void loop()
    {
      // put your main code here, to run repeatedly:
      PORTC = 0b00000001;   delay(pause);
      PORTC = 0b00000010;   delay(pause);
      PORTC = 0b00000100;   delay(pause);
      PORTC = 0b00001000;   delay(pause);
      PORTC = 0b00010000;   delay(pause);
      PORTC = 0b00100000;   delay(pause);
      PORTC = 0b01000000;   delay(pause);
      PORTC = 0b10000000;   delay(pause);
      PORTC = 0b00000000;   delay(pause);
    }

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

    const byte reset_mask     = 0b10000000;   // Mask Reset at the Controlbus.
    const byte phi2_mask      = 0b00000001;   // Mask Phi2 signal at the Controlbus.
    const byte readwrite_mask = 0b00000010;   // Mask R/~W bit at the de Controlbus.
    const byte lcd_mask       = 0b00000100;   // Mask Lcd Ready Signal (not used here).
    const byte adr_en_mask    = 0b10000000;   // Mask Adresse Enable (is MSB of the address).

    void Set_Busses_Out()
    { // Set de Adres op Output
      noInterrupts();         // Disable Interrupts
      DDRC = 0xFF;            // Adressbus Low-Byte
      DDRL = 0xFF;            // Adressbus High-Byte + Enable
      DDRA = 0xFF;            // Databus
      // Set Adres 0x0000 at the Adresbus, include Disable.
      PORTC = 0b00000000;     // Adress Low-Byte
      PORTL = adr_en_mask;    // Adress High-Byte + Enable
      // Set Data 0x00 at Databus.
      PORTA = 0xFF;           // Databus
      // Set Controlbus phi2 and Lcd at Input  and  R/~W at Output
      DDRG = readwrite_mask;
      // Set Controlbus at Read
      PORTG = readwrite_mask;
      interrupts();           // Enable Interrupts
    }
    

    Broncode: [1: Sids Adresbus Test] [2: Sids Adresbus & DatabusTest] [3: Sids Adresbus, Databus en ChipSelect0 Test] [4: Sids Poke Timing]
    [5: Sids Sound Sweep]

    2: De broncode van Sids Adresbus & DatabusTest

    (Sat 23 December 2017) Het testen van de Adresbus en de Databus op de Sids-print.

    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
    /****************************************************************************
        ArSid Sids Test Adresbus & Databus

        Sids Print test Programma.

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


    void setup()
    { // put your setup code here, to run once:
      Set_Busses_Out();
    }

    const int pause=5;      // Delay-time between the toggles

    void loop()
    { // put your main code here, to run repeatedly:
      // Toggle Databus
      PORTA = 0b00000001;   delay(pause);  PORTA = 0b00000000;
      PORTA = 0b00000010;   delay(pause);  PORTA = 0b00000000;
      PORTA = 0b00000100;   delay(pause);  PORTA = 0b00000000;
      PORTA = 0b00001000;   delay(pause);  PORTA = 0b00000000;
      PORTA = 0b00010000;   delay(pause);  PORTA = 0b00000000;
      PORTA = 0b00100000;   delay(pause);  PORTA = 0b00000000;
      PORTA = 0b01000000;   delay(pause);  PORTA = 0b00000000;
      PORTA = 0b10000000;   delay(pause);  PORTA = 0b00000000;

      // Toggle Adressbus Low
      PORTC = 0b00000001;   delay(pause);  PORTC = 0b00000000;
      PORTC = 0b00000010;   delay(pause);  PORTC = 0b00000000;
      PORTC = 0b00000100;   delay(pause);  PORTC = 0b00000000;
      PORTC = 0b00001000;   delay(pause);  PORTC = 0b00000000;
      PORTC = 0b00010000;   delay(pause);  PORTC = 0b00000000;
      PORTC = 0b00100000;   delay(pause);  PORTC = 0b00000000;
      PORTC = 0b01000000;   delay(pause);  PORTC = 0b00000000;
      PORTC = 0b10000000;   delay(pause);  PORTC = 0b00000000;

      // Toggle Adressbus High + Adress Enable
      PORTL = 0b00000001;   delay(pause);  PORTL = 0b00000000;
      PORTL = 0b00000010;   delay(pause);  PORTL = 0b00000000;
      PORTL = 0b00000100;   delay(pause);  PORTL = 0b00000000;
      PORTL = 0b00001000;   delay(pause);  PORTL = 0b00000000;
      PORTL = 0b00010000;   delay(pause);  PORTL = 0b00000000;
      PORTL = 0b00100000;   delay(pause);  PORTL = 0b00000000;
      PORTL = 0b01000000;   delay(pause);  PORTL = 0b00000000;
      PORTL = 0b10000000;   delay(pause);  PORTL = 0b00000000;

    }

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

    const byte reset_mask     = 0b10000000;   // Mask Reset at the Controlbus.
    const byte phi2_mask      = 0b00000001;   // Mask Phi2 signal at the Controlbus.
    const byte readwrite_mask = 0b00000010;   // Mask R/~W bit at the de Controlbus.
    const byte lcd_mask       = 0b00000100;   // Mask Lcd Ready Signal (not used here).
    const byte adr_en_mask    = 0b10000000;   // Mask Adresse Enable (is MSB of the address).

    void Set_Busses_Out()
    { // Set de Adres op Output
      noInterrupts();         // Disable Interrupts
      DDRC = 0xFF;            // Adressbus Low-Byte
      DDRL = 0x7F;            // Adressbus High-Byte
      DDRA = 0xFF;            // Databus
      // Set Adres 0x0000 at the Adresbus, include Disable.
      PORTC = 0b00000000;     // Adress Low-Byte
      PORTL = 0b00000000;     // Adress High-Byte + Enable
      // Set Data 0x00 at Databus.
      PORTA = 0x00;           // Databus
      // Set Controlbus phi2 and Lcd at Input  and  R/~W at Output
      DDRG = readwrite_mask;
      // Set Controlbus at Read
      PORTG = readwrite_mask;
      interrupts();           // Enable Interrupts
    }
    

    Broncode: [1: Sids Adresbus Test] [2: Sids Adresbus & DatabusTest] [3: Sids Adresbus, Databus en ChipSelect0 Test] [4: Sids Poke Timing]
    [5: Sids Sound Sweep]

    3: De broncode van Sids Adresbus, Databus en ChipSelect0 Test

    (Sat 23 December 2017) Het testen van de Adresbus, Databus in combinatie met de ChipSelect van Sid0 op de Sids-print.

    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
    /****************************************************************************
        ArSid Sids Test Adresbus & Databus & ChipSelect0

        Sids Print test Programma.

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


    void setup()
    { // put your setup code here, to run once:
      Set_Busses_Out();
    }

    const int pause=5;      // Delay-time between the toggles

    void loop()
    { // put your main code here, to run repeatedly:
      // Toggle Databus
      PORTA = 0b00000001;   delay(pause);  PORTA = 0b00000000;
      PORTA = 0b00000010;   delay(pause);  PORTA = 0b00000000;
      PORTA = 0b00000100;   delay(pause);  PORTA = 0b00000000;
      PORTA = 0b00001000;   delay(pause);  PORTA = 0b00000000;
      PORTA = 0b00010000;   delay(pause);  PORTA = 0b00000000;
      PORTA = 0b00100000;   delay(pause);  PORTA = 0b00000000;
      PORTA = 0b01000000;   delay(pause);  PORTA = 0b00000000;
      PORTA = 0b10000000;   delay(pause);  PORTA = 0b00000000;

      // Toggle Adressbus Low
      PORTC = 0b00000001;   delay(pause);  PORTC = 0b00000000;
      PORTC = 0b00000010;   delay(pause);  PORTC = 0b00000000;
      PORTC = 0b00000100;   delay(pause);  PORTC = 0b00000000;
      PORTC = 0b00001000;   delay(pause);  PORTC = 0b00000000;
      PORTC = 0b00010000;   delay(pause);  PORTC = 0b00000000;
      PORTC = 0b00100000;   delay(pause);  PORTC = 0b00000000;
      PORTC = 0b01000000;   delay(pause);  PORTC = 0b00000000;
      PORTC = 0b10000000;   delay(pause);  PORTC = 0b00000000;

      // Toggle Adressbus High + Adress Enable
      PORTL = 0b00000001;   delay(pause);  PORTL = 0b00000000;
      PORTL = 0b00000010;   delay(pause);  PORTL = 0b00000000;
      PORTL = 0b00000100;   delay(pause);  PORTL = 0b00000000;
      PORTL = 0b00001000;   delay(pause);  PORTL = 0b00000000;
      PORTL = 0b00010000;   delay(pause);  PORTL = 0b00000000;
      PORTL = 0b00100000;   delay(pause);  PORTL = 0b00000000;
      PORTL = 0b01000000;   delay(pause);  PORTL = 0b00000000;
      PORTL = 0b10000000;   delay(pause);  PORTL = 0b00000000;

    }

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

    const byte reset_mask     = 0b10000000;   // Mask Reset at the Controlbus.
    const byte phi2_mask      = 0b00000001;   // Mask Phi2 signal at the Controlbus.
    const byte readwrite_mask = 0b00000010;   // Mask R/~W bit at the de Controlbus.
    const byte lcd_mask       = 0b00000100;   // Mask Lcd Ready Signal (not used here).
    const byte adr_en_mask    = 0b10000000;   // Mask Adresse Enable (is MSB of the address).

    void Set_Busses_Out()
    { // Set de Adres op Output
      noInterrupts();         // Disable Interrupts
      DDRC = 0xFF;            // Adressbus Low-Byte
      DDRL = 0xFF;            // Adressbus High-Byte + Enable
      DDRA = 0xFF;            // Databus
      // Set Adres 0x0000 at the Adresbus, include Disable.
      PORTC = 0b00000000;     // Adress Low-Byte
      PORTL = 0b00000000;     // Adress High-Byte + Enable
      // Set Data 0x00 at Databus.
      PORTA = 0x00;           // Databus
      // Set Controlbus phi2 and Lcd at Input  and  R/~W at Output
      DDRG = readwrite_mask;
      // Set Controlbus at Read
      PORTG = 0x00;           // readwrite_mask;  // Low is Write / High is Read
      interrupts();           // Enable Interrupts
    }
    

    Broncode: [1: Sids Adresbus Test] [2: Sids Adresbus & DatabusTest] [3: Sids Adresbus, Databus en ChipSelect0 Test] [4: Sids Poke Timing]
    [5: Sids Sound Sweep]

    4: De broncode van Sids Poke Timing

    (Wed 27 December 2017) Het testen van de Poke Timing, het gedrag van de ~CS, R/~W en Phi2. Alleen de belangrijkste funkties zijn hier weergegeven.

    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
    /****************************************************************************
        ArSid Sid-Print

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

        Only the most nescesary functies are shown here ...
        Already working to the end-result

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


    // Include some ArSid_ Libraries
    #include <Some Arsid Libraries> & <Some Basic Libraries>

    void setup()
    { Several_Initializing_Functions();
      ..
      ..
      ..
    }

    void loop()
    {

      for (byte qq=0; qq<=31; qq=qq+1)
          { // Lusje
            Poke(0x0120+qq,0);
            delayMicroseconds(1);
          }

    }

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

    // From the library ArSid_IO - Corrected some timing issues.
    // The 6581 seems very easy with the timing (Phi2 and R/~W).
    // But it is the 8580, who seems to be very strict, so the
    // timing must be correct in this phase of the project.
    //
    //                                    This version is of 27 dec 2017


    void Poke(word aa, byte dd)
    { // Write a byte to the Databus - Just like the Basic-command POKE adres,data
      noInterrupts();                       // Disable Interrupts
      // Write Adres to Adres-bus
      PORTC = aa & 0xFF;                   // Low-Byte
      PORTL = ((aa >> 8) & 0x01 ) | 0x80;  // High-Byte + Enable
      // Set Databus as Output
      DDRA = 0xFF;
      // Write de Data
      PORTA = dd;
      PORTL = PORTL & 0x7F;
      // Put Write at Control-bus
      PORTG = 0b00000000;
      // Wait until Phi2 is High  <=============================================
      while (PING & phi2_mask) != 0)                  // PING = P INput port G
        { // Do Nothing
        }
      // Wait until Phi2 is Low again (The "moment" of writing)
      while (PING & phi2_mask) == 0)                  // PING = P INput port G
        { // Do Nothing
        }
      // Put Write at Control-bus (for a 2nd time) (just to create an extra
      // short delay, much shorter than DelayMicroSeconds can create)

      PORTG = 0b00000000;
      // Disable Adres
      PORTL = PORTL | 0x80;
      PORTG = readwrite_mask;
      // Set Databus as Input again
      DDRA = 0x00;
      interrupts();           // Enable Interrupts
    }

    byte Peek(word aa)
    { // Read a byte from the naar Databus - Just like the Basic-function data=PEEK(adres)
      byte dd = 0;
      noInterrupts();                      // Disable Interrupts
      // Write Adres to Adres-bus
      PORTC = aa & 0xFF;                   // Low-Byte
      PORTL = ((aa >> 8) & 0x01 ) | 0x80;  // High-Byte + Enable
      // Set Databus as Output
      DDRA = 0x00;
      //  PORTA = dd;                        // Twice for a short delay
      // Zet Read at Control-bus
      PORTG = readwrite_mask;
      // Enable Adres
      PORTL = PORTL & 0x7F;
      PORTL = PORTL & 0x7F;                // Twice for a short delay
      // Lees de Data
      dd = PINA;
      // Disable Adres
      PORTL = PORTL | 0x80;
      PORTG = readwrite_mask;
      interrupts();           // Enable Interrupts
      // Return de data
      return dd;
    }

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

    Broncode: [1: Sids Adresbus Test] [2: Sids Adresbus & DatabusTest] [3: Sids Adresbus, Databus en ChipSelect0 Test] [4: Sids Poke Timing]
    [5: Sids Sound Sweep]

    5: De broncode van Sids Sound Sweep

    (Fri 29 December 2017) Het eerste geluid uit een 6581 Sid. Alleen de belangrijkste funkties zijn hier weergegeven.

    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
    /****************************************************************************
        ArSid Sid-Print

        Sid-Print Sound Test Programma.
        Nodig: Schakelaars
               Lcd (Rgb Backlight)
               Control-Potmeters
               Aansturing LedRij
               Latches
               Decoder

        Only the most nescesary functies are shown here ...
        Already working to the end-result

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


    // Include some ArSid_ Libraries
    #include <Some Arsid Libraries> & <Some Basic Libraries>

    word Sid_Adr = 0x0100;     // The basic adress of the first Sid.

    void setup()
    { // Reset en Init all kind of stuff.
      Reset();
      Set_Adres_Out();
      Lcd_Init();
      Panel_Init();
    //  Arsid_Intro("v0.1");  // Show an Intro

      for (byte qq=0; qq<=29; qq=qq+1)
      { Poke(Sid_Adr+qq,0);
      }
    }

    void loop()
    { // Check the FrontPanel Leds and Switches
    //  FrontPanelCheck();
      Write_Lcdback(2);
      Clear_Led(0,19);
      Lcd_gotoxy(0,0);
      Lcd_print("Sid_Adr");
      Lcd_number(Sid_Adr,5);

    const byte wave1 = 0x20;

      Poke(Sid_Adr+24,  15);       // Volume

      Poke(Sid_Adr+ 0,   0);       // Freq Lo
      Poke(Sid_Adr+ 1, 200);       // Freq Hi
      Poke(Sid_Adr+ 2,0x88);       // PulsWid Lo
      Poke(Sid_Adr+ 3,0x88);       // PulsWid Hi
      Poke(Sid_Adr+ 5,0x66);       // AD
      Poke(Sid_Adr+ 6,0xF6);       // SR
      Poke(Sid_Adr+ 4,wave1+1);    // Control (SoundWave)


      for (byte qq=01; qq<=250; qq=qq+10)
        { byte q2=qq & 0xFF;
          Write_Led(qq & 0x0F ,0x03);
          Lcd_gotoxy(0,1);
          Lcd_number(qq,5);
          Lcd_gotoxy(0,2);
          Lcd_number(q2,5);

          Poke(Sid_Adr+ 0,  q2);     // Freq Lo
          Poke(Sid_Adr+ 1,  q2);     // Freq Hi

          Poke(Sid_Adr+ 4,wave1+1);  // Control (SoundWave)
          delay(250);
          Poke(Sid_Adr+ 4,wave1);    // Control (SoundWave)
          delay(250);
          Write_Led(qq & 0x0F ,0x00);
        }

    Poke(Sid_Adr+ 4,wave1);    // Control (SoundWave)
    delay(5000);
    }


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

    // From the library ArSid_IO - Corrected some timing issues.
    // The 6581 seems very easy with the timing (Phi2 and R/~W).
    // But it is the 8580, who seems to be very strict, so the
    // timing must be correct in this phase of the project.
    //
    //                                    This version is of 29 dec 2017


    void Poke(word aa, byte dd)
    { // Write a byte to the Databus - Just like the Basic-command POKE adres,data
      noInterrupts();                             // Disable Interrupts
      /////////////////////////////////////////// // Write Adres to Adres-bus
      PORTC = aa & 0xFF;                          // Low-Byte
      PORTL = ((aa >> 8) & 0x01 ) | adr_en_mask;  // High-Byte + Disable
      PORTG = PORTG & (~readwrite_mask);          // Put Write at Control-bus
      DDRA = all_output;                          // Set Databus as Output
      PORTA = dd;                                 // Write Data
      // Wait until Phi2 is High
      while (PING & phi2_mask) != 0)            // PING = P INput port G
        { // Do Nothing                           // Do Nothing
        }
      PORTL = PORTL & (~adr_en_mask);             // Adress Enable
      // Wait until Phi2 is Low again (The "moment" of writing)
      while (PING & phi2_mask) == 0)            // PING = P INput port G
        { // Do Nothing                           // Do Nothing
        }
      PORTG = PORTG & (~readwrite_mask);          // Put Write at Control-bus
                                                  // (for a 2nd time) (just to create an extra
                                                  // short delay, much shorter than
                                                  // DelayMicroSeconds can create)

      PORTG = PORTG | readwrite_mask;             // Put Read at Control-bus
      PORTL = PORTL | adr_en_mask;                // Adress Disable
      DDRA = all_input;                           // Set Databus as Input again
      interrupts();                               // Enable Interrupts
    }

    byte Peek(word aa)
    { // Read a byte from the naar Databus - Just like the Basic-function data=PEEK(adres)
      byte dd = 0;
      noInterrupts();                             // Disable Interrupts
      /////////////////////////////////////////// // Write Adres to Adres-bus
      DDRA = all_input;                           // Set Databus as Input
      PORTC = aa & 0xFF;                          // Low-Byte
      PORTL = ((aa >> 8) & 0x01 ) | adr_en_mask;  // High-Byte + Enable
      // PORTA = dd;                                 // Twice for a short delay
      PORTG = PORTG | readwrite_mask;             // Put Read at Control-bus
      PORTL = PORTL & (~adr_en_mask);             // Enable Adres
      PORTL = PORTL & (~adr_en_mask);             // Twice for a short delay
      dd = PINA;                                  // Lees de Data
      PORTL = PORTL | adr_en_mask;                // Disable Adres
      PORTG = PORTG | readwrite_mask;             // Put Read at Control-bus
      interrupts();                               // Enable Interrupts
      return dd;                                  // Return de data
    }

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


    Broncode: [1: Sids Adresbus Test] [2: Sids Adresbus & DatabusTest] [3: Sids Adresbus, Databus en ChipSelect0 Test] [4: Sids Poke Timing]
    [5: Sids Sound Sweep]
    [Tekst] [Afbeeldingen] [Aansluitingen] [Broncodes]