Datenlogger auf ARDUINO- Basis

    Diese Seite verwendet Cookies. Durch die Nutzung unserer Seite erklären Sie sich damit einverstanden, dass wir Cookies setzen. Weitere Informationen

    Aufgrund technischer Veränderungen ist der Mailverkehr innerhalb des Forums (Private Nachrichten) nur noch eingeschränkt möglich. Die Einschränkung ist notwendig, um zusätzliche Betriebskosten für das Forum zu vermeiden. Näheres zu den Hintergründen im Thread "Aktuelles zum Forum".Wir bitten um Verständnis.

    Hinweis kann nach Kenntnisnahme deaktiviert werden!

    • Ulrich schrieb:

      an den 328-Pins feine Drähte anlöten.
      Ich zitiere mal aus der ins deutsche übersetzten Beschreibung:

      SPARKFUN schrieb:

      SPI


      Am gegenüberliegenden Ende der Platine sind außerdem vier
      SPI-Testpunkte herausgebrochen. Mit diesen können Sie den Bootloader auf
      dem ATmega328 neu programmieren.

      Das neueste OpenLog (DEV-13712) bricht diese Punkte in kleineren durchkontaktierten Löchern heraus. Wenn Sie einen ISP zum Neuprogrammieren oder Hochladen eines neuen Bootloaders auf OpenLog verwenden müssen, können Sie Pogo-Pins verwenden, um eine Verbindung zu diesen Testpunkten herzustellen.
      Die Pins müssten eigentlich von links nach rechts Reset, SCK, Mosi und Miso sein, entweder der ganz linke oder ganz rechte verlötete Punkt wird die 3.3V des Chips führen (lt. Schaltplan gibt es einen TP1 also Testpunkt), das müsste man heraus messen. Gnd wiederum ist sowieso unten herausgeführt.

      Einfache Flasher brauchen auch keine Verbindung zur Stromversorgung, der MKII meckert aber, wenn der nicht erkennt, dass die Zielschaltung nicht stromversorgt ist.
      Daher sollte die Stromversorgung des Moduls aufrecht sein und auch nicht fremdversorgt werden (viele einfache Flasher tun das) da da ein eigener Spannungsregler alles tut was das Modul braucht während der MKII wiederum die Zielschaltung gar nicht versorgt sondern nur prüft ob die Stromversorgung aufrecht ist.

      Und während dem Flashen sollte auch keine SD-Karte gesteckt sein, weil die wohl auch an den ISP-Punkten hängt.
      Und natürlich kann man über den SPI dann nicht nur einen Bootloader flashen.

    • Ulrich schrieb:

      Die Frage die ich mir auch stelle, wo liegt die Resonatorfrequenz des Moduls und wie kommt der 328 bei 3,3V+/- ? mit den 16MHz zurecht?
      Das Quarz hat keine Aufschrift oder einen Code?
      Was immer funktioniert ist Messen, am besten Mit Oszi.

      Ob der 328p mit 16MHz bei 3,3V klar kommt?
      Er benötigt 2,7V für 10MHz; und 4,5V für 20MHz.
      In einem Diagramm im Datenblatt kann man auslesen, dass bei 3,3V nur ca. 12,25 MHz erreicht werden.
      Ich vermute daher, dass der nicht mit 16MHz läuft.

      Auch da hilft messen, welche VCC der Controller tatsächlich bekommt.

    • Laut Schaltplan ist ein ATMEGA328P_TQFP verbaut der mit 3.3V (Spannungsregler 3.3V MIC5205) versorgt wird.

      Die 3.3V sind wohl wiederum der SD-Karte geschuldet.

      Möglicherweise ist das ganze ja mit der heißen Nadel gestrickt :D .


      Laut Sparkfun sind die Daten aber wohl korrekt.


      SPARKFUN schrieb:

      Der SparkFun OpenLog ist ein Open-Source-Datenlogger, der über eine einfache serielle Verbindung funktioniert und microSD-Karten bis zu 32GB unterstützt. Der OpenLog kann große Mengen serieller Daten speichernoder „protokollieren“ und als eine Art Blackbox fungieren, um alle seriellen Daten, die Ihr Projekt generiert, für wissenschaftliche oder Debugging-Zwecke zu speichern.

      Der SparkFun OpenLog verwendet dank des integrierten Resonators einen ATmega328, der mit 16 MHz läuft.
      Der OpenLog verbraucht im Leerlaufmodus (nichts aufzuzeichnen) etwa 2-3mA. Während einer vollständigen Aufzeichnung kann OpenLog je nach verwendeter microSD-Karte 10 bis 20 mA verbrauchen.

      Alle vom OpenLog protokollierten Daten werden auf der microSD-Karte gespeichert.
      Jede microSD-Karte mit 512 MB bis 32 GB sollte funktionieren. OpenLog unterstützt sowohl die SD-Formate FAT16 als auch FAT32.

      Für eine noch bessere Leistung ist OpenLog Artemis das Tool, das Sie benötigen, mit Protokollierungsgeschwindigkeiten von bis zu 500.000 Bit/s.

    • Ulrich schrieb:

      an den 328-Pins feine Drähte anlöten
      Die benötigten Pins liegen auf den Bohrungen der unbelegten Seite. (Rst,Sck,Mo(si) und Mi(so). Fehlt nur noch Gnd , der kann von der anderen Seite genommen werden ;)
      Direkt an den Pins ist greußlich, das würde ich auch vermeiden wenn möglich.

      Der Bootloader wird sich vermutlich nicht überreden lassen den Flash Inhalt aus zu geben?

    • Aufgrund des Schaltbild sehe ich eine Beschaltung des SCK-Pins.
      Daran hängt eine LED (keine Low-Current) mit 330 Ohm Vorwiderstand.

      Diesen Pin muss ja der Programmer Takten, denn während der Programmierung über ISP ist der Controller Slave.
      Möglicherweise ist genau das das Problem.

      Ich glaube nicht, dass der SCK-Ausgang des Programmers mit 1MHz Takt die LED auch noch mit ca. 5mA treiben kann,
      ohne dass der SCK-Pegel zusammen bricht.

      LED oder Vorwiderstand auslöten und dann nochmal flashen mit anschließendem Verify durchführen.
      Gehts dann, was das das Problem.

      Wenn nicht, geht die Suche weiter.

    • Guter Hinweis

      Mitch64 schrieb:

      ohne dass der SCK-Pegel zusammen bricht.
      Dann hat der einfach keinen "Dampf" X( Mein MKII ist da auch schlapp. Mit 125kHz schafft er es (so gerade) mit dem Mosi über 220R ein LCD Backlight zum Flackern zu bringen.
      Weniger Speed könnte da helfen.
      Oder sind da Reihenwiderstände verbaut? Die 5 mA sollte er eigentlich spielend hin bekommen?
      Schwach, daß so ein "Profigerät" gegen einen 2€ Usbasp "abstinkt"

    • Hallo alle zusammen!

      Um auch meinen Senf dazuzugeben:
      Meinem "no name" OpenLog Modul habe ich vor einigen Tagen ebenfalls die V4.3 Firmware des Sparkfun-Moduls gegönnt. Die Beschaltung ist zwar nicht 100% gleich, aber beide haben den ATMEGA328P_TQFP verbaut.
      Mit meinem alten myAVR MKII Prommer und meiner altbewährten Software (myAVR ProgTool V1.56) zum Brennen hat dies auch Anhieb ohne Probleme funktioniert.
      Beim Brennvorgang hatte ich nicht mal die Verbindung zum Mega2560-Board getrennt und die Stromversorgung während des Brennvorganges erfolgte ausschließlich über den Prommer! (Das Mega2560 Board wurde dadurch natürlich die ganze Zeit vom Prommer spannungsmäßig mitversorgt).

      Hier noch ein Bild vom Anschluss des Adapterkabels (SPI/ISP) für den Prommer:
      ISP_Openlog.JPG
      Ganz links, mit der weißen Markierung, dass ist GND und die 5V vom Prommer habe ich an VCC auf der gegenüberliegenden Anschlussreihe eingespeist.

    • Hallo liebe Untertsützer und Hinweisgeber,

      Habe heute alle Pegel an dem No-Name Modul (mit Update Problem) nachgemessen, siehe Bilder MISO, MOSI, SCK.

      Mitch64 schrieb:

      Ich glaube nicht, dass der SCK-Ausgang des Programmers mit 1MHz Takt die LED auch noch mit ca. 5mA treiben kann,
      ohne dass der SCK-Pegel zusammen bricht.


      Zu diesem Modul, habe ich via Fusebit-Einstellung den Clock-Out gemessen: 15,993MHz sowie die Spannung am AVR-328 Pin4 von 3,255V

      Wenn ich den Chip-Inhalt nach dem Schreiben (Chip/write buffer into chip) in den Buffer zurücklese, deckt er sich nur in Teilen mit dem OpenLog_V43.hex. (siehe Bilder: Buffer zurückgelesen/OpenLog_V43) Vielleicht hängt das mit der niedrigen Spannung zusammen.

      Beim Sparkfun Modul lässt sich offenbar die Fusebit Einstellung nicht auslesen????

      @avralfred

      Erstellt dein No-Name Modul auch automatisch eine Config.txt, wenn auf der SD-Card beim Power-Up keine vorhanden ist?

      Viele Grüsse Ulrich
      Dateien

      • Prommer Bild2.jpg

        (70,59 kB, 15 mal heruntergeladen, zuletzt: )

      • Buffer zurückgelesen.JPG

        (273,81 kB, 13 mal heruntergeladen, zuletzt: )

      • OpenLog_V43 im Buffer.JPG

        (310,98 kB, 11 mal heruntergeladen, zuletzt: )

      • MISO.BMP

        (998,45 kB, 10 mal heruntergeladen, zuletzt: )

      • MOSI.BMP

        (998,45 kB, 5 mal heruntergeladen, zuletzt: )

      • SCK.BMP

        (998,45 kB, 9 mal heruntergeladen, zuletzt: )

    • Mal davon abgesehen, dass der Controller mit 16MHz und 3,3V außerhalb der Spezifikation betrieben wird,
      fallen doch noch die Pegel an der ISP-Schnittstelle auf.

      • Miso passt mit 3,3V. Das ist in Ordnung.
      • Mosi liegt höher, bei 3,8V. Wieso? Treibt dein Programmer 5V am MOSI?
      • Und der SCK (am Controller-Pin gemessen?) hat nur 2,5V. Das sind 75% von VCC. Das halte ich für zu wenig.
      Wie sieht das Reset-Signal aus von den Pegeln?

      Löte mal den Widerstand raus von der LED am SCK-Pin, oder probiere mal einen anderen Programmer, so wie es auch schon Pluto geschrieben hat.

    • Ulrich schrieb:

      wenn auf der SD-Card beim Power-Up keine vorhanden ist?
      Wobei es auch noch eventuell auf den Softwarestand ankommt.
      In der aktuellen Version wird jedenfalls eine Config.TXT angelegt.
      Deren Inhalt ist davon abhängig was vorher mit dem Modul passiert ist.
      Ist das Modul "nagelneu" (z.B. neu geflasht und das EEPROM wurde dabei auch gelöscht) werden die Standard-Vorgabewerte für das Config geschrieben, während bei einem bereits verwendeten Modul jene Werte in die Config.TXT geschrieben werden, welche auch die vorhergehende SD-Karte kannte (die auch abweichend vom Standard sein können.

    • An alle meine Unterstützer und andere Interessierte

      No-Name OpenLog-Modul läuft nun mit Update OpenLog_V43.hex

      Die Aufgabe bestand darin, ein Programm welches nur als *.hex File vorliegt, in einen AVR328 mit einem Diamex-Prommer zu übertragen.

      Die entscheidende Maßnahme war letztlich anstatt:

      Chip/write Buffer into chip das andere

      Chip/Autoprogram auszuwählen.



      Für alle, die sich ebenfalls für diese preiswerten Logger-Module (OpenLog-Module) interessieren und bei Bedarf ein erforderliches update einspielen wollen, hier meine Vorgehensweise. (Diese gilt prinzipiell für alle Dateien, die nur im *.hex Format vorliegen und in einen AVR-Prozessor einprogrammiert werden sollen)

      Hier speziell: Update-Adapter für das No-Name Modul präparieren, d.h. eine ISP-Verbindung mit Prommer herstellen (Ist etwas Lötarbeit, MISO-,MOSI-,SCK-,Reset- sowie Power-Pins des Moduls mit ISP vom Prommer verbinden. Prommer auf 3,3V Spannung einstellen. (Diamex-Bedienungsanleitung/ Bild vom Adapter in Post#68 von avralfred, Modulbilder in Post#39/#41)

      Zunächst im Menue Options/Programmer das Autoflash deaktivieren.

      Um beim Aufruf von Bascom Zugriff auf die ausgegrauten Menue-Icons zu erhalten, ist ein kurzes (beliebiges) Bascom-Programm mit dem entsprechenden AVR-Typ aufzurufen.

      Danach ist der Zugriff auf die Menue-Icons freigegeben und es kann wie folgt weitergehen:
      • Program Chip (F4) aufrufen
      • Im erscheinenden Menue: Buffer/clear anklicken (im Buffer-Bereich zeigen alle Werte nun „FF“/ dies nur zur Sicherheit, kann auch entfallen)
      • Buffer/Load from file anklicken (*.hex file mit Explorer suchen und mit öffnen auswählen, danach wechseln die im Buffer-Bereich angezeigten FF-Werte in die geladenen Hex-Werte )
      • Im Menue nun Chip/Autoprogram! auswählen und

      • warten bis der grüne Fortschrittsbalken abgelaufen ist und das Fenster geschlossen wird. Falls das Fenster nicht schließt, ist wohl ein Fehler aufgetreten.
      • Modul aus dem Update-Adapter entnehmen, und an den Logger-Prozessor anschließen, der die Daten für die SD-Card des Moduls liefern soll.



      Diese Vorgehensweise hat bei mir zum Erfolg geführt (zwei Module upgedated). Die No-Name Module funktionieren damit entsprechend der im Forum-Lexikon zu findenden OpenLog Beschreibung . Auf Basis der detaillierten Programm-Schnipsel von Zitronenfalter (Post#21/#23) kann ich noch mein Programmbeispiel zum Testen und Betrieb solcher Module beisteuern. (Anlegen weiterer Files zur Runtime)

      Ich hoffe, ich habe nichts vergessen…

      Gruß

      Ulrich

    • OpenLog Ergänzung/Hinweise

      Micro SD-Card: wenn möglich schnelle Variante, z.B. Class 10
      Formatierung SD-Card: Fat32
      Max. Grösse SD-Card : 32GB
      Verdrahtung: siehe Bild
      Beispiel/Test-Programm für Arduino Mega2560

      Mit Editor: 38400,26,3,0,0,0,0 als Config.txt vor Betrieb auf die SD-Card schreiben. (es sind alle Baudraten definierbar, 9600Bd ist Standardrate)

      Zur Vorgeschichte:

      Es gab in meinem Umfeld die Anforderung alle 5ms einen ADC-Wert über 12 Stunden mit 115200Bd auf einer SD-Card zu speichern.

      Zudem sollte das SD-Card Modul so klein wie technisch möglich sein, und eine einfache Ansteuerung aufweisen. Die Wahl fiel auf ein OpenLog Modul, welches mit der entsprechenden Config.txt (115200Bd,26,3,0,0,0,0) sowie via Tx-Port zu beschreiben ist.

      Da sonst keine weiteren Einstellungen (auch kein update) vorzunehmen waren, funktionierte das Loggen auf Anhieb und es wurde eine einzige große *.txt Datei erstellt. (8,64MB)

      Um diese riesige Datenmenge auch grafisch darstellen zu können, bot sich der Flow-CSV-Viewer an, welcher vermittels Zoomeinstellung jeden Abschnitt der dargestellten Grafik einsehbar macht, lediglich die Endung *.txt musste vorher in *.csv umbenannt werden.

      Um jedoch auch während der Laufzeit schon mehrere Files anlegen zu können (nicht nur nach Powerup) und zugleich den Namen der Files sowie die File-Endung *.csv selbst definieren zu können, wurde das Testprogramm erstellt.

      Testprogramm folgt....
      Dateien

    • Und hier noch mein Testprogramm für die Kommunikation mit OpenLog-Modul

      BASCOM-Quellcode

      1. '( Datum: 03.10.2023, Bascom Version 2.0.8.6
      3. Programm-Name: Forum V5 Test mit Gosub.bas
      5. Test-Programm für Kommunikation zum Openlog Modul
      6. In diesem Testprogramm wird auch ein Uhr Modul verwendet, z.B.
      7. ' https://www.reichelt.de/raspberry-pi-real-time-clock-modul-rtc-ds3231sn-rpi-rtc-clock-p224214.html?search=RTC-Modul
      9. Hier wurde der Einfachheit halber eine Sub Newfile zur Erkennung der
      10. OpenLog-Quittungszeichen gewählt.
      12. Auf SD-Card config.txt erstellen, Inhalt mittels Editor: 38400,26,3,0,0,0,0
      13. (das OpenLog-Modul wird hier mit 38400Bd beschrieben)
      15. Das Programm wurde auf einem upgedateten No-Nome Modul getestet.
      16. Sicherlich kann man Verbesserungen vornehmen, jedoch ist es ja auch nur
      17. ein Testprogramm
      20. **************************************************************************
      21. Mein besonderer Dank gilt Forums-Mitglied "Zitronenfalter", da ohne seine
      22. Vorarbeit dieses Programm so nicht möglich gewesen wäre
      23. **************************************************************************
      25. ')
      27. $regfile = "m2560def.dat"
      28. $crystal = 15875949 '!!!anstatt 16MHz hat mein Mega2560 nur 15,875MHz
      29. 'bei zu großer Abweichung von 16Mhz anpassen
      30. $hwstack = 200
      31. $swstack = 400
      32. $framesize = 400
      34. Disable Jtag
      37. Dim Naked_date As String * 8
      38. Dim Weekday As Byte
      39. Dim Sekunde As Byte
      40. Dim Got_time As String * 8
      41. Dim Got_date As String * 8
      43. Dim Newfilename As String * 12
      44. Dim Filenumber As Byte
      45. Dim F_nr As String * 3
      46. Dim S As String * 2
      47. Dim Fa As Byte
      48. Dim Fs As String * 3
      49. Dim Op_sent As String * 50
      50. Dim Substring1 As String * 2
      51. Dim Substring2 As String * 1
      52. Dim Cnt As Word
      53. Dim Text As String * 30
      54. Dim A As Byte
      57. Config Portf.0 = Output 'Ersatz-Reset Port für OpenLog Modul
      58. Testport Alias Portf.0
      59. Reset Testport 'separater Start-Reset für OpenLog-Modul
      61. Config Com4 = 38400 , Synchrone = 0 , Parity = None , Stopbits = 1 , Databits = 8 , Clockpol = 0
      62. Open "Com4:" For Binary As #3 'Output zum OpenLog für Daten
      64. Config Com3 = 38400 , Synchrone = 0 , Parity = None , Stopbits = 1 , Databits = 8 , Clockpol = 0
      65. Open "Com3:" For Binary As #2 'Input vom Openlog für Quittungen und anderes
      67. Config Serialin2 = Buffered , Size = 200
      70. Config Com1 = 115200 , Synchrone = 0 , Parity = None , Stopbits = 1 , Databits = 8 , Clockpol = 0
      71. Open "Com1:" For Binary As #1 'Output zu Hterm, Mitlesen der Kommunikation
      73. Enable Interrupts
      76. $lib "i2c_twi.lbx"
      77. '-------------I2C Parameter---------------------------
      79. Config Scl = Portd.0 ' serial clock SCL am mega2560
      80. Config Sda = Portd.1 ' serial data SDA am mega2560
      81. I2cinit
      82. Config Twi = 400000 ' Taktrate 400KHz
      83. Const Ds3231w = &HD0 ' RTCadresse fuers schreiben
      84. Const Ds3231r = &HD1 ' RTCadresse fuers lesen
      85. Config Clock = User
      87. ''setze 32,768kHz (1Hz) Takt-Ausgang
      88. I2cstart
      89. I2cwbyte Ds3231w
      90. I2cwbyte 7
      91. 'I2cwbyte &B10010000 ' Control-Byte für 1Hz am SOW-Out
      92. I2cwbyte &B00010011 ' Control-Byte für 32,768kHz am SOW-Out
      93. I2cstop
      95. Config Date = Dmy , Separator = Minus 'Datumsformat TT-MM-JJ
      97. ''Zum Stellen der Uhr (DS3231) Date und Time aktualisieren und aktivieren
      98. 'Date$ = "03-10-23" 'z.B.: für Tests, Startzit definieren
      99. 'Time$ = "16:15:00" '
      101. ''---------------------Versions-Daten
      102. 'F_name = Version(3)
      103. 'F_date = Version(1)
      105. 'F_datum = Left(f_date , 10)
      106. 'F_time = Right(f_date , 8)
      107. 'Text = F_datum + " " + F_time
      108. 'Print #1, Text
      109. '-----------------------------------------------------------
      111. Clear Serialin2 'Eingangsbuffer für OpenLog Quittungen Löschen
      113. Wait 3 'Wartezeit damit OpenLog nach Powerup bereit wird
      115. ' '*******************************************************************************
      116. Filenumber = 0
      118. ''#############################
      119. Do
      121. Print #1 , "Do-Loop " 'Ausgabe für Hterm zur Kontrolle
      123. Gosub Newfile
      124. If A <> 0 Then 'Schreibfreigabe bei ungleich 0, aus Sub Newfile
      126. 'ab hier beliebige Daten auf Openlog Modul speichern
      127. ' Zur Kontrolle und auch für den Flow CSV Viewer doppelte Ausgabe
      128. 'z.B. Header-Zeilen
      130. Got_time = Time$
      131. Text = "#" + Got_time + "," + "new-Testfile " + "," + "2-Headerline" 'Beispiel Texte
      132. Print #3 , Text
      133. Text = "#" + Got_time + "," + "new-Testfile " + "," + "2-Headerline" 'Beispiel Texte
      134. Print #3 , Text
      135. Wait 1 'dieses Wait hier, nur damit der Time-Wert ein neuer ist
      137. Got_time = Time$
      138. 'ab hier Beispiel Daten, nur um zu sehen ob alles auch auf SD-Card landet
      139. Cnt = 0
      140. Do
      141. Incr Cnt
      142. Text = Str(cnt) + " , " + Got_time
      143. Print #3 , Text 'Daten zur SD-Card
      144. Loop Until Cnt > 100
      145. Print #1 , "---Daten sind geschrieben---" 'Für Hterm ausgabe
      146. End If
      148. Wait 3 'Pause bevor ein neues File angelegt wird
      149. Loop Until Filenumber > 1 'neues File anlegen,
      151. End
      153. '****************************************************************************
      155. Newfile: ''neues File im Command Modus anlegen
      157. Print #1, 'Kontrollausgaben für Hterm
      158. Print #1 , "***sub Newfile*******"
      159. Incr Filenumber
      160. Text = "Filenumber= " + Str(filenumber)
      161. Print #1 , Text 'Kontrollausgaben für Hterm
      162. Print #3 , "{026}{026}{026}"; ' bisherige Datenübertragung beenden
      163. 'und in Command-Modus wechseln
      165. 'Dieses Wait mit 200ms ist wichtig, da sonst nichts auf der SD-Card landet
      166. Waitms 200 'Offenbar benötigt das Modul einige Zeit
      167. ' 'um den Config.txt Inhalt zu interpretieren
      169. Op_sent = ""
      170. Substring1 = "~>" 'Quittungs-Zeichen für Modul im Command-Modus
      172. While Ischarwaiting(#2) = 1 '#2=Com3 für Empfang von OpenLog
      173. Fa = Waitkey(#2) 'Fa als Byte
      174. Fs = Chr(fa) 'von Byte nach Charakterzeichen
      175. Op_sent = Op_sent + Fs 'alle Zeichen sammeln
      176. Waitms 1 '???? Wartezeit, da Programm zu schnell ????
      177. Wend
      179. A = Instr(op_sent , Substring1) 'ist Command_modus?
      180. Print #1 , "A1=" ; A
      181. If A <> 0 Then 'substring gefunden wenn ungleich 0
      182. Print #3 , "sync" ' Restbuffer in file schreiben
      183. '
      184. Got_date = Date$
      185. Naked_date = Got_date
      186. Delchars Naked_date , "-" 'Binde-Striche zwischen den Uhr-Ziffern..
      187. '..entfernen, da max. 8 Zeichen erlaubt sind
      189. F_nr = Str(filenumber) 'wurde in Hauptschleife inkrementiert
      190. S = Format(f_nr , "0") 'einstellig, da sonst nicht in Filenamen passt
      191. Newfilename = Naked_date + "-" + S + ".csv" 'Erweiterung wichtig 8.3
      193. Clear Serialin2 'frei für neue Quitungs-Zeichen
      195. Print #3 , "append " ; Newfilename 'hier neues File erstellen
      196. Print #1 ,
      198. ''*******auf Freigabe zum Daten-Schreiben prüfen
      199. Op_sent = ""
      200. Substring2 = "<" 'Quittungs-Signal vom Modul, bin im Schreib-Modus
      201. Print #1 , "-------" 'Hterm Ausgabe
      202. Print #1 , "Check Freigabe" 'Hterm Ausgabe
      204. While Ischarwaiting(#2) = 1 '#2=Com3 für Empfang von OpenLog
      205. Fa = Waitkey(#2) 'Fa als Byte
      206. Fs = Chr(fa) 'von Byte nach Zeichen
      207. Op_sent = Op_sent + Fs 'alle Zeichen sammeln
      208. Waitms 1 '???? Wartezeit, da Programm zu schnell ????
      209. Wend
      210. A = Instr(op_sent , Substring2) ' Write-Modus
      211. Print #1 , "A2=" ; A 'Hterm Kontroll ausgabe
      212. End If
      213. Return
      215. ''*******************************************************************************
      217. Getdatetime:
      219. I2cstart
      220. I2cwbyte Ds3231w
      221. I2cwbyte 0
      222. I2cstart
      223. I2cwbyte Ds3231r
      224. I2crbyte _sec , Ack
      225. I2crbyte _min , Ack
      226. I2crbyte _hour , Ack
      227. I2crbyte Weekday , Ack
      228. I2crbyte _day , Ack
      229. I2crbyte _month , Ack
      230. I2crbyte _year , Nack
      231. I2cstop
      232. _sec = Makedec(_sec) : _min = Makedec(_min) : _hour = Makedec(_hour)
      233. _day = Makedec(_day) : _month = Makedec(_month) : _year = Makedec(_year)
      235. Return
      236. '*******************************************************************************
      238. Setdate:
      240. _day = Makebcd(_day) : _month = Makebcd(_month) : _year = Makebcd(_year)
      241. I2cstart
      242. I2cwbyte Ds3231w
      243. I2cwbyte 4
      244. I2cwbyte _day
      245. I2cwbyte _month
      246. I2cwbyte _year
      247. I2cstop
      249. Return
      250. '*******************************************************************************
      252. Settime:
      254. _sec = Sekunde 'Hier wird die Sekundenvariable mit dem gestellten Wert ersetzt.
      255. _sec = Makebcd(_sec) : _min = Makebcd(_min) : _hour = Makebcd(_hour)
      256. I2cstart
      257. I2cwbyte Ds3231w
      258. I2cwbyte 0
      259. I2cwbyte _sec
      260. I2cwbyte _min
      261. I2cwbyte _hour
      262. I2cstop
      264. Return
      265. '*******************************************************************************
      Alles anzeigen

    • Hallo Gemeinde,
      hier mein BASCOM Programm für das OpenLog-Moodul auf Basis von Ulrich - Danke hier an dieser Stelle.
      Habe es angepaßt an einen ATmega128. Dieser hat ja nur 2 Schnittstellen.

      Ach ja, das OpenLog-Modul verpaßt jeder Datei das selbe Datum. Kann man das irgendwie ändern? Klar wseiß ich, daß das Modul keine Uhr mit Datum hat, aber wäre schon schön.

      Quellcode

      1. 'OpenLog Test ATmega128.bas abgewandelt von
      3. '( Datum: 03.06.2024, Bascom Version 2.0.8.6
      4. Programm -name : Forum V5 Test Mit Gosub.bas
      5. Test-Programm für Kommunikation zum Openlog Modul
      6. In diesem Testprogramm wird auch eine Echtzeituhr Uhr DS1307 verwendet.
      7. Auf SD-Card config.txt erstellen, Inhalt mittels Editor: 9600,26,3,0,0,0,0
      8. (das OpenLog-Modul wird hier mit 9600 Bd beschrieben)
      9. Das Programm wurde auf einem upgedateten No-Nome Modul getestet.
      10. Sicherlich kann man Verbesserungen vornehmen, jedoch ist es ja auch nur
      11. ein Testprogramm
      12. **************************************************************************
      13. ')
      14. $regfile = "m128def.dat"
      15. $hwstack = 216
      16. $swstack = 216
      17. $framesize = 232
      18. $crystal = 14745600
      19. $version 0 , 3 , 90
      21. Disable Jtag
      23. Dim Naked_date As String * 8
      24. Dim Naked_time As String * 8
      25. Dim Weekday As Byte
      26. Dim Sekunde As Byte
      27. Dim Got_time As String * 8
      28. Dim Got_date As String * 8
      29. Dim Newfilename As String * 12
      30. Dim Filenumber As Byte
      31. Dim F_nr As String * 3
      32. Dim S As String * 2
      33. Dim A As Byte
      34. Dim Rechts As String * 1 'ASCII-Wert der Position 3 der Befehlzeichenfolge
      35. Dim B_udr As String * 7 'wird für das Zusammensetzen der Zeichen von UDR genutzt
      37. Config Portd.5 = Output 'Ersatz-Reset Port für OpenLog Modul
      38. Resetopenlog Alias Portd.5
      39. Reset Resetopenlog 'separater Start-Reset für OpenLog-Modul
      41. Config Portf.5 = Output 'Einschalten OpenLog Modul
      42. Set Portf.5
      44. 'UART0 ist Standard COM1 und wird hier als #2 angesprochen. Verwendung: OpenLog
      45. Config Com1 = 9600 , Synchrone = 0 , Parity = None , Stopbits = 1 , Databits = 8 , Clockpol = 0
      46. Open "Com1:" For Binary As #2 'Daten-Input vom Openlog, Quittungen
      47. Config Serialin1 = Buffered , Size = 200
      49. 'UART1 ist COM2 und wird hier als #1 angesprochen. Verbindung zum Terminal
      50. Config Com2 = 9600 , Synchrone = 0 , Parity = None , Stopbits = 1 , Databits = 8 , Clockpol = 0
      51. Open "Com2:" For Binary As #1 'Daten-Output zu Hterm
      53. On Urxc Open_log_uart ' UART0 Interrupt
      54. Enable Urxc ' Enable Urxc0-Interrupt
      55. 'Ucsr0b.rxcie0 = 1 ' Enable Urxc0-Interrupt
      56. Enable Interrupts
      58. $lib "i2c_twi.lbx"
      59. '-------------I2C Parameter---------------------------
      60. Config Scl = Portd.0 ' serial clock SCL am mega2560
      61. Config Sda = Portd.1 ' serial data SDA am mega2560
      62. I2cinit
      63. Config Twi = 400000 ' Taktrate 400KHz
      64. Const Ds1307w = &HD0 ' RTCadresse fuers schreiben
      65. Const Ds1307r = &HD1 ' RTCadresse fuers lesen
      66. Config Clock = User
      67. '*** setze 32,768kHz (1Hz) Takt-Ausgang ***
      68. I2cstart
      69. I2cwbyte Ds1307w
      70. I2cwbyte 7
      71. I2cwbyte &B10010000 ' Control-Byte für 1Hz am SOW-Out
      72. 'I2cwbyte &B00010011 ' Control-Byte für 32,768kHz am SOW-Out
      73. I2cstop
      74. Config Date = Dmy , Separator = Minus 'Datumsformat TT-MM-JJ
      75. 'Zum Stellen der Uhr (DS1307) Date und Time aktualisieren und aktivieren
      76. 'Date$ = "31-05-24" 'z.B.: für Tests, Startzit definieren
      77. 'Time$ = "16:47:00" '
      78. '*******************************************************************************
      79. Clear Serialin1 ' Lesebuffer für OpenLog Quittungen Löschen
      80. Wait 3 ' Wartezeit damit OpenLog nach Powerup bereit wird
      81. '*******************************************************************************
      82. Filenumber = 0
      83. Print #1 ,
      84. Print #1 , "Version: " ; Version(2)
      85. Print #1 , "Datum vom: " ; Version(1)
      86. Print #1 , "Datei: " ; Version(3)
      87. Print #1 , "Systemzeit: " ; Date$ ; " " ; Time$ : Print #1,
      88. Wait 1
      90. 'Setze OpenLog zurück, damit wir wissen, in welchem Zustand er sich befindet, und
      91. 'warte bis Openlog online geht und mit "<" Bereitschaft meldet.
      93. Gosub Openlog_reset ' RESET vom OpenLog
      94. Do
      95. If Len(b_udr) > 2 Then 'wenn der eingelesene Befehl maximal 3 Zeichen lang ist
      96. Exit Do 'dann verlasse die DO-LOOP Schleife
      97. End If
      98. Loop
      99. 'Print #1 , : Print #1 , "UART0: " ; B_udr ' Kontrollausgabe von OpenLog
      100. Rechts = Right(b_udr , 1)
      101. B_udr = "" ' Empfangsstring löschen
      102. 'Print #1 , "letztes Zeichen: " ; Rechts
      103. If Rechts = "<" Then Print #1 , "OpenLog meldet Empfangsbereitschaft"
      104. Wait 1
      105. Print #2 , "{026}{026}{026}"; ' bisherige Datenübertragung beenden
      106. ' und in Command-Modus wechseln
      107. Do ' warte auf Zeichen von OpenLog
      108. If Len(b_udr) > 1 Then 'wenn der eingelesene Befehl 2 Zeichen lang ist
      109. Exit Do 'dann verlasse die DO-LOOP Schleife
      110. End If
      111. Loop
      112. 'Print #1 , : Print #1 , "UART0: " ; B_udr ' Kontrollausgabe von OpenLog
      113. Rechts = Right(b_udr , 1)
      114. Clear Serialin1 'frei für neue Quitungszeichen
      115. If Rechts = ">" Then Print #1 , "OpenLog im Command-Modus"
      116. Wait 1
      117. F_nr = Str(filenumber) 'wurde in Hauptschleife inkrementiert
      118. S = Format(f_nr , "0") 'einstellig, da sonst nicht in Filenamen passt
      119. Got_date = Date$
      120. Got_time = Time$
      121. Naked_time = Got_time
      122. Naked_date = Left(got_date , 2)
      123. Delchars Naked_time , ":" ' Doppelpunkte zwischen den Uhr-Ziffern löschen
      124. Newfilename = Naked_date + Naked_time + ".csv" ' Erweiterung wichtig 8.3
      125. ' ich will eigene Dateinamen und keine *.LOG Dateien auf der Karte, deshalb
      126. Print #1 , "Lösche alle LOG Dateien" : Print #1, ' lösche alle LOG-Dateien...
      127. Print #2 , "rm LOG*.TXT"
      128. Clear Serialin1 'frei für neue Quitungs-Zeichen
      129. Wait 2
      130. Print #2 , "append " ; Newfilename '...und erstelle hierein neues File
      131. Wait 1
      132. Print #1 , "Neuer Dateiname: " ; Newfilename 'hier neues File erstellen
      133. Wait 1
      134. Clear Serialin1 'frei für neue Quitungs-Zeichen
      135. Print #1 , "Sende nun einige Testdaten"
      136. For A = 1 To 20
      137. Print #2 , A ; " Zeit: " ; Time$ ' schreibe in Datei
      138. Print #1 , A ; " Zeit: " ; Time$ ' Kontrollausgabe
      139. Waitms 100
      140. Next
      141. Clear Serialin1 'frei für neue Quitungs-Zeichen
      142. Print #1 , "Fertig!"
      145. End
      147. '*******************************************************************************
      149. Getdatetime:
      150. I2cstart
      151. I2cwbyte Ds1307w
      152. I2cwbyte 0
      153. I2cstart
      154. I2cwbyte Ds1307r
      155. I2crbyte _sec , Ack
      156. I2crbyte _min , Ack
      157. I2crbyte _hour , Ack
      158. I2crbyte Weekday , Ack
      159. I2crbyte _day , Ack
      160. I2crbyte _month , Ack
      161. I2crbyte _year , Nack
      162. I2cstop
      163. _sec = Makedec(_sec) : _min = Makedec(_min) : _hour = Makedec(_hour)
      164. _day = Makedec(_day) : _month = Makedec(_month) : _year = Makedec(_year)
      165. Return
      166. '*******************************************************************************
      167. Setdate:
      168. _day = Makebcd(_day) : _month = Makebcd(_month) : _year = Makebcd(_year)
      169. I2cstart
      170. I2cwbyte Ds1307w
      171. I2cwbyte 4
      172. I2cwbyte _day
      173. I2cwbyte _month
      174. I2cwbyte _year
      175. I2cstop
      176. Return
      177. '*******************************************************************************
      178. Settime:
      179. _sec = Sekunde 'Hier wird die Sekundenvariable mit dem gestellten Wert ersetzt.
      180. _sec = Makebcd(_sec) : _min = Makebcd(_min) : _hour = Makebcd(_hour)
      181. I2cstart
      182. I2cwbyte Ds1307w
      183. I2cwbyte 0
      184. I2cwbyte _sec
      185. I2cwbyte _min
      186. I2cwbyte _hour
      187. I2cstop
      188. Return
      189. '*******************************************************************************
      190. '*** Interruptroutine zum Zeichenempfang von OpenLog ***
      191. '*******************************************************************************
      192. Open_log_uart:
      193. B_udr = B_udr + Chr(udr) ' lese Zeichen von UART0 und hänge es an den String an
      194. ' Udr1 = Udr ' und gebe es als Echo auf UART1 zurück
      195. Return
      196. '*******************************************************************************
      197. '*** RESET OpenLog ***
      198. '*******************************************************************************
      199. Openlog_reset:
      200. Reset Resetopenlog
      201. Waitms 10
      202. Set Resetopenlog
      203. Return
      204. '*******************************************************************************
      Alles anzeigen

    • Liebe Community,

      ich habe hier ein kleines Problem und finde keine Lösung.

      Aus OpenLog-Modulen sollen die Versionsdaten ausgelesen werden. Dafür gibt es auf Github ein Arduino C-Programm Beispiel, welches mit Bascom nachempfunden wurde.

      Mit diesem Bascom-Programm werden die in Github genannten 200 Datenwerte auf Hterm ausgelesen und nach einem „v“ für die Versionsdaten gesucht. Diese sind jedoch in den ausgelesenen Daten nicht vorhanden.

      Im angehängten Programm, auch mit Teilen von Hal50, ist die Versionsabfrage (nach Github) im Moment wieder auskommentiert, damit zunächst die Funktion des restlichen Programms bestätigt werden kann.

      Hat jemand noch einen Tipp, warum oder wieso die Versionsabfrage bei mir nicht funktioniert?

      BASCOM-Quellcode: OpenLog for Community

      1. 'Datum: 24.11.2024 /16:50
      2. 'Test für Daten-Logging auf SD-Card mit Open-Log Modul
      3. 'Verwendung von Gosubs für die einzelnen Vorbereitungs-Schritte
      4. 'Hardware-Basis: Arduino UNO
      6. $regfile = "m328pdef.dat"
      7. $crystal = 16000000
      8. $hwstack = 64
      9. $swstack = 54
      10. $framesize = 64
      11. $baud = 9600
      13. Dim Time_over As Byte
      14. Dim Naked_date As String * 6
      15. Dim Weekday As Byte
      16. Dim Got_time As String * 8
      17. Dim Got_date As String * 8
      18. Dim Newfilename As String * 12
      19. Dim Filenumber As Byte
      20. Dim A As Byte
      21. Dim F_name As String * 50
      22. Dim F_date As String * 25
      23. Dim F_datum As String * 10
      24. Dim F_time As String * 8
      25. Dim S As String * 1
      26. Dim Sekunde As Byte
      27. Dim I As Byte
      28. Dim B_udr As String * 3
      29. Dim Uart_cnt As Byte
      30. Dim Zeichen_ist_da As Byte
      31. Dim Buf(200) As Byte
      32. Dim Wert As String * 3
      33. '******************************************************************
      35. 'Open a Soft channel for output to Hterm
      36. Open "comd.6:9600,8,n,1" For Output As #1 'zusätzlicher UART-Ausgang
      38. Config Portc.0 = Output ' 'an GRN=kapazitver Input von OpenLog => Reset,
      39. Extra_reset Alias Portc.0
      40. Set Extra_reset
      42. Config Timer1 = Timer , Prescale = 1024
      43. On Timer1 Tim1_isr
      44. Enable Timer1
      45. Stop Timer1
      47. On Urxc Open_log_uart ' UART Interrupt
      48. Enable Urxc ' Enable UART-Interrupt
      50. Enable Interrupts
      52. $lib "i2c_twi.lbx"
      53. '-------------I2C Parameter---------------------------
      54. Config Scl = Portd.0 ' serial clock SCL am mega2560
      55. Config Sda = Portd.1 ' serial data SDA am mega2560
      56. I2cinit
      57. Config Twi = 100000 ' Taktrate 100KHz
      58. Const Ds3231w = &HD0 ' RTCadresse fuers schreiben
      59. Const Ds3231r = &HD1 ' RTCadresse fuers lesen
      60. Config Clock = User
      62. ''setze 32,768kHz (1Hz) Takt-Ausgang
      63. I2cstart
      64. I2cwbyte Ds3231w
      65. I2cwbyte 7
      66. ''I2cwbyte &B10010000 ' Control-Byte für 1Hz am SOW-Out
      67. I2cwbyte &B00010011 ' Control-Byte für 32,768kHz am SOW-Out
      68. I2cstop
      70. Config Date = Dmy , Separator = Minus 'Datumsformat TT-MM-JJ
      72. ''Zum Stellen der Uhr (DS1307) Date und Time aktualisieren und aktivieren
      73. 'Date$ = "23-11-24" 'z.B.: für Tests, letzter Tag im Jahr
      74. 'Time$ = "11:56:00" 'z.B.: für Tests, 3 Minuten vor Mitternacht
      77. F_name = Version(3)
      78. F_date = Version(1)
      80. F_datum = Left(f_date , 10)
      81. F_time = Right(f_date , 8)
      83. Print #1 , F_name
      84. Print #1 , F_datum
      85. Print #1 , F_time
      87. Time_over = 0
      89. Wait 3
      90. Uart_cnt = 0
      93. Gosub Openlog_reset 'Reset OpenLog Modul an GRN
      94. Wait 1
      95. Gosub Check_if_ready 'Ist Modul Alive?; ==> "<"
      96. Wait 1
      97. Gosub Command_mode 'Prepare for Receiving Commands; ==> ">"
      99. '***************************************************************
      100. 'Gosub Version_mode 'hole OpenLog Version
      102. ''Versuch die Versonsdaten auszulesen, jedoch kein "v" zu entdecken
      103. ''Beispiel-Umsetzung Arduino Routine aus Github
      105. '' Auslesen der per read empfangenen Daten
      106. 'For I = 1 To 200
      107. ' Wert = Chr(buf(i))
      108. ' 'If Buf(i) = 118 Then ' ==> "v"
      109. ' Print #1 , I ; " " ; Buf(i) ; " " ; Wert
      110. ' 'End If
      111. 'Next
      112. 'Print #1 , "Ende erreicht"
      114. '*****************************************************************
      115. Print #1, 'Leerzeile
      116. Filenumber = 4 'Vorgabe einer Nummer, (0 - 9 max.?
      117. Gosub Make_filename 'Bilde Filename
      118. Gosub Prep_for_writing 'from Command-Mode to Record-Mode; ==> "<"
      120. Print #1 , "Sende nun einige Testdaten"
      121. Gosub Write_data 'Daten auf SD-Card
      124. End
      125. ''****************************************************************************
      126. Open_log_uart:
      127. B_udr = Chr(udr) ' lese Zeichen von UART0
      128. Zeichen_ist_da = 1
      129. Return
      131. Openlog_reset:
      132. Reset Extra_reset
      133. Waitms 10
      134. Set Extra_reset
      135. Return
      137. Check_if_ready:
      138. Time_over = 0
      139. Timer1 = 40000
      140. Start Timer1
      141. Do
      142. If Time_over = 0 Then
      143. If B_udr = "<" Then 'wenn der eingelesene Befehl
      144. Exit Do 'dann verlasse die DO-LOOP Schleife
      145. End If
      146. Else
      147. Print #1 , "--SD-CARD vorhanden ???--"
      148. Print #1 , " Program gestoppt"
      149. Print #1 ,
      150. Stop
      151. End If
      152. Loop
      153. Stop Timer1
      154. B_udr = "" ' Empfangsstring löschen
      155. Print #1 , "---- OpenLog alive ----"
      156. Print #1,
      157. Return
      159. Command_mode:
      160. Print "{026}{026}{026}"; ' in Command-Modus wechseln
      161. Do ' warte auf Zeichen von OpenLog
      162. If B_udr = ">" Then '
      163. Exit Do '
      164. End If
      165. Loop
      166. B_udr = "" '
      167. Print #1 , "OpenLog im Command-Modus"
      169. Return
      171. Version_mode: '200 Zeichen einlesen, nach Github-Arduino- Beispiel
      172. Print #1,
      173. Print #1 , "-----Versionsabfrage ---"
      174. Print "? " 'Help Aufruf laut Github Arduino Programm
      175. Waitms 100
      177. Do
      178. Print "read " 'Daten von SD-Card einlesen
      179. Do
      180. nop
      181. Loop Until Zeichen_ist_da = 1 'Merker: Uart hat Zeichen empfangen
      183. Zeichen_ist_da = 0 ' 'Merker zurücksetzen
      184. Incr Uart_cnt 'zählen der Zeichen
      185. Buf(uart_cnt) = Udr 'speichern in Buffer, Auslesen im Hauptprogramm
      187. Loop Until Uart_cnt > 200
      188. B_udr = ""
      190. Return
      192. Make_filename:
      193. Got_date = Date$
      194. Naked_date = Got_date
      195. Delchars Naked_date , "-"
      197. S = Str(filenumber)
      199. Newfilename = Naked_date + "-" + S + ".csv" ' Erweiterung wichtig 8.3
      200. ' ich will eigene Dateinamen und keine *.LOG Dateien auf der Karte, deshalb
      201. Print #1 , "Neuer Dateiname: " ; Newfilename
      202. Return
      204. Prep_for_writing:
      205. Print #1 , "Lösche alle LOG Dateien"
      206. Print #1,
      207. Print "rm LOG*.TXT"
      209. Wait 2
      210. Print "append " ; Newfilename '...und erstelle neues File
      212. Do ' warten auf Zeichen von OpenLog
      213. If B_udr = "<" Then '
      214. Exit Do '
      215. End If
      216. Loop
      217. Print #1 , "OpenLog is ready for writing"
      219. Return
      221. Tim1_isr:
      222. Time_over = 1
      223. Timer1 = 0 '
      224. Return
      226. Write_data: 'Beispiel: Schreiben auf SD-Card in OpenLog Modul
      227. Print #1 , "Alles OK" 'Vorbereitung war ok
      229. Got_time = Time$
      230. Got_date = Date$
      232. For A = 1 To 10
      233. Print A ; " Zeit: " ; Got_date ; " " ; Got_time '
      234. Waitms 50
      235. Next
      236. Print #1 , "Fertig!"
      237. Return
      241. Getdatetime:
      243. I2cstart
      244. I2cwbyte Ds3231w
      245. I2cwbyte 0
      246. I2cstart
      247. I2cwbyte Ds3231r
      248. I2crbyte _sec , Ack
      249. I2crbyte _min , Ack
      250. I2crbyte _hour , Ack
      251. I2crbyte Weekday , Ack
      252. I2crbyte _day , Ack
      253. I2crbyte _month , Ack
      254. I2crbyte _year , Nack
      255. I2cstop
      256. _sec = Makedec(_sec) : _min = Makedec(_min) : _hour = Makedec(_hour)
      257. _day = Makedec(_day) : _month = Makedec(_month) : _year = Makedec(_year)
      259. Return
      260. '*******************************************************************************
      262. Setdate:
      264. _day = Makebcd(_day) : _month = Makebcd(_month) : _year = Makebcd(_year)
      265. I2cstart
      266. I2cwbyte Ds3231w
      267. I2cwbyte 4
      268. I2cwbyte _day
      269. I2cwbyte _month
      270. I2cwbyte _year
      271. I2cstop
      273. Return
      274. '*******************************************************************************
      276. Settime:
      278. _sec = Sekunde 'Hier wird die Sekundenvariable mit dem gestellten Wert ersetzt.
      279. _sec = Makebcd(_sec) : _min = Makebcd(_min) : _hour = Makebcd(_hour)
      280. I2cstart
      281. I2cwbyte Ds3231w
      282. I2cwbyte 0
      283. I2cwbyte _sec
      284. I2cwbyte _min
      285. I2cwbyte _hour
      286. I2cstop
      288. Return
      289. '*******************************************************************************
      Alles anzeigen

    • Hast du mal das Buf-Array ausgeben lassen ob da überhaupt ein v drin ist?

      Wenn nicht, liegts wohl am Empfang, wenn doch, dann wohl an der Suchroutine.

      Aber warum machst du dir so eine Mühe?
      Wieso benutzt du nicht einfach den SerialIn Buffer?

      Checken ob was drin ist, wenn ja byte lesen. Ist es v, wenn nicht verwerfen und von vorn.
      Oder v da, dann die nächsten bytes lesen.

      Der Buffer leer sich dann von ganz alleine, kannst eigentlich nichts verpassen.