Was ist das für eine HDL?

[Holm T. (Gast)]

Ich möchte einen IDE Adapter an eine olle PDP11 basteln und habe hier

http://www.chdickman.com/qbus_ide/
das hier gefunden:

Name     QBus14 ;
PartNo   00 ;
Date     03/28/2008;
Revision 14 ;
Designer CHD ;
Company  ;
Assembly None ;
Location ;
Device   f1508ispplcc84 ; 

/* revisions */

/*  14  Name changed to prevent confusion with previous version 13 series. */
/*    Removed all logic support for DMA. */
/*            Changed interrupt logic to more closely follow DC003 logic */

/*  13  Renewed development.  
/*    The contents of the CPLD on the prototype board does not match the .jed file */
/*    generated when version 12 is compiled. The published version 12 has some */
/*    debugging changes that are not shown on a version 11 printout. Revision 13 is */
/*    an attempt to reconstruct the last reasonably functional version as a starting */
/*    point for further efforts. */

/*   pre 2002 */
/*  12  Published version including some debug hooks. */
/*  11  Buggy version used to write wd driver for 2.11BSD. */



/* PIO Mode Only Adapter */

/* $define JUMPERS */  /* include logic for address switches */
        /*   if not defined, address is hardwired */

/* editor font: Courier New, Regular, 10 */

/*
               
                               BB
                             +--------------------------------+
                             |                                | 
                  +-----+    |        +----------+         +-----+
              QB  |     |<---+-+------|          |   CTL   |     |
              ----|TRANS|      |      |  CPLD    |---------| ATA | 
                  |     |    TSBUF    |          |         |     |
                  +-----+      ^      |          |         +-----+
                     |         |      +----------+   
                     +---------+           |   
                         BA                |
                                           |
                  +-----+                  |
              QB  |     |                  |
              ----|TRANS|------------------+    
                  |     |   
                  +-----+      


*/

/* Device Selection */

/* Q22 addressing */

/* 1   7   7   6   0   0   0   0 */
/* 1 111 111 11A AAA AAA BBR RR0 */
/*   where A is the variable base CSR address */
/*         B is the register bank */
/*         R is the register select */

/* 1 111 111 11A AAA AAA A00 000 CSR - base control register (including DMA address extension) */
/* 1 111 111 11A AAA AAA A00 010 CNT - DMA count register - NOT IMPLEMENTED (reserved) */
/* 1 111 111 11A AAA AAA A00 100 DMA - DMA address register - NOT IMPLEMENTED (reserved) */
/* 1 111 111 11A AAA AAA A00 110 VECT - interupt vector number */
/* 1 111 111 11A AAA AAA A01 000 (reserved) */
/* 1 111 111 11A AAA AAA A01 010 (reserved) */
/* 1 111 111 11A AAA AAA A01 100 CS1 disk controller register */
/* 1 111 111 11A AAA AAA A01 110 (reserved) */
/* 1 111 111 11A AAA AAA A1X XX0 CS0 disk controller registers */

/* clock rate: 32MHz *
/*                state1 state2 state3 state4 state5   */
/* minimum delay     1      2      3      4      5     */
/*                  31ns   63ns   94ns  125ns  156ns   */
/* maximum delay     2      3      4      5      6     */
/*                  63ns   94ns  125ns  156ns  188ns   */

$define TRUE  'b'1
$define FALSE 'b'0

/* DECLARATION */

/* Adapter Tri-State Bus */
pin [8, 9, 6, 5, 4, 37, 36, 35, 31, 30, 28, 29, 27, 11, 24, 10]
               = [DAB0..15];  

field DAB      = [DAB0..15];    /* Full word width bus */
field DAB_HIGH = [DAB8..DAB15];  /*   Upper byte */
field DAB_LOW  = [DAB0..DAB7];  /*   Lower byte */

/* disk control signals */
pin [49, 48, 61]
       = [DA0..2];  /* disk register address */
