RAM-Baustein

[Moppi]

Man sieht, das sieht dass Du nicht mit 8 Bit auskommen kannst. Geht aber trotzdem, mathematisch komplexe Sachen in 8 Bit-Rechenoperationen zu erledigen, wenn es denn sein müsste.

Aber jetzt schweifst Du vom Thema ab. Über KI und Assistenzsysteme will ich doch jetzt hier gar nicht streiten. Viel wichtiger ist, dass heute die andern Teile kamen. Steuerbus ist fertig aufgebaut. Und dann bin ich gespannt, ob mein kleines Vorhaben, dass machen wird, was es soll! Nämlich Speicherinhalt schnellstmöglich transferieren und Speicher auslagern Die nächste anstehende Frage ist dann, ob ich 256 Byte breite Spalten und 2048 Zeilen nehme oder lieber gleich 1024 Zeilen und dafür 512 Byte je Spalte. Für kleine Variablen sind 256 Byte noch zu viel, für Große 512 Byt aber noch bei weitem zu wenig. Bis jetzt habe ich es so geplant, dass ich 1024 Zeilen adressiere, bei 256 Byte pro Zeile. Mit dem Carry-Flag, des zweiten 4-Bit-Zählers erweitere ich die 256 Byte, mit der zweiten RAM-Hälfte, auf 512 Byte. Hinsichtlich dessen, dass ein Sektor auf einer normalen Festplatte auch 512 Byte groß ist.

Achso, im Übrigen: die Beschaltung der zwei 4-Bit-Zähler, die ich vor kurzem skizziert hatte, funktioniert in der Tat.



Also bis dahin...

---------------------------------------------------------------

Nachtrag:



Dass Du auch immer so neugierig sein musst! Ich sehe was, was Du nicht siehst

[Searcher]

Steuerbus ist fertig aufgebaut. ...
Achso, im Übrigen: die Beschaltung der zwei 4-Bit-Zähler, die ich vor kurzem skizziert hatte, funktioniert in der Tat.

Man, Du legst aber ein Tempo vor Ich versuche gerade den Steuerbus (mit zwei Leitungen zu jedem Busteilnehmer) auf einem ATtiny44A als Buscontroller zu programmieren. Busteilnehmer sollen auf der Request Leitung mit einem low anfordern und bekommen Zugriff vom Bus Controller mit einem low auf der Grant Leitung. Die Busteilnehmer sollen die Request Leitung so lange auf low halten bis sie den Bus wieder freigeben. Danach nimmt der Bus Controller das low von der Grant Leitung weg und kann den Bus dem nächsten Teilnehmer zuordnen. Die Requests sollen der Reihe ihres Eingangs nach behandelt werden. Gibt der erste den Bus frei, der zweite den Bus belegt und der dritte wartet, während der erste schon wieder anfordert, sollen Prioritäten vergeben werden bzw eine Warteschlange aufgebaut werden um den dritten vor dem ersten den Bus zuzuteilen. Das in Code zu bringen bei diesem Superwetter draußen braucht bei mir anscheinend mehr Zeit als Dein ganzes Projekt

Gruß
Searcher

[PICture]

Hallo!

@ Moppi

Man sieht, das sieht dass Du nicht mit 8 Bit auskommen kannst. Geht aber trotzdem, mathematisch komplexe Sachen in 8 Bit-Rechenoperationen zu erledigen, wenn es denn sein müsste.

Natürlich, ist aber nicht simpel: https://rn-wissen.de/wiki/index.php?...x_Dec_Wandlung.

[HaWe]

Hallo!
Natürlich, ist aber nicht simpel: https://rn-wissen.de/wiki/index.php?...x_Dec_Wandlung.

