Robotrontechnik-Forum

Registrieren || Einloggen || Hilfe/FAQ || Suche || Mitglieder || Home || Statistik || Kalender || Admins Willkommen Gast! RSS

Robotrontechnik-Forum » Technische Diskussionen » P8000 - WDC SDCard » Themenansicht

Autor Thread - Seiten: -1-
000
18.05.2012, 14:02 Uhr
Olli

Avatar von Olli

Moin Moin...

so, ich habe gestern losgelegt mit dem Board - Schritt 1 (AVR -> SDCard) ist fast fertig beschaltet.

Eine Frage aber noch zum AVR Dragon und meinem ATmega1284p.

Wenn ich den auf Full Swing Crystal fuse, kann ich den ja nicht mehr mittels ISP Direkt auf dem AVR Dragon programmieren.
Spricht denn was gegen High Voltage Parallel Programming? Dann brauche ich ja keinen externen Takt und kann den AVR weiterhin auf dem Dragon programmieren....?

Alternativ koennte ich mir auch eine kleine Schaltung mit einem 4Pin-Taktgenerator bauen und den an XTAL1-klemmen auf dem AVR, oder?

Ich will auf meinem Bastelboard erstmal kein ISP beschalten und will auch sichergehen das ich auf jedenfall die CPU programmieren kann sollte ich schaltungstechnisch Murks gebaut haben.
--
P8000 adventures: http://pofo.de/blog/?/categories/1-P8000
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
001
19.05.2012, 19:46 Uhr
Olli

Avatar von Olli

So... ich programmiere nun HVPP.
Habe nun den ATMega verschaltet aber noch kein SD-Slot "gebastelt".
Dann den ATMega programmiert.... und es scheint doch tatsaechlich auf Anhieb zu funktionieren. Über meine rangebastelte serielle kommt dann in meinem HyperTerm nach dem Power-Up


Quellcode:
MMC/SD initialization failed

So.... nun nix wie SD-Card-Slot basteln und verdrahten
--
P8000 adventures: http://pofo.de/blog/?/categories/1-P8000
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
002
19.05.2012, 21:54 Uhr
Olli

Avatar von Olli

Na.. geht doch - ein Floppy-Anschluss als SD-Card-Slot ist aber extrem frickelig... man muss die Karte schon seeeehr genau einstecken, damit sie auch wirklich Kontakt hat - ich glaube, ich muss mir da noch was anderes ueberlegen.

Aktuell verwendete Software:
http://www.roland-riegel.de/sd-reader/

Ausgabe nach einstecken der Karte:


Quellcode:
manuf:  0x18
oem:    IN
prod:   128MB
rev:    03
serial: 0x402d09b3
date:   2/5
size:   119MB
copy:   0
wr.pr.: 0/0
format: 0
free:   125331456/125380608
> ls
test.txt                             4
> cat test.txt
00000000: 74 65 73 74
>

ist doch schonmal ganz nett für meinen allerersten Versuch mit einem Mikroprozessor

Schreiben auf die Karte geht irgendwie nicht... muss ich mal schauen woran das noch liegt....


Quellcode:
> touch test2.txt
error creating file: test2.txt
> ls
test.txt                             4
> mkdir lala
error creating directory: lala

Ich lade auch gleich noch schöne Bilderchen hoch

Danach werde ich erstmal auf der Software-Seite weiter machen. Ich werde das ganze FAT-Zeugs entsorgen so das ich nur noch reine Raw-Zugriffe auf die SD-Karte mache, also einfach nur Block-Schreiben, Block-Lesen. Und dann baue ich mir mal ein paar Routinen zum Performance-Messen und schaue auf was für Schreib/Lese-Raten ich komme
Danach gehts dann mit dem P8000-Interface weiter.
--
P8000 adventures: http://pofo.de/blog/?/categories/1-P8000

Dieser Beitrag wurde am 19.05.2012 um 21:58 Uhr von Olli editiert.
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
003
19.05.2012, 22:25 Uhr
Olli

Avatar von Olli

(click für größer)


--
P8000 adventures: http://pofo.de/blog/?/categories/1-P8000

Dieser Beitrag wurde am 19.05.2012 um 22:27 Uhr von Olli editiert.
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
004
19.05.2012, 23:11 Uhr
Olli

Avatar von Olli

So.. hab den Fehler mit dem schreiben gefunden - die Software geht davon aus, dass am Port-C Write-Locked / Card-Inserted Pins angeschlossen sind und fragt diese Ab - bei mir kommt da natuerlich nix zurueck... was die Software als Write-Locked interpretiert
Das ganze mal rausgehauen.... und schon klappts auch mit dem schreiben


Quellcode:
> mkdir hugo2
> ls
test.txt                             5
hugo                                 5
lala/                                0
hugo2/                               0

So... morgen kanns weitergehen
--
P8000 adventures: http://pofo.de/blog/?/categories/1-P8000
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
005
20.05.2012, 00:03 Uhr
waldheinz



Ich gratuliere zum schnellen Erfolg, hätte aber noch einen Vorschlag: Ich glaube, du solltest das mit FAT durch rohe Sektoren ersetzen noch mal überdenken. Immerhin hast Du ja schon funktionierende Software zum FAT lesen und schreiben, und ob die von der Geschwindigkeit her einen Flaschenhals darstellt muss sich IMHO erst noch zeigen.

Selbst eine sehr naive FAT Implementierung kann bei der Geschwindigkeit nur bei den Zugriffen überhaupt eine Rolle spielen, die Sektorengrenzen überschreiten. Also abhängig von der Formatierung vielleicht jedes 4096-ste Byte oder so. Dann muss sie halt wieder in der FAT nachschlagen, wo der nächste Sektor zu finden ist, das ist dann mal eine zusätzliche Leseoperation um den nächsten Sektor rauszufinden. Und bei Flash geht wahlfreier Zugriff ja wirklich schnell. Und wenn das tatsächlich zum Problem wird, kann man die entsprechenden Datenstrukturen ja evtl. auch im RAM halten, dann hat man die Bandbreite komplett für Nutzdaten. Schneller wirds dann ohne Dateisystem auch nicht.

Und FAT spricht halt Hinz und Kunz, die Bequemlichkeit einfach mal ne Datei hin- und her zu kopieren hat schon ihren Reiz. Freilich, dd geht auch, aber da Du ja eh schon ein FAT am laufen hast würde ichs glaube erst mal damit probieren. Auch um evtl. zum debuggen eine Logdatei zu schreiben kann das ganz nett sein.
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
006
20.05.2012, 01:42 Uhr
Olli

Avatar von Olli

es macht das Programm aber halt viel einfach wenn ich von WEGA aus komme und gesagt bekomme "schreibe auf Sektor 123674 folgende 512 Bytes" das so 1:1 auf die SD-Card zu bappen ohne dann in einer Datei auf der FAT hin und her zu springen. Bedenke - das WEGA-Filesystem ist keine FAT.
Klar kann man quasi mit einer Image-Datei der "Festplatte" in einer FAT Partition arbeiten - aber das kann man spaeter immer nochmal implementieren - raw auf die SD ist erstmal viel simpler und garantiert schneller als ein rumgeseeke in einer Image-Datei.
--
P8000 adventures: http://pofo.de/blog/?/categories/1-P8000

Dieser Beitrag wurde am 20.05.2012 um 01:44 Uhr von Olli editiert.
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
007
20.05.2012, 02:19 Uhr
Olli

Avatar von Olli

Mal etwas bezüglich Performance.

- ATmega1284p
- Zugriff via SPI
- 10MB lesend
- aufgeteilt in 512Byte Blöcke
- 18.432MHz

---> 37,69 Sekunden
---> Lesegeschwindigkeit von 271,69 KB/Sek

Ist wesentlich lahmer als ne MFM Platte, oder? Aber die Frage ist auch, was schafft hier überhaupt die Z80-PIO über die das ja alles geht...
--
P8000 adventures: http://pofo.de/blog/?/categories/1-P8000
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
008
20.05.2012, 09:58 Uhr
Enrico
Default Group and Edit


Das ist nicht wirklich viel, wennman bedenkt, dass die verwaltung noch fehlt.
Die P8000 schafft ca. 150 kb/sec, MFM max 500 kb Brotto. also ca. 300-400 kb
bei 1:1 Interleave.
--
MFG
Enrico
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
009
20.05.2012, 10:32 Uhr
Olli

Avatar von Olli

Naja - ich habe jetzt Überläufe vom internen Timer zählen lassen (durch den Overflow-Interrupt) um die Ausführungsgeschwindigkeit messen zu können - das braucht ja auch ein wenig Rechenzeit. Ich denke, viel Logik für die Kommunikation wird man nicht brauchen - also das "Programm" wird nicht so riesig. Ein wenig optimieren kann man sicherlich auch noch - es ist aktuell eher modular aufgebaut, arbeitet also mit vielen Funktionen - das kostet natuerlich auch alles Rechenzeit.
--
P8000 adventures: http://pofo.de/blog/?/categories/1-P8000

Dieser Beitrag wurde am 20.05.2012 um 10:33 Uhr von Olli editiert.
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
010
20.05.2012, 13:04 Uhr
Micha

Avatar von Micha

wenn Dein Foto die aktuelle Schaltung widergibt: erstaunlich dass der Quarz so weit weg von den XTAL Pins seinen Dienst tut, die beiden typisch zugehörigen 22p Kondensatoren sehe ich auch nicht auf dem Foto(?). Dachte immer man muss das so kurz wie möglich halten.

Und ja: viel Luft ist mit dem Datendurchsatz der SD-Card nicht, hab ich auch schon festgestellt.
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
011
20.05.2012, 14:49 Uhr
Olli

Avatar von Olli

die 22p Kondis sind die 2 blauen neben dem Quarz... hatte gerade keine Keramik-Kondis. Und - soweit weg ist der Quarz doch gar nicht - die Pins liegen doch direkt "daneben" (12+13)
--
P8000 adventures: http://pofo.de/blog/?/categories/1-P8000
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
012
20.05.2012, 16:53 Uhr
holm

Avatar von holm

Olli Micha hat Recht, Dein Quarz ist zu weit weg.
Gruß,

Holm
--
float R,y=1.5,x,r,A,P,B;int u,h=80,n=80,s;main(c,v)int c;char **v;
{s=(c>1?(h=atoi(v[1])):h)*h/2;for(R=6./h;s%h||(y-=R,x=-2),s;4<(P=B*B)+
(r=A*A)|++u==n&&putchar(*(((--s%h)?(u<n?--u%6:6):7)+"World! \n"))&&
(A=B=P=u=r=0,x+=R/2))A=B*2*A+y,B=P+x-r;}
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
013
20.05.2012, 17:21 Uhr
Olli

Avatar von Olli

Mh... es scheint jetzt aber erstmal korrekt zu funktionieren.... muss ich nun trotzdem was umlöten?
--
P8000 adventures: http://pofo.de/blog/?/categories/1-P8000
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
014
20.05.2012, 18:38 Uhr
Enrico
Default Group and Edit


Das merkst Du spätestens. wenn der Atmel mehr zu tun hat.
--
MFG
Enrico
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
015
25.05.2012, 16:42 Uhr
Olli

Avatar von Olli

Wie würdet Ihr nun weitermachen? Erstmal die Ports der WDC-Schnittstelle 1:1 ohne weiteres an den ATMega ranlegen und dann erstmal damit rumspielen? Ich meine, ein erstes Gefuehl sollte man damit schonmal bekommen koennen, oder? Wenn ich rm2's Schaltung richtig verstanden habe, hat er auch nix anderes gemacht.

Wenn das ganze dann zu langsam ist, dann nochmal tiefsinniger drueber nachdenken?
--
P8000 adventures: http://pofo.de/blog/?/categories/1-P8000
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
016
25.05.2012, 17:05 Uhr
holm

Avatar von holm

Klar doch, probiere das. Der Haken scheint zu sein mit der 4Mhz Z8000 synchron zu bleiben und das über 4KBytes.

Gruß,

Holm
--
float R,y=1.5,x,r,A,P,B;int u,h=80,n=80,s;main(c,v)int c;char **v;
{s=(c>1?(h=atoi(v[1])):h)*h/2;for(R=6./h;s%h||(y-=R,x=-2),s;4<(P=B*B)+
(r=A*A)|++u==n&&putchar(*(((--s%h)?(u<n?--u%6:6):7)+"World! \n"))&&
(A=B=P=u=r=0,x+=R/2))A=B*2*A+y,B=P+x-r;}
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
017
25.05.2012, 17:17 Uhr
otto11



Hi Olli,
ich weiß jetzt nicht, was der Atmel an dem entsprechenden Port treiben kann. Du solltest aber zumindest die Signale /TR und /STB in Richtung U8000 treiben. Da sitzen auf der 16Bit Platine jeweils 215Ohm nach 5V und 332Ohm nach Masse dran. Ich musste jedenfalls hier noch 2 x SS216 anhängen um saubere Pegel zu bekommen. Ebenfalls sollte man den Eingangspegel von /RDY und /TE in Richtung Atmel prüfen.

Gruß
Jürgen
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
018
25.05.2012, 17:28 Uhr
holm

Avatar von holm

Atmelports können 20mA nach VCC oder GND treiben.
...würde aber trotzdem auch Treiber empfehlen, die Schnittstelle ist auf S-TTL ausgelegt.

Gruß,

Holm
--
float R,y=1.5,x,r,A,P,B;int u,h=80,n=80,s;main(c,v)int c;char **v;
{s=(c>1?(h=atoi(v[1])):h)*h/2;for(R=6./h;s%h||(y-=R,x=-2),s;4<(P=B*B)+
(r=A*A)|++u==n&&putchar(*(((--s%h)?(u<n?--u%6:6):7)+"World! \n"))&&
(A=B=P=u=r=0,x+=R/2))A=B*2*A+y,B=P+x-r;}

Dieser Beitrag wurde am 25.05.2012 um 17:30 Uhr von holm editiert.
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
019
25.05.2012, 18:03 Uhr
Olli

Avatar von Olli

kann ich die /TR, /STB Richtung P8000 sowie /RDY und /TE Richtung ATmel einfach durch einen LS244 bugsieren? Oder habe ich was falsch verstanden?
--
P8000 adventures: http://pofo.de/blog/?/categories/1-P8000

Dieser Beitrag wurde am 25.05.2012 um 18:03 Uhr von Olli editiert.
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
020
25.05.2012, 19:19 Uhr
holm

Avatar von holm

Richtung Atmel wirst Du nicht viel unternehmen müssen, aber Du sollst den Busabschluß auf dem 16Bit Teil für -TR und -STB richtig trieben. Da tut es auch ein einzelner NPN Transistor
mit einem 1-3K Basiswiderstand.
Gruß,

Holm
--
float R,y=1.5,x,r,A,P,B;int u,h=80,n=80,s;main(c,v)int c;char **v;
{s=(c>1?(h=atoi(v[1])):h)*h/2;for(R=6./h;s%h||(y-=R,x=-2),s;4<(P=B*B)+
(r=A*A)|++u==n&&putchar(*(((--s%h)?(u<n?--u%6:6):7)+"World! \n"))&&
(A=B=P=u=r=0,x+=R/2))A=B*2*A+y,B=P+x-r;}
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
021
25.05.2012, 21:21 Uhr
Olli

Avatar von Olli

Habe noch einen BC548A - geht der? Wie verschalte ich den genau?
--
P8000 adventures: http://pofo.de/blog/?/categories/1-P8000
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
022
25.05.2012, 21:32 Uhr
holm

Avatar von holm

An Atmel Ausgang einen Widerstand 1..3KOhm von dort zur Basis. Emitter an Masse. Kollektor auf den Signaleingang des 16 Bit Teils. Das Ding arbeitet dann als Negator mit Open Kollektor Ausgang auf den Abschlußwiderstand im 16 Bit Teil. Das sollte an und für sich reichen.
Da Dein Oszi im Keller ist kannst Du bei Nichtfunktion noch mal 470Ohm vom Kollektor nach +5V schalten (nicht zu erwarten).

Es geht so ziemlich jeder NPN Transistor dieser Bauform, auch der 548A, welcher aber nicht sonderlich viel Stromverstärkung hat. Sowas findest Du in jedem ollen Transistorradio.

Gruß,

Holm
--
float R,y=1.5,x,r,A,P,B;int u,h=80,n=80,s;main(c,v)int c;char **v;
{s=(c>1?(h=atoi(v[1])):h)*h/2;for(R=6./h;s%h||(y-=R,x=-2),s;4<(P=B*B)+
(r=A*A)|++u==n&&putchar(*(((--s%h)?(u<n?--u%6:6):7)+"World! \n"))&&
(A=B=P=u=r=0,x+=R/2))A=B*2*A+y,B=P+x-r;}
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
023
25.05.2012, 22:03 Uhr
Olli

Avatar von Olli

Laut meiner Liste habe ich auch noch einen C2235 (wohl sicherlich ein 2SC2235?) auch ein NPN - besser den?
--
P8000 adventures: http://pofo.de/blog/?/categories/1-P8000
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
024
25.05.2012, 23:12 Uhr
holm

Avatar von holm

Nein, das ist ein Power Amplifier Treiber, ... übertrieben dick.

Gruß,

holm
--
float R,y=1.5,x,r,A,P,B;int u,h=80,n=80,s;main(c,v)int c;char **v;
{s=(c>1?(h=atoi(v[1])):h)*h/2;for(R=6./h;s%h||(y-=R,x=-2),s;4<(P=B*B)+
(r=A*A)|++u==n&&putchar(*(((--s%h)?(u<n?--u%6:6):7)+"World! \n"))&&
(A=B=P=u=r=0,x+=R/2))A=B*2*A+y,B=P+x-r;}
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
025
26.05.2012, 15:13 Uhr
Olli

Avatar von Olli

Hallo Holm,

ich habe jetzt mal die P8000-Schnittstelle eingezeichnet.

http://pofo.de/tmp/P8000_WDC_SDCard.pdf

Ist es so angeschlossen wie du meintest?
Kann ich den Port C zut Hälft als Input und zur anderen Hälfte als Output benutzen oder konfigurieren?
--
P8000 adventures: http://pofo.de/blog/?/categories/1-P8000
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
026
26.05.2012, 16:08 Uhr
Enrico
Default Group and Edit


Ist /RST = /RESET nicht der Reset-Ausgang vom Rechner?

Beim ATMEGA lassen sich die Ports Bit-weise als Eingang oder Ausgang nehmen.
--
MFG
Enrico
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
027
26.05.2012, 17:04 Uhr
Olli

Avatar von Olli

/RST ist ein als "Resetanweisung" für den WDC welcher auf Seite 7 vom 16 Bit Plan zu sehen ist. Ich schnall den 16 Bit Plan in der Hinsicht aber nicht, da Y3 von 1D21 gar nicht beschaltet ist, aber A3 der Ausgang vom Signal ist.
--
P8000 adventures: http://pofo.de/blog/?/categories/1-P8000

Dieser Beitrag wurde am 26.05.2012 um 17:05 Uhr von Olli editiert.
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
028
26.05.2012, 17:09 Uhr
Micha

Avatar von Micha


Zitat:
Olli schrieb
Kann ich den Port C zut Hälft als Input und zur anderen Hälfte als Output benutzen oder konfigurieren?

Nachdem du schon soweit gekommen bist (u.a. 3rd party SD-Card Software eingebunden hast) verwirrt mich diese Frage. Natürlich kann man jedes Bit einzeln als I oder O einstellen, sogar im laufenden Betrieb - ist ja gerade für dieses Projekt eine essentielle Sache. Bin wirklich verwirrt, die Frage hat bestimmt einen tieferen Sinn den ich im Moment nicht erfasse.
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
029
26.05.2012, 18:31 Uhr
Olli

Avatar von Olli

fertige Software zum laufen zu bringen erfordert nicht diese Art von Beschaeftigung mit dem Mikroprozessor Micha.... ganz einfach

Es war ja nur löten, compilieren, Flashen -> lief.

Klar - MISO und MOSI sind auch out und input, aber ich dachte, das is dann vielleicht ein besonderes "Setup" des Ports - halt fuer SPI. Daraus laesst sich ja nicht autom. schliessen, das man jeden Pin des Portes wie man will auf E oder A konfigurieren kann.
--
P8000 adventures: http://pofo.de/blog/?/categories/1-P8000

Dieser Beitrag wurde am 26.05.2012 um 18:37 Uhr von Olli editiert.
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
030
26.05.2012, 18:37 Uhr
Enrico
Default Group and Edit



Zitat:
Olli schrieb
/RST ist ein als "Resetanweisung" für den WDC

Eben.
"Du" bist doch der WDC, also sollte es bei Dir der Eingang sein.



Zitat:
welcher auf Seite 7 vom 16 Bit Plan zu sehen ist. Ich schnall den 16 Bit Plan in der Hinsicht aber nicht, da Y3 von 1D21 gar nicht beschaltet ist, aber A3 der Ausgang vom Signal ist.

Ist doch Dein Plan.

2D5 ist der Ausgang vom /RST. Eventuell könnte der Y3 Ausgang des 1D21
(A3 ist dessen EIngang) die Alternative dazu sein. Z.B. bei der Compact.
So kommt der als B5 von der PIO.
--
MFG
Enrico

Dieser Beitrag wurde am 26.05.2012 um 18:38 Uhr von Enrico editiert.
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
031
26.05.2012, 19:22 Uhr
Olli

Avatar von Olli

Ach Mensch.... B5 an der PIO hab ich übersehen.... Tomaten auf den Augen....

Es ist (bzw. sollte sein) auch "mein" Eingang - ist er dazu etwa falsch verschaltet mit dem Transistor?
--
P8000 adventures: http://pofo.de/blog/?/categories/1-P8000

Dieser Beitrag wurde am 26.05.2012 um 19:24 Uhr von Olli editiert.
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
032
26.05.2012, 21:32 Uhr
Enrico
Default Group and Edit


Aber sowas von falsch. Das ist ja kein EIngang, sodern ein Ausgang mit dem Transistor.
--
MFG
Enrico
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
033
26.05.2012, 22:49 Uhr
Olli

Avatar von Olli

Achso... ich brauch den Transistor für /TR und /STB? Was ist mit Status0-3?
--
P8000 adventures: http://pofo.de/blog/?/categories/1-P8000
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
034
26.05.2012, 23:35 Uhr
Olli

Avatar von Olli

So... habs nochmal angepasst - nun auch die 2 richtigen Ausgaenge getrieben:

http://pofo.de/tmp/P8000_WDC_SDCard.pdf

Habe den Port-C von der Reihenfolge her mal so beschaltet wie Port-B bei otto11 sein Teil. Wenn das so passt würde ich Sonntag gerne löten und mit der Programmierung starten - bitte nochmal fix einen Blick drauf werfen
--
P8000 adventures: http://pofo.de/blog/?/categories/1-P8000

Dieser Beitrag wurde am 26.05.2012 um 23:49 Uhr von Olli editiert.
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
035
27.05.2012, 03:25 Uhr
Enrico
Default Group and Edit


ASTB und TR am Controller sind bei der Beschaltung eigentlich
H-aktiv. Sollte so aber funktionieren.
Ich denke nicht, das der Stutsu nochmla getrieben werden muss, das geht ja auf die Eingänge des Bus-Treibers.
--
MFG
Enrico
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
036
27.05.2012, 08:21 Uhr
Olli

Avatar von Olli

Stutsu? Status?
--
P8000 adventures: http://pofo.de/blog/?/categories/1-P8000

Dieser Beitrag wurde am 27.05.2012 um 08:23 Uhr von Olli editiert.
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
037
27.05.2012, 12:44 Uhr
Enrico
Default Group and Edit


Ja, jaaa.....
--
MFG
Enrico
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
038
27.05.2012, 13:08 Uhr
Olli

Avatar von Olli

ne, hab echt ueberlegt.... so nachher dann mal ab ans programmieren
--
P8000 adventures: http://pofo.de/blog/?/categories/1-P8000
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
039
27.05.2012, 15:16 Uhr
Olli

Avatar von Olli

Sehr komisch - schließe ich Pin 1 des WDC-Steckers (/RDY) an meine Schaltung an, habe ich auf meiner 5V Schiene 1.7V liegen und mein Netzteil springt nicht mehr an. biege ich den Pin 27 meines ATMega weg (daran ist sonst /RDY angeschlossen), springt alles an. Was soll mir das sagen?
--
P8000 adventures: http://pofo.de/blog/?/categories/1-P8000
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
040
27.05.2012, 15:56 Uhr
holm

