Translate

09 Dezember 2011

Auswertung der empfangenen Daten aus dem Messmodul

Ich will mich hier heute nur mal möglichst kurz fassen,

aber vorhin habe ich die Auswertung der Daten aus meinen
Einzelspannungs-Messmodulen in den Grundfunktionen
zum Laufen gebracht.Bisher war nur ein einzelnes Messmodul
am Auswerte-Rechner, da konnte ich den Messwert
direkt aus der seriellen Schnittstelle übernehmen.
(Da reichte es zu schauen, ob der Wert >14 war)
Ich musste also nicht erst einen bestimmten Wert aus einer
Zeichenfolge herausfiltern. Darum geht es heute.
Diese Auswertung ist eine Art "Nebenprodukt" der Curtis 840
Simulation. Da stand ich vor fast dem selben Problem, und ich
hatte mir das wesentlich schwerer vorgestellt, als es dann letztendlich
war, und am Ende waren das nur wenige Programmzeilen........
Hier kommt noch hinzu, dass ich verschiedene, bzw jedes Zeichen des
String einzeln verarbeiten muss, aber das ist auch nicht weiter tragisch.


Nochmal ganz kurz von vorne erklärt:

Meine Messmodule liefern einen Datenstring, also eine Zeichenfolge
bei der jedes Zeichen bzw die dazugehörige Zahl als Byte je  einem
Messwert entspricht.
Das klingt jetzt ein bisschen kompliziert, aber es macht mir die
Verarbeitung einfacher.(zumindest beim derzeitigen Wissensstand)
Sicher geht das auch noch eleganter (??) per Array und ohne die ganzen
Umwandlungen in den Print-Befehlen, aber so ist das einfach viel
leichter zu verstehen. Das Zusammenstellen des String und das
Einfügen der ganzen Messwerte klappt bereits sehr gut!
.......und ob es dann auch so einfach ist, alle Zeichen eines Array
der Reihe nach seriell zu verschicken, das sei mal dahingestellt!
Zur Zeit wird ganz einfach der String verschickt, und das funktioniert!
Ich habe schon ein wenig rumexperimentiert, aber da ich in meinen
Messmodulen mit "Software-Schnittstellen" arbeite, sind die nicht
zuverlässig in der Lage gleichzeitig zu senden und zu empfangen.
Wenn ich mit einem String arbeite, dann wird der komplett gesendet
und empfangen, ohne dass sonst noch was läuft und dehalb klappt
das hier, und alle anderen "schnelleren" Methoden waren bisher
einfach zu schnell.........deshalb vorerst die String-Methode!
Beim Atmega oder anderen Typen mit "richtiger" serieller Schnittstelle
und der Möglichkeit, den Ein und Ausgang zu puffern sieht das
natürlich ganz anders aus! Ich brauche aber unbedingt die interne
Referenz von 1.1V und den Betriebsspannungsbereich von 1,8-5,5V
und da ist halt der ATtiny 24V ideal. Der hat genug Pins und
macht seine Sache recht gut. Wenn man nur messen möchte,
bzw ggfs einen Oszillator statt dem Quarz bzw Resoator einsetzt,
dann ginge sogar der ATtiny 25. Die ATtinys sind alle (?) auch in
SMD erhältlich, und da sogar billiger als im DIL-Gehäuse,
 und die liegen alle preislich sehr nah beieinander (ca.2 Euro), so dass es ausser
dem Formfaktor eigentlich keinen wirklichen Grund gibt, sich mit
einem zu kleinen Baustein "die Zukunft zu verbauen"
Ich werde also beim 24er bleiben, aber meine Module wohl in SMD
planen, weiterhin mit "String" arbeiten und mir die Sache so möglichst
einfach machen.Die Rechenleistung genügt, und es scheint so zu klappen.
Das schliesst natürlich nicht aus, dass ich in zukunft mal das Verfahren ändere,
aber jetzt möchte ich endlich mal ein funktionierendes System auf die
Beine stellen und das auch mit der "Franzbox" kombinieren.............