Es ist nicht nur nicht simpel, es ist auch nicht sinnvoll, wenn man zuhauf float- und double-Berechnung braucht, zusammen mit den ebenfalls nötigen reellen und transzendenten trigonometrischen und Exponential-Funktionen, die wiederrum intern mit Taylorreihen oder Produktentwicklungen etc. nachbildet werden und dafür intern irrsinnig viele fp-Divisionen durchführen.
Tatsächlich rechnet aber ja jede MCU IMMER nur mit integer-Werten, nämlich binär kodierten bytes (=integer-Werten), tut also nichts anderes, als wenn man das auf 8bit-Prozessoren umständlich selber mit int nachbilden will - es ist nur hochoptimiert seitens C/C++ und MCU für Geschwindigkeit und Genauigkeit. Gerade die C/C++-Compiler sind auch optimiert auf Probleme, die durch den Vergleich zweier fp-Variablen auf Gleichheit oder Ungleichheit betrifft u.v.m., was durch minimalste Rundungsfehler der Rechen-Zwischenschritte bei der Konvertierung von fp in ihre binären Repräsentationen angeht.

Dabei muss man auch wissen, dass floats oder deren int16-Repräsentationen oft nicht genau genug sind, um bestimmte Berechnungen zu lösen (wie z.B. Matrix-Determinanten) und dadurch extremst falsche Ergebnisse liefern, daher muss man dann zwingend double verwenden.
Ich hatte schon oft bei meinen ersten Gehversuchen mit Matrizen mit dem Mega2560 (8bit-AVR, kann nur float, kein double) das "unerklärliche" Ergebnis, dass oft Determinanten einen Wert von deutlich größer null hatten (z.B. ein- oder zweistellig positiv), per float berechnet, obwohl die Matrizen antisymmetrisch waren oder ihre Zeilen nicht linear unabhängig, also die det(M) Null hätten sein müssen. Man kann eine Matrix mit Determinante Null aber nicht invertieren (genausowenig wie man durch Null dividieren darf), und die linearen Gleichungssysteme sind bei det(M)=0 nicht lösbar, und das falsche Ergebnis mit floats hätte dies fälschlich erwarten lassen.
Erst double-fp auf 32-bit ARMs erbrachte dann die korrekten Ergebnisse.

Es geht also bei float vs. double vs. int-Arithmetik nicht (nur) um Genauigkeit des Endergebnisses, sondern sogar u.U. tatsächlich darum, ob das Problem überhaupt grundsätzlich lösbar ist.

Fazit: wer 8bit AVRs mit floats braucht, soll mit floats rechnen, wenn es nicht zeitkritisch ist und die Genauigkeit ausreicht;
wer höhere Genauigkeit oder Geschwindigkeit braucht, soll ARM Cortex verwenden, entweder mit single- oder falls erforderlich double-fp, im Extremfall auch mit fpu (M4 oder SoC).
Alles andere ist Murks.
Wer also weiß, dass später vielfach fp zeitintensiv benötigt wird, soll besser gleich mit ARMs anfangen (my2ct).

[Moppi]

@searcher

War eine gute Idee mit den 74HC161. Erst war ich skeptisch, mit der Reihenschaltung. Das funktioniert aber erstaunlicher Weise sehr gut. Schnell zählen die Dinger auch. Hatte bis jetzt noch keinen Zählfehler. Allerdings komme ich mit einem Atmega328 (16MHz Takt) auch nicht weit über 160KHz Taktfrequenz raus. Mitmachen soll der HC161 lt. Datenblatt 63MHz.

Busteilnehmer sollen auf der Request Leitung mit einem low anfordern und bekommen Zugriff vom Bus Controller mit einem low auf der Grant Leitung. Die Busteilnehmer sollen die Request Leitung so lange auf low halten bis sie den Bus wieder freigeben. Danach nimmt der Bus Controller das low von der Grant Leitung weg und kann den Bus dem nächsten Teilnehmer zuordnen.

richtig, war der einfachste Gedankengang

Die Requests sollen der Reihe ihres Eingangs nach behandelt werden. Gibt der erste den Bus frei, der zweite den Bus belegt und der dritte wartet, während der erste schon wieder anfordert, sollen Prioritäten vergeben werden bzw eine Warteschlange aufgebaut werden um den dritten vor dem ersten den Bus zuzuteilen.