Avatar von holm

Na offensichtlich fließt da viel Strom. Hast Du VCC und GND irgendwo verwechselt?
Ist Dein Netzteil irgendwie mit dem Schutzlieter verbunden und macht darüber Kurzschluß?

Gruß,

Holm
--
float R,y=1.5,x,r,A,P,B;int u,h=80,n=80,s;main(c,v)int c;char **v;
{s=(c>1?(h=atoi(v[1])):h)*h/2;for(R=6./h;s%h||(y-=R,x=-2),s;4<(P=B*B)+
(r=A*A)|++u==n&&putchar(*(((--s%h)?(u<n?--u%6:6):7)+"World! \n"))&&
(A=B=P=u=r=0,x+=R/2))A=B*2*A+y,B=P+x-r;}
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
041
27.05.2012, 16:00 Uhr
Olli

Avatar von Olli

Ist ein Standard-PC-AT-Netzteil mit Schuko. Masse und VCC haben auf dem Board selbst kein Kontakt. Zwischen VCC und GND misst mein Durchgangsprüfer/Diodenmessgerät irgendwas mit 1018 (was auch immer das ist).
Wenn der WDC übrigens "scharf" ist, also der Selbsttest (mit Fehlern) auf der P8000 durchgelaufen ist, somit /RESET aktiv ist, dann kommen ohne das mein Board angeschaltet ist, 2.44V auf der 5V Schiene an. Das Netzteil liefert aber weiter Strom. Es scheint das nur beim Anschalten zu prüfen.
--
P8000 adventures: http://pofo.de/blog/?/categories/1-P8000

Dieser Beitrag wurde am 27.05.2012 um 16:03 Uhr von Olli editiert.
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
042
27.05.2012, 16:32 Uhr
Andreas



@Olli

Der ATmega steckt 180 Grad verdreht drin.

Andreas
--
Viele Grüße
Andreas
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
043
27.05.2012, 16:54 Uhr
Olli

Avatar von Olli

nein, steckt er nicht Er läuft ja - aber nicht wenn Pin-7 angeschlossen ist.

Nun aber mal zur Software (/RDY ist mir jetzt erstmal egal)....

Mit dem Ansprung der Testroutine des 16Bit-Monitors, geht /RESET auf high.
Direkt danach lese ich aus den Daten (D0-D7) 0xFF und unmittelbar danach permanent 0xAA. Das liegt an, bis ich durch drücken des RESET am P8000 den 16Bit-Teil wieder schlafen lege.

Offensichtlich antworte ich auf den Reset nicht richtig. im Quellcode von otto11 steht:


Quellcode:
while ((PORTB & RESET)== RESET) {   // in Reset bleiben, bis RESET inactiv
                   PORTA = 0x00;
               wdcstatus = 0;
                PORTB = ( WDCBUSY );} // /TR + /STB inactiv, + WDCstatus        

Verstehe ich erstmal grundsätzlich nicht, da PORTA auf lesen konfiguriert ist.. also wieso etwas nach PORTA schreiben? Ansonsten habe ich das jetzt mal bei mir genaus abgebildet...


Quellcode:
#define WDCBUSY  0x00
#define TR  0x40
#define STB 0x08
    while(1)
    {
        PORTA = 0x00;
        PORTB = ( TR | STB | WDCBUSY ); // /TR + /STB inactiv, + WDCstatus
        DDRA=0x00;
        DDRC=0x4f;

        while(wdc_reset())
        {

            PORTA = 0x00;
            PORTC = ( WDCBUSY );
        }
    }

Er kommt aber nicht aus der RESET-Schleife raus, bis sich der 16Bit-Teil wieder schlafen legt.
--
P8000 adventures: http://pofo.de/blog/?/categories/1-P8000

Dieser Beitrag wurde am 27.05.2012 um 16:54 Uhr von Olli editiert.
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
044
27.05.2012, 17:29 Uhr
Enrico
Default Group and Edit


Wenn Du am Controller TR und STB auf 1 setzt, sind die am WDC-Interface
aber 0, also aktiv.
Oder was machst Du da?
Kenne mich mit diesem C Klammer-kryptoschismus nicht aus.....

Wo kommt denn das RDY beim Rechner an?
--
MFG
Enrico

Dieser Beitrag wurde am 27.05.2012 um 17:33 Uhr von Enrico editiert.
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
045
27.05.2012, 17:53 Uhr
holm

Avatar von holm

Wie ist den wdc_reset() definiert?

Bitte beachte, das der Atmel Ports mit PORTA=foo; schreibt, aber mit bar=PINA; liest.
Wenn die Ports auf Eingabe geschaltet sind kannst Du mit einer Ausgabe einer 1 auf den ensprechenden Port die internen Pullups zu und mit einer 0 abschalten. Eingabe bleibt das aber trotzem.

Das hier:

PORTB = ( TR | STB | WDCBUSY );

Komt mir auch seltensam vor.

Bits definiert man hier so:


Quellcode:
#define VCC5P                   PC0                     // PNP Transistor for 5P
#define VDD13P                  PC1                     // Switch on 723
#define VPP0P                   PC2
#define VFY                     PC3
#define PGM0P                   PC4
#define A8                      PC5
#define A9                      PC6
#define A10                     PC7

#define RXD                     PD0
#define TXD                     PD1

bei der Augabe dann z.B.


Quellcode:
PORTC|=(1<<VCC5P)|(1<<VDD13P);
PORTC&=~(1<<A8)|(1<<A9);


Ich weiß nicht was die Motorroller-CPU bzw. deren Compiler so mit den Ports treibt...
1:1 übernehmen ist sicher nicht drin.


Übrigens ist bei Dir #define WDCBUSY 0x00
Kannst Du als alter C-Hai mal erklären was das in diesem Oder soll?


Gruß,

Holm
--
float R,y=1.5,x,r,A,P,B;int u,h=80,n=80,s;main(c,v)int c;char **v;
{s=(c>1?(h=atoi(v[1])):h)*h/2;for(R=6./h;s%h||(y-=R,x=-2),s;4<(P=B*B)+
(r=A*A)|++u==n&&putchar(*(((--s%h)?(u<n?--u%6:6):7)+"World! \n"))&&
(A=B=P=u=r=0,x+=R/2))A=B*2*A+y,B=P+x-r;}

Dieser Beitrag wurde am 27.05.2012 um 18:02 Uhr von holm editiert.
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
046
27.05.2012, 17:55 Uhr
Olli

Avatar von Olli

@Enrico
Ich gebe 1 nach /TR und /STB Richtung P8000 aus.
--
P8000 adventures: http://pofo.de/blog/?/categories/1-P8000

Dieser Beitrag wurde am 27.05.2012 um 18:22 Uhr von Olli editiert.
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
047
27.05.2012, 18:00 Uhr
holm

Avatar von holm

...Ähhh...gypten?

Gruß,

Holm
--
float R,y=1.5,x,r,A,P,B;int u,h=80,n=80,s;main(c,v)int c;char **v;
{s=(c>1?(h=atoi(v[1])):h)*h/2;for(R=6./h;s%h||(y-=R,x=-2),s;4<(P=B*B)+
(r=A*A)|++u==n&&putchar(*(((--s%h)?(u<n?--u%6:6):7)+"World! \n"))&&
(A=B=P=u=r=0,x+=R/2))A=B*2*A+y,B=P+x-r;}
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
048
27.05.2012, 18:27 Uhr
Olli

Avatar von Olli


Zitat:
holm schrieb
Wie ist den wdc_reset() definiert?

#define wdc_reset() ((PINC) & (1 << DDC7))




Zitat:
holm schrieb
Bitte beachte, das der Atmel Ports mit PORTA=foo; schreibt, aber mit bar=PINA; liest.

Jo, das ist klar.


Zitat:
holm schrieb
PORTB = ( TR | STB | WDCBUSY );

Komt mir auch seltensam vor.

Setze PORTB einfach auf 0x40 | 0x08 | 0x00 = 0x48 -> Also die Pins /TR und /STB auf high. So denke ich zummindest. (0x48 ist 01001000 -> also PORTC-3, PORTC-6 ---> STB + TR)


Zitat:
holm schrieb
Ich weiß nicht was die Motorroller-CPU bzw. deren Compiler so mit den Ports treibt...
1:1 übernehmen ist sicher nicht drin.

Jo schon klar, aber wenn man versteht was er da macht, kann man das ja adaptieren... Und ich versteh halt gerade 0 - mir ist einfach nicht klar, wie die 2 Ports stehen müssen wenn /RESET auf 1 kommt von der P8000. Offensichtlich muss ich mit irgendwas antworten aber ich habe 0 Plan was.


Zitat:
holm schrieb
Übrigens ist bei Dir #define WDCBUSY 0x00
Kannst Du als alter C-Hai mal erklären was das in diesem Oder soll?

Kann ersatzlos entfallen in der |-Geschichte - schadet aber auch nicht, und ich hatte es so einfach übernommen.
--
P8000 adventures: http://pofo.de/blog/?/categories/1-P8000

Dieser Beitrag wurde am 27.05.2012 um 18:28 Uhr von Olli editiert.
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
049
27.05.2012, 18:39 Uhr
holm

Avatar von holm

Ich kämpfe auch gerade mit einer Baustelle, habe also den Nerv nicht frei.
Das mit dem ersatzlos entfallen halte ich für ein Gerücht.
Klar, der Compilter wirft das sowieso weg, aber warum steht das da, d.h. warum hat otto11 das da eingetragen? Zum ersatzlos wegwerfen sicher nicht, er wollte bestimmt damit irgendwas erreichen.
Dein Hexadezimales Oder ist mir schon klar.

Setze die Ports lieber mit einem Read modify wirte, also mit einem Oder bzw. Und der Bits,
das macht sich besser als immer den aktuellen Status aller eventuell am Ausgang befindlichen Bits mit zu schleppen. Außerdem Änderst Du mit einer kompletten Ausgabe eventuell halt die Pullups von an diesem Port befindlichen Eingängen mit, das kann lustige Effekte nach sich zerren...

Gruß,

Holm
--
float R,y=1.5,x,r,A,P,B;int u,h=80,n=80,s;main(c,v)int c;char **v;
{s=(c>1?(h=atoi(v[1])):h)*h/2;for(R=6./h;s%h||(y-=R,x=-2),s;4<(P=B*B)+
(r=A*A)|++u==n&&putchar(*(((--s%h)?(u<n?--u%6:6):7)+"World! \n"))&&
(A=B=P=u=r=0,x+=R/2))A=B*2*A+y,B=P+x-r;}
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
050
27.05.2012, 19:01 Uhr
Olli

Avatar von Olli


Zitat:
holm schrieb
Setze die Ports lieber mit einem Read modify wirte, also mit einem Oder bzw. Und der Bits,
das macht sich besser als immer den aktuellen Status aller eventuell am Ausgang befindlichen Bits mit zu schleppen. Außerdem Änderst Du mit einer kompletten Ausgabe eventuell halt die Pullups von an diesem Port befindlichen Eingängen mit, das kann lustige Effekte nach sich zerren...

Gruß,

Holm

Wie? Hast du fix n Beispiel?
Und - bei otto11 war es halt auch 0x00 definiert...
--
P8000 adventures: http://pofo.de/blog/?/categories/1-P8000
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
051
27.05.2012, 19:11 Uhr
holm

Avatar von holm

Die Beispiele habe ich Dir oben schon gegeben mit PORTC|= und PORTC&=. Der avr-gcc weiß was er da zu tun hat.
Ich stehe jetzt auch weder mit der 16Bit noch der WDC Schnittstelle in der Materie.
Wenn das aber mit 0 definiert ist, brauchst Du das niemals mit verodern.
Warum ist es dann im Code?
Gruß,

Holm
--
float R,y=1.5,x,r,A,P,B;int u,h=80,n=80,s;main(c,v)int c;char **v;
{s=(c>1?(h=atoi(v[1])):h)*h/2;for(R=6./h;s%h||(y-=R,x=-2),s;4<(P=B*B)+
(r=A*A)|++u==n&&putchar(*(((--s%h)?(u<n?--u%6:6):7)+"World! \n"))&&
(A=B=P=u=r=0,x+=R/2))A=B*2*A+y,B=P+x-r;}
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
052
27.05.2012, 19:14 Uhr
Enrico
Default Group and Edit



Zitat:
Olli schrieb
@Enrico
Ich gebe 1 nach /TR und /STB Richtung P8000 aus.

Ich dachte beim Controller gibts Du eine 1 aus.
Die Transistoren invertieren das ja.
--
MFG
Enrico
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
053
27.05.2012, 19:18 Uhr
Olli

Avatar von Olli


Zitat:
Enrico schrieb

Zitat:
Olli schrieb
@Enrico
Ich gebe 1 nach /TR und /STB Richtung P8000 aus.

Ich dachte beim Controller gibts Du eine 1 aus.
Die Transistoren invertieren das ja.

Ich gebe 1 am ATMega aus.... k.A. was da jetzt bei der P8000 ankommt.



Zitat:
holm schrieb
Wenn das aber mit 0 definiert ist, brauchst Du das niemals mit verodern.
Warum ist es dann im Code?

Weiss nicht warum otto11 es im Code hat? Es ist jedenfalls genau so definiert
http://www.krummsdorf.de/files/hobby/WDCR/software/main.c
--
P8000 adventures: http://pofo.de/blog/?/categories/1-P8000
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
054
27.05.2012, 19:30 Uhr
holm

Avatar von holm

Ich habe das Gefühl er verwendet das um einfach die anderen Signale des Ports abzuschalten.
Das hat aber möglicherweise die falschen Konsequenzen bei Dir, wenn Du am Ausgang einen negierenden Treiber wie die Transistoren dazwischen hast.

Nochmal von wegen keine ahnung was da ankommt:

Wenn Du eine 1 Ausgibst, geht das Portbein auf H und es fließt Strom aus diesem Port über den Basiswiderstand auf die Basis des Transistors. Dieser fängt deshalb an zu leiten und schließt jede Spannung (bis auf eine Restspannung) zwischen seinem Kollektor und dem Emmitter nach Masse kurz. Deswegen steht dann am Kollektor L.

Alles klar?

Gruß,

Holm
--
float R,y=1.5,x,r,A,P,B;int u,h=80,n=80,s;main(c,v)int c;char **v;
{s=(c>1?(h=atoi(v[1])):h)*h/2;for(R=6./h;s%h||(y-=R,x=-2),s;4<(P=B*B)+
(r=A*A)|++u==n&&putchar(*(((--s%h)?(u<n?--u%6:6):7)+"World! \n"))&&
(A=B=P=u=r=0,x+=R/2))A=B*2*A+y,B=P+x-r;}
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
055
27.05.2012, 20:06 Uhr
Olli

Avatar von Olli

Jo OK, Erklärung verstanden.... komme irgendwie nicht weiter. Ich schnall den komplexen ASM Source nicht - weder von der 16 Bit Firmware noch vom WDC... ist mir einfach ne Nummer zu hoch da durchzublicken. Wenn ich nun einen "P8000" Emulator haette, koennte ich sehen wie der echte WDC antwortet wenn er ein RESET bekommt... ich habe nämlich keinen Schimmer

Ein LA welches lange genug aufzeichnen kann waere zum debuggen echt hilfreich....
--
P8000 adventures: http://pofo.de/blog/?/categories/1-P8000
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
056
27.05.2012, 20:08 Uhr
holm

Avatar von holm

Stelle Dein Licht mal nicht dermaßen unter den Scheffel.

Kopiere hier mal die Initialisierung des WDC von der P8K Seite her rein.
Gruß,

Holm
--
float R,y=1.5,x,r,A,P,B;int u,h=80,n=80,s;main(c,v)int c;char **v;
{s=(c>1?(h=atoi(v[1])):h)*h/2;for(R=6./h;s%h||(y-=R,x=-2),s;4<(P=B*B)+
(r=A*A)|++u==n&&putchar(*(((--s%h)?(u<n?--u%6:6):7)+"World! \n"))&&
(A=B=P=u=r=0,x+=R/2))A=B*2*A+y,B=P+x-r;}
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
057
27.05.2012, 20:25 Uhr
Olli

Avatar von Olli

Meinst du die?

http://cvs.laladev.org/index.html/P8000/firmware/MON16/p.disk.s?rev=1.1&content-type=text/x-cvsweb-markup

Ich habe mal eine einfache Ausgabe meines PORTC gemacht - der Inhalt von main()


Quellcode:
DDRA=0x00;
    DDRC=0x4f;
    read_portc = PINC;
    read_portc_old = read_portc;

    uart_puts_p(PSTR("PINC: "));
    uart_putc_hex(read_portc);
    uart_putc('\n');

    while(1)
    {
        read_portc = PINC;
        if( read_portc != read_portc_old)
        {
            uart_puts_p(PSTR("PINC: "));
            uart_putc_hex(read_portc);
            uart_putc('\n');
            read_portc_old = read_portc;
        }    
    }

Alles was ausgegeben wird ist:
PINC: 00
PINC: 80 (der 16 Bit Teil beginnt mit seinen Hardwaretests)
PINC: 00 (Ich drücke RESET am P8000-Grundgerät).

Mehr kommt also nicht an als das /RESET. Bleibt also nur zu wissen, wodrauf /TR /STB und die Stati stehen müssen.

otto hatte in seinem Code folgende Kommentare:


Quellcode:
DDRB = 0x4F;  // Port B bit 0-2 out : Status WDC
                   //        bit 3 out   : /STB :  H-L-H als Reaktion auf /RDY = L
               //  ist   bit 4 in    : /TE ; = 0-> Ausgabedatenbus Treiber des WDC wird aktiviert
               //                              PORTA darf Daten schreiben
               //                            = 1-> PORTA darf keine Data schreiben, darf lesen !!!
               //        bit 5 in    : Mode 0 PIO: /RDY H->L -> gueltige Daten zum Lesen liegen an PortA HOST-PIO
               //                       muss mit Impuls /STB H-L-H quittiert werden
               //                       Mode 1 PIO: /RDY H->L -> Daten sind aus PIO abgeholt worden, frei für neue
               //                       Strobe /STB H-L-H nach Datenausgabe
               //                        ( ist negierter ( 2D21 ) RDY Ausgang PORTA 16BIT )
               //        bit 6 out   : /TR = 0 Transfer Request, -> WDC will daten schreiben an PORTA
               //                    :
               //        bit 7 in    : RESET


--
P8000 adventures: http://pofo.de/blog/?/categories/1-P8000

Dieser Beitrag wurde am 27.05.2012 um 20:26 Uhr von Olli editiert.
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
058
27.05.2012, 21:44 Uhr
holm

Avatar von holm

Erstma das hier:


Quellcode:
//===========================================================================
// forward declarations
static int my_putchar(char c, FILE *stream);
static FILE mystdout=FDEV_SETUP_STREAM(my_putchar, NULL,_FDEV_SETUP_WRITE);
//===========================================================================
// STDOUT putchar routine
static int      my_putchar(char c, FILE *stream)
{
                uartputc(c);
                return(0);
}

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

Danach funktioniert printf(); hat natürlich mit der Mimik nichts zu tun.


Wenn ich die Sache richtig sehe:

Quellcode:
DISK procedure
      entry
    callr    _disk_in    !Hardware init!

    ldl    rr2, rr4
    ld    r4, #PIOAD
    ld    r5, #PIOBD
    ld    r0, #WDATA+OUTPUT
    outb    @r5, rh0    !Datentreiber auf Ausgabe!
    outb    PIOAC, rl0    !Daten-PIO auf Ausgabe!

    ldb    rh0, #%10
wrea0:    ld    r1,#%ffff
wready:    inb    rl0, @r5
    andb    rl0, #%7
    cpb    rl0, #%7
    jr    nz,wrea1
    djnz    r1,wready
    dbjnz    rh0, wrea0

..lädt er erst #WDATA+OUTPU, d.h. 0x0 +0x0f = 0x000f in R0 und schafft das H byte
auf PIOBD also auf die Daten, danach nimmt er r0l und schreibt die 0x0f auf PIOC, das Controlwort für Kanal A (Nicht im Kopf was er da macht, aber kommentiert wird es damit das der DatenPIO auf Ausgabe geschaltet wird).
Danach lädt er längliche Schleifenzähler (rh0 0x10, r1 0xffff), holt von PioB die Daten, macht ein And 0x07 und vergleicht das Ergebnis mit 0x7. So lange das Ergebnis 7 ist, dreht der sich im Kreis bis seine Zählschleife runtergezählt ist und fällt auf einen Timeout Fehler.
Falls das Ergebnis nicht 7 sein sollte, springt er auf wrea1 und wertet dort den Status 6 und 1 aus. Ist der Status 1 freut er sich und hüpft nach wrea2 um dort mit der Kommandoausgabe zu beginnen. Ist der Status 6 lädt er r2 mit dem Fehlercode 20 und springt raus, wenn nicht lädt er r2 mit c1 und springt auch raus.

Damit müßtest Du wissen was Du machen sollst...

Gruß,
Holm
--
float R,y=1.5,x,r,A,P,B;int u,h=80,n=80,s;main(c,v)int c;char **v;
{s=(c>1?(h=atoi(v[1])):h)*h/2;for(R=6./h;s%h||(y-=R,x=-2),s;4<(P=B*B)+
(r=A*A)|++u==n&&putchar(*(((--s%h)?(u<n?--u%6:6):7)+"World! \n"))&&
(A=B=P=u=r=0,x+=R/2))A=B*2*A+y,B=P+x-r;}
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
059
28.05.2012, 00:31 Uhr
Olli

Avatar von Olli

So... nun hab ich mir auch nochmal n Kopf gemacht.

Zu deinen Anmerkungen:
a) "Daten-PIO" muesste dann ja Port-A sein.
b) Dort sollte er ja nach meinem Verstaendniss her, eigentlich den Kommandocode hin ausgeben - gefolgt von den Daten.
c) Der 0x07-Vergleich checkt, ob in Status0-3 111 stehen. Sind sie offensichtlich per Default. Deswegen schreibe ich ja eigentlich 0 auf die Statusleitungen.

Nun mal zur PIO.

Der Port-A sollte ja als bidirektional konfiguriert werden. Somit kann ich also nur Daten Lesen, wenn ich ASTB auf Low setze. Dadurch, das ich es auf High setze und dem Transistor, kommt dann bei der PIO Port-A LOW an -> Daten werden bereit gestellt - korrekt? Muss ich es danach auf High an der PIO setzen? Wenn ja, brauche ich da einen H-L-H Wackler? Wenn ja, wie lange Zeitabstaende?

Port-B - dort sollte mir eigentlich an B5 eine 0 gesetzt werden, damit bei mir bei /RESET eine 1 ankommt - wo genau passiert das? Das TR was ich setze, geht auf B7 des Port-B.

Was ich auch nicht schnalle. Nachdem ich 0x80 (Reset-Pin auf 1) von Port-C lese, und dann z.B. folgendes ausgebe:

#define STATUS0 DDC0
#define STATUS1 DDC1
#define STATUS2 DDC2
#define STB DDC3

PORTC |= (1 << STATUS0);
PORTC |= (1 << STATUS1);
PORTC |= (1 << STATUS2);
PORTC |= (1 << STB);

Und dann nochmal Pin-C einlese, lese ich 0x83 zurück. Aber das ergibt doch keinen Sinn. Müsste ich nicht 0x8f (1000 1111) zurücklesen?

http://www.krummsdorf.de/files/hobby/project.html da sind auch noch ein paar LA-Ausgaben.
--
P8000 adventures: http://pofo.de/blog/?/categories/1-P8000

Dieser Beitrag wurde am 28.05.2012 um 02:06 Uhr von Olli editiert.
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
060
28.05.2012, 09:37 Uhr
holm

Avatar von holm

...wieso hantierst Du hier mit den Data Direction Register Bits?

->#define STATUS0 PC0

Möglicherweise ist das identisch definiert (0x1) aber komisch ist das schon.

->PORTC|=((1<<STATUS0)|(1<<Status1)|(1<<STATUS2));

Das Einlesen von Ausgabebits liest nicht den ausgegebenen Registerwert zurück, sondern den tatsächlich am Port vorhandenen Pegel. Miß doch mal die Spannung nach der Ausgabe an PC3.


>Zu deinen Anmerkungen:
>a) "Daten-PIO" muesste dann ja Port-A sein.
>b) Dort sollte er ja nach meinem Verstaendniss her, eigentlich den Kommandocode hin ausgeben - gefolgt von den Daten.

