was eine Sprache ist, weiß ich, sowohl aus der Linguistik als auch aus der Mathematik bzw. der Informatik-Theorie (Stichworte Alphabet, Kleensche Hülle, Chomsky-Grammatiken).
Was du damit als Anwendung willst, das ist mir schleierhaft.
Druckbare Version
was eine Sprache ist, weiß ich, sowohl aus der Linguistik als auch aus der Mathematik bzw. der Informatik-Theorie (Stichworte Alphabet, Kleensche Hülle, Chomsky-Grammatiken).
Was du damit als Anwendung willst, das ist mir schleierhaft.
Dann hast Du das mit der Sprache richtig verstanden. Ein Beispiel hatte ich ja schon gegeben. :o Nochmal anders: aus einer Fülle gespeicherter Informationen Zusammenhänge und Dinge zu erklären, bzw. dieses tun zu lassen.
Irgendwie kommst du nicht richtig rüber mit der Info - wieso?
sprechen soll wer?
In welcher Sprache?
Wovon wird gesprochen?
Wer soll was erklären?
Wer generiert die Sprachphoneme samt Syntax?
Wer analysiert sie mit welcher Spracherkennungssoftware?
Wozu dient der Speicher?
Wer schreibt was drauf, und wer liest es?
Wieviel Wörter/Sätze in welcher Zeit sind zu verarbeiten?
Und um welche Aufgabe geht es insgesamt genau?
Willst du die web- und KI-basierte Google Spracherkennung oder Alexa mit AVRs für eine Hausautomatisierung oder Bestellwesen lokal selber bauen oder wie oder was?
Du denkst schon zu kompliziert, das Wichtigste ist:
Falls das ausreichend schnell wäre, was ich noch gar nicht weiß, aber versuchen will, käme als nächster Schritt das Interpretieren von Strings (Zeichenketten). Falls das auch ausreichend schnell wäre, folgt komplexere Verarbeitung. Ergibt unterm Strich autonome Datenverarbeitung. Der Inhalt ist völlig undefiniert. Das Anwendungsfeld deshalb vielseitig. Stellt dann erst mal ein leeres Konstrukt dar, das in sich aber funktionstüchtig ist. Was man damit tun will, hängt dann von den eingegebenen Daten und Strukturen ab und den Zielsetzungen. Wenn Ziele definiert sind, wird es auch Ergebnisse geben. Auf dem Weg zum Ziel aber auch jede Menge offene Fragen / fehlende Daten, die nachzutragen wären, bis das erwartete Ziel erreicht wird.Zitat:
Zitat von Moppi
MfG
String-Verarbeitung für "Splitten, Ersetzen, Suchen" gibt es doch schon, per cstrings und ANSI C Funktionen
und per Arduino String class (einer abgespeckten, nicht ganz std::string kompatiblen Klasse)
Das kann doch kein Problem sein?
aber was bedeutet "Interpretieren von Strings (Zeichenketten)" ?
was soll beispielhaft als was "interpretiert" werden?
oder willst du Audiosignale speichern und sie später als Wörter wiedererkennen?
Natürlich gibt es alles, läuft ja auch bei mir. Ich muss das nicht neu ausdenken, das habe ich die letzten Jahre gemacht. Allerdings interessiert mich jetzt, in wie weit ich das mit den gedachten Mitteln auf Hardware vielleicht umsetzen kann. Ob so eine Art Schwarmintelligenz machbar wäre, wenn man so will. Diesen Vorschlag von Dir damals mit den Atmegas fand ich gar nicht schlecht, macht vom Prinzip her in kleinster Einheit das, was ich bräuchte. Jetzt ist bloß die Frage, ob das zum Erfolg führen könnte, aufgrund der Geschwindigkeit?
Es gibt Leute, die bauen aus Legosteinen ganze Häuser oder Tiere oder Fahrzeuge, obwohl es das alles schon in anderer Ausführung gibt. So weit zum Sinn, irgend etwas bauen zu wollen.
Parser? Compiler? Linker? ... Interpreter?
Interpreter: https://www.google.com/search?q=Interpreter
Morgen kommen noch Bauteile, dann kann ich sehen, wie sich die erste Stufe so angehen lässt. Vielleicht scheitert das ja auch schon auf den ersten Metern, mal sehen. Aber dazu muss ich erst mal was bauen. Falls es dann Probleme gibt, muss ich in meinem Softwarependant nachschauen, ob das dann an dieser Stelle schon zum Scheitern verurteilt ist oder ob ich es anders organisieren kann, um weiter zu kommen. Ziel ist es eine bestehende Software auf Hardware umzumünzen. Wäre toll, wäre mal was anderes! :-)
ok, ich sehe, dass ich noch nichts sehe.... ;)
Grundsätzlich halte ich nach meinen bisherigen KI Versuchen (weil du von "Intelligenz" sprachst) die mini-AVRs vom UNO Typ für absolut ungeeignet allein schon wegen dem 2- 2.5kB Micker-RAM. Schon SPI und die seriellen Puffer auch für UART und i2c brauchen ja schon knapp 1 kB, was bleibt da noch für Programm und Daten?!
Ein Mega2560 mit 8kB muss es mindestens sein, damit habe ich immerhin schon einen autonomen Schach-Zuggenerator am Laufen und auch eine Fast-Fourier-Transformation zur Tonsignalerkennung ist damit gerade eben extrem simplifiziert machbar (2 komplexe arrays zu je 256 fp Elementen = 4kB) - auch das ist aber eigentlich immer noch zu schwach auf der Brust.
KI, FFT und fuzzy logic erfordern zwangsweise leistungsstarke MCUs mit viel RAM und hohem Takt für fp math, mit int kommst du keinen müden Steinwurf weit. Diese 8bit-2.5kB-Mini-AVRs taugen höchstens was für Katzen- oder Hühnerklappen.
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:
Anhang 33664
Dass Du auch immer so neugierig sein musst! Ich sehe was, was Du nicht siehst ;)
Man, Du legst aber ein Tempo vor :shock: 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 :-)Zitat:
Zitat von Moppi
Gruß
Searcher
Hallo!
@ Moppi
Natürlich, ist aber nicht simpel: https://rn-wissen.de/wiki/index.php?...x_Dec_Wandlung. ;)Zitat:
Zitat von Moppi
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.Zitat:
Zitat von PICture
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).
@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.
richtig, war der einfachste GedankengangZitat:
Zitat von Searcher
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.Zitat:
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.
Aber da gehst Du von einer anderen Seite ran, als ich. Da bin ich noch gar nicht.
MfG
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.Zitat:
Zitat von Moppi
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 :Strahl
Gruß
Searcher
@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
Ich bin kaum weiter :-(Zitat:
Zitat von Moppi
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.
Ja, "Table 3 Function table" im NXP Datenblatt bestätigt das ;-) - Mit /MR auf high! :-)Zitat:
Ich meine auch gelesen zu haben dass der Zähler nur bei steigender Flanke zählt
Ü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.Zitat:
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.
Das gefällt mir auch.Zitat:
Bleibt noch spannend - vor allem aber kniffelig Hard-und Softwarelogik zusammen zu bekommen.
Gruß
Searcher
PS Auf die Sache mit den Schieberegistern als Zähler komme ich später vielleicht noch mal zurück.
Ich muss gestehen, dass ich einem Rechenfehler unterlegen war. Denn ich habe dieselben Daten ermittelt: ca. 10µs für eine 15(16)Bit Adresse. Ich kann es auf evtl ca. 8µs drücken. Da bin ich mit Deinen Werten erst mal ins Straucheln gekommen. Allerdings ist es schon so, dass ich in dieser Zeit schon 2mal 8 Bit übertrage. Daher kann man nicht von kByte sprechen, weils ja Worte sind. :rolleyes: Also in kByte wär's ja schon das Doppelte (250kByte). Wundern tu ich mich jetzt etwas über diese SPI-Anbindung. Ist dem Atmega dort jegliche Rückmeldung egal? Einfach nur Daten drauf und Takt? - Bemerkenswerter Ansatz. :-) Dann bekommst Du die Daten über SPI auch rein? Kannst Du den Atmega nicht höher takten, nicht mit 20MHz? Wenn Du auf SPI 250KByte/s Daten übertragen willst, muss der Takt per SPI ja th. irgendwo bei 250*1024*8 liegen = 2048kHz.
Mit dem Aufbau ist es in der Tat bei mir etwas anders. Ich übertrage in etwa: 1 Byte, für den Modus (Lesen/Schreiben/Adressieren) und warte noch eine Rückmeldung ab, ob die Daten bereit stehen, bzw. übernommen wurden. Da geht schon einiges hin und her, bevor ein Byte übertragen ist.
MfG
PS: Deine Sammlung meiner "Werke" finde ich echt stark! Simple aufgebaute Dinge, die funktionieren. Wenn man sich dann anschaut, womit Du das gebaut hast ... Du kannst Spielzeugentwickler werden und viel Reichtum damit in den USA machen, Haua-ha! :-) Ich seh schon ... "Searcher-Toys" und die Kinder laufen die Bude ein. ;-)
:-) Ja, genau. Es sei denn BASCOM macht noch irgend etwas, das ich nicht weiß. Der SPI Master teilt doch nur mit SS dem Slave mit, daß da was kommt. Das Byte, das gesendet werden soll, sollte im Senderegister stehen und wird dann durch die Hardware rausgetaktet. Vielleicht programmiere ich das irgendwann auch noch zu Fuß aber im Augenblick läuft das mit den unten stehenden BASCOM Befehlen. Ob der Slave Daten zurückgibt ist in diesem Fall egal. Es soll ja nur die Adresse des zu übertragenden Datenbytes zu den 74HC595ern gelangen. Wenn der RAM Baustein eingebaut ist, soll vom Mega88 über einen Port das Datenbyte angelegt werden und mit einer WRITE Signal/Leitung in den RAM übernommen werden.Zitat:
Zitat von Moppi
Meine Schaltung ist von hier abgekupfert: https://rn-wissen.de/wiki/index.php?...AVR#Schaltplan
mit einem zweiten 74HC595 in Reihe. (und ohne die Widerstände - kommt noch, wenn ich Probleme entdecke - bis jetzt geht es ohne)
Messung mit Oszi zur Adressübertragung mit diesem Programm. Bei Tastendruck werden zwei Byte übertragen.
Code:$regfile = "m88pdef.dat"
$framesize = 32
$swstack = 32
$hwstack = 32
$crystal = 8000000
Config Spi = Hard , Interrupt = Off , Data_order = Msb , Master = Yes , Polarity = Low , Phase = 0 , Clockrate = 4 , Noss = 0
Spsr.spi2x = 1 'double spi speed for master
Spiinit
Ddrb.2 = 1 'SS as output
Portb.0 = 1 'activate pullup for button
Dim A(8) As Byte
Dim Counter_a As Byte
Counter_a = 1
A(1) = &B0000_0001
A(2) = &B0000_0010
A(3) = &B0000_0100
A(4) = &B0000_1000
A(5) = &B0001_0000
A(6) = &B0010_0000
A(7) = &B0100_0000
A(8) = &B1000_0000
Do
Debounce Pinb.0 , 0 , Shift_byte_out , Sub 'waits for button activation
Loop
End 'end program
Shift_byte_out:
Spiout A(counter_a) , 2 'sends two bytes of array A out of SPI Interface
If Counter_a > 6 Then Counter_a = 1 Else Counter_a = Counter_a + 2
Return
Nein. Daten sollen direkt über den Datenbus von einem Port am µC zum RAM gehen und über den gleichen PORT vom RAM gelesen werden. Nur die Schreib/Leseadresse geht bei mir per SPI über die Schieberegister zum RAM.Zitat:
Dann bekommst Du die Daten über SPI auch rein?
Ich könnte auch höher takten allerdings muß ich dann noch 'nen Quarz/e rauskramen und anbauen. Zum Testen reicht mir erstmal der interne Oszillator. Ich habe ja keine konkrete Anwendung wie Du, sondern schaue mal, wie weit ich komme.Zitat:
Kannst Du den Atmega nicht höher takten, nicht mit 20MHz?
Es kann auch sein, daß ich irgendwo einen fatalen Konzeptfehler habe, da ich erst baue und nicht so weit denke :-)
:-) Danke! :StrahlZitat:
PS: Deine Sammlung meiner "Werke" finde ich echt stark! Simple aufgebaute Dinge, die funktionieren. Wenn man sich dann anschaut, womit Du das gebaut hast ... Du kannst Spielzeugentwickler werden und viel Reichtum damit in den USA machen, Haua-ha! :-) Ich seh schon ... "Searcher-Toys" und die Kinder laufen die Bude ein. ;-)
Wo der über die Banane fährt (oder nur die Schale) find ich echt zum schreien, sieht irre aus, wie der schnurgerade drüberfährt.
Ja, die SPI-Schnittstelle hatte ich noch gar nicht im Hinterkopf, die habe ich noch nicht mal ausprobiert. Wenn ich das richtig nachgelesen habe, kann die auch mit einigen MHz arbeiten. Das ist schon interessant! Weil damit Parallel-Seriell und andersrum kein Thema ist. Wie sieht das denn dann mit den max. Kabellängen bei SPI aus? Letzten Endes müssen die Daten ja aber auch wieder irgendwo abgeholt werden, womit wir dann wieder zum Thema Netto-Datenrate kommen, eben das, was an einem bestimmten Punkt im Programm ankommt, dass es auch verarbeitet werden kann.
:-) :-) :-) Bei Youtube kann man ja nachsehen, von wo aus es die meisten Zugriffe gab. Da war "Ein erster Linienfolger ohne µC" in Indien sehr populär. Keine Ahnung wie der da hin kam :-)Zitat:
Zitat von Moppi
Ich hatte in den Blogs auch mal ein Bitbanging (falls die Bezeichnung hier zutrifft) Protokoll einer seriellen Datenübertragung im Zwangslaufverfahren über zwei Adern entwickelt. Da wird jedes Bit einzeln quittiert. Ist also nicht vom Takt abhängig. Die Übertragung kann unterbrochen und wieder aufgenommen werden. Erreichte, glaube ich nur 400000 Bit/s bei 16MHz Systemtakt da nicht HW unterstützt. Keine Ahnung ob Du das brauchen kannst. Hier der Link
Ja. Der SPI Takt läst sich auf halben Systemtakt konfigurieren. 20MHz Systemtakt - 10MHz SPI Master Takt.Zitat:
Ja, die SPI-Schnittstelle hatte ich noch gar nicht im Hinterkopf, die habe ich noch nicht mal ausprobiert. Wenn ich das richtig nachgelesen habe, kann die auch mit einigen MHz arbeiten.
Keine Ahnung. 10 oder 20cm sollten bei 10MHz kein Problem sein!?Zitat:
Wie sieht das denn dann mit den max. Kabellängen bei SPI aus?
Wo die zu verarbeitenden Daten von außerhalb diesen Systems eigentlich herkommen weiß ich (noch) nicht? Kann über UART, die laut Datenblatt auch SPI kann oder I2C oder ... oder.. USB? eingespeist werden.Zitat:
Letzten Endes müssen die Daten ja aber auch wieder irgendwo abgeholt werden, womit wir dann wieder zum Thema Netto-Datenrate kommen, eben das, was an einem bestimmten Punkt im Programm ankommt, dass es auch verarbeitet werden kann.
Die Gesamtgeschwindigkeit, mit der das System die Daten über den RAM hin und her verarbeitet, ist wahrscheinlich nur grob abschätzbar. Da hab ich überhaupt keine Ahnung. Ist für mich das erste Mal, das ich an so etwas brüte.
Da unsere Aufbauten doch anscheinend etwas auseinander laufen, habe ich meinen (geplanten) mal versucht aufzuzeichnen.
Anhang 33676 Anklicken zum Vergößern
Die µCs holen sich vom Bus-Control die Erlaubnis die nach unten führenden Busleitungen zu den Schieberegistern und zum RAM zu benutzen. Die µCs, die keine Erlaubnis haben, müssen ihre Busleitungen auf Input schalten (hochohmig schalten).
Jeder µC hat drei SPI Leitungen (MOSI(serielle Adress Daten), SS und Clock) zu den Schieberegistern. Die Datenleitung ist zum zweiten Schieber in Reihe geschaltet.
Jeder µC hat einen 8 Bit breiten PORT über den RAM-Datenbus an den Daten I/Os des RAMs. Ob der RAM gelesen oder beschrieben werden soll wird bei meinem RAM über zwei/drei Leitungen /OE bzw /WE und eventuel CS (Output Enable, Write Enable, Chip Select) gesteuert.
Grober noch zu testender Ablauf:
µC holt sich Buserlaubnis.
µC schiebt Adressdaten über Schieberegister zum RAM
Bedient /OE und /WE (CS) des RAMs
legt oder entnimmt Daten über den RAM-Datenbus
µC gibt Bus beim Bus Controler wieder frei
Dass man Bits einzeln übertragen kann, über zwei Leitungen ist mir auch klar. Das Prinzip ist ja auch dasselbe, wenn ich 8 Bit auf den Datenbus gebe und ein Signal sende, dass die Daten bereit stehen. Daraufhin bekomme ich eine Quittierung, ob sie abgeholt wurden. Man kann das auch stur nach Zeit machen, wenn man weiß in der Zeit schafft es die Gegenstelle die Daten abzuholen. Bis zu einer gewissen Taktrate, die hardwareabhängig ist, funktioniert das dann sogar. Aber hier ist es etwas anders. Ich muss jederzeit sichergehen, dass die Kommunikation einwandfrei verläuft. Weil ich hantiere ja hier mit mehreren Mikrokontrollern, die sich synchronisieren müssen.
Was ich mit Nettodatenrate meine ist: Die Daten kommen von egal woher. Aber um sie im Programm zu verwerten, muss man sie auch irgendwo abholen. Sie kommen zunächst in einem Puffer (SPI oder was anderes) an. Da muss ich prüfen, ist was im Puffer? - Ja, dann nimm das Byte raus und gib es zur Verarbeitung zum Programmcode zurück, der das Byte angefordert hat. Dieser Vorgang dauert ja auch Zeit, weil mit bestimmten Befehlen verbunden. Problem jetzt: ist die Schnittstelle schneller, als das Programm die Daten aus dem Puffer abholen kann, habe ich dort den Flaschenhals. Einerseits habe ich zwar eine enorme Übertragungsgeschwindigkeit, aber andererseits nur eine beschränkte Verarbeitungsgeschwindigkeit. Ich habe bspw. 8 Operationen inkl. Portzugriffe, je 8 Bit, Brutto, um zwei Byte Netto zu übertragen. Wenn mir das mit 125000Word/s gelingt, sind das theor. etwa 1MByte/s Brutto, die tatsächlich übertragen werden. Das ist auf jeden Fall schwierig zu ermitteln (weil bei der Ausführung der Software noch Unbekannte dabei sind - wie Unterbrechungen für Sachen die der Kontroller nebenbei noch tut: Interrupts, Zähler behandeln ..) und da muss man irgendwann mal das Endergebnis realistisch betrachten und nachmessen wie lange dann große Datenmengen zur Übertragung benötigen. Aber zum Abschätzen, auf was man da hinarbeitet - mit dem Konzept, finde ich es wichtig, dass man das ab und an reflektiert, was da überhaupt möglich ist oder wäre und wie man mit den Hindernissen umgeht.
Das Konzept mit der SPI-Schnittstelle ist auf jeden Fall bestens, wenn es darum geht, eine bekannte Menge Daten auszulagern und wiederzuholen. Ohne dass man die verfügbare Menge ext. Speicher überschreitet.
Ein Problem entsteht dann, wenn die Datenmengen unbekannt sind. Bzw. wenn die Datenmenge auf ein nicht vorher bestimmbares Maß anwachsen kann, wobei man sicher weiß, dass gewisse Größenordnungen (1GB) auch wieder nicht überschritten werden. In solchen Fällen ist immer gut, wenn man davon ausgehen darf, dass man "unbegrenzt" Speicher zur Verfügung hat. Zur Not eben durch Auslagerung. Das dauert zwar sehr viel länger, aber bringt nicht den Verarbeitungsprozess zum Erliegen.
Zurzeit kann ich noch gar nicht abschätzen, ob ich SPI sinnvoll einsetzen könnte. In der ersten Überlegung ja - könnte das Adressieren des Speichers vereinfachen. Ich kenne nur noch nicht alle Schwächen meines Konzepts, weil ich mit der Programmierung noch nicht fertig bin. Evtl. gibt es da auch gar keine. Ich habe einen Kontroller, der sich um den Speicher kümmert. Einen Weiteren, der die SD-Karte bedient. Drum herum habe ich D-Latches zur Abgrenzung zwischen dem Kontroller der Daten verarbeitet (Sender) und den anderen beiden (Empfänger), die sich um die Beschaffung etc. kümmern. Sender und Empfänger laufen in gewissen Grenzen asynchron und können das auch mit unterschiedlichen Geschwindigkeiten. Hat der Sender Daten zum Speichern abgegeben, dann nehmen die Empfänger das entgegen und der Sender macht sich auf den Weg, weitere Daten zu holen. Während dieser Zeit können die Empfänger die abgegebenen Daten verarbeiten (speichern). Beim Lesen dasselbe Prinzip in andere Richtung. Einige Verarbeitungszyklen laufen damit parallel, bei Sender und Empfänger und kosten damit keine zusätzliche Zeit. Vorgänge werden damit zeitlich verkürzt - so die Idee. Jede Datenverarbeitung kann man auch nur zu einem gewissen Teil parallelisieren, weil manche Vorgänge einfach nacheinander stattfinden müssen, weil voneinander abhängig.
MfG
Das übersteigt meine Ambitionen dann doch etwas ;-) Inzwischen habe ich aber noch eine Teilaufgabe für mich entdeckt, die ich mir nochmal ansehen möchte. Die USART kann beim Mega88 (Mega328 ) auch als SPI Schnittstelle verwendet werden.Zitat:
Zitat von Moppi
Da im Gegensatz zur SPI von double Buffer beim Transmitter geschrieben wird: Geht der schneller?
Kann man den parallel zur "normalen" SPI-Schnittstelle betreiben und hat man dann zwei SPI Schnittstelle mit schneller Übertragung zur Verfügung? Je schneller die Daten übertragen sind, desto mehr Zeit gibt es für andere Dinge.
Bin neugierig, wie es bei Dir weitergeht und vielleicht schreibst Du irgendwann mal, was es geworden ist oder was es mal werden sollte.
Gruß
Searcher
Zurzeit brauche ich ewig für ein paar Codezeilen. Ich hab's gerade mal durchgezählt. Ohne RAM sind es 8 Steuersignale, mit denen die gesamte Beschaltungslogik koordiniert wird. Viele laufen immer über ein Byte, also einen Port. Vertue ich mich irgendwo mit einem Bit, kann es passieren, dass ich Ausgang auf Ausgang schalte oder Daten nicht rüberkommen, weil D-Latch-Ausgänge deaktiviert sind. Echte Gehirnakrobatik, zu jedem Zeitpunkt bei der Programmierung zu wissen, in welchem Zustand die Schaltung sich gerade befindet.
Na was es werden soll, ist Datenverarbeitung. Ich hatte schon geschrieben, dass ich mich von der Softwareebene (hier ist das vornehmlich Javascript und PHP) lösen möchte. Daten lesen, verarbeiten, Daten schreiben, Daten verändern (Stringoperationen allgemein, z.B.: indexOf, replace, split), Daten vergleichen. In Größenordnungen bis einige Megabyte. Um es kurz und knapp zu beschreiben: Assistenz in der Datenverarbeitung. Oder: softwarebasierte Assistenten.
Ich habe schon überlegt, ob es dann nicht sinnvoll ist ein extra Board zu bauen und hiermit eine Basis für die Integration mehrerer (vieler) Kontroller zu schaffen. Ich würde das vielleicht Borg Board nennen. Angelehnt an die bekannte Serie. So: erweitere einen bestehenden Verbund durch Assimilation weiterer Kontroller und/oder Speicher und mache ihn damit leistungsfähiger. - na ja, visionär ;)
MfG
Ich mußte mich doch noch an dem USART als SPI-Master im Mega88 versuchen.Zitat:
Zitat von Searcher
Hab die ASM Initialisierungs- und Datensendebeispiele aus dem Datenblatt angepaßt und drei Bytes in 7,7µs, also knapp 400000 Bytes/s bei 8MHz Systemtakt abschicken können. Gemessen mit Oszi an dem, zusätzlich in die ASM-Routinen aufgenommenen SS Pin.
Auch der Master SPI-Takt am USART läßt sich auf halben Systemtakt einstellen indem man nur im Register UCSR0A das U2X0 Bit setzt. Der Geschwindigkeitsvorteil gegenüber der, ich nenn sie mal nativen HW SPI Schnittstelle kommt durch das "double buffering". Beim USART kann das Senderegister schon neu beschrieben werden während das vorhergehende byte noch rausgetaktet wird. Beim nativen SPI muß gewartet werden, bis das byte rausgetaktet wurde. Im Oszillogramm tauchen beim nativen SPI Pausen im Takt zwischen den gesendeten Bytes auf, die es beim USART nicht gibt.
Die Entgegennahme der Daten in den 74HC595 stellt kein Problem dar. Vermutlich eher die Bereitstellung der Daten aus der Anwendung heraus. Wenn man die native HW-SPI auch noch parallel betreibt dürfte das den Flaschenhals doch noch relativ enger machen ;-) :-)
Gruß
Searcher
Den Flaschenkörper nicht so groß wählen, der Inhalt muss dann alles durch den engen Hals! ;-)
--------------------------------------------------------------------------
Nachtrag:
Nachdem ich einiges an meiner Schaltung durchprobiert habe, habe ich gedacht, ich kann es hier mal mit reinstellen, nachdem wir schon so viel darüber geschrieben haben. Funktionell ist es wohl fehlerfrei. Die Notizen zum Komm.-Protokoll: ändert sich während der Programmierung, das war nur ein erster Anhaltspunkt - aber so in etwa geht es.
Anhang 33684
Anhang 33685
MfG
Interssanter Schaltplan.Zitat:
Zitat von Moppi
Da gab's drei Modi, für Mode A + B: 0+0 = Adressieren, 0+1 = Lesen, 1+0 Schreiben, 1+1 = Bestätigung/Quitt.
Obwohl, den gab es nochmal anders:
Anhang 33721