Announcement: there is an English version of this forum on Hallo, Ich bin schon seit einer ganzen Weile leser in dem Forum hier und hab schon sehr viele nützliche Hilfen für meine Arduino/ Atmel und sonstigen Bastelprojekte gefunden. Danke dafür.. Ich bin Hauptberuflich Tontechniker/ Systemingeur für Rundfunk- und Beschallungsanlagen. Privat beschäftige ich mich viel mit uC bastelein (Nixieuhren, kleine Messsysteme usw.) aber auch Röhrenradios und Verstärker sind gern mal auf der Werkbank. Nun kommt mal was neualtes. Ein bekanter Studiobetreiber hat dort mehrere Tascam m700 Konsolen am laufen. Den Analogen Teil wartet er selbst aber das bisschen Automation was der Kahn hat ist Hauptsächlich mit einem EPL 10P8 der Firma Ricoh Datenblatt: http://pdf.dzsc.com/epl/epl16rp6bp-35.pdf gelöst. Ich hab schon herausgefunden das ein PAL 10L8 bzw PAL 10H8 zb. von MMI als ersatz empfohlem werde. Das Problem besteht darin das bei einem der Pulte die Automation nicht mehr Fehlerfrei funktioniert. Was durch tauschen der Logikbausteine untereinander auf den Bausten zurückzuführen ist. Ich hab ein TL866ii plus Programmer, deswegen hat er mich angefragt ob es denn nicht möglich wäre einen Funktionierenden Baustein auszulesen, für die Nachwelt zu sichern und halt einen "Neuen" zu beschreiben? Die 10h8 zb. gibts ja noch bei eBay günstig zu kaufen und ich würde mir ja erstmal lieber ein paar "Opfer" bestellen, um versuche des Schreibens bzw. Lesens zu machen, um Sicher zu gehen das der funktionierende Originalchip nicht bei eventuellen Experimenten Schaden nimmt. Wie kann ich mir ein LogikProgramm "Schreiben" um es dann auf den Baustein zu Brennen/Testen? Geht das in C? Wenn ich den Baustein auslese kommt doch mit sicherheit ein hex bzw bin File raus was ich wieder Brennen kann. Der Inhalt ist mir ja ziemlich wurscht..nur die Reproduktion des Originals ist wichtig. Google und co. sind bei dieser historischen Technologie nicht so Hilfreich deswegen Frag ich halt hier mal nach. Danke schon mal im Voraus. LG Mario
Nein, nicht mit C, sondern einer Hardware Description Language (HDL). Diese compiliert man (z.B. mit CUPL) und bekommt ein Fuse-File, das man dann ins PAL brennt.
Wenn man Glück hat, dann hat sich der Hersteller nicht die Mühe gemacht, die Security Fuse zu blasen. Die bringt bei einem kombinatorischen PAL sowieso nicht viel Sicherheit. Dann liesse sich das Teil mit dem PAL Programmer evtl direkt kopieren. Andernfalls wirds über die HDL deutlich umständlicher.
:
Bearbeitet durch User
A. K. schrieb: > Andernfalls wirds über die HDL deutlich > umständlicher. HDL?? Ja das mit der Security Fuse hab ich auch schon gelesen... Ich muss das Datenblatt nochmal richtig Studieren. mal sehen.. Dank dir Schon mal. EDIT: CUPL ja das lässt sich ja googlen...
:
Bearbeitet durch User
Bei diese einfachen PALs nutzt ne Security-Fuse nichts - man geht alle Eingangskombinationen durch, merkt sich die dazugehörigen Ausgangssignale und erstellt anhand dessen ne neue Beschreibung. Bei denen mit Reigstern wird es etwas aufwendiger, geht üblicherweise aber auch. Ich meine mich zu erinnern, dass einige Programmer das unterstützten und es Software gab, die das erledigte - weiß aber keine Details mehr.
foobar schrieb: > Ich meine mich zu erinnern, dass einige Programmer das > unterstützten und es Software gab, die das erledigte - weiß aber keine > Details mehr. Schade ^^
Mario R. schrieb: > Nun kommt mal was neualtes. Ein bekanter Studiobetreiber hat dort > mehrere Tascam m700 Konsolen am laufen. Den Analogen Teil wartet er > selbst aber das bisschen Automation was der Kahn hat ist Hauptsächlich > mit einem EPL 10P8 der Firma Ricoh > gelöst. Ich hab schon herausgefunden das ein PAL 10L8 bzw PAL 10H8 zb. > von MMI als ersatz empfohlem werde. Das wird u. U. nicht als Ersatz taugen, denn 10P8 hat "programmierbare Polarität" (daher P), während 10L8 nur "low aktiv" und 10H8 nur "high aktiv" hat. Wenn im Originalteil gemischt, geht's also erstmal gar nicht. Außerdem sind die "echten" PAL i. d. R. in bipolarer Technik aufgebaut (gewesen), insbes. die von MMI. Gefräßig (Stromverbrauch) und schwierig zu programmieren (da werden Dioden oder Widerstände wirklich durchgebrannt, und da das offensichtlich nicht vorab getestet werden kann, gibt's da auch Fehlbrände), dafür noch ein Programmiergerät zu finden dürfte mühsam werden. Daher würde ich zu einem GAL16V8 greifen, die gibt's immer noch zu kaufen, können 10P8 emulieren, und sind auch mit einem TL866 zu programmieren (bipolare PALs wohl nicht). Einzige Frage ist das Auslesen der alten. Wie schon jemand geschrieben hatte, ist die Auslesesicherung bei einem rein kombinatorische PAL eher witzlos. Im Notfall schließt man einen 10-Bit Binärzähler an die Eingänge an und notiert sich für jeden Zählerstand den Zustand der 8 Ausgänge. Daraus die Logikgleichungen zu extrahieren ist eine kleine(!!!), aber lästige Fleißarbeit. Daraus muss man dann noch die Fuse-Liste für den neuen Chip erzeugen. CUPL oder so, soweit die noch greifbar sind. Ansonsten: per Hand erzeugen. Hört sich aufwendig an, ist aber durchaus machbar. Vor Urzeiten hatte ich selbst man eine PALASM-ähnliche Variante programmiert (auch mit automatischer Reduktion), leider damals in PEARL, das in C oder so zu konvertieren, hatte ich nie in Angriff genommen ... Aber alles Nötige findet man problemlos in den Datenblättern von Lattice. In der c't gab es seinerzeit auch recht ausführliche Beschreibungen. Nur wo bekommt man diese Artikel aus der "Steinzeit" heute her? Fazit: Durchaus machbar, aber man muss u. U. schon ein paar Tage Arbeit einkalkulieren. Gibt's den Hersteller noch? Vielleicht rückt der ja etwas Doku, Fuse-Listen oder so heraus, wenn man nett fragt?
A. B. schrieb: > Außerdem sind die "echten" PAL i. d. R. in bipolarer Technik aufgebaut > (gewesen), insbes. die von MMI. Gefräßig (Stromverbrauch) und schwierig > zu programmieren (da werden Dioden oder Widerstände wirklich > durchgebrannt, und da das offensichtlich nicht vorab getestet werden > kann, gibt's da auch Fehlbrände), dafür noch ein Programmiergerät zu > finden dürfte mühsam werden. ok sowas dachte ich mir auch schon fast... > Daher würde ich zu einem GAL16V8 greifen, die gibt's immer noch zu > kaufen, können 10P8 emulieren, und sind auch mit einem TL866 zu > programmieren (bipolare PALs wohl nicht). guter Tip danke > Einzige Frage ist das Auslesen der alten. Wie schon jemand geschrieben > hatte, ist die Auslesesicherung bei einem rein kombinatorische PAL eher > witzlos. hoffen wir mal.. > Im Notfall schließt man einen 10-Bit Binärzähler an die Eingänge an und > notiert sich für jeden Zählerstand den Zustand der 8 Ausgänge. Daraus > die Logikgleichungen zu extrahieren ist eine kleine(!!!), aber lästige > Fleißarbeit. Ja darüber hab ich mir auch schon gedanken gemacht..10 bit sind immerhin 1024 möglichkeiten... aber soviel mögliche zustände gibt es in der Automation gar nicht... ich tipp auf ca.20.. Ich würde mir ja fast mit einem Uno ein Analyse/Dokumentationstool schreiben um alle eingangszustände zu erzeugen und die Ausgänge mir über die Serial geben zu lassen... Und dann geht es halt drann in einem Syntax (wohl cupl) eine neue "Fusemap" / Jedec-code zu schreiben/erzeugen. Da muss ich mich erstmal reinfuchsen.. Bücher gibt es halt nur über hdl bzw FPGA. Ob da CUPL behandelt wird weiss ich nicht und fast 60,- bei Amazon ist ganz schön viel für eine einmalige Baustelle. Hat jemand ein Tip wo mann eine schöne Anleitung bekommt?
:
Bearbeitet durch User
Hallo, bei mir steht das " Das GAL Buch" im Regal. ISBN 3-928051-30-X Dort geht es aber hauptsächlich um die Algebra mit der Minimierung per Karnaugh Diagrammen. Eine Diskette mit einem DOS Progamm (GAL Assembler) war auch dabei. Vielleicht gibt es noch ein anderes Programm, was JEDEC-Files erzeugt. Dann benötigt Du noch einen Brenner. Man kann allerdings auch, wenn man viel Zeit hat, die Daten seriell reintakten. Habe ich selber schon gemacht. Jogibär
Mario R. schrieb: > Und dann geht es halt drann in einem Syntax (wohl cupl) eine neue > "Fusemap" / Jedec-code zu schreiben/erzeugen. Da muss ich mich erstmal > reinfuchsen.. Bücher gibt es halt nur über hdl bzw FPGA. Ob da CUPL > behandelt wird weiss ich nicht und fast 60,- bei Amazon ist ganz schön > viel für eine einmalige Baustelle. > > Hat jemand ein Tip wo mann eine schöne Anleitung bekommt? Zu CUPL kann ich nichts sagen, Format von den Fuse-Listen findet man z. B. unter http://k1.spdns.de/Develop/Projects/GalAsm/ beschrieben. Ob die Software dort funktioniert etc. weiß ich nicht. Und wie schon gesagt, beim rein kombinatorischen PAL lohnt es als einmalige Aktion fast nicht, erst lange nach irgendwelcher Software zu suchen. So ein Jedec-File kann man da (bis auf die Prüfsumme) fast schneller händisch schreiben. Einzige Frage, die mir jetzt beim Blick ins Datenblatt vom 16V8 so auffiel, ist ob eine '0' eine Verbindung bzw. keine Verbindung beim P-Term zu einer Variable war ... Aber egal wie, ich würde zuallererst man eine simple "leere" Fuse-Liste erstellen und probieren, ob die Software vom TL866 die auch ohne zu meckern frißt und das GAL damit auch programmieren kann. Wäre doch ärgerlich, wenn man erst zum Schluss feststellt, dass da irgendwas klemmt ...
Michael J. schrieb: > bei mir steht das " Das GAL Buch" im Regal. > ISBN 3-928051-30-X für 7,- bei Medimops macht mann nix Falsch denk ich...guter Tip > Dann benötigt Du noch einen Brenner. > Man kann allerdings auch, wenn man viel Zeit hat, die Daten seriell > reintakten. Habe ich selber schon gemacht. ich hab einen TL866ii + der auch PAL/ GAL auslesen/Schreiben und Testen kann.... ich hab das Teil hauptsächlich als ISP schnittstelle bzw zum dierekten Programieren von Hex Files in Atmega´s verwendet
A. B. schrieb: > In > der c't gab es seinerzeit auch recht ausführliche Beschreibungen. Nur wo > bekommt man diese Artikel aus der "Steinzeit" heute her? Die Artikel aus der Frühzeit der c't (als da noch wirklich interessante Sachen drin standen) kann man tatsächlich heute noch kaufen: https://shop.heise.de/katalog/c-t-archiv-1983-2017-usb-stick
A. B. schrieb: > Im Notfall schließt man einen 10-Bit Binärzähler an die Eingänge an und > notiert sich für jeden Zählerstand den Zustand der 8 Ausgänge. Daraus > die Logikgleichungen zu extrahieren ist eine kleine(!!!), aber lästige > Fleißarbeit. Das macht der VHDL/CPLD Compiler in 1 Minute.
Markus F. schrieb: > Die Artikel aus der Frühzeit der c't (als da noch wirklich interessante > Sachen drin standen) kann man tatsächlich heute noch kaufen: > > https://shop.heise.de/katalog/c-t-archiv-1983-2017-usb-stick Auch ganz schön Teuer..aber bestimmt Lohnenswert
:
Bearbeitet durch User
Pali schrieb: > A. B. schrieb: >> Im Notfall schließt man einen 10-Bit Binärzähler an die Eingänge an und >> notiert sich für jeden Zählerstand den Zustand der 8 Ausgänge. Daraus >> die Logikgleichungen zu extrahieren ist eine kleine(!!!), aber lästige >> Fleißarbeit. > Das macht der VHDL/CPLD Compiler in 1 Minute. Meinst du das Tool: http://www.microchip.com/design-centers/programmable-logic/spld-cpld/tools/software/wincupl ??
Schau dir mal die Software GDSWin an, ob der Hersteller die Software noch verkauft weiß ich nicht (war aber nicht teuer, ich glaube 20€ oder so) die Demo Version war soweit ich mich erinnere nahezu vollfunktionsfähig (ich glaube sie war nur beschränkt auf den GAL16V8)
René F. schrieb: > Schau dir mal die Software GDSWin an, Hab ich, geht gut denk ich, mal sehen was draus wird. Dank dir..
:
Bearbeitet durch User
Wenn's keine Register im PAL sind, geht es noch viel einfacher mit Parallel-EEPROM (z.B.49F002) oder UV-EPROM (z.B. 27C512). Adressleitungen sind Eingänge, Datenleitungen sind Ausgänge. PAL mit einem Zähler 0-1023 auslesen und deren Daten ins EEPROM brennen. Habe mal sowas erfolgreich bei einem uraltem Computer gemacht.
Dimi S. schrieb: > Wenn's keine Register im PAL sind, geht es noch viel einfacher mit > Parallel-EEPROM (z.B.49F002) oder UV-EPROM (z.B. 27C512). > Adressleitungen sind Eingänge, Datenleitungen sind Ausgänge. > PAL mit einem Zähler 0-1023 auslesen und deren Daten ins EEPROM brennen. > Habe mal sowas erfolgreich bei einem uraltem Computer gemacht. Hmm.. okay...das übersteigt meine junges Hirn nun doch wieder ein bischen... Ich hatte ja die Idee mitn Arduino ein 10 bit zähler zu schreiben der dann an anderer seite ein 8 bit Port ausliest und den wert im verglech zum ausganswert aufschreibt... Wära das nicht das selbe Ergebnis oder ist deine Idee dann Quasie schon eine Reproduktion der Ausgangslogik? Der aktuelle stand ist gerade das wir sogar neue unprogramierte PAL 10p8 Bausteine da haben (frag mich nicht wo der die her hat). Wenn ich diesen mit meinem tl866 auslese müsste ich ja eine Jedec Datei o.ä. bekommen mit der ich dann ein GAL 10v8 beschreibe und dann Quasie auch ein (Werksneuen) PAL 10P8 (zummindest von der Logik her) haben sollte. Wir wollen erstmal ein paar Trockenübungen machen bevor wir mit dem Definitv nicht ersetzbaren Original-IC rum Experimentieren. A. B. hatte oben erwähnt das der VHDL/CPLD Compiler die Logiktabelle (bei gesetzter lesesicherung) unter eienr Minute austastet. Wie bekomme ich diesen Compiler dazu auf meine Hardware zuzugreifen?
Mario R. schrieb: > Ich hatte ja die Idee mitn Arduino ein 10 bit zähler zu schreiben der > dann an anderer seite ein 8 bit Port ausliest und den wert im verglech > zum ausganswert aufschreibt... Genau diese Daten braucht man dafür. von 0 bis 1023 zählen und alle ausgelesene 8 bit aufzeichnen. Danach einfach diese Daten ins EPROM brennen. > Wära das nicht das selbe Ergebnis oder ist deine Idee dann Quasie schon > eine Reproduktion der Ausgangslogik? Sehr schön geschrieben - "Reproduktion der Ausgangslogik"! Genau das meine ich!
:
Bearbeitet durch User
Dimi S. schrieb: > Genau diese Daten braucht man dafür. von 0 bis 1023 zählen und alle > ausgelesene 8 bit aufzeichnen. Danach einfach diese Daten ins EPROM > brennen. Ok sind die Eproms Pinkompatibel?
Mario R. schrieb: > Ok sind die Eproms Pinkompatibel? Nein. In meinem Fall musste ich ein wenig flicken.
Angehängte Dateien:
-
EPL_10p8.png
540 KB
Hallöchen, also ich hab das GAL Buch welches Michale J. empfohlen hat(es waren sogar noch Disketten dabei) und das "Programierbare Logik-IC" Buch ISBN:3-7785-1910-7 welches auch sehr empfehlenswert ist durch. Das hilft mir auf jeden Fall dahingehend weiter wenn ich durch "reverse engeneering" mir die Handvoll Eingans-Ausgangszustände neu Formulieren muss. Im anhang ist ein Bild von meinen ersten Gehversuchen. Bei den Boolschen gleichungen ist noch nicht die Low- bzw. High-defintion fertig und sonst Fehlen da bestimmt noch Verbindungen, weil ich den Schaltplan dahingehend noch untersuchen muss. Die Wahrheitstabelle ist Hauptsächlich aus der Bedienungsanleitung Implementiert. Ich habe im Thread: Beitrag "PAL22V10 sichern, womit?" einen Guten Hinweis zu folgender Webseite: http://www.techno-junk.org/ gefunden. Dort wird ein Sockeladapter und eine Analysesoftware vorgestellt, welche der Idee von Dimi S. ähnelt. Nur wird aus der ausgelesenen .bin eine .txt im Wincupl Format erzeugt. Was sich erstmal gut anhört. In dem og. Thread ging es um einnen PAL 22v10 und es hieß das er als GAL22v10 ausgelesen (wenn keine Security Fuse gesetzt ist) werden könnte. Da stoßen mir zwei Sachen auf: 1. die Belegung der "Programier"-relevanten Pins anders und 2. der PAL hat deutlich weniger Produkterme und "Konfigurations"-addressen. Also kann ich die Idee einen Pal 10p8 als GAL 16V8 auszulesen auch glaube ich gleich vergessen. Hat jemmand eigendlich erfahrung aus .bin bzw. Jedec Files wieder Boolsche gleichungen zu extrahieren oder gar ein Jedec Code so umzuschreiben das er in einen anderen "Größeren" PAL / Gal passt. Da ich, Gott sei dank, den einfachsten EPL 10p8 IC ohne Register und Feedback´s auslesen will ist es meiner meinung nach nur eine Suche nach dem Einachsten/ Fehlerfreisten Weg, ein Äquivalentes Jedec File für einen GAL 16v8 zu erstellen. Grüße Mario
Du denkst da zu kompliziert. Aus der Wahrheitstabelle die Kombinatorik zusammen zu frickeln ist ja genau die Aufgabe eines HDL-Tools. Also einfach die 1024 Zeilen mit den Daten da reinwerfen und das Tool seine Arbeit machen lassen... Wenn CUPL und Konsorten dafuer zu doof sind, koenntest du auch ein nahezu beliebiges Tool eines FPGA-Herstellers nehmen, und dir dann die RTL-Files (quasi die Schaltung...) anschauen. Du musst dann nur zusehen, dass das Tool daraus nicht einfach ebenfalls eine LUT in den (B)RAMs macht.
Wenn etwas fuer ein GAL herauskommen soll: WinCUPL. Aber empfehlen moechte ich das nicht nennen. Das ist so als wenn man Pest oder Cholera empfehlen wollte. Es gibt wohl schlicht nichts anderes.
Sempfdazugeber schrieb: > Wenn etwas fuer ein GAL herauskommen soll: WinCUPL. Ok das Prog. geht dann wohl auch für Gal´s die nicht von Microchip sind?! Hab welche von Lattice...GAL 16V8D. Ich werd mir das mal Installieren und Durchstöbern. Dank dir schon mal
> ür Gal´s die nicht von Microchip sind?! Es kommt wohl ein JEDEC-File raus. Da dann den richtigen Typ fuer den Programmer einzutragen traue ich dir schon zu. Nebenbei solltest du dir mal Gedanken machen, den PAL auch mal wirklich auszulesen. 10 Bit Adressen dranlegen und 8 Bit Daten irgendwohin wegschaufeln... In VHDL koennte das etwa so aussehen:
1 | with adr select |
2 | data <= |
3 | "01100000" when "0000000000", |
4 | "11100011" when "0000000001", |
5 | "01111010" when "0000000010", |
6 | "01010101" when "0000000011", |
7 | "11100100" when "0000000100", |
8 | "11010111" when "0000000101", |
9 | |
10 | ...
|
11 | |
12 | "11110010" when "1111111010", |
13 | "11101101" when "1111111011", |
14 | "00011100" when "1111111100", |
15 | "00101111" when "1111111101", |
16 | "00010110" when "1111111110", |
17 | "00000001" when "1111111111"; |
Viel Erfolg!
Angehängte Dateien:
-
Pal_ausleser.png
100 KB
Hy Hy, ich hab da mal was vorbereitet: im Schaltplan eine kleine Verdrahtung mit einem Arduino Nano und unten dann noch der Sketch, der mir Quasi alle kombinatorischen möglichkeiten von unserem 10p8 in zwei verschiedenen "Formatierungen" ausschpuckt. Ich würde das dann auch gleich nutzen um die neu erstellten IC´s mit dem Original "Datensatz", zb. in Excel oder so,zu vergleichen. p.s. Sketch und Schaltung sind noch nicht getestet. Grüße Mario
1 | /********************************************** |
2 | * *******Ausgabeschalter************** |
3 | * 0 == Format: Ausgang eingang |
4 | * z.b.0000100 0101010 |
5 | * 1 == Format: "eingang" when "ausgang" für VHDL |
6 | * z.b. "001010" when "0101010" |
7 | * |
8 | * kommt über serial terminal |
9 | */ |
10 | |
11 | int ausgabeschalter = 0; |
12 | |
13 | /*************************************************/ |
14 | |
15 | |
16 | //von PAL ausgänge= 12, 13, 14, 15, 16, 17, 18, 19 |
17 | int eingange[] = {13, 14, 15, 16, 17, 18, 19, 12};
|
18 | |
19 | // an Pal eingänge= 1, 2, 3, 4, 5, 6, 7, 8, 9, 11, |
20 | int ausgange[] = {2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
|
21 | |
22 | int binwertein = 0; //binärwert eingänge |
23 | int ausgangszustand = 1024; // ausganzähler 0 - 1023 |
24 | |
25 | //________________________________________________________________ |
26 | void setup() {
|
27 | |
28 | //ausgänge |
29 | for(int i= 0; i< 10; i++){pinMode(ausgange[i],OUTPUT);}
|
30 | |
31 | //eingänge |
32 | for(int j = 0; j< 8; j++){pinMode(eingange[j], INPUT);}
|
33 | |
34 | //Seriele Schnittstelle |
35 | Serial.begin(9600); |
36 | |
37 | }// ende Setup |
38 | //___________________________________________________________ |
39 | |
40 | void loop() {
|
41 | |
42 | //start über Terminal |
43 | if(Serial.available() > 0){
|
44 | ausgabeschalter = Serial.read(); |
45 | ausgangszustand = 0; |
46 | } |
47 | |
48 | |
49 | for (; ausgangszustand < 1024; ausgangszustand++){
|
50 | |
51 | for (int n = 0; n < 10; n++){ //for-schleife um ausgänge zu setzen
|
52 | |
53 | if (bitRead(ausgangszustand,n) == 1){ //ausgänge setzen wenn bin wert an stelle n=1 ist
|
54 | digitalWrite(ausgange[n], HIGH); |
55 | } |
56 | |
57 | else{
|
58 | digitalWrite(ausgange[n], LOW); //ausgänge aus wenn bitwert an stelle n=0 ist |
59 | }// ende if - ausgänge setzen |
60 | |
61 | }//ende for schleife für ausgänge |
62 | |
63 | delay(2); //angstpause |
64 | |
65 | for (int m = 0; m < 8; m++){ //for-schleife eingänge auslesen
|
66 | |
67 | if (digitalRead(eingange[m]) == HIGH){
|
68 | bitWrite(binwertein, m , 1); |
69 | } |
70 | |
71 | else{
|
72 | bitWrite(binwertein, m , 0); |
73 | } |
74 | }//ende for schleife eingänge auslesen |
75 | |
76 | delay(2); //angstpause |
77 | |
78 | //___ende erzeugen und auslesen___________________ |
79 | //ausgabe an Serial |
80 | //entscheidung mit ausgabeschalter variable |
81 | |
82 | if (ausgabeschalter == 0){ausgabeNormal(ausgangszustand, binwertein);}
|
83 | else {ausgabevhdl(ausgangszustand, binwertein);}
|
84 | |
85 | delay(2); |
86 | |
87 | }//ende zustands for schleife |
88 | |
89 | //im Ruhemodus alle ausgänge aus |
90 | for (int i = 0; i <10; i++){digitalWrite(ausgange[i],LOW);}
|
91 | |
92 | } // ende Loop |
93 | //_________________________________________________________________ |
94 | |
95 | |
96 | void ausgabeNormal(int ausgangszustand, int binwertein){
|
97 | |
98 | if(ausgangszustand == 0){ //erste zeile
|
99 | Serial.println("Ausgänge:/t/t/t/t Eingänge:");
|
100 | }//ende erste zeile |
101 | |
102 | Serial.print(ausgangszustand,BIN); |
103 | |
104 | Serial.print('/t/t/t/t');
|
105 | |
106 | Serial.println(binwertein,BIN); |
107 | |
108 | }//ende ausgabeNormal |
109 | //______________________________________________________________________ |
110 | |
111 | void ausgabevhdl(int ausgangszustand, int binwertein){
|
112 | |
113 | //ausgabe für VHDL |
114 | if (ausgangszustand = 0){ //erte Zeile
|
115 | Serial.println("/n/n/n");
|
116 | Serial.println("Ausgabe für VHDL:");
|
117 | }//ende erste Zeile |
118 | |
119 | Serial.print('"');
|
120 | Serial.print(binwertein,BIN); |
121 | Serial.print('"/t when /t');
|
122 | Serial.print(ausgangszustand,BIN); |
123 | if(ausgangszustand < 1023){Serial.println('",');}
|
124 | else {Serial.println('";');}
|
125 | |
126 | }//ende ausgabe vhdl |
Angehängte Dateien:
-
Wincupl.jpg
240 KB
So ich habe gestern mir WINCUPL installiert und ein paar Gehversuche unternommen. Wirkt bis jetzt erstmal recht soldie, nur die Error´s beim Compilieren sind ein wenig nichts sagend. Und WinSim ist ja wohl auch eine Wissenschaft für sich. Im Anhang ist ein Bildschirmfoto von einem Script welches mit einer Wahrheitstabelle dann schön ein .doc mit den boolschen Gleichungen und ein Jedec-File für ein ATF16v8 auspukt. Ich hab die Datenblätter des GAL16v8 und des ATF16v8 mal nebeinander gelegt. Beim ATF sind keine Addressen in dem Fuse-diagram eingetragen und beim GAL ist keine Programierspannung angegeben, da hat Google mir aber 14,5-16 V gesagt. Das sollte dann quasie Kompatibel sein. Ich werde die Tage mal die ersten Logiken "brennen" und wieder auslesen und wieder Brennen und vergleichen usw. Mal sehen was da so rauskommt. Ich hab bei eBay ein paar Programierte PAL 10l8 und 10h8 für irgendwelche Amiga anwendungen geschossen. Die werden erstmal als Übungsobjekte (zum auslesen) herhalten müssen. Wenn die dann noch Funktionieren würde ich sie ja gern an jemanden der die braucht Abgeben. Damit die Arduino-Auslesehilfe gleich eine für WINCUPL formatierte Wahrheitstabelle ausgibt. Hier nochmal die überarbeitete "ausgabevhdl" Funktion:
1 | void ausgabevhdl(int ausgangszustand, int binwertein){
|
2 | |
3 | //ausgabe für VHDL - Formatiert für WINCUPL TABLE Eingabe |
4 | //zb. TABLE inputs => outputs |
5 | // 'b'0101010101 => 'b'01010101;} |
6 | if (ausgangszustand = 0){ //erte Zeile
|
7 | Serial.println("/n/n/n");
|
8 | Serial.println("Ausgabe für VHDL:/n");
|
9 | Serial.println("TABLE inputs => outputs{");
|
10 | }//ende erste Zeile |
11 | |
12 | //Wincupl formatierte ausgabe |
13 | Serial.print("/t'b'");
|
14 | |
15 | for(int i = 0; i<10; i++){ //jedes bit einzeln schreiben
|
16 | Serial.print(bitRead(ausgangszustand, i)); |
17 | } |
18 | |
19 | Serial.print("/t=>/t'b'");
|
20 | |
21 | for(int i = 0; i<8; i++){ //jedes bit einzeln schreiben
|
22 | Serial.print(bitRead(binwertein, i)); |
23 | } |
24 | |
25 | if(ausgangszustand < 1023){Serial.println(";");}
|
26 | else {Serial.println(";}");}
|
27 | |
28 | }//ende ausgabe vhdl |
Den Code hast du nie ausprobiert, sonst wäre dir aufgefallen, dass ein Newline mit "\n" gemacht wird, nicht mit "/n"...
> Den Code hast du nie ausprobiert, sonst wäre dir aufgefallen, dass ein > Newline mit "\n" gemacht wird, nicht mit "/n"... > p.s. Sketch und Schaltung sind noch nicht getestet. Ich denke das er diesen Fehler schon noch selber gefunden haette. Bis jetzt hat er sehr selbststaendig und umsichtig die Sache vorangetrieben. Davon das er seine GALs demnaechst in den Haenden halten wird, gehe ich mal aus.
Guter Tipp mit den Newline Zeichen S.R., da hätte ich mich beim suchen auch wieder rumgeärgert. Ich gebe zu das ich solche Codes und Zeichnungen in der Standby-Zeit bei der Arbeit mit irgendwelchen Online Diensten im Groben erstelle und die Arduino IDE so oder so der letzte husten ist und die sowas nicht mal als Warnung ausspuckt. Wie auch sie hätte das einfach so über die Serial ausgegeben. Wird werden, ich bekomme bestimmt in den kommenden Tagen mal wieder Ausgang und darf in meine Werkstatt. Da werd ich das „Auslese-Tool“ mal verdrahten und den Sketch mal Testen. An Senfdazugeber Das macht Mut! Dank dir!
Wincupl ist gut. Nimm ein GAL16v8 nicht die ollen Dinger. Wie man mit secured PALs umspringt: http://dreamjam.co.uk/emuviews/readpal.php Viel Glück
gezuppel schrieb: > Wincupl ist gut. Nimm ein GAL16v8 nicht die ollen Dinger. > Wie man mit secured PALs umspringt: > http://dreamjam.co.uk/emuviews/readpal.php > > Viel Glück Ja Danke, den Empfohlenen link hab ich mir auch schon Angesehen. Ist auch eine Option für unser Vorhaben.
S. R. schrieb: > Den Code hast du nie ausprobiert, sonst wäre dir aufgefallen, dass ein > Newline mit "\n" gemacht wird, nicht mit "/n"... Und Tatsache die empfohlene Änderung wirkt auch in der Online Arduino IDE https://create.arduino.cc/ Farbliche wunder. :D
Frohe Kunde!!! So wie geplant, nur mit ein paar änderungen im Arduino Sketch, funktioniert mein Vorhaben. Ich habe gerade erfolgreich einen im GAL simulierten PAL ausgelesen und in einem GAL 16v8 im Simple Mode Reproduziert. Im Anhang die beiden Serial Ausgaben der IC´s in Excel mit dem Vergleich der Ausgangswerte und der Eingagswerte. Eine Genaue Beschriebung kommt noch. Jetzt Trink ich erstmal ein Bier und werd die Sache noch verfeinern um in den nächsten Tagen dann mich an dem IC vergehen um den es eigendlich geht. Hach bin ich erleichtert! Dank an alle die Konstruktiv geholfen haben.
Die kleine DOS-Software JED2ABL wurde noch nicht erwähnt: Beitrag "Re: Zähler mit GAL16V8 unter WinCupl realisieren" damit kann man ein ausgelesenes JEDEC-File des PAL in lesbare logische Gleichungen zurückverwandeln. Die ".JED"-Files unterschiedlicher Hersteller unterscheiden sich oft irgendwie, aber der Grundaufbau ist gleich, damit kann man vermutlich auch von Ricoh auf MMI umwandeln. CUPL ist eher selten, ABEL was hier herauskommt war gebräuchlicher.
> damit kann man ein ausgelesenes JEDEC-File
Der TO hat kein ausgelesenes JEDEC-File.
Er hat (vielleicht mittlerweile) eine Wahrheitstabelle des PAL.
Daraus die Kombinatorik zu erzeugen, sollte aber auch kein
Problem sein.
So, ich bin wieder aus dem Urlaub zurück. Ja war schön! Ich setz mich die Tage mal ran eine genaue Beschreibung auszuarbeiten und hier Hochzuladen. Ich kann ja kurz anschneiden wie es nun Funktioniert: -Ich habe ein Auslese Tool mit einem Arduino Nano und einer Handvoll LEDs und einem Nullkraftsockel gebastelt. -Auf diesem Nano läuft ein Sketch der beim Empfang eines Zeichens über die Serial eine Routine startet in der Quasie alle für die Kombinatorischen möglichkeiten eine Wahrheitstabelle erstellt und diese in einem für WINCUPL Fertigen Code über die Serial ausgibt. -Ich habe ein kleines Konsolenprogramm in C++ geschrieben welches in zwei Teilen Funktioniert: -1. PAL Auslesen, nach der abfrage welcher Comport und welchen Dateinamen die ausgelesene .pld Datei haben soll sendet das Programm eine „1“ an den Comport und die Routine auf dem Arduino Startet und senden den Code mit Wahrheitstabelle über den Comport und das Programm schreibt das Zeilenweise in die .pld Datei. -den 2. Teil des Programms erklär ich später -So Nun kann ich mit Wincupl die erstellte .pld Datei öffnen und "Compilieren" das ist schon alles für ein GAL 16v8 im Simple Mode ausgegeben worden. -Wincupl erzeug eine Menge projekt Dateien und das .jed was ich brauche -Jetzt kann ich mit meinem TL866 Programmer und dessen Software das Jedec File in einen GAL brennen. -Im 2. teil des Oben erwähnten Programms kann ich nach dem ich den gebrannten GAL wie den ersten PAL ausgelesen habe und eine zweite .pld Datei erstellt habe vergleichen. Ich hab mir da die Mühen gemacht dass so zu schreiben dass das Programm in dem Ordner wo es selbst liegt alle .pld Dateien sucht. Bei weniger als einer Meckert´s, bei zweien Vergleicht er diese und bei mehr als zwei muss Man sie sich aussuchen. Der verglich der Dateien beginnt erst einmal damit die Größen der Dateien zu vergleichen, wenn diese Identisch sind wird Zeile für Zeile mit strgcmp() überprüft. Bei unterschieden schreibt er eine Result.txt wo nochmal alle Unterschiede Dokumentiert werden. Wenn alles Identisch ist gibt es nur ein Info über die Konsole. Ich hab das nur gemacht weil ich wohl eine elementare Anzahl (<20) der Reproduktionen herstellen werde und das unter Windows gar nicht so einfach ist Dateien und deren Inhalt zu vergleichen. Getestet hab ich das alles bis jetzt mit ein paar Pal´s die aus einem Amiga stammen und es hat bis jetzt zufriedenstellend Funktioniert, bald ist der EPL 10p8 (baugleich PAL 10p8) aus der M700 Konsole drann. Ich packe nochmal alle Code´s, Schaltbilder usw. zusammen und stell es hier noch rein. LG Mario
Mario R. schrieb: > Getestet hab ich das alles bis jetzt mit ein paar Pal´s die aus einem > Amiga stammen und es hat bis jetzt zufriedenstellend Funktioniert, bald > ist der EPL 10p8 (baugleich PAL 10p8) aus der M700 Konsole drann. Ich drück dir die Daumen, dass es so erfolgreich weitergeht!
Mario R. schrieb: > Ich packe nochmal alle Code´s, Schaltbilder usw. zusammen und stell es > hier noch rein. Hallo Mario, konntest Du seit Deinem letzten Post die von Dir angegebenen Daten zusammen bringen? Ich stehe vor einem ähnlichen Problem zwei PAL Bausteine ggf. in pin-kompatible EEProms zu konvertieren. Daher habe ich großes Interesse an Deinen Ergebnissen und Lösungen zu partizipieren. Gruß aus Berlin Torsten
Hy und Hallo, ja das hat jetzt alles eine ewigkeit bei Mir rumgelegen. Mein Bekanter hat das Pult immernoch nicht wieder aufegbaut weil sein Studioumbau sich noch in die Länge zieht. Aber das Verfahren ist getestet und funktioniert. Anbei ist ein .zipfile in dem für die Hardwar ein Schaltbild und der Arduino Sketch ist. Deswiteren eine .exe und der .cpp Code für ein Windowsprogramm welche den Arduino ansteuert und dir dabei hilft die erstellten Wincupl-codes zu vergleichen. Dazu noch die nötigen Download Links. Ich komm einfach nicht dazu eine ausführliche Anleitung fertig zu schreiben. Sorry. Aber Kurz: -Hardware bauen und Sketch installieren. (mit der Arduino IDE im Serial Monitor einfach irgendwien Zeichen senden, dann sollte über den Serial Monitor schon was ankommen was aussieht wie ein Wincupl Quellcode) -Wincupl (linkliste) downloaden und installieren -so das pal_auslese Programm strarten, über die Menüfuhrung=> Pal Auslesen=> Comport eingeben=> Dateinamen eingeben ( Datei wird im selben verzeichn is wie die .exe gespeichert.) und nun sollte das "auslese Gerät" anfang zu blinken. -So die erstellte Datei mit Wincupl öffnen und compilieren. -Ich habe ein TL866 EEprom Brenner, damit das erzeugt *.bin auf den ziel GAL-Brennen -den Gal in das "auslese Gerät" stecken und ebenfalls "auslesen" -nun mit dem pal_auslese Programm die beiden erstellten Datein vergleichen. wenn Sie identisch sind wurde eine 1zu1 Kopie erstellt. Wenn nicht steht erstellten logfile in welcher Zeile was für Differenzen sind. (Meistens sind werte der Warheitstabelle different) Bitte habt nachsicht das dass Design der *.ino und der .cpp Codes nicht unbedingt Wartungsfreundlich, Organisiert geschweigeden Optimal ist, ich hab mir das alles in vielen Stunden selbst beigebracht und dennoch Funktioniert´s (zumindest bei mir, Stichwort Comport über msdn anfassen)
Torsten K. schrieb: > Hallo Mario, > > konntest Du seit Deinem letzten Post die von Dir angegebenen Daten > zusammen bringen? Ich stehe vor einem ähnlichen Problem zwei PAL > Bausteine ggf. in pin-kompatible EEProms zu konvertieren. Daher habe ich > großes Interesse an Deinen Ergebnissen und Lösungen zu partizipieren. > > Gruß aus Berlin > Torsten Ach so!!! Also wenn du ein Pin-Kompatiblen EEProm hast, denn lies doch deinen Logic IC einfach mit nem EEProm Brenner (Galep oder so) wie dein EEProm aus und schon hast du eine .bin Datei mit den Informationen. Du siehst zwar nicht auf anhieb was in der Warheitstabelle drinn steht aber das muss mann ja auch nicht. Dann brennst du das .bin in den "Ziel" EEProm und fertig ist. Um was für IC`s handelt es sich den als Quelle bzw. Ziel? Sind die echt 1zu1 Pingleich? Also Addressbus/ Inputs, Datenbus/ Outputs und Vcc und GND? LG Mario
Hallo Mario, erstmal Danke für Deine Informationen... das ist ja schon mal mehr als ich zu hoffen glaubte... insofern musst Du Dich nicht entschuldigen. Ich habe kein 1:1 EEProm... das wäre sicher schön aber das wird es wohl nicht geben. Meine PALs die ich gerne brennen möchte oder eine Ersatzlösung dafür finde sind 16L8B-2 und 16R4A-4 Vielleicht gibt es ja hier im Forum auch einen User der z.B. einen Xeltek Super Z Brenner hat und mir gegen Kostenerstattung selbige PALs brennen würde. Ich bekomme diese Typen in den kommenden Tagen und ich habe auch die Equation Datei... ich habe aber selber nie damit etwas gemacht noch habe ich einen passenden Brenner. Daher mein Interesse an einer eventuellen anderen Lösung, diese PALs gegen GALs/EEProm ? Oder was auch immer mit der gleichen Funktionalität zu ersetzen. Torsten
:
Bearbeitet durch User
Kuck mal in dem Datenblatt vom Lattice GAL 16v8 auf seite 4 siehst du das du den 16L8 mit dem GAL16V8 im Complexmode und den 16R4 mit dem GAL16V8 im Registeredmode emulieren kannst. Das heisst auch das sie 1zu1 Pinkompatibel sind. Ich will dir nicht die Hoffnung nehmen aber ich denke das es unwarscheinlich ist noch ein funktionierendes PAL Brenngerät zu bekommen. Es gibt zwar Lösungen sowas selbst zu bauen, das ist aber alles sehr Oversized. Ich würde dir Raten das mit GAL16v8 zu machen. Ich "Brenne" diese mit einem TL866 (Kostet 20-50 bei ebay/amazon und co.), die GAL´s hab ich über Ebay in China für unter einen euro das Stück bekommen. So wenn du die Equations hast musst du das nur noch mit WIncupl o.ä. zu einem .jed (Jedecfile) o.ä. compilieren und halt "Brennen". Da es sich bei deinen Logic IC´s um PAL´s mit Registern handelt wird das auslesen mit dem "Verfahren" wie ich es anwende eh nicht gehen. Auch das emulieren der Pal´s mit EEProms geht nur bei rein Kombinatorischen Logiken ohne Register! Poste doch mal die Equations ich kann ja mal schauen ob ich dir Helfen kann, wenns passt brenn ich dir auch gleich ein-zwei Gals die ich hab.
Angehängte Dateien:
-
Equations.JPG
87 KB -
Equations.gif
330 KB
Hallo Mario, Danke für Dein nettes Angebot. Etwas zum Hintergrund... ich sammel alte Computer und da möchte ich gerne einen alten DRAM Tester nachbauen (ich weiß das geht auch mit AVRs) das will ich aber nicht. Dieser DRAM Tester nutzt diese beiden PALs um TTL Logik zu minimieren. Soweit so gut... den TL866 habe ich auch und einen Dataman S4, beide können keine PALs der besagten Typen brennen. Daher meine Anfrage. Die GALs kann ich mir beschaffen, das sollte kein Problem sein, wenn Du aber so nett bist das für mich gegen Kostenübernahme zu tun, nehme ich das gerne an. Daher anbei die Equation der jeweiligen PALs: ********************************************** 16L8B-2 ;---------------------------------- PIN Declarations --------------- Pin 1 Q0; Pin 2 ASEL; PIN 3 /RAS; PIN 4 CKINA; PIN 5 MTEST; PIN 6 RD; PIN 7 Q21; PIN 8 Q22; PIN 9 CKINB; ;PIN 10 GND PIN 11 DOUT; PIN 12 /CAS; Pin 13 /CKOUT; PIN 14 DIN; PIN 15 /CKOUTA; PIN 16 /LOWMARG; PIN 17 /NORMMARG; PIN 18 /HIGHMARK; PIN 19 ERROR; ;PIN 20 Vcc ;----------------------------------- Boolean Equation Segment ------ EQUATIONS DIN = /Q21 & /Q0 # Q21 & QO; CAS = /ASEL & RAS; HIGHMARG. OE = MTEST & Q22; LOWMARG. OE = MTEST & IQ22; NORMMARG. OE = /MTEST; HIGHMARG = Q22; LOWMARG = /Q22; NORMARG = Q22 # /Q22; ERROR = RD & RAS & (DOUT & /DIN # /DOUT & DIN); CKOUTA = CKINA & /CKOUTB & /(CKINB & /CKOUTA); CKOUTB = CKINB & /CKOUTA & /(CKINA & /CKOUTB); ********************************************** 16R4A-4 ********************************************** ;---------------------------------- PIN Declarations --------------- Pin 1 CKIN; Pin 2 Q8; PIN 3 Q9; PIN 4 Q18; PIN 5 Q19; PIN 6 CKIN; PIN 7 /CYCLE; PIN 8 RST; PIN 9 ERROR; ;PIN 10 GND PIN 11 IOE; PIN 12 A9; Pin 13 /RAS; PIN 14 /CK1; PIN 15 ; PIN 16 FAIL; PIN 17 PASS; PIN 18 ASEL; PIN 19 A8; ;PIN 20 Vcc ;----------------------------------- Boolean Equation Segment ------ EQUATIONS ASEL = /RAS; A8 = /RAS & Q8 # RAS & Q18; A9 = /RAS & 09 # RAS & 019; RAS = CKO & /CKIN; PASS.D = /FAIL & /Q18; FAIL.D = ERROR & CKO # FAIL & /RST; CK1.D = /RST & CK:1 & /FAIL & CYCLE; ********************************************** Das ist das was ich habe... ich hoffe Du kannst damit etwas anfangen. LG aus Berlin Torsten
:
Bearbeitet durch User
Hallo Mario, ich habe mir eben WINCUPL installiert. Mal sehen ob ich das alleine hin bekomme. GALs muß ich noch bestellen. Ich melde mich wenn ich mich zu blöd anstelle oder aber auch Erfolg habe ;-) Danke für Deine Hilfestellung.
Torsten K. schrieb: > Daher anbei die Equation der jeweiligen PALs Dann hast du kein Problem, du musst nichts auslesen und die reprogrammierbaren und universell verwendbaren GALs sind die besseren Nachfolger der vorgesehenen PALs.
Danke... für Deinen Hinweis... leider sind in den PAL Gleichungen Fehler drin... Beispiel 16R4A PAL Equation aus den beigefügten Bildern "RAS = CK0 & !CKIN" ; -> CK0 (oder CKO) gibt es nicht. Weder als Eingang noch als Ausgang ;-( Beispiel 16L8B PAL Equation aus den beigefügten Bildern "CKOUTA = CKINA & !CKOUTB & !(CKINB & !CKOUTA) ;" "CKOUTB = CKINB & !CKOUTA & !(CKINA & !CKOUTB) ;" wird mit einer Fehlermeldung vom Typ "intermediate dependent on itself: CKOUTB" beim Compilierversuch quitiert. Ich hoffe ich finde da den Fehler/die passende Lösung. Denn nach den Bildern habe ich die Equation's erstmal grob notiert. Habe da schon ein paar kleine Fehler gefunden aber jetzt stecke ich dn den besagten Punkten fest.
Sodele... ich glaube ich bin etwas weiter gekommen. Da ich die PAL Fuse MAPs habe und ich im Internet ein Lattice PAL2GAL V3.12 Converter Tool (DOS) gefunden habe, konnte ich die entsprechenden PAL Fuse Maps in GAL Fuse Maps wandeln. Hier der Link: www.armory.com/~rstevew/Public/Pgmrs/GAL/jedec.htm Dort nach der Überschrift PALTOGAL 3.12 suchen. Das Tool unterstützt nur 8.3 Dateinamen also z.B. PAL_16L8.JED Es ist auch bei Lattice zu finden, allerdings braucht man dort ein Login https://www.latticesemi.com/en/Support/AnswerDatabase/7/1/710 Jetzt muß ich mir erstmal GALs bestellen um dann diese hoffentlich erfolgreich brennen zu können.
:
Bearbeitet durch User
Torsten K. schrieb: > Jetzt muß ich mir erstmal GALs bestellen um dann diese hoffentlich > erfolgreich brennen zu können. Du kannst mir ja mal die Dateien schicken den brenn ich mal einen um zu kucken obs klappt. Das Tool was du gefunden hast klingt erstmal sehr Hilfreich. Ich hätte dir erstmal zu deinem vorrigen Post den Tipp geben wollen, ob du den Mode der Gals auch auf COMPLEX bzw REGISTRED gestetz hast? LG Mario
:
Bearbeitet durch User
Liebe Gemeinde, ich benötige nochmal die Hilfe der Community. Ich habe Lattice GALs vom Typ 16V8A erhalten und versuche gerade die RICHTIGE Programmier- / bzw. Erase Spannungen zu finden. Hintergrund... mein TL866C stellt per default 16V ein, das führte aber nicht zum gewünschten Erfolg. Einige der erworbenen GALs waren bereits programmiert und Löschversuche scheiterten. Einige konnte ich bei 13,5V andere bei 10V löschen. Im Datenblatt zu den Lattice GALs finde ich keinerlei Hinweise (oder ich habe Tomaten auf den Augen) welches die richtigen Spannungen sind. Ich suche also nach der per Spec richtigen ERASE Voltage und nach der PROGRAMMING Voltage. Leider kann ich meinen Dataman S4 Brenner nicht einsetzen, da mir der notwendige Adapter zur GAL Programmierung fehlt und Dataman hier (obwohl das Gerät schon seit Jahren vo Markt ist) ein "Schweinegeld" für solch einen Adapter verlangt. Kann mir ggf. jemand, was die Spannungen angeht, auf die Sprünge helfen? Recht herzlichen Dank
Torsten K. schrieb: > 16V8A Torsten K. schrieb: > Kann mir ggf. jemand, was die Spannungen angeht, auf die Sprünge helfen? Du musst in der PES nachgucken b8..b11=byte B1=programming algorithm 00 VPP 15.75V programming pulse 100ms 01 VPP 15.75V programming pulse 80ms 02 VPP 16.50V programming pulse 10ms 03 VPP 14.50V programming pulse 40ms 04 VPP 14.00V programming pulse 100ms 05 programming parameters follow starting at bit 34 b34..b36: erase pulse time 10,25,50,100,200,400,800,- msec b37..b40: programing pulse time 1,2,5,10,20,30,40,50,60,70,80,90,100,200,-,- msec b41..b45: VPP(program/erase) 5.0,5.5,6.0,...20.5V
Dankeschön, da das meine erste Berührung mit GALs ist... muß ich also zuerst die GALs auslesen und die Bits/Bytes mit obiger Tabelle vergleichen um die entsprechenden Infos zu erhalten. Ist meine Interpretation richtig ? Danke Dir für eine hoffentlich letzte Antwort und ich wünsche schöne Feiertage...
Torsten K. schrieb: > da das meine erste Berührung mit GALs ist... muß ich also zuerst die > GALs auslesen und die Bits/Bytes mit obiger Tabelle vergleichen um die > entsprechenden Infos zu erhalten. Ist meine Interpretation richtig ? Ja, Auslesen mit Editier-Spannung 12V. Hier ist die GAL-Programmierung recht gut beschrieben: http://www.armory.com/~rstevew/Public/Pgmrs/GAL/algo.htm Grüßle Volker
Dankeschön, das werde ich mir mal durchlesen und ausprobieren. Schöne Feiertage Torsten
Der Pal Brenner startete in ct Ausgabe 1/1987. Scan davon ist kein Problem aber nur als PN (wg (c)!) Allerdings ist das eine recht umfangreiche Schaltung und auch dort steht ausdrücklich, dass das (algorithmische) Auslesen nur funktioniert, wenn die Protection-Fuse NICHT gebrannt ist, also das PAL ungeschützt! Zudem ist die Schaltung für den ECB-Bus, mit Adapter auch für ISA, aber das bedeutet auf jeden Fall viel Bastelei und meist das Neuaufsetzen eines historischen PCs... Auch ist die Software dafür nicht komplett in der Zeitschrift abgedruckt und lag auch damals nur als Turbo-Pascal-Quellcode vor, d.h. man musste das für die Zielplattform entsprechend anpassen und selbst kompilieren. Leider (das trifft auch für viele andere Zeitschriften wie Elektor zu!) findet man aber zugehörige Software im Gegensatz zum Artikel NIRGENDS mehr, weder im WWW noch auf den Seiten des Verlags oder auf den Archiv-CD/DVD/USB-Sticks! Insofern der Aufruf: Wer hat den Quellcode dazu noch "griffbereit", um daraus für eine aktuelle Implementierung "lernen" zu können? Die beiden geschilderten Vorgehensweisen für einfache kombinatorische PLA/PAL/GAL sind aber zielführend, sobald Register und/oder Rückkopplungen mit ins Spiel kommen, wird es deutlich komplexer, um nicht zu sagen unbeherrschbar. Wenn man bedenkt, dass auch die Nachfolger der GALs, die CPLDs fast schon wieder am Verschwinden sind, zumindest aber solche mit nativ 5V Versorgung, welche man für die Reparatur älterer Schaltungen meist zwingend benötigt, kann man sehen, wie aussichtslos es aus heutiger Sicht ist, die Funktion von Geräten ab Anfang der 90er Jahre auf "unbegrenzte" Zeit aufrecht zu erhalten! Ich bin selbst auch Typ "Sammler und Jäger", aber muss zunehmend konstatieren, dass man den Lauf der Zeit hier nicht aufhalten kann. Interessanterweise lassen sich insbesondere ganz alte Geräte heute wiederbeleben, da zum Einen die Komplexität noch geringer war, das wäre ja noch irgendwie verständlich, aber zum Anderen auch deshalb, weil für diese Geräte noch ordentliche Dokumentation existiert! Auf Papier versteht sich! Und da das mühsam auch in der Erstellung war, hat man sich auch deutlich mehr Mühe damit gegeben! Traurige Entwicklung, oder einfach ein Zeichen, dass man als Ü50 andere Prios setzt inzwischen?
Rob schrieb: > Traurige Entwicklung, oder einfach ein Zeichen, dass man als Ü50 andere > Prios setzt inzwischen? Und zu recht: Die haben keine Zeit sich mit jahrealten Threads herum zu plagen.
Mario R. schrieb: > Wenn ich den Baustein auslese kommt doch mit sicherheit ein hex bzw bin > File raus was ich wieder Brennen kann. Nein, weil die Security-fuse gesetzt ist. Rob schrieb: > Insofern der Aufruf: Wer hat den Quellcode dazu noch "griffbereit", um > daraus für eine aktuelle Implementierung "lernen" zu können? Wozu ? Das Auslesen eines nicht-geschützen GAL/EPL ist einfach, aber die sind eh alle geschützt. Zudem ist der Code von 1987 schon 1990 veraltet und konnte die lieferbaren Chips nicht mehr programmieren. Für aktuelle Chips (ATF) gibt es das http://www.bhabbott.net.nz/atfblast.html Für ältere (GAL) das http://www.armory.com/~rstevew/Public/Pgmrs/GAL/_ClikMe1st.htm Da muss man also mehr Gehirn investieren: http://dreamjam.co.uk/emuviews/readpal.php Beitrag "Re: PAL Kopieren"
Thread beobachten
Seitenaufteilung abschalten
Bitte melde dich an um einen Beitrag zu schreiben. Anmeldung ist kostenlos und dauert nur eine Minute.
Bestehender Account
Schon ein Account bei Google/GoogleMail? Keine Anmeldung erforderlich!
Mit Google-Account einloggen
Mit Google-Account einloggen
Noch kein Account? Hier anmelden.