Ja sieht so aus, gucke doch einfach in die Assembler Quelle. PIOAC wird wohl das Control Byte des Ports A sein, PIOAD der Datenport.


>c) Der 0x07-Vergleich checkt, ob in Status0-3 111 stehen. Sind sie offensichtlich per Default. Deswegen schreibe ich ja eigentlich 0 auf die Statusleitungen.

Ja, nur läuft die Mimik auf ein Timeout falls das so bleibt. Wenn die Zeitschleife rum ist, fällt der Z8000 automatisch auf errc1: und sollte den Laden mit einem Fehler verlassen.

Der Z8000 erwartet erst 0x07 (Status 0-2 inaktiv) und wartet dann auf Status 1, d.h..
Status1 und Status2=aktiv=low.
Ich weiß jetzt nicht was das Restet im WDC bewirkt, möglicherweise wird es durch den 8127
differenziert und auch wenn Reset Low bleibt läuft der Rechner an...?

Gruß,

Holm
--
float R,y=1.5,x,r,A,P,B;int u,h=80,n=80,s;main(c,v)int c;char **v;
{s=(c>1?(h=atoi(v[1])):h)*h/2;for(R=6./h;s%h||(y-=R,x=-2),s;4<(P=B*B)+
(r=A*A)|++u==n&&putchar(*(((--s%h)?(u<n?--u%6:6):7)+"World! \n"))&&
(A=B=P=u=r=0,x+=R/2))A=B*2*A+y,B=P+x-r;}

Dieser Beitrag wurde am 28.05.2012 um 09:38 Uhr von holm editiert.
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
061
28.05.2012, 10:37 Uhr
Olli

Avatar von Olli

Habe jetzt folgenden Code


Quellcode:
#define wdc_reset()                    ((PINC) & (1 << PINC7))
#define STATUS0 PINC0
#define STATUS1 PINC1
#define STATUS2 PINC2
#define STB PINC3
#define TE PINC4
#define RDY PINC5
#define TR PINC6
#define RESET PINC7

main(){
    DDRA=0x00;
    DDRC=0x4f;

    PORTA = 0x00;
    PORTC = 0x00;
    while(1)
    {
        while(! wdc_reset())
        {

            PORTA = 0x00;
            PORTC = 0x00;
        }

        DDRA = 0x00;   // Port A auf Lesen
        PORTC |=  (1 << STATUS0)|(1 << STATUS1)|(1 << STATUS2);
        PORTC |=  (1 << STB);

        while(1){
        uart_puts_p(PSTR("PINA: "));
        uart_putc_hex(PINA);
        uart_putc('\n');
        uart_puts_p(PSTR("PINC: "));
        uart_putc_hex(PINC);
        uart_putc('\n');
        }        
    }    
    return 0;
}

Wenn ich mich in der inneren while(1) Schleife befinde, also der 16-Bit-Teil angelaufen ist, messe ich folgende Pegel:

habe schrott gemessen..... editiere gleich den Beitrag nochmal.


0-3 kommen mir spanisch vor.... die habe ich doch auf 1 gesetzt?

Wo erkennst du, das er im Status erstmal 111 erwartet? Ich habe nur gesehen, das er wartet bis kein 111 mehr vorkommt -> also muss es auch nie vorkommen. Danach -> wenn es nicht mehr (oder noch nie ) vorkommt, prüft er auf Status 1. Aber irgendwie fehlt mir der ganze /Reset-Teil. Kann es sein, das vor dem DISK Teil im Monitor noch was anderes passiert und er den evtl. gar nicht erst aufruft?

Wenn otto11 was sagen koennte waere das auch hilfreich, er hat das doch schon alles durch
--
P8000 adventures: http://pofo.de/blog/?/categories/1-P8000

Dieser Beitrag wurde am 28.05.2012 um 10:44 Uhr von Olli editiert.
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
062
28.05.2012, 10:51 Uhr
Olli

Avatar von Olli

So... meine Messungen.

Ohne angeschlossenen P8000, alle Ports auf Ausgang, alle Ports auf 1 - ich messe:

pc0 5,10
pc1 5,10
pc2 5,10
pc3 0,83
pc4 5,10
pc5 5,10
pc6 5,10
pc7 5,10

pc3 ist schonmal sehr verdächtig.


angeschlossener P8000, 0x4f als Port-C definition. Nach anliegendem /RESET (also aktivem 16-Bit Monitor) und PC0-4 auf1 (Der Code aus dem Beitrag hier drüber läuft ab):

pc0 5,10
pc1 5,10
pc2 5,10
pc3 0,92
pc4 4,98
pc5 4,67
pc6 0,00
pc7 4,67
--
P8000 adventures: http://pofo.de/blog/?/categories/1-P8000

Dieser Beitrag wurde am 28.05.2012 um 10:52 Uhr von Olli editiert.
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
063
28.05.2012, 11:07 Uhr
Olli

Avatar von Olli

Sobald ich die Verbindung zw. Widerstand und Basis von 1T1 kappe, liegen 5V an.
Kappe ich die Verbindung von 1T1 und der Masse am Emitter, liegen 2.73V an.

Ist der Transistor fratze?

Edit: mit nem neuen Transistor das gleiche Trauerspiel..... ich schnall auch immer noch nicht die 2.66V die im Power-Off aber mit angeschlossenem P8000 auf der 5V Schiene anliegen.
Mit totem 16-Bit-Teil, liegen sie nicht an, wenn man den /RDY-Pin wegknickt.
Mit aktivem 16-Bit-Teil liegen sie jedoch an, auch wenn der /RDY-Pin kein Kontakt hat.... da muessen die von woanders kommen...

so langsam.... grrrrrr
--
P8000 adventures: http://pofo.de/blog/?/categories/1-P8000

Dieser Beitrag wurde am 28.05.2012 um 11:17 Uhr von Olli editiert.
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
064
28.05.2012, 11:21 Uhr
otto11



Hey, hier gehts aber ab!
Aber was macht ihr bei dem schönen Wetter am Labortisch???

Ich konnte die Beiträge nur mal schnell überfliegen und hier ein paar Bemerkungen:

Die Pegel und Signalbezeichnungen beziehen sich auf den Steckverbinder aus der Sicht WDC.

RESET ist ein Eingang vom P8000 und ist High-Aktiv! Der WDC wird mit H rückgesetzt und macht nichts, bis RESET nach Low geht.

@Holm
Read modify write ist normal. Dazu ist hier aber nicht genug Zeit. Der Compiler soll das benötigte Bitmuster schon zusammensetzen und mit nur einem Ausgabebefehl herausschreiben. Und zur besseren Lesbarkeit gibt es auch ein #define WDCBUSY 0x00.
Bei dem "Motorroller" gibt es übringens nicht solchen Unsinn mit Ausgabe H oder L auf ein Portbit, damit die Pullups eingeschaaltet werden! dafür gibt es ein Register :-)

Gruß
Jürgen
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
065
28.05.2012, 11:27 Uhr
holm

Avatar von holm

Die Schwellspannung des Transistors (die Spannung ab der die BE-Strecke zu leiten anfängt) beträgt ca. 0,7V. Du hast von Port PC3 eigentlich einen 1,8K Widerstand zu Basis?
Da fließen 5V-0,7V = 4,3V; I=U/R; I= 4,3/1.8; I=2,38mA in die Basis, da sollte der Ausgang von PortC eigentlich noch volle Spannung liefern (Es sei denn das Bein ist fälschlicherweise als Eingang definiert).
Ich denke mal eher das Portbein PC3 ist frittiert, war das nicht auch das mit den ominösen Startschwierigkeiten beim Netzteil?
Mache mal den Kollektor ab und messe nochmal die Spannung an PC3 bei 0 und 1 Pegel.
Den Transistor kannst Du mit dem Diodentest Deines Multimeters relativ einfach testen,
die Ersatzschaltung muß sich wie 2 Dioden mit gemeinsamen Anoden an der Basis verhalten.
Bei Miuns an der Basis darf nichts leiten (zu C und E) und die dürfen auch untereinander (C-E und E-C) keinen Durchgang haben.

Gruß,

Holm


PS: Du verarschst mich mit Deinen Definitionen:

#define STATUS0 PINC0
#define STATUS1 PINC1
#define STATUS2 PINC2
#define STB PINC3
#define TE PINC4
#define RDY PINC5
#define TR PINC6
#define RESET PINC7

Wieso nun wieder PINC? Vorher hattest Du DDC, nimm doch mal PC0, PC1...

Ok, offensichtlich ist das Wurscht (aus dem Header iom64.h, Atmega64):

/* Port C Data Register - PORTC */
#define PC7 7
#define PC6 6
#define PC5 5
#define PC4 4
#define PC3 3
#define PC2 2
#define PC1 1
#define PC0 0
/* Port C Data Direction Register - DDRC */
#define DDC7 7
#define DDC6 6
#define DDC5 5
#define DDC4 4
#define DDC3 3
#define DDC2 2
#define DDC1 1
#define DDC0 0
/* Port C Input Pins - PINC */
#define PINC7 7
#define PINC6 6
#define PINC5 5
#define PINC4 4
#define PINC3 3
#define PINC2 2
#define PINC1 1
#define PINC0 0
...
bliebe noch die Frage warum Du gerne viel schreibst.
--
float R,y=1.5,x,r,A,P,B;int u,h=80,n=80,s;main(c,v)int c;char **v;
{s=(c>1?(h=atoi(v[1])):h)*h/2;for(R=6./h;s%h||(y-=R,x=-2),s;4<(P=B*B)+
(r=A*A)|++u==n&&putchar(*(((--s%h)?(u<n?--u%6:6):7)+"World! \n"))&&
(A=B=P=u=r=0,x+=R/2))A=B*2*A+y,B=P+x-r;}

Dieser Beitrag wurde am 28.05.2012 um 11:35 Uhr von holm editiert.
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
066
28.05.2012, 11:36 Uhr
Olli

Avatar von Olli

@otto11:

Was genau muss denn passieren, nachdem dann am /RESET-Pin 1 anliegt?


@holm:

Ne, das mit dem Netzteil war ein anderer Pin.
1,8k - ja - auch nochmal nachgemessen
Warum den Kollektor abmachen? Das Fehlerbild ist doch auch das gleiche, wenn auf der P8000 nicht angeschlossen ist - dann ist am Kollektor doch nur ein Kupferdraht ohne Ziel?
Ohne angeschlossenen Transistor liefert der Pin übrigens 5V bei 1.

@gerne viel schreiben.
Mein ATmel Studio kannte PC0 nicht in der Auto-Completion. (aber die scheint auch erst nach dem 4. Buchstaben zu beginnen die Auto Completion). Ich ging daher davon aus, das PC0 undefined ist Das die aber alle gleich definiert sind, hatte ich auch schon gesehen von daher auch nicht so viel Energie dadrauf jetzt verwendet.
--
P8000 adventures: http://pofo.de/blog/?/categories/1-P8000

Dieser Beitrag wurde am 28.05.2012 um 11:38 Uhr von Olli editiert.
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
067
28.05.2012, 11:45 Uhr
holm

Avatar von holm

@Otto11:

>RESET ist ein Eingang vom P8000 und ist High-Aktiv! Der WDC wird mit H rückgesetzt und macht nichts, bis RESET nach Low geht.

..dann müßte Olli den aber mal wackeln sehen bzw. seine Schleife müßte verlassen werden..

>Read modify write ist normal. Dazu ist hier aber nicht genug Zeit. Der Compiler soll das benötigte Bitmuster schon zusammensetzen
> und mit nur einem Ausgabebefehl herausschreiben. Und zur besseren Lesbarkeit gibt es auch ein #define WDCBUSY 0x00.

Der Compiler fasst das aber auch in der Form (1<<foo)|(1<<bar) zusammen, das macht schon der Präprozessor denke ich. Damit bleibt dann einfach nur noch Portx|=0x03 übrig.
Die Schreibweise dient eigentlich nur der Lesbarkeit und der Vermeidung von Glitches am Port.

In wie fern das mit den Pullups beim Atmel unsinnig ist, darüber kann man sich sicher zanken, wenn man das weis, macht das i.A. keine Probleme.
Es ist auch hier nicht wirklich kritisch, da die Eingänge von der Logik getrieben werden und auf die Pullups nicht wirklich angewiesen sind.
Der Atmel macht bei knapp 20Mhz Takt hier wirklich auch 20Mips, wieso denkst Du das der zur Abfrage einer mit 4Mhz getakteten Maschine zu langsam sein sollte?. Ok, im Original ist da Hardware im Spiel, das hatten wir ja schon eher mal diskutiert. Ich denke aber nicht, das es an der Stelle an der Olli jetzt herum tritt zu Problemen kommen sollte, kritisch wird das erst beim Blocktransfer.

Gruß,

Holm
--
float R,y=1.5,x,r,A,P,B;int u,h=80,n=80,s;main(c,v)int c;char **v;
{s=(c>1?(h=atoi(v[1])):h)*h/2;for(R=6./h;s%h||(y-=R,x=-2),s;4<(P=B*B)+
(r=A*A)|++u==n&&putchar(*(((--s%h)?(u<n?--u%6:6):7)+"World! \n"))&&
(A=B=P=u=r=0,x+=R/2))A=B*2*A+y,B=P+x-r;}

Dieser Beitrag wurde am 28.05.2012 um 11:46 Uhr von holm editiert.
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
068
28.05.2012, 12:11 Uhr
Olli

Avatar von Olli

@Holm.

es läuft ja so ab:

- P8000 angeschaltet
- ATMega angeschaltet
- mein ATMega ist in der !wdc_reset() Schleife gefangen
- P8000 "x"-Eingabe
- P8000 NMI-Knopf
- P8000 Selbsttest läuft ab
- mein ATMega verläßt die !wdc_reset() Schleife (/RESET liegt an)
- nun führt der ATMega die Hauptschleife ab, und betritt nie wieder die !wdc_reset() Schleife, da das immer false ergibt.
- P8000 RESET-Knopf gedrückt
- mein ATMega ist wieder in der !wdc_reset() Schleife gefangen

soweit alles toll.

Aber:

- was muss nach dem Verlassen der reset-Warte-Schleife passieren
- warum habe ich 0.92V auf meinem STB-Pin
- warum liegt Spannung an, wenn das ATMega-Board aus ist


- kann ich die beiden Transistoren einfach mal aus der Schaltung entfernen und den ATMega direkt anschliessen oder sind die Widerstände am P8000 an den Leitungen "zu hoch"?
--
P8000 adventures: http://pofo.de/blog/?/categories/1-P8000
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
069
28.05.2012, 12:28 Uhr
Enrico
Default Group and Edit



Zitat:
Olli schrieb
Sobald ich die Verbindung zw. Widerstand und Basis von 1T1 kappe, liegen 5V an.
Kappe ich die Verbindung von 1T1 und der Masse am Emitter, liegen 2.73V an.

Ist der Transistor fratze?


Bist Du dir da sicher, dass Du dich da mit der Port schalterei nicht verhauen hast?
Du kannst doch jeden Port auf einzeln auf Eingang oder Ausgang schalten.
Aussedem gibts noch einen sehr hochohmigen Pullup im AVR, ca. 20k.

Wenn Du z.B. PC3 statt auf Ausgang auf Eingang programmiiert hast, könnte das das erklären. Das steurt da der inrgendwie und nur so halb durch.
--
MFG
Enrico
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
070
28.05.2012, 13:00 Uhr
otto11




Zitat:
Olli schrieb
@Holm.

es läuft ja so ab:

- P8000 angeschaltet
- ATMega angeschaltet
- mein ATMega ist in der !wdc_reset() Schleife gefangen
- P8000 "x"-Eingabe
- P8000 NMI-Knopf
- P8000 Selbsttest läuft ab
- mein ATMega verläßt die !wdc_reset() Schleife (/RESET liegt an)
- nun führt der ATMega die Hauptschleife ab, und betritt nie wieder die !wdc_reset() Schleife, da das immer false ergibt.
- P8000 RESET-Knopf gedrückt
- mein ATMega ist wieder in der !wdc_reset() Schleife gefangen

soweit alles toll.

Das ist alles genau richtig! Der Reset-Eingang dient nur zur Synchronisation/Befehlsabbruch/Reset, wenn der Resetknopf am P8000 gedrückt wird.


Zitat:
Aber:

- was muss nach dem Verlassen der reset-Warte-Schleife passieren
- warum habe ich 0.92V auf meinem STB-Pin
- warum liegt Spannung an, wenn das ATMega-Board aus ist

Nach dem Verlassen der Resetschleife wird der WDC wohl ein Kommando vom P8000 haben wollen!
Ist ja wohl Sinn und Zweck der Sache :-) D.h. Du gibst den Status 0x01 aus = Bereit Kommando Lesen.
Danach wird WDCBUSY ausgegeben, das Kommando dekodiert und entsprechend mit Daten Lesen oder Schreiben zum P8000 fortgesetzt.
Orientiere Dich an meinen LA-Diagrammen wie es dabei weiter geht.
0,92V am STB-Pin: Ich tendiere auch zur Vermutung von Enrico! Um die 3V am /STR bzw. /TR kommt von der kräftigen Widerstandsbeschaltung 215/332 Ohm als Spannungsteiler. Dieser kann gegebenenfalls auch ein Stück ATMega-Baord "rückwärts" mit versorgen, wenn das Board aus ist!

Gruß
Jürgen
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
071
28.05.2012, 13:38 Uhr
holm

Avatar von holm

Olli schreibt, das er 0x4f auf das Datenrichtungsregister schreibt, das hieße


Quellcode:
76543210
EAEEAAAA

Betrffs der Datenrichtungen, PC3 aka STB wäre also richtig als Ausgang programmiert, mich wundert nur die geringe Stromlieferfähigkeit auch etwas.

Das da 0.9v anliegen ist eigentlich erst mal Rille, Hauptsache der Kollektor des Transistors zieht dann auch die STB Leitung auf Low, d.h. unter 0,8V wenn auf dem Portpin eine 1 ausgegeben wird.

Das mit der Rückwärtsversorgung sehe ich auch so.
Gruß,

Holm
--
float R,y=1.5,x,r,A,P,B;int u,h=80,n=80,s;main(c,v)int c;char **v;
{s=(c>1?(h=atoi(v[1])):h)*h/2;for(R=6./h;s%h||(y-=R,x=-2),s;4<(P=B*B)+
(r=A*A)|++u==n&&putchar(*(((--s%h)?(u<n?--u%6:6):7)+"World! \n"))&&
(A=B=P=u=r=0,x+=R/2))A=B*2*A+y,B=P+x-r;}
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
072
28.05.2012, 15:57 Uhr
Micha

Avatar von Micha

eine gemeine Stolperfalle ist bei den Atmegas das JTAG Interface bzw. die ensprechende Fuse-Einstellung. Wenn das JTAG-Fuse-Bit gesetzt ist, kann ein bestimmtes Pin als Ausgang keine Leistung treiben. Wäre einen Blick wert, da das beim 1284P auf Port C liegt.

Ich hab mich wegen dieses Verhaltens mal halb zu tode gesucht bzw. den ersten Atmel weggeworfen
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
073
28.05.2012, 16:00 Uhr
Olli

Avatar von Olli

Sorry das ich so drauf rumreite, aber ich denke, solange kein sauberes STB generiert werden kann, brauche ich nicht weiter machen, oder?

Also... ich verweise nochmal auf meinen Testfall oben

1.) folgendes kleines C-Programm


Quellcode:
main()
{
DDRC=0xff;
PORTC=0xff;
while(1) asm("nop");
}

2.) Nichts am ATMega angeschlossen, kein RS232, kein P8000 - nur die blanke Schaltung unter http://pofo.de/tmp/P8000_WDC_SDCard.pdf

3.) 0.92V an PC3... warum?

4.) Biege ich den PC3-Pin weg, liegen 5V an.

----> PC6 ist genauso verschaltet wie PC3- aber liefert schöne 5V.

Bei dem funktionierenden Pin PC6 lässt sich übrigens folgendes Messen:

- Ausgang ATMega 5V
- vor dem Widerstand 5V
- nach dem Widerstand 0.74V
- Kollektor des Emitters 0.01V

Beim nicht funktionierenden Pin PC3 lässt sich folgendes Messen:

- Ausgang ATMega 0,83V
- vor dem Widerstand 0,83V
- nach dem Widerstand 0.62V
- Kollektor des Emitters 0.01V

Kann es sein, das PC3 Schrott ist? Er zwar 5V liefert, aber sobald was "dranhaengt", die Spannung abfällt?

Achso... ich habe auch mal 0x00 auf den Port geschrieben. An PC3 liegt dann auch 0.83V an. Am Ausgang beider Transistoren liegt dann aber 0.01 bzw. 0.03V an.....ääääh wie soll das funktionieren? Irgedwann muss doch auchmal ein High-Pegel da rauskommen? nehmen wir mal PC6. Ich habe Ihn auf 1 gesetzt - beim Transistor kommen 0.01V raus. Ich habe Ihn auf 0 gesetzt - beim Transistor kommen 0.03V raus...... ääääh da kommt nie high raus?! Ist der BC548A evt. doch ungeeignet??
--
P8000 adventures: http://pofo.de/blog/?/categories/1-P8000
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
074
28.05.2012, 16:01 Uhr
Olli

Avatar von Olli

Aaaaaaah JTAGEN Fuse ist gesetzt!!!

ich probiere gleich nochmal weiter - ich muss eben weg - mehr danach!
--
P8000 adventures: http://pofo.de/blog/?/categories/1-P8000
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
075
28.05.2012, 16:39 Uhr
holm

Avatar von holm

Aus dem Transistor Kollektor "kommt nie etwas raus". Der kann Etwas angeschlossenes (P8000) nur auf Masse ziehen!

Olii, das ist "open Kollektor", aus einem D103 kommt auch nix raus. Ja die JTAGEN Fuse solltest Du löschen.

Gruß,

Holm
--
float R,y=1.5,x,r,A,P,B;int u,h=80,n=80,s;main(c,v)int c;char **v;
{s=(c>1?(h=atoi(v[1])):h)*h/2;for(R=6./h;s%h||(y-=R,x=-2),s;4<(P=B*B)+
(r=A*A)|++u==n&&putchar(*(((--s%h)?(u<n?--u%6:6):7)+"World! \n"))&&
(A=B=P=u=r=0,x+=R/2))A=B*2*A+y,B=P+x-r;}
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
076
28.05.2012, 17:03 Uhr
Olli

Avatar von Olli

so - ohne JTAGEN Fuse kommen überall 5V aus den Pins wenn ich sie mit 0xff beschreibe - Problem 1 also gelöst. Das Thema warum Spannung anliegt ist auch geklärt... also baue ich nun mal den ganzen losen Drahtverhau zurück und dann nochmal zurück auf Anfang
--
P8000 adventures: http://pofo.de/blog/?/categories/1-P8000
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
077
28.05.2012, 17:36 Uhr
Olli

Avatar von Olli

So.... nun hängt die P8000 wieder an der Schaltung.
Der Selbsttest rauscht nun auch nicht einfach so durch, sondern braucht bei jedem Testschritt etwas länger.

Leider ist das Programm von otto11 unvollständig - docommands() ist leider nirgends definiert. Ich habe also mal gemacht was otto11 schrieb. Ich habe nachdem /RESET anliegt, einfach mal auf den Statusleitungen 0x01 ausgegeben (WDCGCMD). Bewirkt irgendwie nix.

1. /RESET liegt an vom P8000
2. ATMega legt 0x01 auf den Status
3. Auslesen von PINA führt zu 0xff
4. Auslesen von PINC führt zu 0x91 --> /RESET, /TE, STATUS0

Und genauso bleibt es auch - da ändert sich nix....

Wenn ich mir den unvollständigen main() Code von otto11 anschaue...