Ich bekomme also eine Zeichenfolge mit so viel Zeichen wie Messwerten.
(die Steuerzeichen sind da bereits entfernt bzw im
Auswerterechner gar nicht erst in den String eingefügt)

Bei 45 Zellen wäre das ein String aus 45Zeichen

Die Umwandlung eines solchen String in einzelne Werte ist in Bascom
relativ einfach.
Da ich momentan nur ein einzelnes Messmodul betrachte interessiert
momentan nur der letzte Wert.
Um flexibel zu sein, und weil das auch später interessant ist
ermittle ich zunächst mal die Länge des String.
(Das will ich später auch als minimale Plausibilitätsprüfung einsetzen)

Der String hat bei mir die Variable S3
für die Länge habe ich die Variable Lang definiert.

mit         Lang = Len(s3)     ermittle ich die Länge des String

Nun möchte ich das letzte Zeichen des String in die Variable Ceinl schreiben
Das erledigt der Bascom-Befehl     Ceinl = Mid(s3 , Lang , 1 )

(Mid holt Zeichen aus einem String und zwar in diesem Fall
aus String s3 , ab der "lang"-ten Stelle ein Zeichen)

Ich brauchealso statt "lang"  nur die gewünschte Zelle anzugeben und bekomme
deren Messwert aus dem String herausgeholt.
Allerdings noch als das jeweilige Zeichen laut Ascii-Tabelle.

Das ist aber kein Problem, und mit     Einl = Asc(ceinl)  schreibe ich
deren  "Wert" als Byte in die Variable Einl

Wie schon gesagt, man könnte mit den empfangenen Bytes
(alle Zeichen werden ja als Byte über die serielle Verindung
geschickt) auch ein Array füllen und die gewünschten Werte
dann da rauspicken, aber das mache ich ein andermal.

Jetzt bin ich erst mal froh dass es schon mal so funktioniert,
und das auch mit etwas längeren Strings (mit einigen Dummy-Werten,
die ich als simulierte Module bereits im Auswerte-Rechner generiere)
Für heute reicht mir das aber, und als nächstes werde ich erst mal ein paar
Messmodule mehr aufbauen und mal untersuchen, wie schnell eigentlich die
Übertragung abläuft, und wie lang der String sein kann, bis es Probleme gibt.
Ich habs noch nicht mit dem Oszilloskop gemessen, aber bei zuletzt
20 Byte blinkt eine LED an der seriellen Leitung nur ganz kurz,
geschätzt noch deutlich unter 1/10 sek. also sind 50 Byte
wohl auch in der Größenordnung einer zehntel Sekunde zu übertragen.

Das waren also dann wohl so zwei bis vier Sekunden um alle ca 50 Zellen
auszulesen...........mal sehen, ob meine Schätzung stimmt!!!!


Hier ein kleines Video.... Wenn die LED kurz leuchtet sind das
50 Byte bei 2400Bd ; der kurze Blitz dazwischen ist der
Lesebefehl , das kann man gar nicht jedesmal sehen,
das ist zu schnell für die Kamera