pin 17 = !DCS1;    /* disk chip select 0 - pin */
node      CS1;    /* disk chip select 0 latch */
pin 34 = !DCS0;    /* disk chip select 1 - pin */
node      CS0;    /* disk chip select 1 latch */            
pin 16 = !DIOR;    /* disk controller read operation */
pin 15 = !DIOW;    /* disk controller write operation */
pin 39 =  DIORDY;    /* disk controller ready for word transfer  */
pin 40 =  DINTRQ;    /* disk controller interrupt request */
pin 50 = !DIOCS16;    /* disk controller 16-bit transfer operation */
pin 60 = !DRESET;    /* disk controller hardware reset */

/* QBUS control signals */
pin  1 = INIT;    /* bus reset */
pin 58 = S7;      /* device page select */
pin 81 = SYNC;    /* bus address sync */
pin  2 = DIN;      /* data read cycle */
pin 45 = DOUT;    /* data write cycle */
pin 25 = RPLY;    /* bus cycle handshake */
pin 18 = IRQ4O;    /* interrupt request - level 4 - QBus out*/
pin 44 = IRQ5;    /* interrupt request - level 5 */
pin 46 = IRQ6;    /* interrupt request - level 6 */
pin 41 = IAKI;    /* interrupt acknowledge daisy chain in */
pin 12 = IAKO;    /* interrupt acknowledge daisy chain out */

pin 83 =  CLOCK32;    /* clock for delays */
pin 20 = !QB_DREN;    /* Qbus read - enable OC bus drivers */
        /*   This signal drives the qbus BDAL with the tristate bus contents. */
pin 21 = !QB_TSEN;    /* Qbus write - enable TS buffers between bus A and bus B */
        /*   This signal drives the tristate bus from the qbus. */
pin    =  SEL;    /* address match */
node      [RPLYD0..3];  /* state vector for RPLY delay */
node      [IOWD0..3];  /* state vector for IOW delay */
node      INT_ARB_WON;  /* internal signal indicating that adapter gets interrupt */
node      ATA_IRQ;    /* internal F/F to capture drive interrupt request */

$ifdef JUMPERS
/* Option Configuration */
pin    = [CSR_BASE0..7];  /* CSR base address jumpers */
field    CSR_BASE = [CSR_BASE0..7];
field    DAB_CSR = [DAB5..12];
$endif

/* TEST and misc signals */
pin 22 = SYNC_LITE;    /* light driver showing bus activity */

/* CSR - Control and Status Register */
pin    = CS_COM;      /* internal select */        

pin =    INT_ENABLE;    /*      6: interrupt enable from disk controller to QBus */
node     IORDY_ENABLE;    /*      5: use IORDY signal from disk controller */

/* VECTOR - Interrupt Vector Number Register */
pin    = CS_VECT;      /* internal select */

node     [VECTOR0..6];    /* Interrupt vector number */
field VECTOR = [VECTOR0..6];
field DAB_VECT = [DAB2..8];

/* reserved space */
node RSRVD;

field REG_ADDR = [DAB0..4];

/* LOGIC */

/* QBUS Reset */
DRESET = INIT;

/* QBUS Addressing */

/* 1 111 111 11A AAA AAA BBR RR0 */
/*                1  7  7  7  1  0  0  0 */
$ifndef JUMPERS
SEL = S7 & DAB:'b'xxxxxxxxx10010000xxxxx;
$endif

$ifdef JUMPERS
field MATCH = [MATCH0..7];
MATCH = !(CSR_BASE $ DAB_CSR);
SEL = S7 & MATCH:&;
$endif

CS_COM.L     = SEL & REG_ADDR:'b'00000;  /* BASE + 0 */
CS_COM.LE    = !SYNC;

CS_VECT.L    = SEL & REG_ADDR:'b'00110;  /* BASE + 6 */
CS_VECT.LE   = !SYNC;