Quellcode:
// 9 Byte Kommando empfangen + Fertigmeldung fuer letzten Befehl ohne Fehler!    
        LED3off();
        DDRA = 0x00;   // Port A auf Lesen
      cmdcnt =0;
       datapt = &cmdbuffer[0];
      PORTB = ( WDCGCMD ); // /TR + /STB inactiv, + WDCstatus ausgeben!
      while (( PORTB & 0x10 ) == 0x00); // wait for /TE = 1
         while (( PORTB & 0x20 ) == 0x00); // wait for /RDY = 1
      DISABLE_INTERRUPTS();
      while ( cmdcnt < 9 ) {
       while (( PORTB & 0x20 ) == 0x20); // wait for /RDY = 0    
       PORTB = ( STB | WDCGCMD );  // /STB active;  Zeit > 150ns ... 200ns für UA855 Pio
                       // Breite /STB = 640ns bei 6MHz ECLOCK ohne nop
                       // Breite /STB = 470ns bei 30MHZ ohne nop  / 3,2 us Abstand, original ca. 200ns breit!
                       // Breite /RDY = 1,26 us   Messwerte! 4.2.12
       *datapt++ = PORTA;  // data lesen    
       PORTB = (WDCGCMD );  // / STB inactive
       while (( PORTB & 0x20 ) == 0x00); // wait for /RDY = 1    
          cmdcnt++;    
       }  // while cmdcnt < 9
      PORTB = ( WDCBUSY ); // TR + STB inactiv, + WDCstatus ausgeben !
      ENABLE_INTERRUPTS();
      wdcstatus = 0x00; // Status noch nicht ausgeben, Zeit gewinnen in 1. Schleife Host

Frage ich mich doch ernsthaft, wie das funktionieren soll?
1. While-Schleife Laut Kommentar wartet die, das /TE auf 1 steht. /TE steht aber auf eins, wenn ein Bit-AND mit 0x10 0x10 zurückliefert und nicht 0x00! verstehe also schonmal den Kommentar nicht.... bei mir steht mit 0x91 /TE auf 1. Danach wird /RDY abgefragt und gewartet bis es auf 1 steht.... steht bei mir nie auf 1. Dann in der nächsten while Schleife ist nochmal eine while Schleife die wartet bis /RDY wieder auf 0 ist.... wie soll das funktionieren? Grob gesagt...

PORTB = ( WDCGCMD );
while (( PORTB & 0x10 ) == 0x00);
while (( PORTB & 0x20 ) == 0x00);
while (( PORTB & 0x20 ) == 0x20);

Würde ja bedeuten:
- Wir Setzen STATUSß
- Wir Warten bis /TE auf 0 geht
- Wir Warten bis /RDY auf 0 geht
- Wir Warten bis /RDY auf 1 geht

Die Kommentare im Quellcode sagen etwas komplett anderes aus.... und mein PINC bleibt konstant auf 0x91 wenn ich STATUS0=1 anlege.... da tut sich nix.... Bahnhof?
--
P8000 adventures: http://pofo.de/blog/?/categories/1-P8000
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
078
28.05.2012, 17:57 Uhr
Olli

Avatar von Olli

aktueller code:


Quellcode:
int main()
{

    set_sleep_mode(SLEEP_MODE_IDLE);

    uart_init();
    uart_puts_p(PSTR("P8000 WDC Emulator 1.0\n"));

    DDRA=0x00;
    DDRC=0x4f;

    while(1)
    {

        while(! wdc_reset())
        {

            PORTA = 0x00;
            PORTC = 0x00;
        }

        PORTC =  0x01;
        uart_puts_p(PSTR("PIN A/C: "));
        uart_putc_hex(PINA);
        uart_puts_p(PSTR("/"));
        uart_putc_hex(PINC);
        uart_putc('\n');
        
        while(wdc_reset()){
            uart_puts_p(PSTR("PIN A/C: "));
            uart_putc_hex(PINA);
            uart_puts_p(PSTR("/"));
            uart_putc_hex(PINC);
            uart_putc('\n');
        }        
    }    
    return 0;
}    

Setze ich übrigens PORTC auf 0x07 anstelle 0x01, liefert der Hardwaretest sofort einen Fehler bei jedem Testschritt, und PINC enthällt 0xb7 (/RESET, /RDY, /TE, STATUS0-2). Also scheint diese Statusüberprüfung in der P8000 schon entsprechend angesprungen zu werden - also liest er wohl auch mein 0x01 - aber dann gehts irgendwie halt nicht weiter....
--
P8000 adventures: http://pofo.de/blog/?/categories/1-P8000

Dieser Beitrag wurde am 28.05.2012 um 17:58 Uhr von Olli editiert.
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
079
28.05.2012, 17:58 Uhr
Enrico
Default Group and Edit


Müsstest Du mit der Status-Änderung nicht solange warten bis /RST wieder H wird?
Der Z80 vom WDC kann solange ja nichts machen, bis /RST inaktiv wird.
Eventuell wertet die P8000 das ja auch aus.
--
MFG
Enrico
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
080
28.05.2012, 18:15 Uhr
holm

Avatar von holm

Weisste warum bei mir der Maschinist langsam rauskommt?
Ich nehme mir den Rechner um mir Details zu merken, das will ich nicht selber machen.
Wer soll sich denn mit den Bits auskennen?

Sowas:

Quellcode:
while (( PORTB & 0x10 ) == 0x00);

hat eigentlich so auszusehen:

Quellcode:
while(!(PINB & (1<<SIGNALNAME))

Dann kann man sich auch vorstellen was das werden soll.

Du kannst übrigens lange warten das sich auf PORTB etwas ändert wenn Du eigentlich PINB meinst. PORTB ist das AUSGABEREGISTER!

Sowas datapt = &cmdbuffer[0]; geht übrigens auch so: datapt=cmdbuffer;


Gruß,

Holm
--
float R,y=1.5,x,r,A,P,B;int u,h=80,n=80,s;main(c,v)int c;char **v;
{s=(c>1?(h=atoi(v[1])):h)*h/2;for(R=6./h;s%h||(y-=R,x=-2),s;4<(P=B*B)+
(r=A*A)|++u==n&&putchar(*(((--s%h)?(u<n?--u%6:6):7)+"World! \n"))&&
(A=B=P=u=r=0,x+=R/2))A=B*2*A+y,B=P+x-r;}
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
081
28.05.2012, 18:27 Uhr
otto11




Zitat:
Olli schrieb
........
Leider ist das Programm von otto11 unvollständig - docommands() ist leider nirgends definiert. Ich habe also mal gemacht was otto11 schrieb
.........
Wenn ich mir den unvollständigen main() Code von otto11 anschaue...

Es war als ein Ausschnitt des Programmes deklariert! docommands() arbeitet die diversen Kommandos ab. Und etwas sollst Du ja auch noch schreiben :-)


Zitat:
Frage ich mich doch ernsthaft, wie das funktionieren soll?
1. While-Schleife Laut Kommentar wartet die, das /TE auf 1 steht. /TE steht aber auf eins, wenn ein Bit-AND mit 0x10 0x10 zurückliefert und nicht 0x00! verstehe also schonmal den Kommentar nicht....

Also zurück zum Urschleim. :-) Das Programm in einer while-Schleife wartet solange, wie die Bedingung erfüllt ist. Wie der Name schon sagt.
Die angegebene Bedingung wartet, bis eine positive Flanke am entsprechenden Eingang erscheint. Deshalb steht im Kommentar: "wait for /TE=1"

Nochmal: RESET ist = 1, wenn der Z8000 den WDC rücksetzt!

Gruß
Jürgen
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
082
28.05.2012, 18:57 Uhr
Olli

Avatar von Olli


Zitat:
holm schrieb
Weisste warum bei mir der Maschinist langsam rauskommt?
Ich nehme mir den Rechner um mir Details zu merken, das will ich nicht selber machen.
Wer soll sich denn mit den Bits auskennen?

Sowas:

Quellcode:
while (( PORTB & 0x10 ) == 0x00);

hat eigentlich so auszusehen:

Quellcode:
while(!(PINB & (1<<SIGNALNAME))

Dann kann man sich auch vorstellen was das werden soll.

Du kannst übrigens lange warten das sich auf PORTB etwas ändert wenn Du eigentlich PINB meinst. PORTB ist das AUSGABEREGISTER!

Sowas datapt = &cmdbuffer[0]; geht übrigens auch so: datapt=cmdbuffer;


Gruß,

Holm

Holm... das wodrauf du eingehst, ist der Orignalcode von otto11! Der dient mir als Vorlage.... _ich_ mache eh nix auf PORTB, da mein Statusgelumpe an Port-C hängt!

es steht auch oben drüber über dem Code:
Wenn ich mir den unvollständigen main() Code von otto11 anschaue...
--
P8000 adventures: http://pofo.de/blog/?/categories/1-P8000
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
083
28.05.2012, 19:04 Uhr
Olli

Avatar von Olli


Zitat:
otto11 schrieb
Also zurück zum Urschleim. :-) Das Programm in einer while-Schleife wartet solange, wie die Bedingung erfüllt ist. Wie der Name schon sagt.
Die angegebene Bedingung wartet, bis eine positive Flanke am entsprechenden Eingang erscheint. Deshalb steht im Kommentar: "wait for /TE=1"

Nochmal: RESET ist = 1, wenn der Z8000 den WDC rücksetzt!

Gruß
Jürgen

Ich schnalls nicht Jürgen.... "RESET ist = 1, wenn der Z8000 den WDC rücksetzt!" Bei mir ist RESET = 1 und zwar die ganze Zeit so lange der 16-Bit-Teil läuft. Wenn ich deinen Satz so lese, dürfte ja RESET nur ganz kurz 1 sein - ists bei mir aber nicht. Ich hatte ja oben schonmal geschrieben...

- P8000 angeschaltet
- ATMega angeschaltet
- mein ATMega ist in der !wdc_reset() Schleife gefangen
- P8000 "x"-Eingabe
- P8000 NMI-Knopf
- P8000 Selbsttest läuft ab
- mein ATMega verläßt die !wdc_reset() Schleife (/RESET liegt an)
- nun führt der ATMega die Hauptschleife ab, und betritt nie wieder die !wdc_reset() Schleife, da das immer false ergibt.
- P8000 RESET-Knopf gedrückt
- mein ATMega ist wieder in der !wdc_reset() Schleife gefangen

Du sagtest ja, das das so richtig ist. Also liegt /RESET auf 1, solange der 16-Bit-Teil läuft. Soweit so gut. Nur kann ich immer noch nicht erkennen, was dann passieren soll? Du wartest so lange bis /TE=1 ist - OK - kann ich auch, dann warte ich aber halt bis zum Sankt-Nimmerleinstag Wenn ich direkt nachdem /RESET auf 1 geht, also der 16-Bit-Teil läuft, 0x01 auf PORTC schreibe - also STATUS=0x01 setze, dann geht danach /TE nie auf 1. Ich möchte nochmal auf den Code aus 078 verweisen. Ich starte also den ATMega, drücke x auf der P8000 und dann NMI. Das einzige was mir mein ATMega dann auf der UART ausgibt ist:

P8000 WDC Emulator 1.0
PIN A/C: ff/91
PIN A/C: ff/91
PIN A/C: ff/91
PIN A/C: ff/91
PIN A/C: ff/91
PIN A/C: ff/91
PIN A/C: ff/91
PIN A/C: ff/91
PIN A/C: ff/91
PIN A/C: ff/91
PIN A/C: ff/91
PIN A/C: ff/91
PIN A/C: ff/91
PIN A/C: ff/91

und das so lange, bis ich den RESET-Knopf am P8000 drücke. Wenn /TE = 1 wäre, müsste er 0x99 oder ähnliches ausgeben.... macht er aber halt nicht - bzw. sehe ich es nicht.

Edit:
So ein Ablaufplan wäre halt mal ganz nett a lá

- Warte bis /RESET = 1 ist (16-Bit Teil aktiv)
- Warte bis xyz = 1 ist (Kommandocode liegt an zur abholung)
- Setze Pin xyz auf 1
usw.....
oder halt etwas Pseudocode.... Mir ist das /TR /TE /STB /RDY Konzept halt einfach unverständlich.

Weil wie gesagt - nachdem /RESET auf 1 ist, weiss ich einfach nicht, was dann ablaufen muss um weiter zu kommen. Aus dem Quellcode von otto11 werde ich nicht schlau, da ich nicht weiss ob docommands() im switch von 0x00 irgendwas auf den Ports macht, und dann scheint er wohl in 0x01 reinzugehen und die Dinge dort ergeben halt für mich keinen Sinn.... oder meine UART Ausgabe ist einfach zu lahm...
--
P8000 adventures: http://pofo.de/blog/?/categories/1-P8000

Dieser Beitrag wurde am 28.05.2012 um 19:21 Uhr von Olli editiert.
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
084
28.05.2012, 19:26 Uhr
Micha

Avatar von Micha

eine Ablauf-Logik fände ich auch sehr hilfreich!

Dass die UART Ausgabe die Echtzeit-Reaktion stört kann ich mir gut vorstellen. Ich würde mich da wahrscheinlich so drumherum mogeln, dass ich erst mal alle Statusinfos in einem Array aufsammle und die dann per UART hinterher zum PC ausgebe
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
085
28.05.2012, 19:42 Uhr
otto11



Olli,
wegen RESET kann ich jetzt aus dem Stand nicht sagen, ob es da Unterschiede zwischen P8000 und P8000compact gibt. Bei meiner compact ist das Signal am Steckverbinder jedenfalls 1-aktiv.
In der main() gibt es eine Statemachine, die über den switch wdcstatus gesteuert wird.
Die Funktion docommands erhält den aktuellen Kommandocode aus dem Status 1 übergeben, wertet das Kommando aus (SD-Card,Memmory -schreiben,-lesen usw.) und gibt den nächsten erforderlichen Status zurück( Daten lesen, Daten schreiben oder Fehler). docommands schreibt nicht auf die Ports zum Z8000.


Zitat:
.... oder meine UART Ausgabe ist einfach zu lahm...

Das wird es wohl sein, wenn ich mir die Logikanalysator-Diagramme ansehe. Wenn die Zeitangabe im Diagramm stimmt, wovon ich erstmal ausgehe, dauert die Kommandoausgabe ab /TE = 1 etwa 60 us.

Die Firmwarebeschreibung WDC-Firmware, Kapitel 6, ist auch ganz hilfreich.

Gruß
Jürgen

Dieser Beitrag wurde am 28.05.2012 um 19:43 Uhr von otto11 editiert.
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
086
28.05.2012, 20:11 Uhr
Olli

Avatar von Olli

@otto11 also das was bei dir direkt nach dem /RESET ablaeuft ist der Code in dem 0x01 Switch? in 0x00 passiert in docommands() erstmal nix? Weil, zuerst geht er ja bei dir in 0x00 rein - mir ist dann halt nicht klar, wie er von dort in 0x01 kommt. docommands muesste ja 0x01 zurueckliefern dazu.
Dann könnte ich das ja einfach mal nach implementieren? Dann müsste ich aus PORTA den Commandocode lesen können?
--
P8000 adventures: http://pofo.de/blog/?/categories/1-P8000
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
087
28.05.2012, 20:42 Uhr
otto11



@olli
Hmm, das ist dann schon die zweite Ungenauigkeit, die jetzt hier hervor kommt:
Die erste war die Zeile PORTB=(TR|... in 043. Muss heißen PORTB = (WDCBUSY). In der Resetschleife darunter stehts ja richtig. Das resultiert noch aus dem Einbau der Transistortreiber und der damit erfolgten Negation der Signale :-(
Das Gewackel hat aber keine Auswirkungen mehr gehabt.
Wie du richtig bemerkst, ist nicht offensichtlich, wie der Status 0x00 im ersten Durchlauf behandelt wird. Das klappt aber doch, da der cmdbuffer im RAM beim Startup mit 0x00 gelöscht wird (legt der Compiler an).Docommands bekommt also 0x00 als Kommandocode übergeben. In docommands wird dann der status 0x01 zurückgegeben und zum Schluß der cmdbuffer wieder auf 0x00 gelöscht.
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
088
28.05.2012, 20:50 Uhr
otto11



@Olli
Du hast Post.
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
089
28.05.2012, 21:54 Uhr
holm

Avatar von holm

Olli es gibt wohl tatsächlich einen Unterschied der WDC Controller Ansteuerung bezüglich Reset. Wenn ich darüber nachdenke erinnere ich mich da an was. Irgendwie war die Polarität bei den neueren Platinen andersherum. Guck mal bitte in die Schaltpläne.

Gruß,

Holm
--
float R,y=1.5,x,r,A,P,B;int u,h=80,n=80,s;main(c,v)int c;char **v;
{s=(c>1?(h=atoi(v[1])):h)*h/2;for(R=6./h;s%h||(y-=R,x=-2),s;4<(P=B*B)+
(r=A*A)|++u==n&&putchar(*(((--s%h)?(u<n?--u%6:6):7)+"World! \n"))&&
(A=B=P=u=r=0,x+=R/2))A=B*2*A+y,B=P+x-r;}
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
090
28.05.2012, 22:13 Uhr
Olli

Avatar von Olli

So... nachdem nun quasi mal gesagt wurde, das von otto11's Quellcode nach /RESET genau 0x01 ausgeführt wird, war mir das nun klar und ich habe jetzt mal otto11's "get commandocode" Funktion für den ATMega "nachprogrammiert". Noch Quick and Dirty ohne Defines.


Quellcode:
#define wdc_reset()                    ((PINC) & (1 << PINC7))
#define TR  0x40
#define STB 0x08
#define RESET 0x80

#define WDCBUSY  0x00
#define WDCGCMD  0x01
#define WDCRDATA 0x02
#define WDCWDATA 0x03
#define WDCERROR 0x07

int main()
{
    uint8_t cmdbuffer[9];
    uint8_t cmdcnt;
    
    set_sleep_mode(SLEEP_MODE_IDLE);

    uart_init();
    uart_puts_p(PSTR("P8000 WDC Emulator 1.0\n"));

    DDRA=0x00;
    DDRC=0x4f;

    while(1)
    {

        while(! wdc_reset())
        {

            PORTA = 0x00;
            PORTC = 0x00;
        }

        DDRA  = 0x00;
        cmdcnt = 0;
        PORTC = 0x01;
        
        while ( (PINC & 0x10) == 0x00 );
        while ( (PINC & 0x20) == 0x00 );
        while ( cmdcnt < 9 )
        {
            while ( (PINC & 0x20) == 0x20);
            PORTC = ( STB | WDCGCMD );
            cmdbuffer[cmdcnt] = PINA;
            PORTC = ( WDCGCMD );
            while ( (PINC & 0x20) == 0x00 );
            cmdcnt++;
        }
        
        uart_puts_p(PSTR("CMD Buffer:"));
        uart_putc_hex(cmdbuffer[0]);
        uart_putc_hex(cmdbuffer[1]);
        uart_putc_hex(cmdbuffer[2]);
        uart_putc_hex(cmdbuffer[3]);
        uart_putc_hex(cmdbuffer[4]);
        uart_putc_hex(cmdbuffer[5]);
        uart_putc_hex(cmdbuffer[6]);
        uart_putc_hex(cmdbuffer[7]);
        uart_putc_hex(cmdbuffer[8]);
        uart_putc('\n');
    }    
    return 0;
}    

und... es funktioniert - denke ich - jedenfalls kommt was an....!
Die 16-Bit-Testroutine:

P8000 WDC Emulator 1.0
CMD Buffer:18002eaaaa550200ff
CMD Buffer:18002eaaa1ff0200ff
CMD Buffer:08002eaaa1ff0200ff
CMD Buffer:18002e5500000200ff
CMD Buffer:18002e55a1ff0200ff
CMD Buffer:08002e55a1ff0200ff
CMD Buffer:f8c1555500000200ff

Nun bin ich schonmal einen riesen Schritt weiter.
Morgen mache ich den C-Code mal schön, und dann beschaeftige ich mich mal mit der Auswertung.... des Commandocodes

Wodrauf bin ich reingefallen? Richtig - ich habe mir immer schön PINC über mein RS232 ausgeben lassen - aber? Richtig.... eh da mal was über seriell gewackelt ist, und der nächste read kam, war die Flanke von der P8000 schon längst wieder weg.... mit nem LA hätte man das wohl gesehen... aber den habe ich eben nicht. Daher sah es immer aus nach "liegt nie an!"


Achso - wiso hast du das über n Pointer gemacht otto11 und nicht direkt in cmdbuffer[] geschrieben? das letzte Kommando sieht komisch aus.... f8... was soll des sein.. aber ich sehe gerade - Schritt 54 ist ja auch "Test auf invaliden Kommandocode"
--
P8000 adventures: http://pofo.de/blog/?/categories/1-P8000

Dieser Beitrag wurde am 28.05.2012 um 22:26 Uhr von Olli editiert.
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
091
28.05.2012, 22:28 Uhr
otto11




Zitat:
Olli schrieb

.... mit nem LA hätte man das wohl gesehen... aber den habe ich eben nicht. Daher sah es immer aus nach "liegt nie an!"

Mal ohne Werbung, ich hab mir den angeschafft: http://www.watterott.com/de/Open-Logic-Sniffer

Sicher muß man bei den Eingangspegeln aufpassen, daß man nichts zerstört. Aber für <= 5V Systeme finde ich das Teil absolut ausreichend.

Jedenfalls schön, daß es nun Erfolge gibt!
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
092
28.05.2012, 22:44 Uhr
Olli

Avatar von Olli

Ist ja recht billig das Ding. Muss ich mir mal bei Gelegenheit anschauen.

Mal sehn ob ich unter der Woche dazu komme, weiter zu machen um durch den Eigentest zu kommen... ansonsten wieder am Wochenende
--
P8000 adventures: http://pofo.de/blog/?/categories/1-P8000
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
093
29.05.2012, 07:56 Uhr
Olli

Avatar von Olli

bzgl. der Reset-Generierung aus dem Hardwarehandbuch:


Quellcode:
4.2.3. WDC Index 3
Die Weiterentwicklung des WDC fuehrt ueber Index 2 (interner
Arbeitsstand) zum Index 3, der sich dadurch auszeichnet,
dass keine Zusatzleiterkarte mehr vorhanden ist.
Gegenueber den WDC Index 0 und Index 1 ist das Hostinterface
bezueglich des Reset-Signals veraendert. Ab Index 3 ist
dieses Signal high-aktiv (vorher low-aktiv) und liegt an
einem anderen Steckerstift des Hoststeckers. 16-Bit-Karten
ab Index 4 sind mit beiden Signalausgaengen versehen,
koennen also mit WDC-Karten eines beliebigen Index gekoppelt
werden. WDC-Leiterkarten ab Index 3 duerfen jedoch nur mit
16-Bit-Karten ab Index 4 betrieben werden!

Es sollte dann ja funktionieren, wenn man einfach den low-aktiv-Teil entwickelt da damit ja offensichtlich alle 16-Bit-Karten umgehen können.

Wie hast du eigentlich die Reihenfolge der /TE und /RDY Signale erarbeitet auf die ja gewartet werden muss und auf die dann quasi /STB folgt zum CMD-Lesen erarbeitet otto11? Über die Analyse der Logikanalysator-Ausgaben oder über Schaltplan+ASM-Quellen? Das würde mich noch interessieren....
--
P8000 adventures: http://pofo.de/blog/?/categories/1-P8000
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
094
29.05.2012, 09:24 Uhr
Olli

Avatar von Olli

Noch was... Die Kommandos welche mit dem WDC-RAM arbeiten, würde ich auf den ATMega RAM "umbiegen". D.h. ich muss die vom P8000 übergebenen Adressen in ATMega-Adressen umsetzen.


Quellcode:
Data Memory
+----------------------+
|    32 Registers      | 0x0000 - 0x001F
+----------------------+
|   64 I/O Registers   | 0x0020 - 0x005F
+----------------------+
|   160 Ext I/O Reg.   | 0x0060 - 0x00FF
+----------------------+
|    Internal SRAM     |
|       16384x8        | 0x0100 - 0x40FF
+----------------------+

Ich kann also ab 0x0100 den SRAM verwenden, oder? der WDC-RAM beginnt bei 0x2000 - ich müsste also von allen Adressen die mir die P8000 liefert, 0x1f00 abziehen um auf 0x0100 zu kommen, oder?
--
P8000 adventures: http://pofo.de/blog/?/categories/1-P8000
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
095
29.05.2012, 10:10 Uhr
holm

Avatar von holm

..ja, nur solltest Du dem C-Compiler auch sagen was Du vor hast. An deiner Stelle würde ich das nicht absolut umlegen, sondern einfach ein Array in C anlegen in dem Du mit den Offset indizierst mit dem was der WDC liefert. Damit gehst Du der Änderung der Speicherdefinition des Atmels für den GCC aus dem Weg.

Gruß,

Holm
--
float R,y=1.5,x,r,A,P,B;int u,h=80,n=80,s;main(c,v)int c;char **v;
{s=(c>1?(h=atoi(v[1])):h)*h/2;for(R=6./h;s%h||(y-=R,x=-2),s;4<(P=B*B)+
(r=A*A)|++u==n&&putchar(*(((--s%h)?(u<n?--u%6:6):7)+"World! \n"))&&
(A=B=P=u=r=0,x+=R/2))A=B*2*A+y,B=P+x-r;}
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
096
29.05.2012, 17:57 Uhr
Olli

Avatar von Olli

So - ATMega immer hin und her stecken ist doch etwas lästig

Wie kann ich denn am einfachsten einen ISP-Port auf das Board packen?

http://pofo.de/tmp/P8000_WDC_SDCard.pdf

Einfach die SPI-Ports entsprechend der Belegung auf nen Header führen wird ja nicht viel bringen, oder? Das beisst sich doch bestimmt mit der ebenfalls angeschlossenen SD-Card. Das muss doch sicherlich anders gebaut werden? Weiss einer wie?
--
P8000 adventures: http://pofo.de/blog/?/categories/1-P8000
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
097
29.05.2012, 18:06 Uhr
holm

Avatar von holm

Keine Ahnung was das mit der SD Card macht, aber SPI am Atmega geht nicht anders als mit den SPI Anschlüssen. Es gibt aber noch eine Möglichkeit: Serieller Bootlader.

http://www.mikrocontroller.net/articles/AVR_Bootloader_FastBoot_von_Peter_Dannegger

Damit kannst Du Dein Programm über die V.24 hochladen.

Gruß,

Holm
--
float R,y=1.5,x,r,A,P,B;int u,h=80,n=80,s;main(c,v)int c;char **v;
{s=(c>1?(h=atoi(v[1])):h)*h/2;for(R=6./h;s%h||(y-=R,x=-2),s;4<(P=B*B)+
(r=A*A)|++u==n&&putchar(*(((--s%h)?(u<n?--u%6:6):7)+"World! \n"))&&
(A=B=P=u=r=0,x+=R/2))A=B*2*A+y,B=P+x-r;}

Dieser Beitrag wurde am 29.05.2012 um 18:06 Uhr von holm editiert.
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
098
29.05.2012, 18:07 Uhr
Enrico
Default Group and Edit


Zieh doch die Karte beim Programmieren raus.

PS: müsste doch trotzdem gehn. für SD-Karte brauchst Du doch noch ein /CS, zum
programmieren aber nicht.
Beim AVR-Webserver scheint das jedenfalls zu funktionieren.
--
MFG
Enrico

Dieser Beitrag wurde am 29.05.2012 um 18:19 Uhr von Enrico editiert.
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
099
29.05.2012, 18:19 Uhr
Olli

Avatar von Olli

Also mit rausziehen ists getan? Die Widerstände gegen Masse an den Leitungen und so sind nicht weiter wild?
Hatte erst vermutet, das man die SD-Card hinter ner Logik verstecken muss welche einfach inaktiv ist, solange kein /CS anliegt - und das würde man dann für den gewollten Betrieb der SD-Card über nen Port am ATMega setzen. und bei der SPI-Programmierung ists halt nicht gesetzt.
--
P8000 adventures: http://pofo.de/blog/?/categories/1-P8000

Dieser Beitrag wurde am 29.05.2012 um 18:21 Uhr von Olli editiert.
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
100
29.05.2012, 18:21 Uhr
holm

Avatar von holm

Ich denke nicht, probiere das doch einfach.
Evtl. must Du die ISP Taktfrequenz etwas runtersetzen.

Übrigens hatte ich Dir gesagt das das Umstecken zumindest mir auf den Wecker fallen würde :-)

Gruß,

Holm
--
float R,y=1.5,x,r,A,P,B;int u,h=80,n=80,s;main(c,v)int c;char **v;
{s=(c>1?(h=atoi(v[1])):h)*h/2;for(R=6./h;s%h||(y-=R,x=-2),s;4<(P=B*B)+
(r=A*A)|++u==n&&putchar(*(((--s%h)?(u<n?--u%6:6):7)+"World! \n"))&&
(A=B=P=u=r=0,x+=R/2))A=B*2*A+y,B=P+x-r;}
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
101
29.05.2012, 18:26 Uhr
Enrico
Default Group and Edit


Schau doch mal ins Datenblatt, dann siehst Du ja, was Sache ist.

Fürs ISP wird ja auch noch /RESET benötigt. Ev. wird das solange ja auf Masse gezogen. Hab das ja auch nicht im Kopp (kein Platz).
--
MFG
Enrico
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
102
29.05.2012, 18:36 Uhr
otto11



Hihi,
das ist ja dann wieder ein klarer Punktsieg für meinen "Motorroller". Programmieren und Debuggen über exakt 1 Pin ( + Reset)! Diverse Derivate haben sogar eine internen Tracebuffer, der über einen ganz intelligenten Algorithmus gefüllt wird, damit möglichst eine lange Historie hineinpasst.

Musste nochmal gesagt werden :-)