Nachtrag vom 14.12.2011:
Mittlerweile läuft das Messmodul seit fast zwei Wochen im Dauerbetrieb.
Ich habe daran ganz bewusst nichts mehr verändert, und mache meine
"Spielereien" am Auswerte-Rechner. (Atmega48 auf dem STK500)
Das Messmodul bekommt mittlerweile Strings von 50 Zeichen Länge,
(Anm.:  68 Zeichen wurden inzwischen werfolgreich getestet)
also etwa der beabsichtigte Maximalausbau eines "Messpfades"
(Mehr geht derzeit nicht, der String ist nicht länger definiert,
das teste ich mal in einer ruhigen Stunde, wie weit man notfalls gehen
könnte, aber 50 ist genug.... Wenn noch mehr Zellen zu überwachen
sind empiehlt es sich, das Ganze in zwei Pfade aufzuteilen
und getrennt zu übertragen und auszuwerten)
Ich musste dazu allerdings schon jetzt ein klein wenig
an den zeitlichen Abläufen herumkorrigieren.
Das Lesesignal (die 0000 0001 ) wurde etwas zu früh rausgeschickt und
ging dann wohl irgendwo verloren, so dass das Lesemodul nicht mehr
zuverlässig gemessen hat.Und wenn nicht eingelesen wird, bleibt der
letzte Wert im Speicher,das ist gemein! Ein "hängender" Messwert!
da muss ich noch nachbessern und den Messwert nach dem Senden
einfach mal auf 0 setzen, damit das in Zukunft sofort auffällt und zu einer
Fehlermeldung führt! Lieber mal eine Fehlermeldung zuviel,
als ein im "grünen Bereich" hängengebliebener Messwert.


Nachtrag 16.12.2011:
Das Messmodul läuft und läuft und läuft...........
Die drei Mars AA 2100mAh Zellen vom Penny haben fast zwei Wochen
durchgehalten, bis sie leer waren. Der Messwndler lief bis nur noch etwa
1,6V anlagen, aber beim vorsichtigen wiederaufladen begann er erst bei
etwa 2,3V wieder zu laufen. Da muss ich mir mal die Fusebits genauer
anschauen. (Die sind noch im Auslieferungszustand)
Mir fehlt im Augenblick die nötige Zeit, um effizient weiterzuarbeiten.
Aber im Großen und Ganzen schaut alles gut aus!
Die Geschwindigkeit sollte reichen, und die Messmodule kommen mit
Strings aus 50 Zeichen zurecht.Das reicht!
(kleiner Nachtrag v.19.12.2011:  Ein String von 68 Zeichen klappt auch,
nachdem ich die max. Länge im Messmodul einfach mal auf 70 Zeichen
erhöht habe.)

Was ist sonst noch dringend zu ändern???????

1.: Rücksetzen des Messwertes in den Modulen nach dem Absenden.
           So wird ein "hängenbleiben" des Messwertes vermieden.
           (19.12.2011: Ich habe einfach mal die Einleseroutine nochmal
           nach dem Seriellen Senden eingefügt das klappt auch,
           aber eine Kontrolle ist nicht möglich, nullsetzen des Wertes
           teste ich auch noch, aber ein andermal, heute fehlt die Zeit.....)

2.: eventuell ein anderes Stopbyte verwenden.
          Wenn ich das letzte Semikolon im Print-befehl weglasse, dann wird
          automatisch ein Linefeed gesendet und ich spare noch ein paar
          Programmzeilen. bringt nicht viel, aber die Strings sind so auch besser
          PC- und Arduino-kompatibel......ich werds mal ausprobieren!

3.: Kalibrierung der Module
          Die Kalibrierung muss in die Module verlagert werden.
          Mal sehen, wie ich das am elegantesten hinbekomme.
          ob ich dafür wirklich einen Steuerbefehl "opfern" sollte,
          oder nur eine anzupassnde Variable ins Programm einbaue,
          Die Qualität der AD-Wandler ist recht gut, aber die interne
          Referenzspannung ist von Chip zu Chip leicht verschieden.
           (19.12.2011: von Bruno kam der Vorschlag, beim Programmieren
          gleich eine definierte Spannung anzulegen, und die zu messen,
          wenn das EEprom noch voller FF steht, und dann den Korrekturwert im
          EEprom abzulegen! einfach, aber genial!Das geht automatisch, und
          der Eingangsspannungsteiler wird auch gleich mit abgeglichen bzw.
          beim Abgleich mit berücksichtigt.Das brauchen dann auch keine
          0,1% Messwiderstände sein!)