Wenn ich das richtig verstehe, nimmst Du nur 2 Leitungen, an die Du alle Teilnehmer anschaltest? - Oder doch mehrere parallele? Sonst müsstest Du ja mit jedem Teilnehmer dieselbe Leitung abhören und dann müssen die raten, ob noch jemand anders gerne möchte oder ob sie zurzeit alleine am Bus horchen? Nicht, dass man Kollisionen nicht auflösen könnte. Einer wird der Erste sein, der zu irgendeinem Zeitpunkt sagt: ich belege die Leitung, vorher war sie frei.
Aber da gehst Du von einer anderen Seite ran, als ich. Da bin ich noch gar nicht.


MfG

[Searcher]

Wenn ich das richtig verstehe, nimmst Du nur 2 Leitungen, an die Du alle Teilnehmer anschaltest? - Oder doch mehrere parallele?

Nein, nein. Ich nehme parallele. Also von jedem Busteilnehmer zwei Leitungen (kein Bus) zum Buscontroller. Bei mir sind im Augenblick drei Busteilnehmer vorgesehen - also kommen von denen sechs Leitungen beim Buscontroller an. Die Fall c) Verdrahtung von der Arbiter Internetseite ohne Bus-busy Leitung. Die Busteilnehmer sind bei mir noch LEDs an denen ich die Zustände der Busleitungen betrachten kann. Ein, noch auf dem Steckbrett steckender Mega88 dient als Testmustererzeuger für die Requestleitungen. Die Muster schalte ich mit einem Taster weiter.

Wenn das Programm auf dem Buscontroller mal steht, versuche ich mit nur 74HC595 ohne 74HC161 weiterzumachen, da ich die Binärzähler nicht habe. Gleich geht es aber erst mal zum Radeln

Gruß
Searcher

[Moppi]

@searcher

Und schon weiter gekommen?

Schieberegister funktionieren auch als Zähler, bloß nicht in richtiger Reihenfolge der Zählerstände. Pro Takt kann man einen neuen, einmaligen Zählerstand erzeugen. Mit einem 8-Bit-Register sind das 256 Verschiedene. Eine gesamte 8-Bit-Adresse dort reinzuschieben dauert seine Zeit - wesentlich länger.

Ich bin noch bei der Steuerlogik. Die Hardware auf die Beine zu stellen, geht noch relativ flott. Dann muss aber die Softwaresteuerung zur Hardwarelogik passen. Gestern habe ich eine extra Steuerleitung eingeführt, um bessere Kontrolle über die Kommunikation zu haben. Eigentlich aus dem Grund, weil ich mir dachte, dass den Zähler rücksetzen und takten gemeinsam keine gute Idee wäre. Denn immerhin soll der Zähler bei Takt zählen, was aber direkt schon nach dem Rücksetzen passiert. Allerdings habe ich heute Morgen rausgefunden, dass der Zähler, wenn er während des Rücksetzens getaktet wird, nicht darauf reagiert. Also wenn das Rücksetzen aktiv ist und das Taktsignal auf LOW und beides zur selben Zeit umgeschaltet wird (Reset-Signal weg und Taktsignal auf HIGH). Ich meine auch gelesen zu haben dass der Zähler nur bei steigender Flanke zählt. Wenn die steigende Flanke vom Reset überlagert ist, zählt er wohl tatsächlich nicht.