@Olli

Die Reihenfolge von TE und RDY usw habe ich anhand des Schaltplanes und der Datenblätter der Schaltkreise (waren leider nicht mehr online aus dem Gedächtnis abrufbar) entwickelt. Mit dem LA habe ich das später überprüft. Es gibt auch ein paar Signalnamen in der ASM-Quelle p.disk.s. Die scheinen aber am Ende der Entwicklung doch nicht mehr ganz das getan zu haben, was der Name ursprünglich versprach.

Es sind nur die zwei WDC-RAM Schreib und Lesekommandos, die den WDC-RAM behandeln. Ist nur zum Test. Ich habe die Adressen auch willkürlich festgelegt. Für alle anderen Kommandos ist das Brust.
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
103
29.05.2012, 19:59 Uhr
holm

Avatar von holm

@otto11:
Du hast da was mißverstanden, ich habe überhaupt gar nix gegen Motoroller CPUs, eher im Gegenteil. Plaque bekomme ich nur bei Intel. Das "Motorroller" ist also keine Wertung, es ist allenfalls ein Spitzname.
Ich habe auch schon 6809, 68000 und 68010 programmiert (embedded) in Workstations auch 68020 und aufwärts, das sind wunderschöne Architekturen, die kommen gleich nach der PDP11 bzw. haben ja auch von dieser gelernt. BDM ist mir also durchaus ein Begriff.
AVRs und deren Befehlssätze sind von Softwareleuten entwickelt worden, d.h. die Befehlsliste sieht bei weitem nicht so schön regelmäßig aus wie z.B. bei Motorrollern.
PIC geht gar nicht, zumindest das was ich an 12Cxxx und 16[CF]xxx zwischen den Fingern hatte. Das Zeug programmiere ich nur, wenn ich mit Geld dazu gezwungen werde.

Da Du aber Wissenslücken hast: Es gibt auch Atmels mit 1 Draht Programmierung (aka "Debugwire") Ollis Programmer unterstützt auch das. Sowas ist aber meist in kleinen nur 8 beinigen Käfern implementiert. Üblich ist ISP (das was Olli gerade macht), das ist eigentlich ein Standard SPI Interface was auch erklärt warum die SD Card da angespaxt ist und komfortabel ist JTAG. Da ein Atmel sich aber auch selbst flashen kann, gibts auch serielle Bootloader.

Ich kann also speziell bei dem was Du hier zu bemerken für notwendig hältst, keinen Vorteil erkennen, zumal das DEV Board als Dauerplattenersatz für den P8K wohl eher ungeeignet bzw. viel zu teuer ist.

Gruß,

Holm
--
float R,y=1.5,x,r,A,P,B;int u,h=80,n=80,s;main(c,v)int c;char **v;
{s=(c>1?(h=atoi(v[1])):h)*h/2;for(R=6./h;s%h||(y-=R,x=-2),s;4<(P=B*B)+
(r=A*A)|++u==n&&putchar(*(((--s%h)?(u<n?--u%6:6):7)+"World! \n"))&&
(A=B=P=u=r=0,x+=R/2))A=B*2*A+y,B=P+x-r;}

Dieser Beitrag wurde am 29.05.2012 um 20:07 Uhr von holm editiert.
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
104
29.05.2012, 22:01 Uhr
Enrico
Default Group and Edit



Zitat:
holm schrieb
....zumal das DEV Board als Dauerplattenersatz für den P8K wohl eher ungeeignet bzw. viel zu teuer ist.

Gruß,

Holm

Das sehe ich dabei auch als grösstest Problem.
Interessenten gibts bestimmt genug.
--
MFG
Enrico

Dieser Beitrag wurde am 29.05.2012 um 22:02 Uhr von Enrico editiert.
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
105
29.05.2012, 22:30 Uhr
Olli

Avatar von Olli


Zitat:
Enrico schrieb

Zitat:
holm schrieb
....zumal das DEV Board als Dauerplattenersatz für den P8K wohl eher ungeeignet bzw. viel zu teuer ist.

Gruß,

Holm

Das sehe ich dabei auch als grösstest Problem.
Interessenten gibts bestimmt genug.

Ich arbeite ja drann

Habe heute mal den C-Code etwas aufgeräumt und mal in mein Versionskontrollsystem geladen....

http://cvs.laladev.org/index.html/P8000/P8000_WDC_Emulator/P8000_WDC_Emulator/#dirlist

Mal schaun, ob ich morgen zum echten weiterprogrammieren komme.
--
P8000 adventures: http://pofo.de/blog/?/categories/1-P8000
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
106
29.05.2012, 22:55 Uhr
Enrico
Default Group and Edit



Zitat:
Olli schrieb


Habe heute mal den C-Code etwas aufgeräumt und mal in mein Versionskontrollsystem geladen....

Nur gut, dass ich mir das nicht angucken muss, da Du das als fertigen Klotz rausgibst.
--
MFG
Enrico
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
107
30.05.2012, 08:52 Uhr
paulotto



irgendwie funktioniert der Download von uart.c nicht (main.c funktioniert) und wo sind die ganzen Funktionen ala configure() versteckt?
Oder bin ich nur zu blöd, das zu finden?

Gruß,

Klaus

edit: gerade gefunden, wo configure versteckt war...

Dieser Beitrag wurde am 30.05.2012 um 08:53 Uhr von paulotto editiert.
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
108
30.05.2012, 10:13 Uhr
Olli

Avatar von Olli

hm... uart.c müsste auch klappen.
Ich weiss aber noch nicht, ob das auch Bestandteil der finalen Version sein wird. Wenn es dann mal läuft, wird es das ganze auch als ZIP zum Download geben. Ist jetzt erstmal mehr für mich um etwas die Änderungen am Code vorzuhalten. Und configure... jo - ist als Präprozessor-Constante in main.h definiert. Finde ich so etwas lesbarer als das ganze DDR... Geraffel direkt in den Code zu schreiben.
--
P8000 adventures: http://pofo.de/blog/?/categories/1-P8000
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
109
30.05.2012, 18:44 Uhr
Olli

Avatar von Olli

So - Selbsttest läuft nun schonmal fehlerlos durch.

@otto11 - kann es sein, das man zwischen Kommando-abholen und Arbeitsdaten abholen bzw. senden etwas Zeit verstreichen lassen muss? Ich hab gefummelt und gefummelt bis ich einfach mal n for loop mit 1000 NOPs eingebaut habe zwischen beiden Schritten und dann gings.... sieht für mich sehr "hacky" aus - kann man nicht irgendwie "abfragen", ob es weitergehen kann? Ich vermute mal, mit deiner LED-Anschaltung erzwingst du auch einen wait "über Umwege" zwischen beiden Vorgängen?

Morgen werde ich mir dann mal über die Struktur des Programms Gedanken machen bevor ich die weiteren Kommandos implementiere... aktuell ists doch etwas Spagetti-Code-mäßig....
--
P8000 adventures: http://pofo.de/blog/?/categories/1-P8000
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
110
30.05.2012, 20:32 Uhr
holm

Avatar von holm

@Olli: /usr/local/avr/include/util/delay.h .... F_CPU entsprechend setzten...
(das sollte es auch beim avrstudio geben)

Gruß,

Holm
--
float R,y=1.5,x,r,A,P,B;int u,h=80,n=80,s;main(c,v)int c;char **v;
{s=(c>1?(h=atoi(v[1])):h)*h/2;for(R=6./h;s%h||(y-=R,x=-2),s;4<(P=B*B)+
(r=A*A)|++u==n&&putchar(*(((--s%h)?(u<n?--u%6:6):7)+"World! \n"))&&
(A=B=P=u=r=0,x+=R/2))A=B*2*A+y,B=P+x-r;}
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
111
30.05.2012, 20:36 Uhr
Olli

Avatar von Olli

Ah cool... wusste ich nicht
Das verwende ich dann mal - mal sehn wie weit ich runter komme mit den waits
--
P8000 adventures: http://pofo.de/blog/?/categories/1-P8000
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
112
30.05.2012, 20:46 Uhr
holm

Avatar von holm

:-) ja, war mir klar als ich das von den tausend nops las.
__asm volatile ("nop")...

Ich wollte es Dir halt nicht unnötig schwehr machen...
Was hast Du für Optimizer Flags beim Compilieren? Da Du volatile nicht verwendet hast, denke ich mal gar kein -O, ansonsten wäre Dein nop Zeug verschwunden.

*grin*

Holm
--
float R,y=1.5,x,r,A,P,B;int u,h=80,n=80,s;main(c,v)int c;char **v;
{s=(c>1?(h=atoi(v[1])):h)*h/2;for(R=6./h;s%h||(y-=R,x=-2),s;4<(P=B*B)+
(r=A*A)|++u==n&&putchar(*(((--s%h)?(u<n?--u%6:6):7)+"World! \n"))&&
(A=B=P=u=r=0,x+=R/2))A=B*2*A+y,B=P+x-r;}

Dieser Beitrag wurde am 30.05.2012 um 20:48 Uhr von holm editiert.
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
113
30.05.2012, 22:09 Uhr
Olli

Avatar von Olli

ich meine, standardmaessig macht er -O1 - aber ich geh jetzt erstmal ins bett

CMD_WR_WDC_RAM-case ist jetzt mal "schön" gemacht.
Morgen dann die anderen beiden Cases... und dann weitere Cmd-Codes basteln

http://cvs.laladev.org/index.html/P8000/P8000_WDC_Emulator/P8000_WDC_Emulator/main.c?rev=1.4&content-type=text/x-cvsweb-markup
--
P8000 adventures: http://pofo.de/blog/?/categories/1-P8000
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
114
30.05.2012, 22:24 Uhr
holm

Avatar von holm

http://www.rn-wissen.de/index.php/Inline-Assembler_in_avr-gcc

Siehe "Syntax und Semantik"

Gruß,

Holm
--
float R,y=1.5,x,r,A,P,B;int u,h=80,n=80,s;main(c,v)int c;char **v;
{s=(c>1?(h=atoi(v[1])):h)*h/2;for(R=6./h;s%h||(y-=R,x=-2),s;4<(P=B*B)+
(r=A*A)|++u==n&&putchar(*(((--s%h)?(u<n?--u%6:6):7)+"World! \n"))&&
(A=B=P=u=r=0,x+=R/2))A=B*2*A+y,B=P+x-r;}
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
115
30.05.2012, 22:37 Uhr
Micha

Avatar von Micha

Optimierung ist einen Versuch wert, wenn einem bei einem Projekt so langsam die Ressourcen ausgehen, also z.B. Speicher knapp wird. Ohne Notwendigkeit würde ich Optimierung nicht mal in Erwägung ziehen. In erster Linie ist das nur eine Fehlerquelle, wenn die maschinelle Intelligenz meint, irgendwas cleverer machen zu müssen als der Mensch. (Ich kenne sehr wohl das Schlüsselwort volatile und weiss wozu es gut ist)
Aber wie gesagt: solange keine Not an Ressourcen, ist Optimierung einfach überflüssig. Soweit meine 2 Cent zu dem Thema.
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
116
31.05.2012, 07:10 Uhr
holm

Avatar von holm

Di oben genannten delay routinen der AVR Bibliotheken funktionieren ohne eingeschalteten Optimizer nicht richtig Micha. Ich habe schon Projekte gemacht, bei denen in knappen RAM der Atmels Strings bearbeitet werden mussten. Ich habe mit dynamischer Speicherverwaltung und verketteten Listen in dem Ding rumgebastelt damit das überhaupt da rein paßt..
Die Standardeinstellung ist deshalb bei mir -Os.

Gruß,

Holm
--
float R,y=1.5,x,r,A,P,B;int u,h=80,n=80,s;main(c,v)int c;char **v;
{s=(c>1?(h=atoi(v[1])):h)*h/2;for(R=6./h;s%h||(y-=R,x=-2),s;4<(P=B*B)+
(r=A*A)|++u==n&&putchar(*(((--s%h)?(u<n?--u%6:6):7)+"World! \n"))&&
(A=B=P=u=r=0,x+=R/2))A=B*2*A+y,B=P+x-r;}

Dieser Beitrag wurde am 31.05.2012 um 07:12 Uhr von holm editiert.
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
117
31.05.2012, 22:26 Uhr
Olli

Avatar von Olli

So - Statusmeldung heute:
- BTT und PAR (Anzahl Heads, Sektoren usw) im "WDC-RAM" funzen.
- habe mein riesen-main.c mal aufgesplittet in einzelne files wdc_ram.[ch], wdc_if_pio.[ch], wdc_if_sdcard.[ch]

sa.format läuft schonmal soweit, das er loslegen will mit formatieren - aber mein Emulator kennt 0x24 noch nicht

Morgen oder am WE gehts dann los mit den ersten Schritten auf der SD-Card.
--
P8000 adventures: http://pofo.de/blog/?/categories/1-P8000
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
118
31.05.2012, 23:08 Uhr
Enrico
Default Group and Edit


Mal ne Fragen wg. der Neugier zu SD-Karten.
Wenn Du da was drauf schreibst, woher wesit Du, dass dort auch richtig drauf landet?
Meldet die Karte einen Status zurürck, oder muss man nochmal lesen, und
vergleichen bzw. eine CRC, o.ä. bilden?
--
MFG
Enrico
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
119
01.06.2012, 07:16 Uhr
Olli

Avatar von Olli

Die Karte meldet sich. Die hat ja n eigenen Controller drin der das eigentliche schreiben auf den Speicherzellen handelt. Man redet nur mit dem Controller.
--
P8000 adventures: http://pofo.de/blog/?/categories/1-P8000
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
120
01.06.2012, 21:22 Uhr
Olli

Avatar von Olli

So.. formatieren der SD-Card funktioniert auch schonmal - 10 Cylinder a 5 Köpfe dauert ca. 1,80 Sek.

Es hat mich ca ne halbe Stunde gekostet rauszufinden, das mein 512-Byte write per Byte-Loop nicht funzt, weil der Zähler als uint8_t deklariert war, und ich so lange die Schleife laufen liess, bis er 512 erreicht.... nur fing er nach 255 natürlich wieder bei 0 an (8 Bit halt) - erreichte also nie 512..... das haette mein gcc aber auch ruhig mal merken können!

Edit: huch... ich hab ja pro Kopf/Zylinder 18 Sektoren zu formatieren - nicht nur einen - die gemessene Zahl stimmt also nicht ganz - einfach * 18 nehmen geht aber auch nicht da der Kommunikationsoverhead zw. P8000 und WDC nur einmal anfaellt
--
P8000 adventures: http://pofo.de/blog/?/categories/1-P8000

Dieser Beitrag wurde am 01.06.2012 um 21:51 Uhr von Olli editiert.
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
121
01.06.2012, 22:48 Uhr
Enrico
Default Group and Edit


Ich melde mich vorsorglich schon mal für 2 Bausätze und 2 Platinen an (mindestens).
--
MFG
Enrico

Dieser Beitrag wurde am 01.06.2012 um 22:49 Uhr von Enrico editiert.
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
122
01.06.2012, 23:20 Uhr
Olli

Avatar von Olli

Hehe... es wird noch etwas Zeit vergehen. Sofern am Ende alles funktionieren sollte, will ich auf jedenfall noch etwas die Hardware anpassen:

- vernünftige Level-Converter zw 5V und 3.3V für die SD-Card
- SPI der auch mit gesteckter SD-Card keine Fisematenten macht
- "Trennung" der P8000-Schnittstelle vom System so das keine Spannung zurück auf meine 5V-Schiene fließt.

Aber das sind dann alles kosmetische Dinge die ich mir dann ganz am Ende vornehme - bis dahin gehts auch erstmal ohne und die Software ist wichtiger
--
P8000 adventures: http://pofo.de/blog/?/categories/1-P8000
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
123
02.06.2012, 00:46 Uhr
holm

Avatar von holm

...IDE Schnittstelle für "echte" Festplatten...

Gruß,

Holm
--
float R,y=1.5,x,r,A,P,B;int u,h=80,n=80,s;main(c,v)int c;char **v;
{s=(c>1?(h=atoi(v[1])):h)*h/2;for(R=6./h;s%h||(y-=R,x=-2),s;4<(P=B*B)+
(r=A*A)|++u==n&&putchar(*(((--s%h)?(u<n?--u%6:6):7)+"World! \n"))&&
(A=B=P=u=r=0,x+=R/2))A=B*2*A+y,B=P+x-r;}
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
124
02.06.2012, 01:13 Uhr
Olli

Avatar von Olli

Wiso? Ich find SD-Cards sexy - schön klein und handlich. und PATA ist doch auch schon wieder am aussterben
--
P8000 adventures: http://pofo.de/blog/?/categories/1-P8000
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
125
02.06.2012, 02:50 Uhr
Olli

Avatar von Olli

So... Ende für "heute" *gähn*
sa.format, sa.verify, sa.shipdisk und Selbsttest laufen nun fehlerfrei durch

involvierte Kommandos


Quellcode:
#define CMD_WR_WDC_RAM      0x18                /* write data to WDC RAM                  */
#define CMD_RD_WDC_RAM      0x08                /* read data from WDC RAM                 */
#define CMD_RD_PARTAB       0x28                /* read Parameter block from WDC RAM      */
#define CMD_WR_PARTAB       0x78                /* write Parameter block to WDC RAM       */
#define CMD_DL_BTTAB        0x48                /* delete Bad Track Table from WDC RAM    */
#define CMD_RD_BTTAB        0x58                /* read Bad Track Table from WDC RAM      */
#define CMD_WR_BTTAB        0x68                /* write Bad Track Table to WDC RAM       */
#define CMD_FMT_BTT         0x24                /* format a track and provide BTT info    */
#define CMD_ST_PARBTT       0xC2                /* store PAR and BTT on harddisk          */
#define CMD_RD_WDCERR       0x38                /* read error statistics                  */
#define CMD_VER_TRACK       0x44                /* verify track                           */
#define CMD_RD_SECTOR       0x01                /* read data beginning at given sector    */

Morgen wirds dann lustig... dann kommt sa.mkfs ran - erstellen des UNIX-Filesystems
--
P8000 adventures: http://pofo.de/blog/?/categories/1-P8000
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
126
02.06.2012, 02:54 Uhr
Enrico
Default Group and Edit



Zitat:
Olli schrieb
Morgen wirds dann lustig... dann kommt sa.mkfs ran - erstellen des UNIX-Filesystems

Morgen?

Bin gespannt wie ein Flitzebogen, wie schnell es dann ist.
--
MFG
Enrico
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
127
02.06.2012, 19:57 Uhr
Olli

Avatar von Olli

Beim erstellen des Filesystems, scheint der ATMegaam Ende des mkfs 2 mal aus meiner while(1) Schleife rauszufallen und führt main() nochmal aus - oder er resettet sich - k.a.
Jedenfalls habe ich ganz am Anfang von meinem main() eine Start-Ausgabe auf meinen UART. Und die kommt am Ende von meinem mkfs 2 Mal - die sollte eigentlich nie nochmal kommen, da der Rechner dann in nem while (1) loop gefangen ist. Irgendwie fliegt er also raus, oder er resettet sich oder.... k.A.

Wie kann ich das näher untersuchen?
--
P8000 adventures: http://pofo.de/blog/?/categories/1-P8000

Dieser Beitrag wurde am 02.06.2012 um 19:58 Uhr von Olli editiert.
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
128
02.06.2012, 20:07 Uhr
Enrico
Default Group and Edit


Ich bau mir an freien Ports gerne LEDs.
--
MFG
Enrico
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
129
02.06.2012, 20:17 Uhr
Olli

Avatar von Olli

Ich glaube, ich hatte ne Endlosschleife... würde mich nur wundern, wenn er dadurch resettet, aber nunja
--
P8000 adventures: http://pofo.de/blog/?/categories/1-P8000
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
130
02.06.2012, 21:53 Uhr
Olli

Avatar von Olli

So... Mädels.... es funktioniert!

