Wie Timeout berechnen in Pulsein.lib

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

    • Wie Timeout berechnen in Pulsein.lib

      Ich würde gerne die Zeit bis zum Timeout bei Pulsein verkürzen. In der Vollversion gibt es laut Hilfe die Möglichkeit, die Zeit bis zum Timeout zu reduzieren.

      BASCOM-Quellcode

      1. const cPulseIn_Timeout = 0 'This is the default timeout value. When you increase the value you will get a shorter time out period.

      Leider wird nicht erwähnt, welcher Wert zu welchem Timeout führt.

      Laut Hilfe hängt der Timeout auch noch mit der Länge der Zeiteinheiten zusammen.

      Bascom-Hilfe schrieb:

      A time out will occur after 65535 unit counts. With 10 uS units this will be after 655.35 mS.

      Leider habe ich nicht die Möglichkeiten, die Zeiten zu messen, daher meine Frage: Wie kann man die Timeout Zeit, bzw den Wert, den man bei cPulseIn_Timeout = 0 setzen müsste, ermitteln?

      Gruß
      Robert
    • Ich lese das so: wenn es die Konstante cPulseIn_Timeout gibt, dann kann man damit time-out verkürzen. time-out gibt es immer, wenn der interne Zähler &HFFFF erreicht, mit der Konstanten kann man den Startwert ändern. Bei default ist der =0 mit der Konstanten kommt man näher an &HFFFF ran und verkürzt so die Zeit. 1 digit entspricht dann 10µs, wenn das bPulseIn_Delay auch mit 10 belegt wird.
      Raum für Notizen

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

      -----------------------------------------------------------------------------------------------------
    • Mal ein Beispiel: bPulsein_Delay=10 (10µs), man möchte Puls mit max Länge von 50 msec messen, nach 75 msec soll timeout sein. 75 msec sind bei 10µsec 7500 digits, die von (2^16)-1 abziehen = 58035. Das ist der Wert für cPulsein_timeout.
      Raum für Notizen

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

      -----------------------------------------------------------------------------------------------------
    • Vielen Dank für Eure Antworten.

      Ich habe mir nun ein kleines Testprogramm geschrieben, mit dem ich (zumindest ganz grob) die Zusammenhänge zwischen Cpulsein_timeout und Bpulsein_delay experimentell zu ermitteln versucht habe. Ich lese dabei RC Impulse (ca. 1-2ms, Wiederholung alle 20ms) ein und lasse sie mir mittels eines Leuchtpunktes auf einem WS2812b Strip anzeigen. Da meine anderen Programme dabei meist PulseIn-Werte im Bereich von 100 bis 200 verwendet haben, war es auch nun mein Ziel, diese zu erreichen.

      Bis jetzt konnte ich folgende Erkenntnisse gewinnen:

      1. "Dim Bpulsein_delay As Byte : Bpulsein_delay = 10" wirft beim Compilieren Fehler raus. Abhilfe schafft hier "Const Bpulsein_delay = 10"

      2. Änderungen bei Cpulsein_timeout wirken sich drastisch auf das Ergebnis von PulseIn aus . Das Ergebnis scheint sich um den Cpulsein_timeout-Wert zu erhöhen (das gibt lustige Ergebnisse, wenn man das Ergebnis bisher nur in einer Byte-Variablen gespeichert hat)

      3. Cpulsein_timeout-Werte über 50700 führen nur noch zu wildem Flackern bei meinem Code. Vielleicht verhaspelt sich bei Werten zwischen 50700 und (2^16)-1 irgendwas in der Lib?

      BASCOM-Quellcode

      1. 'Pulsein.Lib Test mit WS2812-Leds
      2. 'Bascom Version 2.0.8.1
      3. '$sim
      4. $regfile = "attiny85.dat"
      5. $crystal = 8000000
      6. $hwstack = 32
      7. $swstack = 10
      8. $framesize = 40
      9. Const Num_leds = 30
      10. Const Num_leds_1 = Num_leds - 1
      11. Config Rainbow = 1 , Rb0_len = Num_leds , Rb0_port = Portb , Rb0_pin = 2
      12. Rb_selectchannel 0
      13. Dim Farbe(3) As Byte
      14. Rot Alias Farbe(_base)
      15. Gruen Alias Farbe(_base + 1)
      16. Blau Alias Farbe(_base + 2)
      17. Const Cpulsein_timeout = 50700 'This is the default timeout value. When you increase the value you will get a shorter time out period.
      18. 'Dim Bpulsein_delay As Byte : Bpulsein_delay = 10 'For 10 uS units , the default is 1 ******** wirft Fehler raus ************
      19. Const Bpulsein_delay = 10
      20. $lib "pulsein.lib" 'include the lib to overload the function
      21. Config Pinb.4 = Input 'RC Signal Eingang
      22. Dim Impulslaenge_1 As Word
      23. Do
      24. Rb_clearcolors
      25. Pulsein Impulslaenge_1 , Pinb , 4 , 1
      26. Impulslaenge_1 = Impulslaenge_1 - Cpulsein_timeout
      27. Impulslaenge_1 = Impulslaenge_1 + 12 'kleiner Offset
      28. Select Case Impulslaenge_1
      29. Case Is < 80
      30. Rot = 30
      31. Gruen = 0
      32. Blau = 0
      33. Rb_setcolor 7 , Farbe()
      34. Case 80 To 89
      35. Rot = 40
      36. Gruen = 20
      37. Blau = 0
      38. Rb_setcolor 8 , Farbe()
      39. Case 90 To 99
      40. Rot = 40
      41. Gruen = 20
      42. Blau = 0
      43. Rb_setcolor 9 , Farbe()
      44. Case 100 To 109
      45. Rot = 40
      46. Gruen = 20
      47. Blau = 0
      48. Rb_setcolor 10 , Farbe()
      49. Case 110 To 119
      50. Rot = 40
      51. Gruen = 20
      52. Blau = 0
      53. Rb_setcolor 11 , Farbe()
      54. Case 120 To 129
      55. Rot = 40
      56. Gruen = 20
      57. Blau = 0
      58. Rb_setcolor 12 , Farbe()
      59. Case 130 To 139
      60. Rot = 40
      61. Gruen = 20
      62. Blau = 0
      63. Rb_setcolor 13 , Farbe()
      64. Case 140 To 148 'Bereich um die Mittelstellung
      65. Rot = 30
      66. Gruen = 30
      67. Blau = 0
      68. Rb_setcolor 14 , Farbe()
      69. Case 149 To 150 'Mittelstellung
      70. Rot = 0
      71. Gruen = 40
      72. Blau = 0
      73. Rb_setcolor 15 , Farbe()
      74. Case 151 To 159 'Bereich um die Mittelstellung
      75. Rot = 30
      76. Gruen = 30
      77. Blau = 0
      78. Rb_setcolor 16 , Farbe()
      79. Case 160 To 169
      80. Rot = 40
      81. Gruen = 20
      82. Blau = 0
      83. Rb_setcolor 17 , Farbe()
      84. Case 170 To 179
      85. Rot = 40
      86. Gruen = 20
      87. Blau = 0
      88. Rb_setcolor 18 , Farbe()
      89. Case 180 To 189
      90. Rot = 40
      91. Gruen = 20
      92. Blau = 0
      93. Rb_setcolor 19 , Farbe()
      94. Case 190 To 199
      95. Rot = 40
      96. Gruen = 20
      97. Blau = 0
      98. Rb_setcolor 20 , Farbe()
      99. Case 200 To 209
      100. Rot = 40
      101. Gruen = 20
      102. Blau = 0
      103. Rb_setcolor 21 , Farbe()
      104. Case 210 To 219
      105. Rot = 40
      106. Gruen = 20
      107. Blau = 0
      108. Rb_setcolor 22 , Farbe()
      109. Case Is > 220
      110. Rot = 30
      111. Gruen = 0
      112. Blau = 0
      113. Rb_setcolor 23 , Farbe()
      114. End Select
      115. If Err = 1 Then 'bei Timeout rote LED setzen
      116. Rot = 50
      117. Gruen = 0
      118. Blau = 0
      119. Else
      120. Rot = 0
      121. Gruen = 0
      122. Blau = 0
      123. End If
      124. Rb_setcolor 29 , Farbe()
      125. Rb_send
      126. Loop
      127. End
      Alles anzeigen
      Da ich keine geeigneten Geräte (Oszilloskop, Taktgeber usw) besitze, beziehen sich die genannten Erkenntnisse bisher nur auf meinen Testaufbau, bei dem der Attiny mit interem Taktgeber (8MHz) arbeitet und die RC Signale mit einem billigen Servotester erzeugt werden.

      Beim verwendeten Cpulsein_timeout-Werte von 50700 müsste Timeout nach rund 148ms kommen, theoretisch
      Ich überlege zur Zeit noch, ob ich die tatsächliche (wenn auch nur grobe) Timeout Zeit mit einem weiteren Testprogramm ermitteln kann.


      Gruß

      Robert


      P60918382.jpg
    • Wenn ein bpulsein_delay als Konstante vorhanden ist, dann wird sie als Wert für ein waitus in der lib verwendet. Ein wait berechnet der Compiler durch die Angabe von $crystal. Wenn du da spielst und den doppelten Wert als real einträgst, dauern die waits auch doppelt so lange. Wenn du jetzt das Spielchen weiter treibst, kommst du vielleicht in Bereiche, wo du mit der Stoppuhr messen kannst. Beliebig wird das nicht gehen, schätze ich. Aber du könntest den tiny mit 1MHz takten und $crystal=20000000 vorgeben, dann hast du immerhin Faktor 20.
      Raum für Notizen

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

      -----------------------------------------------------------------------------------------------------
    • Habe nun mit dem $crystal Wert gespielt, am Ende war ich noch verwirrter als ich es ohnehin immer bin a_51_b30e0498
      Dann kam mir eine recht pragmatische Idee. Warum nicht einfach vor dem Pulsein einen freilaufenden Zähler zurücksetzten, keine Impulse anlegen (dann läuft Pulsin ins Timeout), und anschließend den Zähler auslesen. Zum groben Abschätzen der Timeout Zeit sollte es reichen. Da mein Attiny85 nur 8-Bit Timer hat und ich den bei 8MHz nicht soweit gebremst bekomme, das er im ms-Takt hämmert, zähle ich auch die Überläufe mit und teile anschließend durch 8.

      Bitte korrigiert mich, wenn ich da irgendwo einen Denk- oder Rechenfehler drin hab. Denn das Ergebnis hat mich etwas überrascht: Mit den gegebenen Werten hätte ich eine Timeout Zeit von etwa 148ms erwartet. Tatsächlich liegt sie aber im Bereich von 18-19ms (wenn ich, wie gesagt, mich nicht verrechnet habe) a_27_b277ca12

      Wenn das tatsächlich stimmt, erklärt sich wenigstens das wilde Flackern, wenn ich den Cpulsein_timeout Wert weiter als 50700 erhöhe. Meine RC Signale wiederholen sich ja nur ca alle 20ms, vorher renn ich aber bereits ins Timeout.


      BASCOM-Quellcode

      1. 'Pulsein.Lib Test mit WS2812-Leds
      2. 'Bascom Version 2.0.8.1
      3. '$sim
      4. $regfile = "attiny85.dat"
      5. $crystal = 8000000
      6. $hwstack = 32
      7. $swstack = 10
      8. $framesize = 40
      9. Const Num_leds = 30
      10. Config Rainbow = 1 , Rb0_len = Num_leds , Rb0_port = Portb , Rb0_pin = 2
      11. Rb_selectchannel 0
      12. Dim Farbe(3) As Byte
      13. Rot Alias Farbe(_base)
      14. Gruen Alias Farbe(_base + 1)
      15. Blau Alias Farbe(_base + 2)
      16. Const Cpulsein_timeout = 50700 'When you increase the value you will get a shorter time out period.
      17. 'Dim Bpulsein_delay As Byte : Bpulsein_delay = 10 'For 10 uS units , the default is 1 ******** wirft Fehler raus ************
      18. Const Bpulsein_delay = 10
      19. $lib "pulsein.lib" 'include the lib to overload the function
      20. Config Pinb.4 = Input 'RC Signal Eingang
      21. Dim Impulslaenge_1 As Word
      22. Config Timer0 = Timer , Prescale = 1024 '128uS
      23. On Timer0 Isr_0
      24. Enable Interrupts
      25. Dim Isr_counter As Byte
      26. Dim Timeout_ms As Word
      27. Do
      28. Rb_clearcolors
      29. Isr_counter = 0
      30. Timer0 = 0
      31. Pulsein Impulslaenge_1 , Pinb , 4 , 1 'zu Testzwecken keine Pulse anliegend
      32. Timeout_ms = Isr_counter * 256 'Timerüberläufe mit 8-Bit multiplizieren
      33. Timeout_ms = Isr_counter + Timer0 '+ aktuellem Timerwert
      34. Timeout_ms = Timeout_ms / 8 'Umrechnung in ms (128uS * 8 = 1ms)
      35. If Timeout_ms < 19 Then 'bei 18 bleibt LED dunkel, ab 19 ist sie an
      36. Rot = 0
      37. Gruen = 0
      38. Blau = 30
      39. Else
      40. Rot = 0
      41. Gruen = 0
      42. Blau = 0
      43. End If
      44. Rb_setcolor 28 , Farbe()
      45. If Err = 1 Then 'bei Timeout rote LED setzen
      46. Rot = 50
      47. Gruen = 0
      48. Blau = 0
      49. Else
      50. Rot = 0
      51. Gruen = 0
      52. Blau = 0
      53. End If
      54. Rb_setcolor 29 , Farbe()
      55. Rb_send
      56. Loop
      57. End
      58. Isr_0:
      59. Incr Isr_counter
      60. Return
      Alles anzeigen
    • Nach weiteren Testen musste ich leider feststellen, dass ich im oben genannten Code ein "Enable Timer0" vergessen habe a_67_e210de67
      Um weitere Fehler zu vermeiden, habe ich den Testaufbau nun geändert. Da die WS2812B nicht mit einer Taktung von 1Mhz funktionieren, zeigt nun eine einfach LED an, ob der angegebene Wert bei der If Abfrage zu hoch oder zu niedrig ist. Also jedes mal den Wert ändern, brennen und sehen, ob sich der Zustand geändert hat. Ist zwar ziemlich dilettantisch, aber ich wollte es möglichst einfach halten und endlich auf plausible Werte kommen.

      BASCOM-Quellcode

      1. 'Pulsein.Lib Test mit Led
      2. 'Bascom Version 2.0.8.1
      3. $regfile = "attiny85.dat"
      4. $crystal = 1000000
      5. $hwstack = 32
      6. $swstack = 10
      7. $framesize = 40
      8. Const Cpulsein_timeout = 25000 'When you increase the value you will get a shorter time out period.
      9. 'Dim Bpulsein_delay As Byte : Bpulsein_delay = 10 'For 10 uS units , the default is 1 ******** wirft Fehler raus ************
      10. Const Bpulsein_delay = 10
      11. $lib "pulsein.lib" 'include the lib to overload the function
      12. Config Pinb.4 = Input 'RC Signal Eingang (zu Testzwecken ohne Impulse)
      13. Config Portb.2 = Output 'Kontroll-LED
      14. Led Alias Portb.2
      15. Config Timer0 = Timer , Prescale = 1024 '1024us
      16. On Timer0 Isr_0
      17. Enable Timer0
      18. Enable Interrupts
      19. Dim Isr_counter As Byte
      20. Dim Timeout_ms As Word
      21. Dim Impulslaenge_1 As Word
      22. Do
      23. Isr_counter = 0
      24. Timer0 = 0
      25. Pulsein Impulslaenge_1 , Pinb , 4 , 1 'zu Testzwecken keine Pulse anliegend
      26. Disable Interrupts
      27. Timeout_ms = Isr_counter * 256 'Überläufe
      28. Timeout_ms = Timeout_ms + Timer0 '+ aktuellem Timerwert
      29. Enable Interrupts
      30. If Timeout_ms < 400 Then 'hier Testwerte eingeben
      31. Led = 1
      32. Else
      33. Led = 0
      34. End If
      35. Loop
      36. End
      37. Isr_0:
      38. Incr Isr_counter
      39. Return
      Alles anzeigen

      Attiny läuft mit internem Taktgeber und 1MHz (CKDIV8 gesetzt)

      Ergebnisse
      Cpulsein_timeout:
      65000= 6ms
      60000= 55ms
      50700= 145ms
      50000= 152ms
      49000= 162ms
      48000= 172ms
      47000= 181ms
      40000= 245ms
      35000= 299ms
      30000= 348ms
      25000= 400ms
      20000= 448ms
      15000= 494ms
      10000= 544ms
      5000 = 592ms
      1000 = 631ms
      Zum Vergleich ohne PulseIn.Lib= 641ms
      (Alle ms Angaben müssen noch mit 1,024 multipliziert werden, um die tatsächlichen Timeout-Zeiten zu erhalten)

      Endlich habe ich plausible Werte.

      ABER: Sobald ich ihn mit 8Mhz betreibe (CKDIV8 NICHTgesetzt), werden die Zeiten etwa um den Faktor 8 verkleinert. Im folgenden Programm wurde $crystal auf 8000000 gesetzt und die Zeile 43 neu eingefügt.


      BASCOM-Quellcode

      1. 'Pulsein.Lib Test mit Led
      2. 'Bascom Version 2.0.8.1
      3. $regfile = "attiny85.dat"
      4. $crystal = 8000000
      5. $hwstack = 32
      6. $swstack = 10
      7. $framesize = 40
      8. Const Cpulsein_timeout = 25000 'When you increase the value you will get a shorter time out period.
      9. 'Dim Bpulsein_delay As Byte : Bpulsein_delay = 10 'For 10 uS units , the default is 1 ******** wirft Fehler raus ************
      10. Const Bpulsein_delay = 10
      11. $lib "pulsein.lib" 'include the lib to overload the function
      12. Config Pinb.4 = Input 'RC Signal Eingang (zu Testzwecken ohne Impulse)
      13. Config Portb.2 = Output 'Kontroll-LED
      14. Led Alias Portb.2
      15. Config Timer0 = Timer , Prescale = 1024 '128us
      16. On Timer0 Isr_0
      17. Enable Timer0
      18. Enable Interrupts
      19. Dim Isr_counter As Byte
      20. Dim Timeout_ms As Word
      21. Dim Impulslaenge_1 As Word
      22. Do
      23. Isr_counter = 0
      24. Timer0 = 0
      25. Pulsein Impulslaenge_1 , Pinb , 4 , 1 'zu Testzwecken keine Pulse anliegend
      26. Disable Interrupts
      27. Timeout_ms = Isr_counter * 256 'Überläufe
      28. Timeout_ms = Timeout_ms + Timer0 '+ aktuellem Timerwert
      29. Enable Interrupts
      30. Timeout_ms = Timeout_ms / 8 '8 Timertakte ergeben 1024ms, daher hier die Teilung durch 8
      31. If Timeout_ms < 50 Then
      32. Led = 1
      33. Else
      34. Led = 0
      35. End If
      36. Loop
      37. End
      38. Isr_0:
      39. Incr Isr_counter
      40. Return
      Alles anzeigen


      $crystal = 8000000
      Prescale = 1024

      Ergebnisse
      Cpulsein_timeout:
      65000= 6ms
      60000= 7ms
      50700= 18ms
      50000= 19ms
      49000= 20ms
      48000= 22ms
      47000= 23ms
      40000= 31ms
      35000= 37ms
      30000= 44ms
      25000= 50ms
      20000= 61ms
      15000= 62ms
      10000= 68ms
      5000 = 74ms
      1000 = 79ms
      Zum Vergleich ohne PulseIn.Lib= 81ms
      (Alle ms Angaben müssen wieder mit 1,024 multipliziert werden, um die tatsächlichen Timeout-Zeiten zu erhalten)


      Das würde bedeuten: Je schneller der Prozessor läuft, umso kürzer ist die maximal mögliche Timeout Zeit.

      Habe ich da vielleicht schon wieder etwas übersehen ?(

      Gruß
      Robert
    • Bei 8MHz geht alles 8x so schnell, es wirkt auf mich so, dass das bpulsein_delay ignoriert wird. In der lib wird das ja das 'bedingt' mit dem waitus=bpulsein_delay eingebaut. Wenn du mal in der lib diese Bedingungen probehalber ausbaust, sodass immer ein waitus ausgeführt wird? Es ist auch die Fehlermeldung seltsam, das dim bpulsein_delay as byte generiert. Wenn du das 'dimen' weg lässt und bpulsein_delay direkt den Wert zuordnest, geht das? Vielleicht ist die Variable schon vorhanden?
      Vielleicht ist auch eine Reihenfolge nötig, setze mal das $lib "pulsein.lib" über das Anlegen der zugehörigen Einstellungen.
      Raum für Notizen

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

      -----------------------------------------------------------------------------------------------------
    • Habe gerade alle Deine Vorschläge ausprobiert, es bleibt aber immer alles beim alten:
      Es wird nur

      BASCOM-Quellcode

      1. Const Bpulsein_delay = 10
      akzeptiert. Bei allen anderen Varianten kommt nach wie vor die Fehlermeldung

      Quellcode

      1. Error : 61 Line : 57 Label not found [_MICRO_DELAY] , in File : C:\PROGRAM FILES (X86)\MCS ELECTRONICS\BASCOM-AVR\LIB\PULSEIN.LIB
      2. Error : 61 Line : 57 Label not found [_MICRO_DELAY] , in File : C:\PROGRAM FILES (X86)\MCS ELECTRONICS\BASCOM-AVR\LIB\PULSEIN.LIB

      Auch spielt es keine Rolle, wann die Lib eingebunden wird.

      In der Lib hab ich die Bedingung nun testweise so gespeichert

      BASCOM-Quellcode

      1. ;#IF varexist("bPulseIn_Delay")
      2. *BASIC: Waitus bPulseIn_Delay
      3. ;#ELSE
      4. ; @genus(9) ; THIS FOR 10 US UNITS but approx. depends on XTAL
      5. ;#ENDIF
      , also nur die eine Zeile mit dem *BASIC: Waitus bPulseIn_Delay stehen lassen, aber auch hier keine Änderungen an den Ergebnissen.

      Mir persönlich würden die verkürzten Timeout Zeiten bei 8MHz auch locker reichen. Nur kennen sollte man diesen Umstand, dass mit höherer Taktung die Timeout Zeit runter geht. WENN also meine Testprogramme nicht noch Rechen- oder Denkfehler enthalten, wäre die Formel für das bestimmen der Timeout-Zeit diese hier:

      (65535 - Cpulsein_timeout) / 100 / Prozessortakt in MHz


      z.B. mit den Zahlen des 8MHz-Code
      (65535 - 25000) / 100 / 8 = 50,67 ms

      Gruß
      Robert
    • Was ich so vermutete und als Lösungsversuch mal geraten habe, kannst' vergessen. Ich hab' jetzt auf deiner Programmgrundlage bisschen experimentiert.
      Wenn man es gemäß Hilfe macht, kommt eine Fehlermeldung, das ein label in der lib nicht gefunden wird. Diese Meldung kommt nur, wenn man im Hauptprogramm bpulsein_delay anlegt und zuweißt. Es kommt nicht, wenn man diese Anlage und Zuweisung in der lib vor nimmt. Probier doch mal die Zeiten, wenn du in einer Kopie der pulsein.lib unter der [_PULSE_IN] - Zeile ein
      *Basic: Dim bpulsein_delay as byte : bpulsein_delay=10
      einbaust.

      Vielleicht ist die lib mit der neuesten 2.081-Version nicht mehr kompatibel (neue Vwermutung)
      Raum für Notizen

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

      -----------------------------------------------------------------------------------------------------
    • Arg, wieder Mist geschrieben. Es gibt die gleichen Meldungen, wenn man es schafft die neu generierten Fehler zu beseitigen. <X
      Ein letzter Tipp von mir, dann geb' ich's auf.
      Schreib mal in der lib

      ;#IF varexist("bpulsein_delay")
      *basic: Waitus 10
      ;#ELSE
      ; @genus(9) ; THIS FOR 10 US UNITS but approx. depends on XTAL
      ;#ENDIF

      also statt der Variablen einfach mal die Zahl 10 für 10µs pause.
      Raum für Notizen

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

      -----------------------------------------------------------------------------------------------------
    • Alles probiert, aber wieder ohne eine Änderung.

      Aber wie gesagt, die verkürzten Timeout Zeiten stellen für meinen Verwendungszweck kein Problem dar. Ich lese RC Signale ein (1ms-2ms, Wiederholung alle 20ms) und wollte bei fehlendem Impuls zum einen nicht über eine halbe Sekunde warten, zu anderen aber auch nicht zu wenig Zeit für ein Timeout einbauen. Ein Timeout von ca 40ms ist lange genug, selbst wenn mal ein Impuls nicht kommen sollte reicht die Zeit, um noch auf einen zweiten zu warten.
      Durch die Testerei hab ich nun eine Formel für die Timeout Zeit und weiß, dass ich vom eingelesenen Impuls-Wert noch den Cpulsein_timeout Wert abziehen muss, um wieder in die Nähe meiner gewohnten Werte zu kommen.
      Vielleicht nutzen diese Erkenntnisse auch mal dem ein oder anderen :D

      Gruß
      Robert
    • Es hat mir doch keine Ruhe gelassen. Ich hab' dein Programm auf einen Arduino uno portiert und gebe jetzt den Wert timeout_ms auf das terminal aus. ich erhalte mit diesem code

      BASCOM-Quellcode

      1. 'Pulsein.Lib Test mit Led
      2. 'Bascom Version 2.0.8.1
      3. $regfile = "m328pdef.dat"
      4. $crystal = 16000000
      5. $hwstack = 32
      6. $swstack = 10
      7. $framesize = 40
      8. $lib "pulsein.lib"
      9. Const Cpulsein_timeout = 5000
      10. Const Bpulsein_delay = 10
      11. Config Pinb.4 = Input 'RC Signal Eingang (zu Testzwecken ohne Impulse)
      12. Config Portb.2 = Output 'Kontroll-LED
      13. Led Alias Portb.2
      14. Config Timer0 = Timer , Prescale = 1024 '1024us
      15. On Timer0 Isr_0
      16. Enable Timer0
      17. Enable Interrupts
      18. Dim Isr_counter As Byte
      19. Dim Timeout_ms As Word
      20. Dim Impulslaenge_1 As Word
      21. Dim N As Word
      22. Do
      23. Isr_counter = 0
      24. Timer0 = 0
      25. Pulsein Impulslaenge_1 , Pinb , 4 , 1 'zu Testzwecken keine Pulse anliegend
      26. Disable Interrupts
      27. Timeout_ms = Isr_counter * 256 'Überläufe
      28. Timeout_ms = Timeout_ms + Timer0 '+ aktuellem Timerwert
      29. Enable Interrupts
      30. Print "Timeout :";Cpulsein_timeout ; " Timerwert :" ; Timeout_ms
      31. Wait 1
      32. Loop
      33. End
      34. Isr_0:
      35. Incr Isr_counter
      36. Return
      Alles anzeigen
      folgende Ausgabe
      pulsein.PNG

      das passt doch genau zu deinem Ergebnis mit 1 MHz (Jetzt mit 16 MHz und einem delay von waitus=10)
      Da muss doch was anderes faul sein a_27_b277ca12

      Leider muss cpulsein_timeout eine Konstante sein, sonst könnte man eine schöne Messreihe machen, aber das hast du ja auch schon bemerkt.
      Raum für Notizen

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

      -----------------------------------------------------------------------------------------------------
    • Um die Sache noch zu verwirren, eine Änderung am bpulsein_delay ändert am ausgegebenen Ergebnis nix. Seltsamerweise kann man in der lib auch das waitus händisch ändern und das @genus(9) natürlich auskommentieren. Ändert an der Ausgabe auch nix. Das find' ich jetzt alles recht komisch.
      Raum für Notizen

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

      -----------------------------------------------------------------------------------------------------
    • tschoeatsch schrieb:

      Da muss doch was anderes faul sein
      das bin ich a_52_eb39d6ae Was bei mir angezeigt wird, ist einfach der Zählerstand des timers. Den müsste ich aber noch durch 16 teilen um annähernd die msec zu bekommen. Diese Zeile fehlt in meinem code. Ich glaub', ich geh' ins Bett, ist gar nicht mein Tag. Gute Nacht...
      Raum für Notizen

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

      -----------------------------------------------------------------------------------------------------
    • Du müsstest aber Timeout_ms noch durch 16 teilen, da Dein Timer bei 16MHz in der selben Zeit 16x weiter kommt als mit 1MHz. Dann hättest Du (ganz grob) die Timeout Zeit in ms (oder mit 1,024 multiplizieren, wenns ganz genau sein soll).
      Ich gehe mal davon aus, dass die PulseIn.lib so selten von jemanden geändert wird und daher diese Umstände (die wir hier vorgefunden haben) noch nie jemanden so richtig aufgefallen sind. a_56_df238249

      bpulsein_delay ändert (bei gleich langen Impulsen) den Wert, der in "Impulslaenge_1" geschrieben wird, wirkt sich aber nicht auf die Timeout Zeit aus. Umgekehrt aber wird bei der Benutzung der Pulsein.Lib mit Cpulsein_timeout der Wert, der in "Impulslaenge_1" geschrieben wird, zu dem Cpulsein_timeout-Wert addiert. Im ersten geposteten Code hatte ich daher

      BASCOM-Quellcode

      1. Impulslaenge_1 = Impulslaenge_1 - Cpulsein_timeout

      mit drin, um wieder auf meine gewünschten Ergebnisse zu kommen.

      Gruß
      Robert

      Ups, Antwort hat sich überschnitten
    • ein letztes Aufbäumen im Fieberwahn. Weißt du was? Wir liegen falsch, wenn wir denken, den timeout kann man mit bpulsein_delay ändern. Der timeout-Zähler wird immer mit der gleichen Geschwindigkeit erhöht. Das delay wirkt sich nur beim Messen der Pulslänge aus. Schau dir mal die lib an, dieses delay wird nur da verwendet, wo während der Pulsmessung hochgezählt wird. Timeout wird oberhalb festgestellt. Will man das auch anpassen, dass timeout bei 16 MHz und default=0 die 641msec ergibt, dann müsste im oberen Bereich der lib auch das delay eingebaut werden.
      Raum für Notizen

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

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