RSRVD.L      = SEL & REG_ADDR:'b'00010  /* BASE + 2 */ 
     # SEL & REG_ADDR:'b'00100  /* BASE + 4 */
             # SEL & REG_ADDR:'b'01000  /* BASE + 8 */ 
             # SEL & REG_ADDR:'b'01010  /* BASE + 10 */
     # SEL & REG_ADDR:'b'01110;  /* BASE + 14 */
RSRVD.LE     = !SYNC;

CS1.L        = SEL & REG_ADDR:'b'01100;  /* BASE + 12 */
CS1.LE       = !SYNC;
DCS1 = CS1 & SYNC;

CS0.L        = SEL & REG_ADDR:'b'1XXX0;  /* BASE + 16 */
CS0.LE       = !SYNC;
DCS0 = CS0 & SYNC;

[DA0..2].L   = [DAB1..3];           /* save for disk register select */
[DA0..2].LE  = !SYNC;

DISK_SEL = CS0 # CS1;
ADPTR_SEL = CS_COM # CS_VECT # RSRVD;
FAST_CYCLE = CS0 & [DA0..2]:'b'000;    /* data register */
DIOCS16 = FAST_CYCLE;

/* I/O Control - QBUS read */
IOR = DISK_SEL & DIN;        /* disk controller read */
DIOR = IOR;            /*   pin */
QBR = (DISK_SEL # ADPTR_SEL) & DIN;    /* enable QBUS drivers */
QB_DREN = QBR # IAKI & INT_ARB_WON;

/* Reply */
/* Reply from DIN = 91ns for byte transfers */
/*                = 30ns for word transfers */
append RPLY = DIN & ADPTR_SEL
            # DIN & !FAST_CYCLE & RPLYD3 & (IORDY_ENABLE & DIORDY # !IORDY_ENABLE) 
            # DIN &  FAST_CYCLE & RPLYD1 & (IORDY_ENABLE & DIORDY # !IORDY_ENABLE);

/* I/O Control - QBUS write */
IOW = DISK_SEL & DOUT & SYNC & !IOWD3;    /* disk controller write */      
DIOW = IOW;              /*   pin */
QBW = (DISK_SEL # ADPTR_SEL) & DOUT;    /* connect bus A to bus B */
QB_TSEN = QBW # !SYNC & !(IAKI & INT_ARB_WON);  /* let the Qbus address pass thru */

/* Reply */
/* Reply from DOUT = 91ns for byte transfers */
/*                 = 30ns for word transfers */
append RPLY = DOUT & ADPTR_SEL
            # DOUT & IOWD1; 

RPLYD0.D = DISK_SEL & (DIN # DOUT);  /* synchronizer */
RPLYD1.D = RPLYD0;        /* 31ns */
RPLYD2.D = RPLYD0 & RPLYD1;      /* 62ns */
RPLYD3.D = RPLYD0 & RPLYD2;      /* 94ns */
[RPLYD0..3].CK = CLOCK32;

IOWD0.D = DOUT        /* synchonizer */
   & (!FAST_CYCLE & RPLYD3 # FAST_CYCLE & RPLYD1)
   & (IORDY_ENABLE & DIORDY # !IORDY_ENABLE);
IOWD1.D = IOWD0;          /* 31ns  63ns 125ns */
IOWD2.D = IOWD0 & IOWD1;      /* 63ns  94ns 156ns */
IOWD3.D = IOWD0 & IOWD2;      /* 94ns 125ns 188ns */
[IOWD0..3].CK = CLOCK32;      /*      word  byte  */

append DAB = 'b'0000000000000000;

append DAB.OE = ADPTR_SEL & DIN & SYNC;

/* QBus Interrupt Cycle - Modeled after DC003 logic */
ATA_IRQ.D = TRUE;
ATA_IRQ.CK = INT_ENABLE & DINTRQ;    /* interrupt is triggered on leading edge of DINTRQ */
ATA_IRQ.AR = IAKI & INT_ARB_WON;    /* clear interrupt on acknowledge or reset */
ATA_IRQ.AP = INIT;

IRQ4O = DINTRQ & INT_ENABLE & ATA_IRQ;  /* QBus signal to processor */

INT_ARB_WON.D = DINTRQ & INT_ENABLE & ATA_IRQ & !IRQ5 & !IRQ6;  /* perform arbitration */
INT_ARB_WON.CK = DIN;
INT_ARB_WON.AR = INIT;

IAKO = IAKI & !INT_ARB_WON;      /* pass on if not for us */

append DAB_VECT = IAKI & INT_ARB_WON & VECTOR;  /* place vector on TS bus */
append DAB.OE = IAKI & INT_ARB_WON;
append RPLY = IAKI & INT_ARB_WON;      /* reply to acknowledge */
  /* does RPLY need to be lengthened? Qbus docs say 125ns from RPLY to vector clocked */

/* CSR - Control and Status Register */
/*   read cycle */
append DAB7 = QBR & CS_COM & DINTRQ;    /* disk interrupt request line */
append DAB6 = QBR & CS_COM & INT_ENABLE;    /* interrupt enable */
append DAB5 = QBR & CS_COM & IORDY_ENABLE;  /* disk IORDY control enable */
append DAB4 = QBR & CS_COM & ATA_IRQ;    /* disk interrupt pending */
append DAB0 = QBR & CS_COM;        /* LSB always reads as 1 */

/*   write cycle */
INT_ENABLE.D = DAB6;
INT_ENABLE.CK = !(CS_COM & DOUT);
INT_ENABLE.AR = INIT;
IORDY_ENABLE.D = DAB5;
IORDY_ENABLE.CK = !(CS_COM & DOUT);
IORDY_ENABLE.AR = INIT;

/* Vector Register */
/*   read cycle */
append DAB_VECT = QBR & CS_VECT & VECTOR;

/*   write cycle */
VECTOR.D = DAB_VECT;
VECTOR.CK = !(CS_VECT & DOUT);

/* Miscellaneous logic */
SYNC_LITE = !SYNC;

Ich würde das gerne auf ein XC9572 umwursteln, habe aber von der ganzen 
ISE noch keine Ahnung, kann ich das in die Xilinx ISE direkt 
importieren?

Gruß,

Holm

[lkmiller (Gast)]

Such mal nach ABEL ...
Mit der ISE geht da aber nichts.

[Xenu (Gast)]

Das ist nicht ABEL sondern CUPL, ursprünglich von der Firma Logical 
Devices:

http://en.wikipedia.org/wiki/Programmable_Array_Logic#CUPL

Atmel hat CUPL für ihre CPLDs benutzt:

http://www.atmel.com/tools/WINCUPL.aspx

[DD (Gast)]

Sieht ein bissl aus wie das alte GHDL von Genrad

[Holm T. (Gast)]

hmm... dieses CPLD besteht wohl in D haupstächlich aus Unobtanium, ich 
habe mal ein Bissel gegoogelt, da gibts höchstens Treffer bei Ebay aus 
China...

Die hier angesagte Sprache ist wohl VHDL (und nicht Verilog). Da ich 
weder das Eine noch das Andere kenne wäre der Plan wohl sich da mal 
einzuarbeiten.

Für mich sah das oben auch nach Abel aus, damit habe ich früher mal 
einige wenige GALs gemacht, aber es sieht nur teilweise so aus.
Kennt sich hier Jemand ausreichend damit aus um das zu dechiffrieren und 
mir bei der Umsetzung nach VHDL unter die Arme zu greifen?

Gruß,

Holm

[Weltbester FPGA-Pongo (Gast)]

Ohne dieses ABEL oder CUPL je genutzt zu haben, kann ich sagen, dass 
sich mir der Code sofort erschliesst.

Die Signalzuweisungen sind derart ausdrücklich, dass man es in VDSL 
sofort hinschreiben kann, wobei der Weg zu Verilog noch direkter zu sein 
scheint.

Sobald Du VHDL ein bischen kennst, kriegst Du das locker ohne Hilfe hin.

[Georg A. (georga)]

Das ist aber schon ein ziemliches Gewürge von zig Takten, asynchronen 
Pre- und Resets und Latches. Also ein typisches Design der 80er ;) Kann 
man ohne viel Nachdenken sicher nach VHDL umsetzen, aber ob sich das 
bequem in ein XC95* mappen lässt und dann auch noch vom Timing her 
sauber läuft? Gelegenheiten für Glitches gibt es sicher genug...

[Holm T. (Gast)]

Ich glauube kaum, das das aus den 80ern stammt, da gab es noch keine IDE 
Disks. Das ist der Versuch eine "modernere" Disk an Technik der 80er zu 
betreiben. Ich sehe da nur einen 32Mhz Takt, der auf seltsame Weise 
mehrere Verzögerungen generiert..

RPLYD0.D = DISK_SEL & (DIN # DOUT);  /* synchronizer */
RPLYD1.D = RPLYD0;        /* 31ns */
RPLYD2.D = RPLYD0 & RPLYD1;      /* 62ns */
RPLYD3.D = RPLYD0 & RPLYD2;      /* 94ns */
[RPLYD0..3].CK = CLOCK32;

..wie funktioniert das?

Dann das hier z.B.:

CS_VECT.L    = SEL & REG_ADDR:'b'00110;  /* BASE + 6 */
CS_VECT.LE   = !SYNC;

S_VECT.L ist wohl ein gelatchtes Signal und was macht .LE?


BTW das hier:
>"Sobald Du VHDL ein bischen kennst, kriegst Du das locker ohne Hilfe hin."

ist nicht wirklich hilfreich.

Gruß,

Holm

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Holm Tiffe schrieb:
> RPLYD0.D = DISK_SEL & (DIN # DOUT);  /* synchronizer */
> RPLYD1.D = RPLYD0;        /* 31ns */
> RPLYD2.D = RPLYD0 & RPLYD1;      /* 62ns */
> RPLYD3.D = RPLYD0 & RPLYD2;      /* 94ns */
> [RPLYD0..3].CK = CLOCK32;
>
> ..wie funktioniert das?
Sieht nach Schieberegister aus:
32Mhz = 31,25ns
2 * 31,25ns = 62,5ns
3 * 31,25ns = 93,75ns
Na, klingelts?


> S_VECT.L ist wohl ein gelatchtes Signal und was macht .LE?
E = Enable?


Holm Tiffe schrieb:
> BTW das hier:
>>"Sobald Du VHDL ein bischen kennst, kriegst Du das locker ... hin."
> ist nicht wirklich hilfreich.
Richtig, denn das Problem hier hat vorrangig nichts mit VHDL, sondern 
erst mal nur mit traditioneller Digitaltechnik zu tun: erst muss mal das 
Verhalten der Beschreibung und der Schaltung verstanden sein.

[Holm T. (Gast)]

>> ..wie funktioniert das?
>Sieht nach Schieberegister aus:
>32Mhz = 31,25ns
>2 * 31,25ns = 62,5ns
>3 * 31,25ns = 93,75ns
>Na, klingelts?

Da gibts nicht viel zu klingeln.
Wenn ich mir ansehe wie das oben vereinbart ist  komme ich ins Grüblen.
Was genau bewirkt das ".D" an dem Signal? Handelt es sich um ein Latch 
das mit ".CLK" die Daten übernimmt? Ein D-Flipflop?

> S_VECT.L ist wohl ein gelatchtes Signal und was macht .LE?
E = Enable?

:-)
Klar doch. Und was enabled das? Den Takt oder den Ausgang...?


>Richtig, denn das Problem hier hat vorrangig nichts mit VHDL, sondern
>erst mal nur mit traditioneller Digitaltechnik zu tun: erst muss mal das
>Verhalten der Beschreibung und der Schaltung verstanden sein.

Genau deswegen fragte ich auch ob sich Jemand so damit auskennt das er 
das dechiffrieren kann. Den Q-Bus Abhängigen Teil kann ich sicherlich 
beisteuern. Das ist dokumentiert.
Problematischer ist halt dieses WinCUPL, ich hoffte hier Jemanden zu 
finden der das erklären kann, so komme ich nicht umhin gleich 2 
Hardwarebeschreibungssprachen lernen zu müssen..

Gruß,

Holm

[berndl (Gast)]

Moin,

das ganze beschreibt doch den PIO mode (evtl. noch mit MWDMA). Das 
Protokoll ist doch im Web ganz gut beschrieben, damit sollte auch die 
Funktion klar werden.
Ausserdem gibt es sicher fertige (nicht UDMA faehige) IDE-Controller 
Beschreibungen in VHDL oder Verilog (oder sogar fuer uC via GIO-Pins)...

[Holm T. (Gast)]

Du meinst ich soll das Fahrrad neu erfinden?
Ich würde lieber das erwiesenermaßen funktionierende Produkt oben 
verwenden, da da auch die passenden Treiber existieren.
Es muß doch möglich sein das obige passend umzusetzen. Wenn es ein 
XC9572 nichts schafft muß ich halt den XC95108 nehmen.

Gruß,

Holm

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Holm Tiffe schrieb:
> Du meinst ich soll das Fahrrad neu erfinden?
Nein, du sollst dir nur anschauen, wie andere ein Fahrrad gebaut haben, 
und das mit deinen Mitteln nachvollziehen.
> Es muß doch möglich sein das obige passend umzusetzen.
Klar, aber dazu muss man es vorher verstehen (mögen)...

Holm Tiffe schrieb:
>> S_VECT.L ist wohl ein gelatchtes Signal und was macht .LE?
> E = Enable?
> Klar doch. Und was enabled das? Den Takt oder den Ausgang...?
Innerhalb eines programmierbaren Bausteins wird immer der Eingang 
validiert. Da macht es keinen Sinn, einen Ausgang hochohmig zu schalten.

CS_COM.L     = SEL & REG_ADDR:'b'00000;  /* BASE + 0 */
CS_COM.LE    = !SYNC;

So wie ich diese Beschreibung ansehe, wird im Latch bei low-aktivem SYNC 
eine 0 oder eine 1 gespeichert, abhängig davon, wie SEL steht und vom 
Wert von REG_ADDR.

> Handelt es sich um ein Latch
> das mit ".CLK" die Daten übernimmt? Ein D-Flipflop?
D ist wohl der Dateneingang eines D-Flipflops, davon würde ich auch 
ausgehen. Und AR heißt dann vermutlich asynchroner Reset, mit AP dürfte 
asynchroner Preset gemeint sein.

[Holm T. (Gast)]

Ok, das hilft wirtschaften :-)

Gruß,

Holm

[Georg A. (georga)]

> Ich glaube kaum, das das aus den 80ern stammt,

Aber der QBUS...

> Ich sehe da nur einen 32Mhz Takt,

Der "[RPLYD0..3].CK = CLOCK32;"? Das ist fast das einzig synchrone an 
der Schaltung ;)

Aber was ist mit

ATA_IRQ.CK = INT_ENABLE & DINTRQ; (+asynchronen Pre/Reset)
INT_ARB_WON.CK = DIN;
INT_ENABLE.CK = !(CS_COM & DOUT);
IORDY_ENABLE.CK = !(CS_COM & DOUT);
VECTOR.CK = !(CS_VECT & DOUT);

[berndl (Gast)]

Holm Tiffe schrieb:
> Du meinst ich soll das Fahrrad neu erfinden?
> Ich würde lieber das erwiesenermaßen funktionierende Produkt oben
> verwenden, da da auch die passenden Treiber existieren.
> Es muß doch möglich sein das obige passend umzusetzen. Wenn es ein
> XC9572 nichts schafft muß ich halt den XC95108 nehmen.

Hallo, IDE bzw. PATA ist doch gerade mal ein paar Jahre her. Und in dem 
Code oben ist definitiv nix von UDMA zu sehen. Also bleibt nur PIO und 
MDMA (oder hiess es MWDMA? Steht auf jeden Fall fuer Multiword-DMA...).

Und das ist ein 'source-synchronous' Interface, im Gegensatz zu UDMA 
also trivial einfach. Geh halt mal googeln nach IDE/PATA und PIO bzw. 
MDMA. Wenn du dann halbwegs verstanden hast, wie diese Protokolle 
funktionieren, dann verstehst du auch den Code weiter oben.

Es gab doch schon 'ne Menge guter Tipps:
* irgendwas.D koennte ein FF-Eingang sein
* irgendwas.Q muesste eigentlich ein Ausgang sein
* irgendwas.E deutet auf ein Enable hin
Und der Rest scheint mir nur noch Boolsche Algebra zu sein...

PS: Ich kenne diese HDL oben auch nicht, aber ich hab' mal was mit 
IDE/PATA gemacht...

[Holger (Gast)]

@Holm Tiffe
Hallo !
Ich kann doch noch ABEL mit XILINX machen.
 XC2C64A XC9572XL XC2C32A XC9536 oder ???
Tolle Homepage, und Project.
Erst mal das Datenblatt analysieren.
-------------------------------------------------------------------
Hier das ist der Hersteller: MMI, wie auf den Bildern sehen ist.
also ein PAL Derivat. pal16l8bcnl.pdf

 Für POWER ON Reset Output LOW(default),
 mit Preset…Term- für „User-Config-Boot-Strap”
 CLK Logic ist also hoffentlich Rising-Edge-aktiv, /OE und Thristate.
########################## 16L8       16R8 #########################

Aufpassen Unterschiede als Latch Typ, oder REGister Typ.

Siehe Datenblatt „Note…“

####################################################################

Eine schöne Fundgrube ist das mit Bildern Source.code.
Das ist noch vor der Lattice GAL 16V8 Hardware.
Das war ein guter Hint, für die Fein-Analyse, sowie das lernen der
guten „alten“ EMV Robust Kuchenblech Technik.
Für mein LMD18245
3,3 V Z-Diode an 5V Pull-Up.
12Bit I/O Karte mit 2*Dioden und R47Ohm-R470Ohm..ist halt robust.
Die TTY Schnittstelle mit BREAK Sync und Feeder Run.

####################################################################
Hint:
http://flipprojets.free.fr/AlvinBSMT_E.html

Adress Decoder in Vector Schreibwiese….mit CUPEL
Keyword Node: ist kombinations via Register ?? reg
Keyword field    DAB_CSR = [DAB5..12];

http://www.transputer.net/tn/14/tn14.html#x1-100004.1

Viel Erfolg.
Gruss Holger.

[Georg A. (georga)]

Ich find eigentlich alles selbsterklärend (syntaktisch zumindest...) bis 
auf das komische append... Es gibt mehrere Zuweisungen auf ein Signal 
damit. Soll das ein implizites OR sein, damit man verschiedene Minterme 
auf unterschiedliche Orte (Text)Positionen verteilen kann?

[Lattice User (Gast)]

Georg A. schrieb:
> Es gibt mehrere Zuweisungen auf ein Signal
> damit. Soll das ein implizites OR sein, damit man verschiedene Minterme
> auf unterschiedliche Orte (Text)Positionen verteilen kann?

Ja, siehe:

http://ee.sharif.edu/~logic_circuits_t/readings/CUPL_Reference.pdf


The expression that results from multiple APPEND statements is the 
logical OR of all the APPEND statements. If an expression has not 
already been assigned to the variable, the first APPEND statement is 
treated as the first assignment.