WEGA im Single-User-Mode läuft schonmal problemlos.
Lesezugriffe sind schneller als auf der Originalplatte:

Originalplatte:


Quellcode:
#1 time dd if=/dev/root of=/dev/null bs=512 count=6000
6000+0 records in
6000+0 records out
2.0u 29.1s 1:02 50%

Also - 1:02 Minuten, zum lesen von 6000 512Byte Blöcken

ATMega-Platte:


Quellcode:
#7 time dd if=/dev/root of=/dev/null bs=512 count=6000
6000+0 records in
6000+0 records out
2.9u 37.9s 0:41 99%

0:41 Minuten zum lesen von 6000 512Byte Blöcken.

Ich denke, beim C-Code des ATMega ist noch Optimierungspotential... wenn ich meine Timer-Geschichten zum laufen bekomme, dann werd ich da nochmal etwas forschen.
Schreibe mir auch mal ein kleines C-Programm welches ein bischen auf die Platte unter WEGA schreibt und vergleiche das dann mal... leider gibts kein /dev/zero unter WEGA so das ein dd in die andere Richtung nicht funzt....
--
P8000 adventures: http://pofo.de/blog/?/categories/1-P8000
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
131
02.06.2012, 21:57 Uhr
Enrico
Default Group and Edit


Goil!
Dann kann ich ja schon mal auf 4 Bausätze und und 4 Platinen erhöhen!

Eventuell wäre IDE ja doch schneller?
--
MFG
Enrico

Dieser Beitrag wurde am 02.06.2012 um 21:58 Uhr von Enrico editiert.
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
132
02.06.2012, 22:11 Uhr
Olli

Avatar von Olli

naja - man könnte auch SDIO machen anstelle SPI mit der SD-Card. Aber ich finde irgendwie keine gescheiten dedizierten SDIO-Controller und eine C-Funktionssammlung scheint es auch nicht zu geben. Aber - ich muss mal schauen wieviel noch rauszuholen ist aus SPI. Einige berichten da von auch so 1MB/sec oder so (raw-transfer ohne overhead). Denke da geht noch was... irgendwo ist auch eh das Limit der P8000 erreicht

Ich werde jetzt noch die Software "perfektionieren" und dann gehe ich nochmal an die Hardware... und dann mach ich mal n Platinen-Layout fertig
--
P8000 adventures: http://pofo.de/blog/?/categories/1-P8000

Dieser Beitrag wurde am 02.06.2012 um 22:11 Uhr von Olli editiert.
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
133
03.06.2012, 00:03 Uhr
Olli

Avatar von Olli

So... ich habe jetzt mal ne halbe Stunde den Quellcode zum lesen und schreiben der SD-Card optimiert. Lesen und Schreiben auf unterster Ebene von "vor Optimierung" bis "nach Optimierung" - schon merklich fixer geworden, aber immer noch lahm...


Quellcode:
60487 overflows / 2500kB gelesen in 6.72 Sekunden  ---> 372,0 KB/Sek.
48955 overflows / 2500kB gelesen in 5.44 Sekunden  ---> 459,5 KB/Sek.
46355 overflows / 2500kB gelesen in 5.15 Sekunden  ---> 485,4 KB/Sek.
46278 overflows / 2500kB gelesen in 5.14 Sekunden  ---> 486,4 KB/Sek.


135206 overflows / 2500kB geschrieben in 15.02 Sekunden ---> 166,4 KB/Sek.
124952 overflows / 2500kB geschrieben in 13,88 Sekunden ---> 180,1 KB/Sek.
116517 overflows / 2500kB geschrieben in 12,95 Sekunden ---> 193,1 KB/Sek.
114353 overflows / 2500kB geschrieben in 12,71 Sekunden ---> 196,7 KB/Sek.
104647 overflows / 2500kB geschrieben in 11.63 Sekunden ---> 214,9 KB/Sek.
104530 overflows / 2500kB geschrieben in 11.61 Sekunden ---> 215,3 KB/Sek.
104167 overflows / 2500kB geschrieben in 11.57 Sekunden ---> 216,1 KB/Sek.

Kann es sein, das meine Widerstände welche ich als Level-Converter 5V->3.3V einsetze mit Schuld daran haben können?
--
P8000 adventures: http://pofo.de/blog/?/categories/1-P8000

Dieser Beitrag wurde am 03.06.2012 um 00:03 Uhr von Olli editiert.
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
134
03.06.2012, 00:32 Uhr
Enrico
Default Group and Edit


480k lesen und 216k schreiben ist doch gar nicht schlecht.
Ich hätte da weniger erwartet.
Ich hatte doch mal nach deiner Anleitung ca. 150k lesen bei mir rausgefunden.

An den Widerständen kann es durchaus liegen. Dadurch ändern sich die Pegel langsamer.
Hast Du kein Oszi?


Du könntest zum Vergleich ja mal ein Programm schreiben, dass ein paar
MB im RAM umschaufelt und die Zeit dafür mitmeisseln. Das wäre das theoretische Maximum. Die Platte hängt ja auch nur mit 8 Bit dran, ist also davon schon mal nur dieh Hälfte machbar. Die I/O Zugriffe sind doch wohl auch etwas langsamer als RAM-Zugriffe? Ist jedenfalls bei der Z80 so.
--
MFG
Enrico

Dieser Beitrag wurde am 03.06.2012 um 00:39 Uhr von Enrico editiert.
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
135
03.06.2012, 00:43 Uhr
Olli

Avatar von Olli

Hab ich - aber ich bekomme doch kein konstanten Fluss drauf - ist kein Speicheroszi - kann also nur den jeweils aktuellen Zustand triggern - dazu bräuchte ich schon was konstant anliegendes. Und das senden eines 512Blocks ist so schnell, da merkt man nix - 5000 Blöcke senden ist aber mit einigem Kommunikationsoverhead verbunden - so das quasi keine konstante Kommunikation mit der SD-Card abläuft.

Welche Level-Converter könnte man denn einbauen die auch bis zu 20MHz können?

http://www.mikrocontroller.net/articles/Pegelwandler#5V_-.3E_3.3V

Da gibts ja n paar, aber beim HC4050 habe ich z.B. gelesen, das der nicht so schnell schalten kann.

http://www.mikrocontroller.net/articles/Pegelwandler#AVR_SPI_.28SDC.2FMMC.29

gibt auch noch extra diese MAX-Teile aber die kosten n bischen was, und gibts glaube ich nur als SMD.

Achso:
Die Lese-/Schreibgeschwindigkeit oben (Beitrag 133) ist auf dem untersten Level! Also direkt ATMega <-> SD-Card ohne irgendeine P8000-Kommunikation.

Auch nach meinen Verbesserungen bin ich nach wie vor bei 42 Sekunden für 3000KB -> 72KB/Sec. Mit meiner Originalplatte komme ich aber auf 62 Sekunden -> 48KB/Sec.

Das ist alles irgendwie extrem lahm... ich muss nochmal suchen, ob ich evtl. einen Meßfehler habe.
--
P8000 adventures: http://pofo.de/blog/?/categories/1-P8000

Dieser Beitrag wurde am 03.06.2012 um 00:48 Uhr von Olli editiert.
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
136
03.06.2012, 01:36 Uhr
Enrico
Default Group and Edit


74LVC14 sollte da gehen. Alle Anschlüsse zur Karte sind unidirektional.

Ich denke 74VHC geht auch, wenn der mit 3,3V läuft.
Schick Dir die Datenbl.
--
MFG
Enrico

Dieser Beitrag wurde am 03.06.2012 um 01:44 Uhr von Enrico editiert.
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
137
03.06.2012, 01:45 Uhr
Olli

Avatar von Olli

Dann brauch ich aber davor oder dahinter noch nen Negator, oder?
--
P8000 adventures: http://pofo.de/blog/?/categories/1-P8000
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
138
03.06.2012, 01:46 Uhr
Enrico
Default Group and Edit


Nö, die invertieren nicht.
Das sind Schmitt-Trigger-Treiber.
--
MFG
Enrico
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
139
03.06.2012, 02:18 Uhr
Olli

Avatar von Olli

Hö? Laut Datenblatt kommt aber bei L H raus und umgekehrt?!

http://www.digchip.com/datasheets/parts/datasheet/364/74LVC14-pdf.php
--
P8000 adventures: http://pofo.de/blog/?/categories/1-P8000
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
140
03.06.2012, 02:39 Uhr
Olli

Avatar von Olli

Was mir auch noch einfällt - otto11 schrieb ja, das WEGA mit 4k Blöcken auf dem WDC rummacht - ich habe die Block-Kommandos bei mir gleich so implementiert, das sie mit beliebig großen Blöcken umgehen können (sofern der SRAM reicht ).

Ich muss morgen mal checken, wie oft Blöcke > 512 gelesen oder geschrieben werden. Dann kann ich mich mal dran machen, Multi-Block Zugriffe via SPI zu implementieren - das könnte dann noch etwas schneller werden, da Kommunikationsoverhead nochmal wegfällt (1*4096 Bytes abholen vs. 8*512 Bytes)
--
P8000 adventures: http://pofo.de/blog/?/categories/1-P8000
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
141
03.06.2012, 02:47 Uhr
Olli

Avatar von Olli

auch ganz nett:

http://elm-chan.org/docs/mmc/mmc_e.html
--
P8000 adventures: http://pofo.de/blog/?/categories/1-P8000
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
142
03.06.2012, 07:52 Uhr
holm

Avatar von holm

Als Erstes: Fein gemacht, Bravo!

Noch ein paar Anmerkungen: Ich habe gestern Abend schon mal reingeguckt und ich drücke Dir die Daumen, das die Malloc Implementation jetzt wirklich fehlerfrei ist.
Wenn Du sie nicht verwenden must, lasse es lieber und verwende einen statischen 4K Buffer.
Ich habe zusammen mit Jörg Wunsch da ziemlich lange Fehler in der Lib gesucht..und auch gefunden.

Dann SD Card: ja SD Card ist sexy. I Phone ist auch sexy, deswegen denke ich aber noch lange nicht, das ich so ein Ding haben will.
Aus hysterischen Gründen würde ich eine IDE Platte bevorzugen, meinetwegen alternativ.
SD Cards haben seit der Speicherung von mehreren Bits in einer Zelle nicht mehr so einen guten Ruf...
IDE Disks gibt es für unsere Zwecke ausreichend, zumal in Größen die man hier braucht.
Man kann aber durchaus später darüber nachdenken.

Gruß,

Holm
--
float R,y=1.5,x,r,A,P,B;int u,h=80,n=80,s;main(c,v)int c;char **v;
{s=(c>1?(h=atoi(v[1])):h)*h/2;for(R=6./h;s%h||(y-=R,x=-2),s;4<(P=B*B)+
(r=A*A)|++u==n&&putchar(*(((--s%h)?(u<n?--u%6:6):7)+"World! \n"))&&
(A=B=P=u=r=0,x+=R/2))A=B*2*A+y,B=P+x-r;}

Dieser Beitrag wurde am 03.06.2012 um 07:59 Uhr von holm editiert.
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
143
03.06.2012, 10:01 Uhr
Olli

Avatar von Olli

Naja - es gibt ne ATA-Implementierung für fatfs

http://elm-chan.org/fsw/ff/ffsample.zip

Aber.... für ATA brauche ich min. 3 freie Ports - macht dann min. 5 Ports (und dann hab ich auch keinen UART mehr frei - also will ich eigentlich 6 Ports) - das isses dann mit DIP vorbei

Da muss mann dann erstmal n SMD-ATMega finden der 20MHz kann, genug IO-Ports hat und > 4KB SRAM

http://www.atmel.com/devices/ATMEGA6450.aspx

der hätte 7 Ports - aber nur 4KB SRAM.

Naja - aber erstmal muss alles absolut fehlerfrei laufen. Ich hatte gestern nach der Installation aller Floppies und durchlaufen von /etc/new.install n segfault bei Verwendung von "mount". Das kann am DRAM der P8000 oder aber an meiner SD-Card liegen - ich müßte mal schauen, ob ich vielleicht doch Checksumming over SPI implementiere - vielleicht wird ja auch Müll auf die Karte geschrieben teilweise via dem Widerstandnetzwerk - er macht ja keinerlei Checksummen.

Ich muss das System mal etwas stresstesten.
--
P8000 adventures: http://pofo.de/blog/?/categories/1-P8000
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
144
03.06.2012, 12:24 Uhr
holm

Avatar von holm

Olli eine FAT muß da nicht drauf sein, im Endeffekt kannst Du auf fast jeder IDE Platte 2 P8000 Platten abbilden, auch einfach nur über die logischen Blocks.
Es wäre aboluter Nonsens ein ein Unix Filesystem innerhalb einer FAT abzulegen, da ist ja regelrecht krank :-))
Das mit den Ports muß Dich auch nicht kirre machen, schaue Dir doch mal das GIDE Interface an, wie da aus 8 Bits des Datenbusses plötzlich 16 werden, auch ist es möglich einen Atmega mit externem Businterface zu verwenden, an ein solches lassen sich Register für die Adressen der Festplatte genauso anlöten wie ein externer RAM. Das muß also nicht wirklich zwangsläufig alles in einen Controller. Der Controller selber ist denke ich schnell genug mit der Bedienung dieser Sachen, 20Mhz bei einem Takt pro Befehl war zu Z80 Zeiten eine Traumwelt.

Du hast aber Recht, erst mal eins zum Laufen bringen, gerade das Debugging bei so einer komplexen Sache ist nicht ohne. Wenn man erst mal sieht das das Prinzip funktioniert, kann man sich um weitergehende Sachen den Kopf zerbrechen.

Für die Fehlersuche empfehle ich Dir wirklich erst mal die dynamische Speicherallokation aus den Routinen raus zu nehmen und mit einem großen Array zu arbeiten zumal ja Blöcke größer 4k hier wirklich nicht zu erwarten sind, da käme ja auch aus dem originalen WDC der Maschinist mit der weißen Flagge raus...

Wie Jörg Wunsch mir immer gerne erzählt bekommt man von Atmel auch kein Geld zurück wenn man den wenigen da drin vorhandenen Speicher nicht nutzt/belegt :-)

Ich hatte dort wirklich tüchtige Dreckeffekte, z.B. wurde freigegebener Speicher oft nicht wirklich wieder in die freelist eingetragen (da arbeitet eine verkettete Liste im RAM, wenn Du Näheres dazu wissen willst, gerne...)

Die Widerstände als Pegelwandler sind wirklich eine sehr umstrittene Sache, es werden da eigentlich immer wenn Jemand Ärger damit hat sofort die entsprechenden Levelshifter angeboten (Microcontroller.net, z.B. SN74LVCH8T245,MC74LVX125DT) allerdings gibts die kaum im DIL Gehäuse.

Gruß,

Holm
--
float R,y=1.5,x,r,A,P,B;int u,h=80,n=80,s;main(c,v)int c;char **v;
{s=(c>1?(h=atoi(v[1])):h)*h/2;for(R=6./h;s%h||(y-=R,x=-2),s;4<(P=B*B)+
(r=A*A)|++u==n&&putchar(*(((--s%h)?(u<n?--u%6:6):7)+"World! \n"))&&
(A=B=P=u=r=0,x+=R/2))A=B*2*A+y,B=P+x-r;}

Dieser Beitrag wurde am 03.06.2012 um 12:26 Uhr von holm editiert.
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
145
03.06.2012, 12:48 Uhr
Olli

Avatar von Olli

Hi Holm

mir gings mit dem beispiel von fsfat nicht um FAT, sondern um die Ansteuerung einer IDE-Platte welche dort als "example project" realisiert wurde - also mit Sourcecode der ATA-Ansteuerung und Schaltplan usw. Nicht um den ganzen FAT-Quatsch - den mache ich natuerlich nicht! aber in der oben verlinkten ZIP Datei hast du quasi eine PATA Implementation als library für ATMega welche read_block(), write_block() usw. bereit stellt... nur darum gings

Ich habe jetzt mit etwas Hirnschmalz erfolgreich CRC-Handling für SPI implementiert (hat mich ja nur 2h gekostet )

Nun weiss ich wenigstens wenn Schrott bei der Karte ankommt oder ich lese. Das wird mir schonmal weiter helfen.....

Und - das alloc() Zeug hatte ich nach deinem letzten Hinweis auch schon raus genommen. habe jetzt einen data_buffer[4096] und einen cmd_buffer[9]
--
P8000 adventures: http://pofo.de/blog/?/categories/1-P8000

Dieser Beitrag wurde am 03.06.2012 um 12:51 Uhr von Olli editiert.
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
146
03.06.2012, 13:43 Uhr
Enrico
Default Group and Edit



Zitat:
Olli schrieb
Hö? Laut Datenblatt kommt aber bei L H raus und umgekehrt?!

http://www.digchip.com/datasheets/parts/datasheet/364/74LVC14-pdf.php

Stimmt, hast Recht. Dann schaltetest Du eben 2 Inverter hintereinander.


Zitat:
Olli schrieb
Naja - es gibt ne ATA-Implementierung für fatfs

http://elm-chan.org/fsw/ff/ffsample.zip


Da kommen aber nur Verbraucherinformationen.
--
MFG
Enrico

Dieser Beitrag wurde am 03.06.2012 um 13:44 Uhr von Enrico editiert.
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
147
03.06.2012, 13:45 Uhr
Olli

Avatar von Olli

Oh... komisch

http://elm-chan.org/fsw/ff/00index_e.html

Dann unten bei "Resources" downloaden:

Download: FatFs sample projects (AVR, PIC24, LPC2300, LPC1700, FM3, V850ES, H8/300H, SH-2A, RX62N, Win32 and Generic uC) May 9, 2012
--
P8000 adventures: http://pofo.de/blog/?/categories/1-P8000
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
148
03.06.2012, 14:13 Uhr
Enrico
Default Group and Edit


So geht es.
--
MFG
Enrico
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
149
03.06.2012, 15:20 Uhr
Olli

Avatar von Olli

So... alles "vor" WEGA - also sogar die Installation von WEGA kommuniziert nur in 512 Byte Blöcken.

WEGA selbst kommuniziert dann in Blockgrößen bis zu 4K aber immer ein vielfaches von 512 - also 1536,2560 usw....

sogar dd.... bs=512 Aufrufe schlagen als multiblock zum WDC durch!

Da ich das nun weiss, macht es also wirklich Sinn multiblock-Write and Read via SPI zu implementieren....

aber erstmal sicherstellen das wirklich alles laeuft
--
P8000 adventures: http://pofo.de/blog/?/categories/1-P8000

Dieser Beitrag wurde am 03.06.2012 um 15:27 Uhr von Olli editiert.
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
150
03.06.2012, 15:32 Uhr
Enrico
Default Group and Edit


Verstehe ich jetzt nicht. Geht bei den SD-Karten etwa auch was anderes als 512 Byte Blöcke?
Bei Festplatten hat man i.d.R. doch auch 512 Byte Blöcke.
(Auch wenn man bei manchen MFM Platten Angaben von 256 Bytes pro Block stehen)
--
MFG
Enrico
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
151
03.06.2012, 16:42 Uhr
Olli

Avatar von Olli

Ja - die SD-Karten sind ja intern nicht in 512Byte Blöcke unterteilt. häufig sind wohl 4K Blöcke - es gibt aber auch andere Organisationen. Das führt dann dazu, das wenn man 512 Byte schreibt, er 4K in den internen Speicher lädt, die zu schreibenden 512 Byte an der richtigen Stelle drüberbügelt und dann die 4K wieder zurückschreibt.... nicht sooooo performant.

Dazu gibt es dann ein SPI-Kommando, welches eine Multibyte-Schreib oder -Leseanforderung stellt. Die kann dann mehrere logische 512Blöcke auf einmal senden oder empfangen (eigentlich kann man eine x-beliebige Anzahl an Bytes empfangen oder senden - sie müßen kein vielfaches von 512 sein).
Dadurch spart man sich dann erstmal den Protokoll-Overhead der vor und nach jedem Senden eines einzelnen 512Byte Blockes entsteht, und wenn man ein Glückspilz ist, sendet man genau 4K an einen Sektor der SD-Card an dem auch ein Hardware-4K Block anfängt... dann hätte man quasi den maximalen Performance-Gewinn. Die Chancen sind aber denke ich nicht so hoch aber wenn man z.B. 1024 Byte sendet, muss er - sofern die auf dem gleichen Sektor liegen nur einmal den 4K Sektor auslesen, modifizieren und zurueckschreiben.... und nicht 2 Mal wenn man zwei 512 Blöcke getrennt geschrieben hätte...

Verstehst?

Edit: gemeint bei dem ganzen 4K lesen, auffüllen, schreiben usw. ist natürlich der interne Controller in der SD-Card. Nicht der ATMega.... der sendet nur seinen Block an die Karte und die macht "den Rest".
--
P8000 adventures: http://pofo.de/blog/?/categories/1-P8000

Dieser Beitrag wurde am 03.06.2012 um 16:49 Uhr von Olli editiert.
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
152
03.06.2012, 17:30 Uhr
Enrico
Default Group and Edit


Alles klar.

Dann ist nur noch die Frage offen, warum Du bei der P8000 ca. 50k/sek misst und ich damals nicht.
--
MFG
Enrico
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
153
03.06.2012, 17:45 Uhr
Olli

Avatar von Olli

Sofern mehr als ein 512Byte Block ins Spiel kommen passiert Gülle. Ich mach mich mal ran an Multi-Byte Support kein Plan wo ich jetzt in meiner aktuellen Implementierung nach nem Fehler suchen soll - eigentlich sollte die funzen. Vielleicht ist sie ja auch einfach zu lahm... werden wir sehen wenn Multi-Byte läuft - in der Hoffnung das es fixer geht.
--
P8000 adventures: http://pofo.de/blog/?/categories/1-P8000
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
154
04.06.2012, 00:32 Uhr
Olli

Avatar von Olli

Multibyte-Support via SPI scheint echt ziemlich übel zu sein... bekomms nicht wirklich zum laufen. Ich muss mal gucken ob ich mir doch nochmal meine single-block logik anschaue ob sie doch irgendwo n fehler hat.... morgen oder so

Checksumming frisst jedenfalls ca. die Hälfte der Zeit... soll heissen, Transferraten alle nur noch halb so schnell

Kleine Karten scheinen übrigens einen ziemlichen Geschwindigkeitsvorteil zu haben - meine hier schreibt so schnell wie sie liest - also ca 370 KB/sec. Die 1GB Karte schreibt mit ca. 200KB/Sec und eine meiner zwei 2GB Karten bricht sogar auf unter 100KB/Sec. ein. Vermute mal, die 128MB Karte ist mit 512Byte-Zellen ausgestattet, und die größeren haben größere Zellen. Meine 128MB Karte hat aber auch ne Macke... vielleicht ist sie auch deswegen so schnell

Fragt sich nur, wo man heute noch so kleine SD-Karten herbekommt. Das kleinste was man "um die ecke" bekommt, sind 2GB Karten....
--
P8000 adventures: http://pofo.de/blog/?/categories/1-P8000
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
155
04.06.2012, 17:14 Uhr
Micha

Avatar von Micha

jenseits der inhaltlichen Erforschung des Themas ist auch noch ein spannendes Thema, wie ein Board-Design zweckmäßigerweise aussehen sollte: als Einbauteil in die P8000 oder als externes Teil zum Anstöpseln. Schick wär natürlich eine Platine, die für beide Varianten geeignet ist...
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
156
04.06.2012, 20:23 Uhr
Olli

Avatar von Olli

Muss man dann mal sehen - Einbauteil hat den Nachteil, das man nicht mehr an die SD-Card kommt. Aktuell schwebt mir ein schönes Einbaugehäuse vor. Das bekommt dann einen 25pin Anschluss und gut is

Multibyte-Write geht nun übrigens inzwischen... hat mich bestimmt 6 Stunden gekostet bis es lief.... dafür kann ich nun z.B. 4KB Blöcke mit 370 KB/Sec. schreiben.

Irgendwer im Mikrocontroller-Forum meinte noch, das man beim ATMega 1284P SPI lieber über einen der USART Ports machen sollte. Das "Software-SPI" wäre dann schneller, da der ATMega beim USART wohl einen 2 Byte-Puffer hat. Das Hardware-SPI Interface hat dies nicht.