Zurzeit bin ich doch erstaunt, welche Bruttodatenrate über die IO-Ports zu erreichen wäre. Bei der Adressierung habe ich z.Z. um die 125kByte/s netto. Allerdings ist das erst mal nur die Segmentadressierung. Einen Offset will ich später eigentlich auch noch einführen, dann sinkt die Nettodatenrate nochmal etwas. Dafür wird das Lesen und Schreiben schneller gehen; wenn nicht ständig die Adresse wahllos geändert wird. Dann werden wesentlich weniger Zyklen für Portoperationen benötigt. So dass ich damit rechne, in die Nähe der 200kByte/s netto zu kommen. Wenn ich über 160kByte/s käme, wäre ich fürs Erste auch zufrieden. Kommt die SD-Karte ins Spiel, sinkt die Datenrate nochmals, nach allem was ich probiert hatte auf max. 25kByte/s. Mal sehen. Bleibt noch spannend - vor allem aber kniffelig Hard-und Softwarelogik zusammen zu bekommen.

MfG

[Searcher]

Und schon weiter gekommen?

Ich bin kaum weiter

Ich hatte mich zu lange beim Buscontroller/Arbiter aufgehalten. Da gab es immer wieder Fälle, die nicht in meine Vorstellung paßten. zB brachte ein Controller, der eine BUsanforderung stellte und vor der Zuteilung wieder zurücknahm, die Reihenfolge der Übrigen durcheinander. Nachdem solche Bugs durch Flicken im Code entfernt waren, sah das Programm recht übel aus und muße nochmal neu geschrieben werden. Jetzt steht es aber, braucht jedoch, getaktet mit internem 8MHz Oszillator auf ATtiny44A, etwa 35µs von Entgegennahme der Anforderung bis Zuteilung des Busses, wenn natürlich kein anderer Controller den Bus belegt hat.

Dann hab ich die 74HC595 aufs Steckbrett gebracht und an den ersten Controller (ATMega88PA, 8MHz interner Oszillator) an die HW-SPI Schnittstelle angeschaltet. Deren Parallelausgänge sollen ja die Adresse am RAM setzen. Hier unterscheidet sich mein AUfbau schon von Deinem. Ich habe keine 74HC161 zur Verfügung (vielleicht besorg ich mir noch welche) Auch brauche ich für mein 32KiByte Speicher mit 15 Adressleitungen nur zwei 74HC595, die ich hintereinander geschaltet habe.

Nach Kampf mit den SPI Parametern wie CPOL und CPHA kommen die Bits richtig im Schieberegister an und der der SPI Takt läuft mit halbem Systemtakt also mit 4MHz. Ich benutze Bascom Befehle und brauche pro Adressbyte etwas mehr als 5µs zur Übertragung, also 10,2µs für eine 15(16)Bit Adresse. Gemessen mit Oszilloskop am Slave Select Pin, der auch von Bascom gesetzt wird. An der Stelle gibt es wahrscheinlich Optimierungsmöglichkeiten weil der SS sich nach Übertragung reichlich Zeit bis Rückkehr nach idle läßt. Erst soll aber der Rest noch funktionieren.

Heute möchte ich den Mega88 an den Buscontroller anschalten und anfangen die Busschnittstelle darauf zu programmieren. Der RAM Baustein ist noch tief in einer Schublade vergraben.

Ich meine auch gelesen zu haben dass der Zähler nur bei steigender Flanke zählt

Ja, "Table 3 Function table" im NXP Datenblatt bestätigt das - Mit /MR auf high!

Zurzeit bin ich doch erstaunt, welche Bruttodatenrate über die IO-Ports zu erreichen wäre. Bei der Adressierung habe ich z.Z. um die 125kByte/s netto.

Über HW-SPI und Schieberegister liege ich bei 200kByte/s mit 8MHz Controllertakt. Allerdings kann ich bei folgendem Datentransfer keine Zeit durch Adresserhöung mit einfachem Takt sparen. Und ich rechne noch nichts sondern lese einfach nur Bytes aus einem Array und schreibe sie per HW-SPI raus.

Bleibt noch spannend - vor allem aber kniffelig Hard-und Softwarelogik zusammen zu bekommen.

Das gefällt mir auch.

Gruß
Searcher

PS Auf die Sache mit den Schieberegistern als Zähler komme ich später vielleicht noch mal zurück.