4.: Balancer-Funktion:
          Ich werde vorerst mal nur einen "oben"-Transistor + Shunt
          vorsehen, und die Leistung recht gering dimensionieren, damit da
          nichts heizt. so 2,5 Ohm / 10Watt sollte reichen.......
          Ich denke da an etwa 1A Balanzierstrom wenn der erste
          Balancer einschaltet.

5.: Grundsätzliche Gestaltung
          Leute, sagt Bescheid, wie es Euch besser gefällt!
          Einzelne Platinen je Zelle oder ein zentrales Gerät
          oder aber auch kleinere Einheiten mit je acht (?)
          oder zehn Messwandlern in einem Modul (mein Favorit)
          So etwa wie das bisherige "Franz-Box-Gehäuse"
          Da hätten 12 Klemmen platz, das reicht aber nur für 9 Zellen
          also doch nur acht ????

....möglich ist fast alles......man muss nur wissen, was man haben will.......




.....und kleine Bemerkung am Rande.....im Auswerte-Rechner läuft noch
"ganz nebenbei" schon eine Umsetzung eines Spannungswertes in drei PWM-Signale
( mit 8kHz bei 4MHz Takt) und ich habe mir einen IR2130 besorgt sowie einen
sehr hübschen kleinen IGBT der aus drei Halbbrücken  à 25A @ 1200V besteht.........
Da werde ich mal irgendwann einen "Charger-Versuch" starten, aber das wird dann
eine andere Geschichte........aber ich finde, das gehört genau hier mit reingepackt!
Nicht das BMS muss den Charger steuern, sondern das BMS sollte gleich
auch der Charger sein.........und irgendwann verschmilzt dann der
Controller auch noch damit....ist doch eh fast das Gleiche......und alle Anschlüsse
wären dann auch schon an einem Ort..........

Mein Traum wäre eine schöne Kiste, die nur noch an die Akkus und den Motor
angeschlossen werden muss.........alles Andere ist fertig da drin vormontiert!
Das bauen noch nicht mal die Chinesen.....warum nicht??????????
obwohl ich schon den Trend festgestellt habe, den Controller in den
Motor zu integrieren. (Das fiel mir "neulich" auf der E-CARTEC auf!!!!)