Wenn mein MultiRead-Block-Zeug dann irgendwann auch noch läuft, und die P8000 immer noch nicht so recht mag beim arbeiten mit >512Byte Blöcken, dann probiere ich das mal. Wenn das auch nix bringt, weiss ich auch nicht so recht was man noch machen kann. Ich bekomme ja irgendwie auch keinerlei Fehlermeldungen - einige Programme segfaulten einfach nur, oder kommen nicht wieder - z.B. ein ls im /. Ein ls im /tmp geht - aber da sieht man auch Unterschiede... /tmp ist leer - er macht nur Arbeiten mit 512 Blöcken (lesen und schreiben). / ist nicht leer... dort arbeitet er mit größeren Blöcken - und schon gehts nicht....

Naja - erstmal multiblock read irgendwie hinbekommen.... dann weitersehen.

Achso... nur 2 meiner 4 Karten können überhaupt Multiblock-Kommandos.... die anderen nicht. Sieht man denen natürlich nicht an....
--
P8000 adventures: http://pofo.de/blog/?/categories/1-P8000
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
157
04.06.2012, 20:35 Uhr
Mobby5




Zitat:
Olli schrieb
Aktuell schwebt mir ein schönes Einbaugehäuse vor. Das bekommt dann einen 25pin Anschluss und gut is

Und was ist mit der P8000 Compact? Man könnte doch dort das Teil in eine 5,25-Zoll Blindfrontplatte rein basteln. Der 25pin-Anschluß wäre da ja nicht so passend. Ein zusätzlicher Platz für diese Flachkabel-Quetschstecker wäre nett.
--
und ausserdem muss in Zeile 20 der Doppelpunkt durch ein Semikolon ersetzt werden
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
158
04.06.2012, 21:17 Uhr
Olli

Avatar von Olli

Jo, kann man ja auf der Leiterplatte vorsehen - entweder man bestückt nen 25Pin DSub oder ein Flachbandkabel-Header.... Bis zur Leiterplatte dauert es aber noch.... jedes Problemchen zu seiner Zeit
--
P8000 adventures: http://pofo.de/blog/?/categories/1-P8000
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
159
04.06.2012, 21:43 Uhr
Olli

Avatar von Olli

So.... Multiblock-Operationen sind fertig. Leider habe ich hier nur eine lahme Karte die das kann.

falsche Zahlen da mit falscher Taltfrequenz errechnet.
Multiblock lesen: 209KB/Sec
Multiblock schreiben: 152KB/Sec

Singleblock lesen: 151KB/Sec
Singleblock schreiben: 39 KB/Sec.

Oh man ist letzteres lahm... diese "modernen" Karten mit ihren 4K Blöcken sind echt ein totaler Rotz....



Naja - noch eben Filesystem drauf, und dann gehts wohl auch erstmal ins Bett für heute
--
P8000 adventures: http://pofo.de/blog/?/categories/1-P8000

Dieser Beitrag wurde am 04.06.2012 um 22:14 Uhr von Olli editiert.
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
160
04.06.2012, 21:51 Uhr
Enrico
Default Group and Edit


Vielleicht würde es mit IDE doch besser sein.

Das ist aber auch immer noch AVR <--> SD-Karte, oder doch schon
P8000?
--
MFG
Enrico
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
161
04.06.2012, 22:07 Uhr
Olli

Avatar von Olli

Moment.... meine Zahlen sind falsch...... ich habe die Overflows fuer 8MHz berechnet - nicht meinen 18...

ich mache gleich nochmal ein neues Posting.
--
P8000 adventures: http://pofo.de/blog/?/categories/1-P8000
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
162
04.06.2012, 22:13 Uhr
Olli

Avatar von Olli

lahme Karte (offensichtlich 4K Blöcke intern):

Multiblock lesen: 482KB/Sec
Multiblock schreiben: 350KB/Sec

Singleblock lesen: 348KB/Sec
Singleblock schreiben: 92 KB/Sec.

schnellere Karte (hatte meine Frau noch rumliegen ):

Multiblock lesen: 451KB/Sec
Multiblock schreiben: 693KB/Sec

Singleblock lesen: 335KB/Sec
Singleblock schreiben: 492 KB/Sec.

Im schreiben ist die letzte Karte ja echt ein Monster!

Das ist nur AVR -> SPI -> SD-Card (und Vice Versa).
--
P8000 adventures: http://pofo.de/blog/?/categories/1-P8000
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
163
05.06.2012, 19:46 Uhr
Olli

Avatar von Olli

So... auf ein neues - WEGA installieren - nun mit vollstaendigem Multiblock Support. Danach mache ich mir dann erstmal ne Sicherung von der Karte. Das was immer am laengsten dauert ist echt diese Floppy-Installation
--
P8000 adventures: http://pofo.de/blog/?/categories/1-P8000
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
164
05.06.2012, 22:45 Uhr
Olli

Avatar von Olli

Na was soll ich sagen - mit der realisierten Multiblock Lese/Schreib-Logik und der damit gesteigerten Performance geht es nun bisher ohne Segfaults!
Ich weiss jedoch nicht, ob es nun wirklich an der Multibyte-Lösung liegt, oder ob meine vorherige Schleifen Lösung (lese 8 mal 512 Byte) einen Fehler hatte und sich irgendwie ins Knie geschossen hat was zu korrupten Daten führte. Jedenfalls läuft jetzt bisher alles Fehlerfrei - keine Abstürze - ich komme bis in den Multiuser-Mode.

Ich komme unter WEGA so auf 160 KB/Sec. lesen von /dev/rz mittels dd in 4K Blöcken (1000 Blöcke gelesen). Ich muss morgen mal die Originalplatte messen.

Jetzt noch etwas Software-Kosmetik.
Am Donnerstag probiere ich dann mal den SD-Card-Slot aus den mir Micha gesendet hat mit Level-Converter, eigener 3V-Erzeugung und so.
Und danach probiere ich mal, ob ich SPI via USART ans laufen bekomme, und ob das wirklich schneller ist
--
P8000 adventures: http://pofo.de/blog/?/categories/1-P8000
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
165
05.06.2012, 23:11 Uhr
Enrico
Default Group and Edit


Das hört sich doch schon mal alles ganz prima an.
--
MFG
Enrico
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
166
06.06.2012, 07:25 Uhr
Olli

Avatar von Olli

Die Original-P8000 schafft beim

4KBlock*1000-lesen ca 83KB/Sec
512Block*8000 lesen ca 26KB/Sec

Eigentlich muesste ich mal schauen, ob ich bonnie auf dem Hobel zum laufen bekomme. Der testet lesen und schreiben und das immer mit RAM-Größe*2 um dem Caching des OS aus dem Weg zu gehen....
--
P8000 adventures: http://pofo.de/blog/?/categories/1-P8000

Dieser Beitrag wurde am 06.06.2012 um 07:25 Uhr von Olli editiert.
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
167
06.06.2012, 08:44 Uhr
Enrico
Default Group and Edit


Du könntest ja auch mal im RAM ein paar MB umschauffeln um das maximum zu ermitteln.
Ich denke von dem ausgehend, dürfte bei der Plattte ca. 1/4 das Maximum sein.
--
MFG
Enrico
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
168
06.06.2012, 14:20 Uhr
Olli

Avatar von Olli

Wie meinst du das? Ne "RAM-Disk" unter WEGA anlegen und dann mal auf der I/O Prüfungen machen?
Oder meinst du die Daten auf der ATMega-Seite erstmal nur in den RAM schaufeln? Letzteres hatte ich auch mal überlegt, aber da musst du ja RAM extern anbinden und 8Bit - maximal 64K also irgendwie Banking... aber das liegt noch ueber meinem Verstaendniss
--
P8000 adventures: http://pofo.de/blog/?/categories/1-P8000
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
169
06.06.2012, 15:37 Uhr
Enrico
Default Group and Edit


Dann schon eher was wie eine RAM-Disk.
Ich dachte aber eigentlich im RAM der P8000 einfach umkopieren.
Von einem Bereich A an nach B mehrere Blöcke umkopieren.
--
MFG
Enrico
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
170
06.06.2012, 15:41 Uhr
Olli

Avatar von Olli

Ich meine, es sind keine direkten RAM-Zugriffe möglich CPU läuft doch unter WEGA im "Protected Mode".
--
P8000 adventures: http://pofo.de/blog/?/categories/1-P8000
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
171
06.06.2012, 16:16 Uhr
Olli

Avatar von Olli

Edit: kein Beitrag
--
P8000 adventures: http://pofo.de/blog/?/categories/1-P8000

Dieser Beitrag wurde am 06.06.2012 um 16:19 Uhr von Olli editiert.
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
172
06.06.2012, 17:23 Uhr
holm

Avatar von holm

...damit würde man die Speicherbandbreite messen...will das Jemand?

Gruß,

Holm
--
float R,y=1.5,x,r,A,P,B;int u,h=80,n=80,s;main(c,v)int c;char **v;
{s=(c>1?(h=atoi(v[1])):h)*h/2;for(R=6./h;s%h||(y-=R,x=-2),s;4<(P=B*B)+
(r=A*A)|++u==n&&putchar(*(((--s%h)?(u<n?--u%6:6):7)+"World! \n"))&&
(A=B=P=u=r=0,x+=R/2))A=B*2*A+y,B=P+x-r;}
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
173
06.06.2012, 17:35 Uhr
Enrico
Default Group and Edit



Zitat:
Olli schrieb
Ich meine, es sind keine direkten RAM-Zugriffe möglich CPU läuft doch unter WEGA im "Protected Mode".

Verstehe ich nicht. Wenn Du Dein eigenes Programm laufen lässt, macht das auch RAM Zugriffe.
Wo ist da der Unterschied? RAM ist RAM.


Zitat:
holm schrieb
...damit würde man die Speicherbandbreite messen...will das Jemand?

Gruß,

Holm

Ja, ich. Bin ja neugierig.
Das wäre doch mal ein Anhaltspunkt.
--
MFG
Enrico

Dieser Beitrag wurde am 06.06.2012 um 17:36 Uhr von Enrico editiert.
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
174
06.06.2012, 17:49 Uhr
holm

Avatar von holm

...dann miß die Zeit von memcpy() über 2 verscheidene Felder..i.A. gibts dafür auf einer Maschine keine schnellere Implementierung..

Gruß,

Holm
--
float R,y=1.5,x,r,A,P,B;int u,h=80,n=80,s;main(c,v)int c;char **v;
{s=(c>1?(h=atoi(v[1])):h)*h/2;for(R=6./h;s%h||(y-=R,x=-2),s;4<(P=B*B)+
(r=A*A)|++u==n&&putchar(*(((--s%h)?(u<n?--u%6:6):7)+"World! \n"))&&
(A=B=P=u=r=0,x+=R/2))A=B*2*A+y,B=P+x-r;}
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
175
06.06.2012, 18:14 Uhr
Olli

Avatar von Olli

Naja - aber dann hast du Äpfel, und die Festplatte sind Birnen.
interessanter wäre doch, was geht maximal durch die 8Bit-PIO.
Dazu bräuchte man dann aber RAM auf der ATMega Seite....
--
P8000 adventures: http://pofo.de/blog/?/categories/1-P8000
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
176
06.06.2012, 18:15 Uhr
Enrico
Default Group and Edit


Der AVR hat doch jede Menge RAM.

Aber ein Anhaltspunkt wäre der Speichertest schon.
--
MFG
Enrico

Dieser Beitrag wurde am 06.06.2012 um 18:18 Uhr von Enrico editiert.
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
177
06.06.2012, 18:26 Uhr
Olli

Avatar von Olli

16K... was soll man da groß testen. Klar ich kann paar 4K rüber schieben - aber ich kann das nicht wirklich sicher hochrechnen. Und mich würde die maximale Transferrate unter WEGA interessieren... und die schiebt schon für simple Kommandos 4-8K durch die Gegend - jeder Zugriff schreibt erstmal was aufs FS (ich vermute "last access time" der Datei) und liest dann was... und um das zu testen, brauchst du schon ne WEGA-Installation in diesem RAM.

Und wenn du ohne Wega testen willst, musst du ein Programm schreiben was dann auf der z8000 läuft als standalone Programm. Kann man machen, ja - aber ich bin jetzt auch nicht der Assembler-Crack

Achso.... ich habe jetzt uebrigens "mal eben" bonnie für WEGA portiert und lasse es mal eben laufen... wird etwas dauern... dann wissen wir mehr
--
P8000 adventures: http://pofo.de/blog/?/categories/1-P8000

Dieser Beitrag wurde am 06.06.2012 um 18:28 Uhr von Olli editiert.
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
178
06.06.2012, 18:32 Uhr
Enrico
Default Group and Edit


Assembler ist aber einfacher und verständlich.

Man o man, machst Du das spannend. Erst Jahre lang nichts, und dann so was....
--
MFG
Enrico
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
179
06.06.2012, 18:48 Uhr
Olli

Avatar von Olli

Naja - für Leute die Assembler kennen ist er einfacher und verständlich - ich kann aber nur die Basics - mit viel Glück und viel Grübelei meine ich dann auch mal was zu verstehen was da vor sich geht - ist fuer mich aber enorm zeitaufwaendiger als einfer C zu programmieren.

http://pofo.de/blog/index.php?/archives/115-Rebuilding-WEGAs-libc.html

Da in der Mitte habe ich mich z.B. mal dran versucht aus nem Objekt und disassembling wieder eine C-Quelle rauszubekommen

Und bzgl. "Erst Jahre lang nichts" - kommt halt immer drauf an, wenn ich mal Blut lecke lasse ich nicht mehr los

So bonnie läuft immer noch... 10MB Files schreiben is vielleicht doch etwas viel fuer die Kiste... viel Geduld ist gefragt
Da kommt ja jetzt noch ein "WEGA Filesystem" vor der üblichen Schlange WEGA-Kernel -> P8000 Monitor -> PIO -> ATMega -> SPI -> SDCard
Aber das wird man dann wenigstens gut vergleichen können mit der Originalplatte.
--
P8000 adventures: http://pofo.de/blog/?/categories/1-P8000

Dieser Beitrag wurde am 06.06.2012 um 18:57 Uhr von Olli editiert.
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
180
06.06.2012, 19:12 Uhr
Olli

Avatar von Olli

Aktuelles Photo:
http://pics.pofo.de/gallery3/index.php/P8000/P8000_boards/WDC-SDCard/P1110867

Ja - der Quarz ist immer noch so weit weg - aber es läuft
--
P8000 adventures: http://pofo.de/blog/?/categories/1-P8000
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
181
06.06.2012, 19:25 Uhr
kaiOr

Avatar von kaiOr

Wenn ich spaßeshalber von /dev/mem nach /dev/null schaufel kommen nur um die 5kByte/s rüber. o_O

Setze ich dagegen /dev/mem auf eine FIFO-Datei an (keine echte Datei, wird wenn dann im RAM gecached) und hole mir das nach /dev/null ab, komme ich auf 122 kByte/s.

Dieser Beitrag wurde am 06.06.2012 um 19:25 Uhr von kaiOr editiert.
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
182
06.06.2012, 20:09 Uhr
holm

Avatar von holm

Olli man kann auch in C Assembler schreiben, ich habe mir schon paar mal anhören müssen das ich sowas machen würde :-)

Ich kenne die Z8000 CPU fast gar nicht (nur von hier mal reinlinsen wenn einer bhauptet er würde den Assemblerquelltext nicht verstehen :-)) )
Im Prinzip ist das Ding dem Z80 sehr ähnlich, nur das die Assemblerschreibweise gegenüber C sehr laut ist (die vielen Ausrufezeichen..)

Mit den Äpfeln hast Du Recht, deswegen schrieb ich ja die Frage ob das einer machen will..

@kaiOr: Weiß der Teufel was der da triebt, irgendwelche signifikanten Zahlen sind das sicher nicht...

Gruß,

Holm
--
float R,y=1.5,x,r,A,P,B;int u,h=80,n=80,s;main(c,v)int c;char **v;
{s=(c>1?(h=atoi(v[1])):h)*h/2;for(R=6./h;s%h||(y-=R,x=-2),s;4<(P=B*B)+
(r=A*A)|++u==n&&putchar(*(((--s%h)?(u<n?--u%6:6):7)+"World! \n"))&&
(A=B=P=u=r=0,x+=R/2))A=B*2*A+y,B=P+x-r;}
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
183
06.06.2012, 20:27 Uhr
Olli

Avatar von Olli

Jo... kann man ja auch machen - bei oft verwendeten Funktionen die viel Ressourcen brauchen macht sowas sicherlich auch Sinn... Checksummen berechnen z.B. - aber selbst da fände ich es dann besser, sie in extra Assembler Files auszulagern und sie dann dazuzulinken. Asm in C läuft der Portierbarkeit etwas entgegen - wobei die existiert bei C-Coder für µC auch nur noch theoretisch....
--
P8000 adventures: http://pofo.de/blog/?/categories/1-P8000
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
184
06.06.2012, 21:39 Uhr
holm

Avatar von holm

Nein, ich meine jetzt nicht Inlineassembler.
Jemand hat sich mal beschwehrt was ich so schreibe, da waren ein Haufen Bitschiebereien und solches Zeuch drin, ist ja auch bei Controllern nicht unüblich.
Das war der Unix Systemi (und Ursache dafür, dass auf den PDP11 und VAX Rechnern an der Uni immer Unix lief, der der mich mal angesteckt hatte) an der Uni vor und bis ein Jahr nach der Wende.
Ich habe eigentlich gestaunt das er das so sieht, Treiber waren dem ja eigentlich nicht fremd.

Gruß,

Holm
--
float R,y=1.5,x,r,A,P,B;int u,h=80,n=80,s;main(c,v)int c;char **v;
{s=(c>1?(h=atoi(v[1])):h)*h/2;for(R=6./h;s%h||(y-=R,x=-2),s;4<(P=B*B)+
(r=A*A)|++u==n&&putchar(*(((--s%h)?(u<n?--u%6:6):7)+"World! \n"))&&
(A=B=P=u=r=0,x+=R/2))A=B*2*A+y,B=P+x-r;}
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
185
06.06.2012, 23:05 Uhr
Olli

Avatar von Olli

So... nach Stunden habe ich bonnie endlich mehr oder weniger am laufen. Den "Random Seek" Test habe ich entfernt... das war mir jetzt zu abgedreht den ans laufen zu bekommen.

Hier mal die Testergebnisse mit der SD-Card:


Quellcode:
File './Bonnie.1106', size: 5242880
Writing with putc()...      6:43.6
Rewriting...                1:57.0
Writing intelligently...    1:17.2
Reading with getc()...      8:18.5
Reading intelligently...    1:02.1

Wichtig sind mehr oder weniger die "intelligent" Zeilen - dort werden die 5MB in 16K Blöcken gelesen/geschrieben. Bei den putc() / get() Tests werden immer einzelne Bytes geschrieben - das ist natuerlich extrem zeitraubend wenn man das fuer 5MB Byteweise macht... daher die exorbitant hohen Zeiten.

Wenn man die intelligently-Zeiten auswertet, kommt man auf

Schreiben: 66,5 KB/Sek.
Lesen 82,6 KB/Sek.

Was davon aber mit CPU-Rechnereien und was auf I/O drauf gegangen ist, habe ich jetzt nicht untersucht... ich denke man sollte es am besten nur zum vergleichen heranziehen mit den Daten des Original-WDC... und die hole ich jetzt mal ein - in ner Stunde wissen wir mehr
--
P8000 adventures: http://pofo.de/blog/?/categories/1-P8000

Dieser Beitrag wurde am 06.06.2012 um 23:46 Uhr von Olli editiert.
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
186
06.06.2012, 23:43 Uhr
Olli

Avatar von Olli

So, hier die Zahlen mit dem Original-P8000-WDC.

Bei den getc() / putc() sieht man, das die ganze Zeit wohl mit dem Handling in WEGA draufgeht, und der I/O eher so "nebenbei" passiert - die Zahlen sind quasi identisch mit der SD-Card Lösung - aber auf die kommts ja auch nicht an


Quellcode:
File './Bonnie.61', size: 5242880
Writing with putc()...      6:43.7
Rewriting...                2:47.6
Writing intelligently...    1:21.1
Reading with getc()...      8:18.2
Reading intelligently...    1:33.5

Schreiben: 63,2 KB/Sek.
Lesen: 55,1 KB/Sek.

Schreiben kann ich mit der SD-Card jedenfalls ein klein wenig schneller - lesen aber doch fixer (50%)
--
P8000 adventures: http://pofo.de/blog/?/categories/1-P8000

Dieser Beitrag wurde am 06.06.2012 um 23:45 Uhr von Olli editiert.
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
187
07.06.2012, 00:47 Uhr
Enrico
Default Group and Edit


Sag mal, Du hattest mir doch vor langer Zeit mal gesagt, was ich eintippen soll und davon die Zeit stoppen.
K.A. was das war, den Zettel finde ich auch nicht.
--
MFG
Enrico
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
188
07.06.2012, 00:59 Uhr
Olli

Avatar von Olli

time befehl

es geht auch

timex befehl

das listet die nach Ausfuehrung des Befehls auf, wie lange der gebraucht hat.

Aus nem Mailverkehr zw. uns im April 2009:


Zitat:
Enrico schrieb

Zitat:
Olli schrieb
Ansonsten koennte ich dd empfehlen. Lesend:

dd if=/dev/z of=/dev/null bs=512 count=1024

Wenn das funktioniert: Liest die Z-Partition ins "nichts" mit einer
Blockgroesse von 512byte und 1024 Bloecke lang. Damit hast du dann eine
Idee wieschnell der Lesezugriff ist.

Sind 14 sek, macht also 36,6 KB/sek.
Ist die Frage woran das liegt. PIO Anbindung, CPU hat so viel mit MFM CRC, etc zu tun,
oder der Interleave ist ungünstig.

Vielleicht wäre IDE schneller?

Besser ist uebrigens /dev/rz anzugeben anstelle von /dev/z - dann greift er auf die "raw" Partition durch... ist fixer.
--
P8000 adventures: http://pofo.de/blog/?/categories/1-P8000

Dieser Beitrag wurde am 07.06.2012 um 00:59 Uhr von Olli editiert.
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
189
07.06.2012, 01:04 Uhr
Enrico
Default Group and Edit


Sowas aber auch.
Und ich habe da was mit 150 k in Erinnerung.
Hhhm, Alter?

Hätte es was gebracht, statt 512 Byte Block Grösse 4 k anzugeben?
--
MFG
Enrico
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
190
07.06.2012, 01:07 Uhr
Olli

Avatar von Olli

Jo, anstelle 512 4096 schreiben waere sicherlich fixer - das ist die maximale Blockgröße die er über die PIO in einem Rutsch schieben kann. Aber - ich meine mich zu erinnern das er auch bei den 512 eine Optimierung vornimmt, und größere Pakete schickt.... aber ich weiss nicht mehr so genau... war zwar erst vor 3 Tagen als ich meine das gesehn zu haben, aber ich sitz ja inzw. an jeder freien Minute vor dem Ding und prömpel rum... da kann man schonmal was vergessen hehe.

Mal was anderes - die P8000 drückt ja nach wie vor 3,irgendwas Volt auf meine 5V Schiene durch. Sowas will ich auf nem finalen Board eigentlich nicht haben. Wie mache ich das am besten? Hatte erst überlegt: Optokoppler - aber a) is das ja ein riesiges rumgebastle für die 16 Signale, und 8 davon sind ja auch mal Input und mal Output... also noch viel aufwaendiger - zu aufwaendig.... gibts andere Loesungen?
--
P8000 adventures: http://pofo.de/blog/?/categories/1-P8000
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
191
07.06.2012, 06:31 Uhr
holm

Avatar von holm

Optokoppler sind viel zu langsam (jedenfalls die "normalen") das fällt flach.
Die Speisung ist ein parasitärer Effekt über irgendwelche Schutzdioden an den AVR Pins.
Kannst Du mal der Reihe nach die Strippen ablöten und gucken woher das konkret kommt?


Bei Einbau Deines Controllers in die P8000 entfällt das Problem natürlich von alleine.

Gruß,

Holm
--
float R,y=1.5,x,r,A,P,B;int u,h=80,n=80,s;main(c,v)int c;char **v;
{s=(c>1?(h=atoi(v[1])):h)*h/2;for(R=6./h;s%h||(y-=R,x=-2),s;4<(P=B*B)+
(r=A*A)|++u==n&&putchar(*(((--s%h)?(u<n?--u%6:6):7)+"World! \n"))&&
(A=B=P=u=r=0,x+=R/2))A=B*2*A+y,B=P+x-r;}
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
192
07.06.2012, 10:04 Uhr
Olli

Avatar von Olli