Kommentare:

  1. Hallo Franz,

    zu 3. (Kalibrierung):

    Ich machs bei mir so, dass ich das EEPROM prüfe of schon ein Wert drin steht oder leer ist.
    Wenns leer ist steht ja ein "FF" im Speicher.

    Hier mal BASCOM-Code:

    DIM U_call as ERAM_Word

    IF U_call = "FFFF" then
    U_wert = Getadc(0)
    U_call = U_wert
    END IF

    //BASCOM-OFF

    Wenn Du beim Programmieren den Atmel mit 3V versorgst wird nach dem Reset der Hexwert für 3V im EEPROM abgelegt. Der ganz grosse Vorteil ist, dass dir interne Referenz und der externe Spannungsteiler zusammen kalibriert werden.

    Leider weis ich nicht wo Du programmierst. Im STK oder per ISP in der Schaltung. ich bevorzuge immer die Schaltung.

    Grüße

    AntwortenLöschen
  2. Hallo Bruno,

    So ähnlich schreibe ich im "Franzbox"-Programm
    schon die Standardwerte ins EEprom.
    ..aber an eine vollautomatische Kalibrierung
    gleich beim Programmieren...daran hab ich
    noch nicht gedacht! Vielen Dank für diese
    Anregung!( vielleicht noch ein paar ms
    warten vor dem Abgleich, und das Ganze
    möglichst nah am Balancer-Schaltpunkt....)

    Die ATtiny 24 hab ich bisher in einem kleinen
    Adapter programmiert, aber das erfolgt
    später natürlich in der Schaltung, vor allem, weil ich da die SMD-Version verwenden will.
    Im STK steckt derzeit der Auswerte-Atmega.

    Wie schon erwähnt werde ich vorerst mal
    einen Auswerte-Atmega zwischen die Module und die Box hängen, damit ich das Box-Programm
    erst mal so lassen kann,wie es ist,
    und ich will dem Auswerte-Atmega noch so Dinge
    wie Charger-Steuerung und Temperaturmessungen
    mit draufpacken und versuchen das dann auch
    eigenständig lauffähig hinzubekommen.

    Messmodule alleine = balancer

    Module + Auswerte-Atmega = Charger-Steuerung

    Module + Auswerte-Atmega + Franzbox
    = Komplettes System mit Einzelspannungs-
    überwachung und MIN-MAX-Anzeige

    Wenn alles passt werde ich versuchen,
    die Auswertung in die Box mit rein zu
    bekommen.Das ist mir aber gar nicht so
    wichtig, weil ich sowieso irgend ein
    Umsetz-Teil dazwischen brauche für
    galv.Trennung und Schaltaufgaben etc.

    AntwortenLöschen
  3. Hallo,

    mir lässt die Datenübertragung einfach keine Ruhe. Bei 30 Modulen vergeht ganz schön viel Zeit wenn erst gelesen wird und dann der ganze String gesendet wrid.
    Ich hab mir jetzt mal mehrere Platinen gebaut um einfach mal die Verschiedenen Verfahren zur Übermittlung zu testen.
    Zur Verfügung stehen Tiny25 und Optokoppler EL817 für Übermittlung zur nächsten Stufe.
    Die Datenübertragung läuft mit 1200Baud, weil ich den internen 8MHz-Takt des Tinys nehme.

    Hier mal mein Listing (auch in BASCOM):

    --------- BASIC ON ---------


    $crystal = 8000000

    Config Adc = Single , Prescaler = Auto , Reference = Internal_1.1
    Start Adc

    Config Portb.0 = Output
    Config Portb.4 = Input

    Portb.4 = 1

    Dim Datensatz As String * 30
    Dim Zeichen As String * 1
    Dim Z_wert As Byte
    Dim Vadc As Word
    Dim V_wert As Byte

    Open "comb.4:1200,8,n,1" For Input As #1
    Open "comb.3:1200,8,n,1,inverted" For Output As #2


    Do

    Z_wert = Inkey(#1)
    If Z_wert > 0 Then Gosub Verarbeitung

    Loop


    Verarbeitung:

    If Z_wert = 1 Then
    Print #2 , Chr(1);
    Vadc = Getadc(1)
    Vadc = Vadc / 4
    V_wert = Vadc
    If V_wert < 15 Then V_wert = 15
    End If

    If Z_wert = 2 Then:
    Print #2 , Chr(2);
    Portb.0 = 1
    End If

    If Z_wert = 3 Then
    Print #2 , Chr(3);
    Portb.0 = 0
    End If

    If Z_wert = 5 Then
    Print #2 , Chr(5) ;
    Do
    Z_wert = Inkey(#1)
    If Z_wert > 0 Then
    If Z_wert = 13 Then Exit Do
    Print #2 , Chr(z_wert);
    End If
    Loop
    Waitms 25
    Print #2 , Chr(v_wert) ;
    Waitms 25
    Print #2 , Chr(13);
    V_wert = 0
    End If

    If Z_wert = 6 Then
    Input #1 , Datensatz
    Print #2 , Chr(6) ; Datensatz ; Chr(v_wert) ; Chr(13);
    V_wert = 0
    End If

    Return

    ------ BASIC OFF -------

    Bei Steuercode 5 wird Zeichenweise eingelesen und sofort gesendet! Wichtig ist, dass ca 25ms Pause zwischen den Zeichen ist, da nur ein Soft-UART verwendet wird. Die Übertragung geht sehr schnell ca. 800ms dann sind 32Bytes durch.

    Bei Steuercode 6 wird der ganze String eingelesen und erst nach Steuercode 13 weiter geschickt. Laut Hochrechnung werden dann ca. 1700ms benötigt um die ganzen Messwerte durch die Kette zu bekommen.

    Ich schicke Dir mal meinen Schaltplan von der Platine. Ich hoffe ich hab Deine richtige Adresse!

    Grüße

    AntwortenLöschen
  4. Hast Du das auch schon getestet, wenn mehrere
    Bausteine hintereinander hängen?

    Das Problem ist, wie ich weiter oben schon beschrieben habe, dass bei Soft-Uart
    senden und empfangen zugleich Probleme macht.
    Da helfen auch Waitms nicht, ganz im Gegenteil!
    Wenn der Chip per "Wait" angehalten wird, dann macht er GAR NICHTS!!, und das ist in diesem Fall überhaupt nicht zu brauchen.
    Beim Umweg über den String komme ich völlig
    ohne Warteschleifen und Pausen aus, und
    dann geht das doch recht flott.Ich bin grad
    am Basteln, und lasse gerade Strings mit
    70 Byte durchrauschen, und weil ichs jetzt
    wissen will hänge ich jetzt einen Oszi dran.
    ......kurze Pause......
    so....
    1. der Lesebefehl (0000 0001) braucht bei mir
    exakt 7,5 ms vom Anfang des Einlesens bis
    zum Ende des Sendens.da ist er aber im nächsten Modul auch schon angekommen und wird bereits wieder gesendet, das macht also 3,5ms je Modul.
    (ich schick den sofort weiter und lese dann
    erst die Spannung)das wären dann 160ms bei
    45 Zellen für den Durchlauf des Leseimpulses.

    2.Das Datenpaket aus derzeit 70 Werten braucht etwas weniger als 300ms und wird dann auch ohne Verzögerung rausgeschickt. das macht dann auch
    so etwa 4ms je Byte.
    Das müsste ich jetzt hochrechnen... das sind ja
    erst zwei, dann drei, dann vier.......
    das sollte dann bei 45 Zellen etwa 4 Sekunden dauern.....damit hatte ich in etwa gerechnet.
    ...und das reicht auch locker aus.....
    man kann ja dazwischen den Status abfragen
    ohne zu messen, das geht in 200ms.

    ....das reicht mal für heute!

    AntwortenLöschen
  5. Ich hab mir das jetzt nochmal in Ruhe
    angeschaut, und finde Dein Programm sehr
    interessant!
    Die Version mit "sofort senden" hatte ich
    auch schon versucht, aber mit 2400Bd und
    4MHz Takt ging das bei längeren Strings nicht.
    (wenn ich die zusammenhängend schickte)
    Das passiert aber hier nicht, weil
    ja die Pause eingefügt wird, wenn wieder
    ein Zeichen dazukommt, insofern tritt
    also der Zustand gar nicht auf, dass die
    Zeichen zu schnell hintereinander kommen.
    und weil in der Zeit nach der Übertragung
    auch nicht sofort wieder ein Zeichen kommen sollte, geht das an DER Stelle auch mit
    dem Wait-Befehl in Ordnung.

    Die Übertragungsgeschwindigkeit ist mir
    vorerst mal nicht allzu wichtig.Ob nun alle
    zwei oder vier Sekunden alle Werte
    aktualisiert werden, was solls......

    Ich hab mir das ein bisschen aufgehoben, und wollte mal versuchen, was da sonst noch an
    Möglichkeiten besteht, z.B wie man die
    Auflösung verfeinern kann.
    Da denke ich dran, nicht durch vier zu teilen,
    sondern erst 256 zu subtrahieren und dann durch
    drei zu teilen.
    Die Kopplung der Module könnte auch mit einem
    kleinen Op oder Komparator erfolgen.Der Mehraufwand wäre gering, aber das Signal
    wäre dann besser definiert, als das
    per Transistor und pull-up möglich ist.
    Die halbe Betriebsspannung des unteren
    Moduls als Referenz und zwei Zellen als
    Spannungsversorgung. Der "oberste"
    hängt dann an der letzten Zelle plus
    den 5V aus dem ADUM5241.
    Na ja, da gäbs viele Möglichkeiten....
    Entscheidend ist halt die geringe
    Versorgungsspannung, bei der die Module
    noch arbeiten müssen.
    Ich will zuverlässige Funktion bis 2V!
    deshalb scheiden Optokoppler zur
    Ankopplung aus! Das geht zum Einspeisen
    des seriellen Signals, zum Auslesen brauche
    ich aber schon die zusätzliche Spannung
    aus dem ADUM! (Wobei mich der ADUM ein
    bisschen enttäuscht....der nimmt einige
    mA auf um wenige mA treiben zu können,
    und wird ganz schön warm dabei!)
    z.B.jedes Messmodul per ADUM mit
    Spannung zu versorgen, um dann auch
    Chips mit 2,56V int. Referenz und
    Hardware-UART nehmen zu können würde
    ein mittleres Heizkraftwerk ergeben.

    AntwortenLöschen
  6. Ich hab jetzt mal mit zwei Modulen rum gespielt.
    Dabei habe ich einen kompletten Datensatz von 38 byte + 3 Steuerbytes in den ersten Ballancer eingespeist. Der hat dann nach dem Empfang von "13h" seinen AD-Wert + "13h" hinzugefügt. Den dann wieder der zweite Ballancer empfangen hat und der natürlich auch seinen Wert dazu gepackt hat.

    Also folgender Code wurde in den ersten Ballancer übertragen:
    01066162636465666768696A6B6C6D6E6F707172737431323334353637383913

    Aus dem letzten kam raus:
    01066162636465666768696A6B6C6D6E6F7071727374313233343536373839BFC213

    Dafür wurden ca. 1,5 Sekunden bei 1200Baud benötigt.

    Wenn jetzt das ganze mit 40 Ballancer gemacht wird, werden ca. 22,5 Sekunden benötigt bis alle Werte am Ende der Schleife ausgegeben werden.

    Wird das Zeichen sofort durgereicht und 13h durch den Messwert ersetzt und dann wieder 13h gesendet werden bei zwei Modulen ca. 10ms verbraten bei 40 Ballancern sind das dann 200ms.

    Ein weiterer Vorteil ist, dass die Anzahl der Ballancer in der Schleife nicht von der Größe des Strings abhängig ist.

    Ich hab hier noch sechs Tiny25 rumliegen, die werde ich mal nach Weihnachten verbasteln. Dann kann ich noch genauere Messwerte liefern.

    AntwortenLöschen
  7. Ich gehe mal davon aus, dass dann da immer
    25ms zwischen den Zeichen waren,als es bei
    zwei Modulen schon 1,5 Sekunden dauerte.
    Weil meine Messung gestern beim String
    ohne Pausen zwischen den Zeichen knapp 300ms
    pro Modul für 70! Zeichen bei 2400Bd ergab.
    Aber da brauchen wir jetzt nicht kleinlich
    werden, auf alle Fälle ist es viel besser,
    alle Zeichen sofort durchzureichen.
    Der String wird ja nur wenn überhaupt am
    Ende beim Auswerten benötigt, und da wäre
    ein Array mindestens genau so gut geeignet
    Das war von Anfang an klar!
    Ich habe mich halt foppen lassen,
    weil es nicht ging, einen String von gut 30 Zeichen ohne Pause zwischen den Zeichen
    direkt weiterzuleiten.Aber dieser Fall kommt ja dann in der Praxis gar nicht vor!
    Und bei einem Zeichen (Lesebefehl)
    klappt das sofortige Weiterleiten
    bei mir auch wunderbar.
    (und mit Printbin sollte man die Zahlen auch
    direkt rauschicken können, ohne irgendwas umzurechnen, und ohne das letzte Semikolon
    wird das Stopzeichen beim Senden automatisch
    erzeugt)
    Das wird schon noch!

    AntwortenLöschen