Die Pins, welche auf High stehen am AT-Mega sorgen dafür.

Nach dem Einschalten der P8000 ist es nur der /RDY Pin der auf high steht, knickt man den Fuss weg, habe ich nur 0.7V auf der 5V Schiene (kommt sicherlich von den Pins welche auf Low stehen, also mit 1.irgendwas Volt gespeist werden).

Ist der WDC dann zum ersten Mal angesprochen (nach dem 16-Bit Selbsttest) liegen folgende Pins auf high:

/TE
/RDY
/RST
D7
D5
D3
D1

Nur wenn man die dann alle wegknickt hat man wieder einigermßen Ruhe auf der 5V Schiene.

Edit:
Und ich habe den SD-Card Quellcode gestern abend nochmal optimiert... Assembler-Listings angeschaut, C-Code umgestellt, nochmal Assembler-Listing angeschaut usw usw....

vorher
Multiblock lesen: 451KB/Sec
Multiblock schreiben: 693KB/Sec
Singleblock lesen: 335KB/Sec
Singleblock schreiben: 492 KB/Sec.


nachher
Multiblock lesen: 570KB/Sec
Multiblock schreiben: 696KB/Sec
Singleblock lesen: 350KB/Sec
Singleblock schreiben: 501KB/Sec.

Edit2:
Übrigens kam mir noch eine Idee - ich müsste mal analysieren, wie genau so das Lese/Schreibverhalten unter WEGA ist. Wenn er erst was schreibt, und dann den Block nochmal anfordern sollte, könnte man das ja beschleunigen, indem man den vorher geschriebenen Block noch im SRAM des ATMega vorhällt - ich hab ja noch so ca 8KB frei. Achtung.... ich rede wenn nur von Lese-Puffer. Von Schreibpuffer halte ich nix (Strom aus, Datenverlust und so - ja ich weiss, Stützbatterie - und Karte raus? Slot mit elektronischer Verriegelung...? )
--
P8000 adventures: http://pofo.de/blog/?/categories/1-P8000

Dieser Beitrag wurde am 07.06.2012 um 15:31 Uhr von Olli editiert.
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
193
07.06.2012, 11:54 Uhr
Enrico
Default Group and Edit


Na, wenn der Strom weg ist, ist der von der P8000 auch weg, ist also egal, wo
die Daten verloren gehn.
Die Frage ist, ob der LeseBuffer was bringt, wie lang es dauert ein Byte von der Karte zu lesen, bzw aus dem RAM des AVR zur P8000.
Ob das ein Unterschied macht? Es sollte doch eigentlich beides wesentlishc schneller, als der Zugriff der P8000 sein.
--
MFG
Enrico
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
194
07.06.2012, 13:09 Uhr
Olli

Avatar von Olli

Hi Enrico,

die P8000 hat doch ne extra Spannungsversorgung. Wenn du die P8000 also ausschaltest, gehst du ja davon aus, das alles auf der Karte gespeichert ist. Wenn die letzte Schreibanweisung aber noch im Puffer ist, und du dann den WDC-Emulator ausschaltest, gehen diese Daten verloren.

Und bzgl. Lesecache. Wenn ich einen Block auf die SD-Card schreibe, habe ich ihn zu diesem Zeitpunkt ja schon im RAM des AVR. Dort kann ich den ja lassen - vielleicht liest die P8000 ja genau diesen Block nach der Schreibinformation wieder zurück? Dann kann ich den sofort zurückpumpen ohne ihn nochmal von der Karte zu holen. Verstehst was ich meine?

Ich muss nur gucken, ob dieses Schreib-/Leseverhalten von WEGA überhaupt so auftaucht - wenn nicht braucht man das naemlich auch nicht
--
P8000 adventures: http://pofo.de/blog/?/categories/1-P8000

Dieser Beitrag wurde am 07.06.2012 um 13:11 Uhr von Olli editiert.
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
195
07.06.2012, 13:37 Uhr
Enrico
Default Group and Edit


Olli, ja klar, aber so schnell bist Du mit Ausschalten aber nun doch nicht.
Ausserdem habe ich mal gehört, dass man UNIX-Rechner nicht einfach mal eben so ausschalten soll.

Klar, das mit dem Lesen könnte schon so sein.
--
MFG
Enrico
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
196
07.06.2012, 13:43 Uhr
Enrico
Default Group and Edit


Ich habe mir mal das Zilog-HB geschnappt, da stehen die Befehle drin.
Wenn ich mir mal so in etwa eine Schleife zum abholen eines Bytes
zusammenreime, komme ich nur auf ca. 43 k/sek.
--
MFG
Enrico
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
197
07.06.2012, 13:44 Uhr
Olli

Avatar von Olli

nochmal... es geht ja auch nicht um den UNIX Rechner! Der wird natürlich nicht einfach so ausgeschaltet. Aber das "sync" was man am Ende eingibt um den WEGA-Filesystem-Cache mit der Festplatte zu synchronisieren, kommt als normaler schreib/lese-Befehl beim WDC-Emulator an. Der WDC-Emulator weiss nicht, das du den Rechner gleich ausschaltest. Er cached also deine Schreibanweisung und wartet auf die nächste... nur das keine kommt.... Schreibcache muss man immer mit Stützbatterien versehen... das ist nicht nur bei RAID-Controllern mit ihren "Battery Backup Units" so
--
P8000 adventures: http://pofo.de/blog/?/categories/1-P8000
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
198
07.06.2012, 13:55 Uhr
Enrico
Default Group and Edit



Zitat:
Olli schrieb
nochmal... es geht ja auch nicht um den UNIX Rechner! Der wird natürlich nicht einfach so ausgeschaltet. Aber das "sync" was man am Ende eingibt um den WEGA-Filesystem-Cache mit der Festplatte zu synchronisieren, kommt als normaler schreib/lese-Befehl beim WDC-Emulator an. Der WDC-Emulator weiss nicht, das du den Rechner gleich ausschaltest. Er cached also deine Schreibanweisung und wartet auf die nächste... nur das keine kommt.... Schreibcache muss man immer mit Stützbatterien versehen... das ist nicht nur bei RAID-Controllern mit ihren "Battery Backup Units" so

OK. Du bist ja der UNIX Spezialist.

Ich tipp also SYNC ein, damit kopiert also UNIX alle letzten Reste vom RAM auf Platte. UNIX sagt mir dann irgendwann mal, dass es damit fertig ist.

Bis ich das sehe und dann auch noch die Hand zum Schalter recke, draufdrücke, brauche ich bestimmt nochmal .... 5 sek?

Bis dahin dürfte doch Dein WDC-Emulator leicht mit rumschreiben fertig sein?


Zur Sicherheit kannst Du später ja auch noch einen grossen Elko auf der Platine versehen, der stützt dann noch ein paar Sek mehr.
--
MFG
Enrico

Dieser Beitrag wurde am 07.06.2012 um 13:58 Uhr von Enrico editiert.
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
199
07.06.2012, 13:57 Uhr
Enrico
Default Group and Edit


Blocktransferbefehle hat der Z8000 grausam viele.

Nehme ich mal LDIR, welcher 20 Takte brauch, komme ich auf ca.
390 k/sek beim Wortweisen umschaufeln des RAMs.

Edit:

Beim LDIR habe ich mich wohl vertan.
Im HB ist nur eine Kurzübersicht mit allen Befehlen drin, wie die was genau machen, steht nicht im einzelnen drin.

Zur Takt-Anzahl von LDIR heisst es: (11 x 9n)
Heist also wohl eher, dass der Befehl erstmal 11 Takte brauch, und dann für
jeden Schleifendurchlauf nochmal je 9 Takte. Demzufolge ist der doppelt so schnell.
--
MFG
Enrico

Dieser Beitrag wurde am 07.06.2012 um 14:53 Uhr von Enrico editiert.
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
200
07.06.2012, 16:47 Uhr
Olli

Avatar von Olli

So.. ich habe jetzt mal das SD-Card Modul von Micha verlötet... gleiche Geschwindigkeiten. Die Widerstände haben also offensichtlich keinen negativen Einfluss darauf.

So.. mal sehn ob ich SPI über USART ans laufen bekomme

Achso... nach SD-Card habe ich mir sowas vorgestellt:

http://s7.directupload.net/file/d/2914/vqk4zjzi_png.htm

Geht das so in etwa? Ist mir heute morgen als ich so im Bett lag in den Sinn gekommen
Habe jetzt nicht alles verbunden - aber ich denke die Idee ist klar

Der große Kasten in der Mitte ist der ATMega
--
P8000 adventures: http://pofo.de/blog/?/categories/1-P8000

Dieser Beitrag wurde am 07.06.2012 um 17:05 Uhr von Olli editiert.
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
201
07.06.2012, 17:37 Uhr
Enrico
Default Group and Edit


Hhm, keine Ahnung, was das darstellen soll.
Das Einzige, was mir dazu einfällt, ist erstmal, dass Dein AVR gar keinen
externen Bus unterstützt. Du musstest bei den Treibern also jedes mal die Richtung per Hand mit den Ports umschalten.

Der ATMEGA 162 unterstützt einen ext. Bus. Siehe Netzwerkkarte.
--
MFG
Enrico
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
202
07.06.2012, 17:56 Uhr
Olli

Avatar von Olli

Hä? Zum Umschalten soll doch der Adressdekoder dienen (der geht doch an CS und DIR auf meinem Picassobild).


Also ich kanns ja mal versuchen zu erläutern - dachte das mein Bild Bände spricht

Port A) die ganzen Statusleitungen der ATA-Schnittstelle.
Port B) die ganzen Statusleitungen der P8000-Pio.
Port C) drei Busstreiber "1", "2" und "3" angeschlossen
Port D) 3 Adressleitungen kommen an einen Adressdecoder.

Bustreiber "1" ist mit den I/O Leitungen der P8000 verbunden
Bustreiber "2" und "3" sind mit den I/O Leitungen der ATA-Schnittstelle verbunden.

Der Adressdecoder reagiert bei folgenden Adressen wie folgt:
0x00: nichts
0x01: /CS des Busstreiber "1" auf Low + Direction auf "Input"
0x02: /CS des Busstreiber "1" auf Low + Direction auf "Output"
0x03: /CS des Busstreiber "2" auf Low + Direction auf "Input"
0x04: /CS des Busstreiber "3" auf Low + Direction auf "Output"
0x05: /CS des Busstreiber "4" auf Low + Direction auf "Input"
0x06: /CS des Busstreiber "5" auf Low + Direction auf "Output"

Möchte ich nun von der P8000 lesen, schreibe ich auf Port D 0x01.
Bustreiber "1" geht auf "Input" und wird aktiv.
Ich stelle PortC auf "Input"
Ich lese meine Daten.

Möchte ich nun zur P8000 schreiben, schreibe ich auf Port D 0x02
Bustreiber "1" geht auf "Output" und wird aktiv.
Ich stelle PortC auf "Output"
Ich schreibe meine Daten.

Das gleiche auch mit der ATA-Schnittstelle. Das funzt aber nur, wenn es einen Bustreiber gibt, der weiterhin am "Output" Richtung ATA-Interface die Daten anliegen hat, auch wenn /CS nicht mehr LOW ist, da ich ja 8 Bit Daten auf den einen Bustreiber stellen muss, und dann 8 Bit weitere Daten auf den anderen. Und dann kann ich der Festplatte sagen "nun hol dir mal deine 16 Bit Daten ab".

So in etwa habe ich mir das in meinem jugendlichen Leichtsinn vorgestellt
--
P8000 adventures: http://pofo.de/blog/?/categories/1-P8000

Dieser Beitrag wurde am 07.06.2012 um 17:58 Uhr von Olli editiert.
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
203
07.06.2012, 19:15 Uhr
Enrico
Default Group and Edit


Na, wird wohl dann irgendiwe so gehen, Ist aber eine ziemliche Byte-schalterei.
Mit eineme richtigen ext. Bus hättest Du weniger Arbeit, und wäre schneller.
Macht am ENde aber bestimmt auch nicht so sehr viel aus.
--
MFG
Enrico
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
204
07.06.2012, 19:38 Uhr
Olli

Avatar von Olli

So... wir sind leider etwas abgedriftet - ich versuche nochmal auf mein Thema "keine Spannungen von der P8000 auf meiner 5V Schiene" zurueck zu kommen


Zitat:
Olli schrieb:
Die Pins, welche auf High stehen am AT-Mega sorgen dafür.

Nach dem Einschalten der P8000 ist es nur der /RDY Pin der auf high steht, knickt man den Fuss weg, habe ich nur 0.7V auf der 5V Schiene (kommt sicherlich von den Pins welche auf Low stehen, also mit 1.irgendwas Volt gespeist werden).

Ist der WDC dann zum ersten Mal angesprochen (nach dem 16-Bit Selbsttest) liegen folgende Pins auf high:

/TE
/RDY
/RST
D7
D5
D3
D1

Nur wenn man die dann alle wegknickt hat man wieder einigermßen Ruhe auf der 5V Schiene.


--
P8000 adventures: http://pofo.de/blog/?/categories/1-P8000
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
205
07.06.2012, 20:09 Uhr
Mobby5



Wenn Du Deinen SD-Card-Controller als externes Gerät am P8000 hast, sollst Du ja normalerweise diesen sowieso VOR dem P8000 einschalten und auch nach dem P8000 wieder aus. Wie das eben bei Verwendung von externer Computerperipherie zu sein hat.
--
und ausserdem muss in Zeile 20 der Doppelpunkt durch ein Semikolon ersetzt werden
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
206
07.06.2012, 21:29 Uhr
Olli

Avatar von Olli

Echt? Du schaltest deinen Drucker an bevor du deinen PC anschaltest? Also ich ja nicht
--
P8000 adventures: http://pofo.de/blog/?/categories/1-P8000
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
207
07.06.2012, 21:56 Uhr
Mobby5



Na gut, USB ist"plug and pray".
--
und ausserdem muss in Zeile 20 der Doppelpunkt durch ein Semikolon ersetzt werden
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
208
07.06.2012, 21:59 Uhr
Olli

Avatar von Olli

Ne... ich habe nicht von USB Druckern geredet.... aber auch egal. Ich bin der Meinung, da sollte nix auf meine 5V Schiene drücken - egal was ich da zuerst anschalte.
--
P8000 adventures: http://pofo.de/blog/?/categories/1-P8000
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
209
08.06.2012, 00:11 Uhr
Enrico
Default Group and Edit


Olli, wieso stört Dich das eigentlich?
Die Karte dürfte doch dadurch bestimmt nicht versaut werden können?

Ich denke mal, dass beim org. WDC das selbe Problem besteht.
Du wirst nur nicht grossartig was messen können, weil der mehr Logik drauf hat (kein CMOS), und die alles ableitet.

Viel wird sich dagegen wohl auch nicht machen lassen können.
Die internen Pull-Ups hast Du doch abgeschaltet?

Bei den Steuerleitungen könntest Open Kollektor Treiber dazwischen schalten.
Bei den Datenleitungen einen HCT245, die Richtung wird durch /TR ? umgeschaltet, /OE per INverter an die Betriebsspannung vom WDC-Emulator.
Ich denke aber nicht wirklich, dass es was bringt.
--
MFG
Enrico

Dieser Beitrag wurde am 08.06.2012 um 00:19 Uhr von Enrico editiert.
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
210
08.06.2012, 00:12 Uhr
Enrico
Default Group and Edit



Zitat:
Mobby5 schrieb
Na gut, USB ist"plug and pray".

Die haben i.d.R auch keinen richtigen Aus-Schalter.
--
MFG
Enrico
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
211
08.06.2012, 06:41 Uhr
Olli

Avatar von Olli

Pull up ist aus, jo - ist ja glaube ich auch der Reset-Zustand - und ich schreibe kein FF auf den Port....
--
P8000 adventures: http://pofo.de/blog/?/categories/1-P8000
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
212
08.06.2012, 17:00 Uhr
Mobby5



Ich frag mal:" Was bringt das, die Ports auf einen bestimmten Zustand zu programmieren?" Wenn der AVR ausgeschaltet war, stehen doch die Ports sowieso da, wo die AVR-Hardware sie "hinzwingt".
--
und ausserdem muss in Zeile 20 der Doppelpunkt durch ein Semikolon ersetzt werden
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
213
08.06.2012, 17:43 Uhr
Enrico
Default Group and Edit



Zitat:
Mobby5 schrieb
Ich frag mal:" Was bringt das, die Ports auf einen bestimmten Zustand zu programmieren?" Wenn der AVR ausgeschaltet war, stehen doch die Ports sowieso da, wo die AVR-Hardware sie "hinzwingt".

hast Recht, darfst einen ausgeben.
--
MFG
Enrico
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
214
09.06.2012, 10:46 Uhr
Olli

Avatar von Olli

So... mein Emulator verhällt sich so langsam auch in "Sondersituationen" genauso wie das Original, keine SD-Card eingesteckt (Verhalten=keine Festplatte angeschlossen), neue SD-Card eingesteckt (Verhalten=Cyl 0/0/1 nicht lesbar).

Ich baue jetzt noch ein wenig die rückgemeldeten Fehler aus (angeforderte Blocknummer zu groß z.B. usw).

Für wie wichtig erachtet Ihr es, dass das Format der Daten auf Sektor 0 (Parameter + BTT) exakt genauso erfolgt wie beim Original-Controller? Aktuell speichere ich die Parametertabelle. Sie beginnt mit der WDC Version, dann folgen die Festplattenparameter, dann folgen WDC-Steuerbits, dann folgt die BTT.

Die Originalfirmware schreibt aber irgendwie an den Anfang des Sektor 0 PARMTR, dann folgen die Festplattenparameter, dann folgt der String DEFEKT und dann folgt die BTT.

Nach "aussen hin" ist mein Unterschied aktuell nicht merkbar.

Ich frage mich - soll ich es genauso versuchen wie das Original hinzubekommen oder isses egal? Wenn "wie Original" müßte ich mal schauen wie ich an den genauen Aufbau kommen. Evtl kann ich mit ein sa.xxxx Programm bauen was irgendwie Sektor 0 auslesen und auf dem Schirm ausgeben kann. So ganz schlau werde ich naemlich nicht aus der Firmware.
--
P8000 adventures: http://pofo.de/blog/?/categories/1-P8000
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
215
09.06.2012, 10:53 Uhr
holm

Avatar von holm

Olli normalerweise besteht keine Möglichkeit eine P8000 Festplatte irgendwo anders zu lesen als an einem P8000 Controller, der das dann ja seinerseits wieder handelt wie er lustig ist.
Es wäre also Allenfalls für den P8000 Emulator interessant mit Deinen SDCard Images irgendwie kompatibel zu sein, das wars dann aber auch.
Ich selber benutze den nicht in sofern ist mir das völlig egal wie Du das machst. Benutzt Du den selber?

Gruß,

Holm
--
float R,y=1.5,x,r,A,P,B;int u,h=80,n=80,s;main(c,v)int c;char **v;
{s=(c>1?(h=atoi(v[1])):h)*h/2;for(R=6./h;s%h||(y-=R,x=-2),s;4<(P=B*B)+
(r=A*A)|++u==n&&putchar(*(((--s%h)?(u<n?--u%6:6):7)+"World! \n"))&&
(A=B=P=u=r=0,x+=R/2))A=B*2*A+y,B=P+x-r;}
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
216
09.06.2012, 12:33 Uhr
Micha

Avatar von Micha

die Idee, dass man Images zwischen dem P8000 Emu und dieser Lösung direkt (z.B. per dd) hin und herschieben kann finde ich sehr gut! Wär toll wenn das so kompatibel implementiert würde.
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
217
09.06.2012, 12:47 Uhr
holm

Avatar von holm

..dann müßte aber gecheckt werden, wie genau der P8000 Emulator die "Disk" ablegt.
Der Emulator hat ja auch keine Bastrack Liste sondern wird sich um das Wesentliche gekümmert haben.

Gruß,

Holm
--
float R,y=1.5,x,r,A,P,B;int u,h=80,n=80,s;main(c,v)int c;char **v;
{s=(c>1?(h=atoi(v[1])):h)*h/2;for(R=6./h;s%h||(y-=R,x=-2),s;4<(P=B*B)+
(r=A*A)|++u==n&&putchar(*(((--s%h)?(u<n?--u%6:6):7)+"World! \n"))&&
(A=B=P=u=r=0,x+=R/2))A=B*2*A+y,B=P+x-r;}
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
218
09.06.2012, 13:15 Uhr
Olli

Avatar von Olli

Nun... der Emulator arbeitet so wie ich aktuell arbeite - aber... Sektor 1 ist nicht mit abgelegt im Image sondern hardcoded im Code. Man müsste also wenn man das nutzen will, immer eine ROB K5504.50 verwenden, und vom SD-Card Image 90 Blöcke vom Anfang skippen.
Daher, dass das hardcoded ist, ists auch wieder um egal wie man es macht

Arbeite aber selber auch nicht mit dem Emulator.
--
P8000 adventures: http://pofo.de/blog/?/categories/1-P8000
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
219
09.06.2012, 14:56 Uhr
Enrico
Default Group and Edit


Also mir wäre der Emulotr egal, da ich ja Hardware habe.

Die Frage ist, ob Du überhaupt mit dieser BTT was anstellen musst.
Eigentlich ja wohl eher nicht, da dort drin steht, welche Sektoren bei
einer MFM-Platte defekt sind. Das fällt bei Dir ja schon mal aus.
Wenn was defekt ist, müsstest Du dich darum ja selber kümmern.
Bzw. Ersetzt die SD-Karte defekte Blöcke nicht von allein?
--
MFG
Enrico
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
220
09.06.2012, 15:43 Uhr
Olli

Avatar von Olli

Ja, sie sollte sie alleine ersetzen. BTT-Handling ist eigentlich soweit bei mir implementiert - nur wird die Tabelle der defekten Sektoren nicht berücksichtigt bei den Operationen auf der SD-Card. Man könnte natürlich die eingetragenen Sektoren (sind ja auch nur eine andere Notation für einen Block) überlesen, aber das würde die Ermittlung des "richtigen" Blockes verlangsamen da man immer die ganze BTT durchschrubben müsste und jeden Eintrag auswerten müsste und dann den richtigen Block weiterschieben müßte. Du musst ja bei 4 Einträgen in der BTT, und einem angeforderten Block von 90000 z.B. auf Block 90004 kommen, wenn die 4 Einträge "vor dem" angeforderten Block liegen.

Das habe ich erstmal nicht implementiert. Ich habe auch noch keine SD-Card mit echten Defekten, so das ich gar nicht weiss, wie die reagiert beim Zugriff.
--
P8000 adventures: http://pofo.de/blog/?/categories/1-P8000
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
221
09.06.2012, 16:33 Uhr
Olli

Avatar von Olli

Ich denke, ich werde die nächsten Tage so mehr oder weniger "fertig" werden mit dem Teil.

Und dann?

Ich fand Holms Idee mit der PATA-Schnittstelle auch ganz interessant und werde mich auf jedenfall zummindest drann versuchen. Ich wollte das dann als "entweder SD-Card oder PATA" bauen - so das man man mittels Jumper einstellen kann ob man SD-Card oder PATA verwenden will - beides auf eine Platine.

Vorher trotzdem SD-Card Leiterplatten-Layout erstellen? Fragt sich dann halt nur ob sich diese Arbeit lohnt... Falls ich PATA nicht hinbekommen sollte, haette man dann zwar ein fertiges "Fallback", aber wenn doch ists halt viel fuer die Katz.
--
P8000 adventures: http://pofo.de/blog/?/categories/1-P8000
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
222
09.06.2012, 17:14 Uhr
UR1968
Default Group and Edit


Hallo Olli,

ich finde beide Varianten interessant und würde beide auf eine Platine machen. So kann man es sich aus suchen ob man PATA oder SD-Karte verwenden will.
Ein Layout würde ich erst erstellen wenn PATA funktioniert. Falls es nicht funktioniert, dann machst Du halt eins nur für die SD-Karte.

Tschüß
Uwe
--
https://uwes-bastelbude.ch
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
223
09.06.2012, 17:14 Uhr
Enrico
Default Group and Edit


Probier es erstmal aus. Es rennt ja nicht weg.
--
MFG
Enrico
Seitenanfang Seitenende
Profil || Private Nachricht || Suche Zitatantwort || Editieren || Löschen
Seiten: -1-     [ Technische Diskussionen ]  



Robotrontechnik-Forum

powered by ThWboard 3 Beta 2.84-php5
© by Paul Baecher & Felix Gonschorek