ASK-Empfänger einlesen?

    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!

    • Hallo Franz,

      ich hatte seinerzeit hier im Forum meine Ergebnisse für verschiedene solcher Billigheimer einmal dargelegt, tatsächlich ist es genau so, wie du es auch erfahren hast, sobald ein Signal vorhanden ist, regeln die Empfänger die Störungen herunter.

      Auch ist zu überprüfen, in welcher "elektronischen Störumgebung" so eine Funkstrecke, vielleicht auch mit keiner oder falscher Antenne betrieben wird.
    • Hallo Micht64!

      Mitch64 schrieb:

      Ein anderer Ansatz wäre, um beim Sampeln mit 5-facher Frequenz zu bleiben, anstatt die Bits in einer Variable zu zählen, die Variable direkt abhängig vom Sampel-Wert zu erhöhen oder zu veringern.

      Ziemlich genauso mache ich es gerade in meinem ersten, kläglichen Versuch.
      In der Gewichtungs-Entscheidung nehme ich die Variable Pegel auf Mittelwert 128 gesetzt.
      Dann alle 100µs den Pegel abfragen und den Mittelwert dann +1 oder -1
      Innerhalb von 5 Messungen (1.Bitzeit) sollte der Mittelwert sich irgendwo zwischen 123-133 bewegen, so dachte ich.
      Doch dem ist nicht so...:

      BASCOM-Quellcode

      1. 'ARUDINO-NANO auf Steckbrett mit 433MHz ASK-Empfänger
      2. 'Evaluation eines ASK-Empfängers zur Langzeitdoku über UART
      3. 'Nach dem scheitern der ASK-Einlesung via Pulsein oder Input-Capture nun der nächste
      4. 'Versuch. Diesmal mit Mittelwertbildung über Oversampling
      5. $regfile = "m328pdef.dat" 'ARUNDIO-NANO Prozessor
      6. $crystal = 16000000 'ARUNDIO-NANO Originalquarz
      7. $hwstack = 100
      8. $swstack = 100
      9. $framesize = 100
      10. $baud = 115200
      11. Config Portb = &B11111110 'Pull Up Deaktiviert (0) oder aktiviert (1)
      12. Config Portc = &B11111111 'Pull Up Deaktiviert (0) oder aktiviert (1)
      13. Config Portd = &B11111111 'Pull Up Deaktiviert (0) oder aktiviert (1)
      14. Ddrb = &B11111110 'definieren der verwendeten Ports ( 1 = ausgang; 0= eingang)
      15. Ddrc = &B11111111 'definieren der verwendeten Ports ( 1 = ausgang; 0= eingang)
      16. Ddrd = &B11111111 'definieren der verwendeten Ports ( 1 = ausgang; 0= eingang)
      17. Dim RXword as Word
      18. Dim RXwordpacket(26) as Word
      19. Dim PacketA(26) as Byte
      20. Dim PacketB(26) as Byte
      21. Dim Pulse as Word
      22. Dim Bitcounter as byte
      23. Dim Bytecounter as byte
      24. Dim Wordcounter as Byte
      25. Dim Newpackets as Byte
      26. Dim FoundPreamble as byte
      27. Dim Pegel as Byte
      28. Dim Sampelcounter as byte
      29. ASK Alias PinB.0 'Signaleingang ASK-Digital
      30. Bitcounter = 0 'Bitcounter Dec 0-16 zur Word-Begrenzung
      31. Bytecounter = 1 'Byte-Zähler für die spätere Manchester-Decodierung der Wörter
      32. Wordcounter = 1 'Menge empfangender Wörter (Array)
      33. Pegel = 128 'Mittelwert zur Low/High-Bestimmung der Messwerte
      34. Const Preload = 56
      35. Config Timer0 = Timer, Prescale = 8 'Teimer-Int alle 100µs, = 5-facht Bitzeit des ASK-Signals
      36. Enable Timer0
      37. On Timer0 suche 'Zur Oversampling-Abtastung
      38. Enable Interrupts
      39. Print "Starte Schleife...."
      40. Do
      41. If Sampelcounter = 5 then gosub Bewertung
      42. If Rxword = &b0011001100110011 then Print "Dotting erkannt!"
      43. If RXword = &b1001011010010110 then
      44. Print "Syncwort erkannt!"
      45. Gosub RX
      46. end if
      47. wait 10
      48. Print "Live...Pegel:";Pegel;" RXword: h";Hex(RXword);" Wordcounter: ";Wordcounter
      49. Loop
      50. suche:
      51. Stop Timer0
      52. Timer0 = Preload
      53. If Pinb.0 = 1 then Pegel = Pegel + 1 'wenn ASK-Pegel H dann Mittelwert addieren +1
      54. If Pinb.0 = 0 then Pegel = Pegel - 1 'Wenn ASK-Pegel L dann Mittelwert Subrahieren -1
      55. Sampelcounter = Sampelcounter + 1
      56. Start Timer0
      57. Return
      58. Bewertung:
      59. If Pegel < 127 then 'Wenn Mittelwert deutlich unter Mittelwert (128)
      60. Shift Rxword, left, 1 'dann als logische 0 betrachten, Wxword dazu shiften
      61. Bitcounter = Bitcounter + 1 'Bitcounter weiterzählen
      62. Sampelcounter = 0 'Sampelcounter zurücksetzen
      63. Pegel = 128 'Pegel-Mittelwert für neue Messung setzen
      64. end if
      65. If Pegel > 127 and Pegel < 129 then 'Wenn Mittelwert kaum verändert,als Fehler erkennen
      66. Sampelcounter = 0
      67. Pegel = 128
      68. end if
      69. If Pegel > 129 then 'Wenn Mittelwert deutlich über Mittelwert (128)
      70. Shift RXword, left, 1 'dann als logische 1 betrachten und ins Rxword shiften
      71. RXword = RXword + 1 'Hier als LSB einfügen durch Addition
      72. Bitcounter = Bitcounter + 1
      73. Sampelcounter = 0
      74. Pegel = 128
      75. end If
      76. Return
      77. RX:
      78. RXwordpacket(Wordcounter) = Rxword 'Gefundenes Syncword in Array kopieren
      79. Wordcounter = Wordcounter + 1
      80. Sampelcounter = 0
      81. Print "Neues Wort empfangen!"
      82. Return
      Alles anzeigen

      Zu meiner Verwunderung sieht die ausgabe eher so aus:

      Live...Pegel: 8 RXword: h0000 Wordcounter: 0

      Nach 5 Messungen erreiche ich Pegelwerte zwischen bislang 7 (-121) und 249 (+121).
      Also scheint er nicht 5 mal in 500µs zu messen, sondern eher bis zu 121 mal? *grübel*

      Ulrich schrieb:

      Ich versuch es trotzdem mal; bei mir läuft seit einigen Jahren dieser ASK-Müll völlig problemlos, über mehrere Stockwerke und auch draußen über Entfernungen größer 20m.Man muss den Müll nur entsprechend aufgereiten, z.B. eine Präambel auswerten und erst dann die Daten.

      Genauso mache ich es ja auch.
      Den Sensor kann ich vom Protokoll nicht beeinflussen.
      Brauche ich an diesem Punkt auch nicht, denn er sendet bereits eine Präambel von immerhin 4Bytes + Manchester = 8Bytes = stolze 64Bit.

      Franz schrieb:

      Soweit ich Jürgen verstanden habe, hat er immer noch jede Menge Piks im Signal, selbst wenn er sendet.
      Das ist bei mir überhaupt nicht der Fall. Ich habe hier so einen Billigheimer Sender/Empfänger für 433MHz. Wenn nicht gesendet wird, kommt da Dauermüll raus. Sobald aber ein Signal kommt, scheint die automatische Verstärkung sofort runterzuregeln und ich sehe ein absolut sauberes Signal.
      Daher frage ich mich, ob der Zustand bei Jürgen wirklich nicht auf der Empfängerseite verbessert werden könnte.

      Exakt das ist mein Problem bisher mit allen drei Empfängern hier.
      Namentlich:
      - RXB6
      - RWS-371-3
      - XY-MK-5V

      Und ja, die AGC dieser Teile kann einen wahnsinnig werden lassen, weil beim warten erstmal tausende Rauschdaten gemessen werden und man die Daten des gesuchten Paketes gefühlt ne Stunde je 10 Sekunden mitloggen suchen muss.

      Hingegen am Oszi oder zwischendurch mit Soundkarte an den Empfängerausgängen sieht man die Daten ziemlich deutlich.
      Das genau ist das Signal was ich auch über den NANO sampeln möchte.
      Hier der Ausschnitt vom ersten Dotting bis zum Anfang des Syncwortes.

      Beginn.jpg

      Nur irgendwie reicht das bislang nicht für meine Auswertungsversuche.
      Schon gefühlt 100 mal gemacht:
      Wenn ich das so via Soundkarte aufgenommene signal weit genug aufzoome und von hand decodiere, passt das alles.
      Doch egal was ich mit Bascom versuche, egal ob Pulsein oder Input Capture oder jetzt das Oversamplig.
      Genau das im Bild zu erkennende Ausgangssignal der drei Empfänger hier reicht nicht, um irgendwo sinnvolle Ergebnisse zu bekommen.
      Und wirklich verstehen woran es liegt, kann ich im Monent noch gar nicht.

      Jürgen
    • Hallo Jürgen,
      also in dem Oszi sehe ich überhaupt keine Fehler im Signal. Das Rauschen vorher ist ja egal.
      Pulsein würde ich niemals für so ene Aufgabe verwenden, sondern immer den ICP.
      Du hast doch eine minimal und maximale Breite der Flanken, jeweils für die kuren und die langen. Dann nimmst du z.B. theoretische Breite der kurzen Flanke *0,8 und theoretische Breite der längsten Flanke *1,2. In der ISR fragst du zunächst diese Grenzen ab. Ist der ICR innerhalb, hast du ein valides Bit empfangen und musst jetzt noch feststellen, ob kurz oder lang. Dann speicherst du das in deinem Empfangsarray ab.
      Ist es außerhalb der Grenzen, dann verwirfst du alles, was bisher empfangen wurde. Es können ja zufällig im Rauschen auch noch solche Flanke enthalten sein.
      Bei mir klappt diese Vorgehensweise bei allen Empfängern, ob nun 433 oder 868 MHz.

      Wenn du ein verrauschtes Signal hättest, wäre die Sache sehr kompliziert das wieder per Software auszugleichen. Aber das sehe ich bei dir nicht.
    • Das Signal sieht für mich aus, wie es zu erwarten ist. Anfangs Rauschen, dann der Übergang zum Signal, was dann bei ca. 6x63ms mit der Preamble beginnt.

      Aber die Auswertung, die du in der ISR versuchst, macht für mich keinen Sinn.
      Du musst die Variable, deren Mitte mit 128 angegeben ist, symetrisch begrenzen.
      Und zurücksetzen auch nicht. Der Wert soll nur durch den eingelesenen Pegel andern können, Sowas wie Integrieren (Tiefpass).

      Das Einlesen würde ich so machen, ohne den Timer zu stoppen.

      BASCOM-Quellcode

      1. ' Variablen
      2. SampelSignal Alias PinB.0
      3. Dim BitPegel as Byte
      4. Dim BitOld as Bit
      5. Dim BitNew as Bit
      6. ' Sampel-Signal einlesen und Bitwert zählen (BitPegel)
      7. If SampleSignal = 1 then
      8. If BitPegel < 5 then
      9. Incr BitPegel
      10. End If
      11. Else then
      12. If BitPegel > 1 then
      13. Decr BitPegel
      14. End If
      15. End If
      Alles anzeigen
      Die Werte können so nur zw 0 und 5 schwanken.

      Und habe ich schon erwähnt einen CTC-Timer-Mode zu verwenden?
      Keinen Timer2 oder Timer1 mehr frei?
    • Hallo!

      Franz schrieb:

      Hallo Jürgen,
      also in dem Oszi sehe ich überhaupt keine Fehler im Signal. Das Rauschen vorher ist ja egal.
      Pulsein würde ich niemals für so ene Aufgabe verwenden, sondern immer den ICP.
      Du hast doch eine minimal und maximale Breite der Flanken, jeweils für die kuren und die langen. Dann nimmst du z.B. theoretische Breite der kurzen Flanke *0,8 und theoretische Breite der längsten Flanke *1,2. In der ISR fragst du zunächst diese Grenzen ab. Ist der ICR innerhalb, hast du ein valides Bit empfangen und musst jetzt noch feststellen, ob kurz oder lang. Dann speicherst du das in deinem Empfangsarray ab.
      Ist es außerhalb der Grenzen, dann verwirfst du alles, was bisher empfangen wurde. Es können ja zufällig im Rauschen auch noch solche Flanke enthalten sein.
      Bei mir klappt diese Vorgehensweise bei allen Empfängern, ob nun 433 oder 868 MHz.

      Wenn du ein verrauschtes Signal hättest, wäre die Sache sehr kompliziert das wieder per Software auszugleichen. Aber das sehe ich bei dir nicht.
      Ja, das entspräche in etwa dem, was ich Freitag Abend als Versuch 4 gemacht habe.
      Hat nur nicht funktioniert wie gehofft.
      Da du aber schreibt du hättest das genau so schon mehrfach in funktionsfähig geschafft, werde ich mich nun darauf weiter konzentrieren.
      Irgendwo muss der Fehler ja bei mir liegen.

      Jürgen
    • Hallo nochmal,

      Nach dem Hinweis von Franz habe ich den Ansatz meines Input-Capture Versuches nochmal neu aufgesetzt.
      Allerdings um Feherquellen weitestgehend aus zu schließen, habe ich meine ASK-Empfänger und den bisherigen NANO sammt Steckboard mal zur Seite gelegt.

      Einen noch originalverpackten Nano frisch hergenommen und als Signalquelle meinen TTL-Teiler genommen.
      Mit dem 2MHz TTL-Oszillator lag ich etwas oberhalb meiner benötigten Flankenzeiten: 512µs / 1024µs
      Habe mal geguckt ob ich ein TTL-Oszillator finde der noch näher rankommt an meine gesuchten Flankenzeiten.
      Nicht exakt, aber immerhin näher drann an den benötigten 488µs / 976µs habe ich jetzt:

      4,096MHz / 4096 = 1000µs
      4,096MHz / 8192 = 500µs

      Mein Programm sieht bisher so aus:

      BASCOM-Quellcode

      1. 'ARUDINO-NANO auf Steckbrett mit 433MHz ASK-Empfänger RXB6
      2. 'Evaluation eines ASK-Empfängers zur Langzeitdoku über UART
      3. 'Datenausgang des RXB6 liegt auf PB0
      4. $regfile = "m328pdef.dat" 'ARUNDIO-NANO Prozessor
      5. $crystal = 16000000 'ARUNDIO-NANO Originalquarz
      6. $hwstack = 40
      7. $swstack = 40
      8. $framesize = 40
      9. $baud = 115200
      10. Config Portb = &B11111110 'Pull Up Deaktiviert (0) oder aktiviert (1)
      11. Config Portc = &B11111111 'Pull Up Deaktiviert (0) oder aktiviert (1)
      12. Config Portd = &B11111111 'Pull Up Deaktiviert (0) oder aktiviert (1)
      13. Ddrb = &B11111110 'definieren der verwendeten Ports ( 1 = ausgang; 0= eingang)
      14. Ddrc = &B11111111 'definieren der verwendeten Ports ( 1 = ausgang; 0= eingang)
      15. Ddrd = &B11111111 'definieren der verwendeten Ports ( 1 = ausgang; 0= eingang)
      16. Dim RXword as Word
      17. Dim RXwordpacket(255) as Word
      18. Dim Rxbitpacket(255) as Byte
      19. Dim PacketA(26) as Byte
      20. Dim PacketB(26) as Byte
      21. Dim Pulse as Word
      22. Dim Pulse_neu as Word
      23. Dim Pulse_alt as Word
      24. Dim bitcount as Byte
      25. Dim bytecount as Byte
      26. Dim Wordcount as Byte
      27. Dim Pegel as Bit
      28. Dim Pegel1 as Bit
      29. bitcount = 0
      30. 'ASK Alias PinC.1 'Signaleingang ASK-Digital
      31. 'Signaleingang nun PB0 -> ICP1
      32. Config Timer1 = Timer, Prescale = 64, Noise_Cancel = 1, Capture_EDGE = RISING 'müssten 4µs (250kHz) sein.
      33. 'Config Timer1 = Timer, Prescale = 8, Noise_Cancel = 1, Capture_EDGE = RISING 'müssten 0,5µs (2MHz) sein.
      34. 'tccr1b = &b10000011 'für 4µs und Noise-Canceller
      35. 'tccr1b = &b10000010 'für 0,5µs und Noise Canceller
      36. timsk1 =&b00100000 'Input Capture Int Enable
      37. On ICP1 Readtime
      38. enable interrupts
      39. Print "Start..."
      40. Wordcount = 1
      41. Do
      42. If Wordcount =251 then
      43. stop Timer1
      44. Print "Stoppe Timer, gebe Array aus:"
      45. wait 2
      46. For Wordcount = 1 to 250
      47. Print Bin(RXwordpacket(Wordcount))
      48. next
      49. Print "Starte Timer"
      50. wait 10
      51. Wordcount = 1
      52. Start Timer1
      53. end if
      54. Loop
      55. Readtime:
      56. Pulse_neu = ICR1
      57. Pegel1 = TCCR1B.6
      58. Pulse = Pulse_neu - Pulse_alt
      59. Pulse_alt = Pulse_neu
      60. Toggle TCCR1B.6
      61. Pegel = NOT Pegel1
      62. If Pulse < 96 and Pulse > 260 then
      63. toggle tccr1b.6
      64. Bitcount = 0
      65. Wordcount = 0
      66. end if
      67. If Pulse < 174 then
      68. Shift RXword,left, 1
      69. Rxword.0 = Pegel
      70. Bitcount = Bitcount + 1
      71. Gosub nextword
      72. end if
      73. If Pulse > 174 then
      74. Shift RXword, left, 1
      75. Rxword.0 = Pegel
      76. Bitcount = Bitcount + 1
      77. Gosub nextword
      78. Shift Rxword, left, 1
      79. Rxword.0 = Pegel
      80. Bitcount = Bitcount + 1
      81. Gosub nextword
      82. end If
      83. Return
      84. nextword:
      85. If Bitcount = 16 then 'prüfen ob das Buffer-Wort voll ist
      86. RXwordpacket(Wordcount) = RXword 'Wenn voll, dann ins Array schreiben
      87. Wordcount = Wordcount + 1 'und Index weiter schalten
      88. end if
      89. Return
      Alles anzeigen

      Und damit klappt es bis hier her:
      Testsignal 1kHz Rechteck landet bei einem TCR1-Wert von 124-125 und füllt mein Array wie es soll mit b1010101010101010.
      Testsignal 500Hz Rechteck landet bei TCR1-Wert 248-249 und füllt mein Array zuverlässig mit b1100110011001100.

      Morgen dann mal gucken ob das nun auch endlich an einem meiner ASK-Empfänger funktioniert.

      Jürgen
    • Hallo Jürgen

      An deiner ISR sehe ich 2 Probleme.

      BASCOM-Quellcode: ISR

      1. Readtime:
      2. Pulse_neu = ICR1
      3. Pegel1 = TCCR1B.6
      4. Pulse = Pulse_neu - Pulse_alt
      5. Pulse_alt = Pulse_neu
      6. Toggle TCCR1B.6
      7. Pegel = NOT Pegel1
      8. If Pulse < 96 and Pulse > 260 then
      9. toggle tccr1b.6
      10. Bitcount = 0
      11. Wordcount = 0
      12. end if
      13. If Pulse < 174 then
      14. Shift RXword,left, 1
      15. Rxword.0 = Pegel
      16. Bitcount = Bitcount + 1
      17. Gosub nextword
      18. end if
      19. If Pulse > 174 then
      20. Shift RXword, left, 1
      21. Rxword.0 = Pegel
      22. Bitcount = Bitcount + 1
      23. Gosub nextword
      24. Shift Rxword, left, 1
      25. Rxword.0 = Pegel
      26. Bitcount = Bitcount + 1
      27. Gosub nextword
      28. end If
      29. Return
      Alles anzeigen

      1.
      In Zeile 9 prüfst du, ob der Flankenabstand im erlaubten Bereich ist. Angenommen, der Flankenabstand ist zu klein oder zu groß, dann werden die Bits trotzdem in deinem RxWord abgelegt.

      Wenn Puls angenommen 95 ist, setzt du zwar Bitcount und Wordcount auf 0, aber in Zeile 15 ist Pulse (95) < 174 True, also wird der falsche Pegel als Bit gespeichert. Gleiches gilt für Pulse, die Werte > 260, die siend auch > 174 (Zeile 23).

      Ich denke du must nach Abarbeitung des IF-Blocks (Zeile 9) die ISR verlassen.

      2.
      Du gehst in deinem Code immer davon aus, dass mit dem ersten gültigen Flankenabstand auch ein gültiges Bit kommt. Wenn da ein Störpuls kommt, werden deine ganzen Werte um 1 Bit versetzt eingelesen. Du must die Bitfolge als Stream sehen und nicht als Daten-Words.

      Du solltest also erkennen, ob es sich um die Preamble handelt oder um Daten. Preamble startet immer mit einer bestimmten Bitfolge, und die erste Abweichung ist der Start für das 1. Datenbit. Ers ab da darfst du die Bits in das RxWord schieben.
    • Hallo!

      Franz schrieb:

      mich wundert, dass das funktioniert.
      In der Sub nextword müsstest du Bitcount auf 0 setzen, wenn es 16 war und du RXword abspeicherst.

      Oh, ganz übersehen. Danke!

      Mitch64 schrieb:

      Hallo Jürgen

      An deiner ISR sehe ich 2 Probleme.

      [....]
      Ich denke du must nach Abarbeitung des IF-Blocks (Zeile 9) die ISR verlassen.

      [...]

      Tja, im laufe meiner Versuche bisher bekomme ich ganz langsam eine Idee des Timings.
      Wenn ich zu langsam war, verschluckt er Bits.
      Habe dein Vorschlag aber inzwischen umgesetzt:

      BASCOM-Quellcode

      1. 'ARUDINO-NANO auf Steckbrett mit 433MHz ASK-Empfänger RXB6
      2. 'Evaluation eines ASK-Empfängers zur Langzeitdoku über UART
      3. 'Datenausgang des RXB6 liegt auf PB0
      4. $regfile = "m328pdef.dat" 'ARUNDIO-NANO Prozessor
      5. $crystal = 16000000 'ARUNDIO-NANO Originalquarz
      6. $hwstack = 40
      7. $swstack = 40
      8. $framesize = 40
      9. $baud = 115200
      10. Config Portb = &B11111110 'Pull Up Deaktiviert (0) oder aktiviert (1)
      11. Config Portc = &B11111111 'Pull Up Deaktiviert (0) oder aktiviert (1)
      12. Config Portd = &B11111111 'Pull Up Deaktiviert (0) oder aktiviert (1)
      13. Ddrb = &B11111110 'definieren der verwendeten Ports ( 1 = ausgang; 0= eingang)
      14. Ddrc = &B11111111 'definieren der verwendeten Ports ( 1 = ausgang; 0= eingang)
      15. Ddrd = &B11111111 'definieren der verwendeten Ports ( 1 = ausgang; 0= eingang)
      16. Dim RXword as Word
      17. Dim RXwordpacket(255) as Word
      18. Dim Rxbitpacket(255) as Byte
      19. Dim PacketA(26) as Byte
      20. Dim PacketB(26) as Byte
      21. Dim Pulse as Word
      22. Dim Pulse_neu as Word
      23. Dim Pulse_alt as Word
      24. Dim bitcount as Byte
      25. Dim bytecount as Byte
      26. Dim Wordcount as Byte
      27. Dim Pegel as Bit
      28. Dim Pegel1 as Bit
      29. Dim Newbit as Bit
      30. bitcount = 0
      31. 'ASK Alias PinC.1 'Signaleingang ASK-Digital
      32. 'Signaleingang nun PB0 -> ICP1
      33. Config Timer1 = Timer, Prescale = 64, Noise_Cancel = 1, Capture_EDGE = RISING 'müssten 4µs (250kHz) sein.
      34. 'Config Timer1 = Timer, Prescale = 8, Noise_Cancel = 1, Capture_EDGE = RISING 'müssten 0,5µs (2MHz) sein.
      35. 'tccr1b = &b10000011 'für 4µs und Noise-Canceller
      36. 'tccr1b = &b10000010 'für 0,5µs und Noise Canceller
      37. timsk1 =&b00100000 'Input Capture Int Enable
      38. On ICP1 ASKvalidierung
      39. enable interrupts
      40. Print "Start..."
      41. Wordcount = 1
      42. Do
      43. If Newbit = 1 then gosub Readtime
      44. If Wordcount =251 then
      45. stop Timer1
      46. Print "Stoppe Timer, gebe Array aus:"
      47. wait 2
      48. For Wordcount = 1 to 250
      49. Print Bin(RXwordpacket(Wordcount))
      50. next
      51. Print "Starte Timer"
      52. wait 10
      53. Wordcount = 1
      54. Start Timer1
      55. end if
      56. Loop
      57. ASKvalidierung:
      58. Pulse_neu = ICR1
      59. Pegel1 = TCCR1B.6
      60. Pulse = Pulse_neu - Pulse_alt
      61. Pulse_alt = Pulse_neu
      62. Toggle TCCR1B.6
      63. Pegel = NOT Pegel1
      64. If Pulse < 96 and Pulse > 260 then
      65. Bitcount = 0
      66. Wordcount = 0
      67. Newbit = 0
      68. Else
      69. Newbit = 1
      70. end if
      71. Return
      72. Readtime:
      73. If Pulse < 174 then
      74. Shift RXword,left, 1
      75. Rxword.0 = Pegel
      76. Bitcount = Bitcount + 1
      77. Newbit = 0
      78. Gosub nextword
      79. end if
      80. If Pulse > 174 then
      81. Shift RXword, left, 1
      82. Rxword.0 = Pegel
      83. Bitcount = Bitcount + 1
      84. Gosub nextword
      85. Shift Rxword, left, 1
      86. Rxword.0 = Pegel
      87. Bitcount = Bitcount + 1
      88. Newbit = 0
      89. Gosub nextword
      90. end If
      91. Return
      92. nextword:
      93. If Bitcount = 16 then
      94. RXwordpacket(Wordcount) = RXword
      95. Wordcount = Wordcount + 1
      96. Bitcount = 0
      97. end if
      98. Return
      Alles anzeigen

      Die eigentliche ISR verlasse ich nun sehr viel früher und schreite nur die Variable "Newbit" ob das Timing im erlaubten Bereich war oder nicht.
      Aus der Haptschleife dann springe ich in die Sub der weiteren Verarbeitung.

      Zu deinem 2. Einwand:
      Das ist dem aktuellen Projektstand geschuldet. Das Programm soll mr erstmal alles (im erlaubten Wertbereich) ins Word-Array packen und gesammelt ausgeben.
      Eben um zu gucken ob er irgendwo das gesuchte Bitmuster auffängt.
      Tut er das hoffentlich bald zuverlässig, greife ich deinen Einwand 2 auf:
      Der Empfangsbuffer RxWord soll forlaufend am LSB-Ende neue Bits die ankomen reingeschoben werden.
      Nach jederm hinzufügen eines neuen Bits soll ein Vergleich mit zwei Vorgaben erfolgen:
      Wenn b0011001100110011 soll das Dotting erkannt werden, ab hier solange stur weiter empfangen bis ungültige Bits kommen.
      Wenn b1001011010010110 soll das als Wordsync erkannt und als erstes Word in Rxwordpacket(1) gespeichert werden.
      Macht aber erst Sinn, wenn die Bitfolgen hinreichend sauber erkannt werden.
      Mehr als zwei identische Bits aufeinanderfolgend ist faktisch ein Fehler.
      Und genau die habe ich noch:
      0100110100010111
      0011111101101010
      1101101010111010
      usw.

      An die nachfolgende Herrausforderung will ich noch gar nicht denken.
      Das wäre dann nämlich die Erkennung des Paketendes.
      Der zu loggende Sensor sendet nämlich zwei unterschiedlich lange Pakete.
      Den einen Pakettyp mit Wordsync bis zum letzten Bit einer CRC insgesamt 17 Wörter.
      Den zweiten Pakettyp mit Wordsync bis zum letzen Bit einer CRC mit 25 Wörtern.
      Nach erkennen des Wordsync das ein ungültiges Bit erst kommen, wenn Rxwordpacket bis midesten 17 oder 25 gefüllt ist, alles andere wäre dann Müll.
      Aber da bin ich noch nicht.
    • Hallo Franz!

      Franz schrieb:

      Hast du jetzt noch deinen Taktgenerator dran oder schon den ASK Empfänger?
      Bei dem Letzteren könnte doch sicherlich eine längere Folge auftreten, oder?
      Seit heute habe ich den ASK-Empfänger RWS-371-3 dran:
      Link zum Datenblatt

      Timingfehler sind eigentlich so gut wie sicher.
      Denn schon der originale Sensor schwankt mit seiner Bitzeit abhängig von Temperatur und Batteriestand.
      Im Durchscnitt exakt 488µs, als ich das letzte mal nachts (da waren es knapp unter 0°C draussen) gemessen hatte, waren es 460µs.
      Von daher war ich ja ziemlich rigoros mit meiner Zeiterkennung.
      In der ISR sortiere ich alles kleiner 96x4µs = 384µs und größer als 260x4µs = 1040µs als Fehler aus.
      Die harte Entscheidung ob nun eine Bitzeit oder zwei Bitzeiten gemessen wurden, mache ich an der Mitte fest. Bei 174x4µs = 696µs.
      Es kann sein das ich da nochmal schmalbandiger werden muss um noch mehr Rauschen zu filtern.
      Dumm nur...im Array landen noch immer Bitfolgen wie weit mehr als die erlaubten zwei identischen Bits enthalten.

      Mein TTL-Teiler kann leider keine Bitwechsel.
      Es sind da nur Stiftleisten wo ich wahlweise 500Hz und 1000Hz nacheinander abgreifen kann.

      Den problematischen RXB6 habe ich von meinem Tisch entfernt, denn so wie er das DutyCycle verbiegt würde mein Projekt nur noch komplizierter.
      Statt dessen hängt er nun testweise an einem RaspberryPi3 an einem Tool welches Funksteckdosen sniffen können soll.
      Und dieses Tool scheint ws mit dem RXB6 und seinem krummen Signal was anfangen zu können:
      Screenshot_1.jpg

      Aber mal so nebenher.
      Eben im Programm zwei Wordchecks eingefügt die mich stutzig werden lassen.
      Wordsync korrekt (h9696) wird bislang nicht gefunden. Invertiert (h6969) schon...
      Ist es üblich bei ASK-Empfängern das sie ein negiertes Ausgangssignal haben?

      Jürgen
    • DG7GJ schrieb:

      Mein TTL-Teiler kann leider keine Bitwechsel.
      Wieso baust du nicht ne kleine Schaltung mit AVR, die das tut?
      So könntest du das Signal simulieren, was der Empfänger ausgeben würde.

      Lass so einfach alle 5s einmal Temperatur senden.
      Also Preamble, Dann Daten.

      Deine obige ISR wirs do nie klappen. Du machst dir das Timing selber kaputt durch ungeschickte programmierung.

      Versuchs doch mal mit einer Select Case Struktur in der ISR

      Quellcode

      1. Select Case Pulse
      2. Case vonGrenze to bisGrenze ' gültigen 0-Bit
      3. Case vonGrenze to bisGrenze ' gültiges 1-Bit
      4. Case Else ' ungültiger Flankenabstand
      5. End Select
    • Mitch64 schrieb:

      Wieso baust du nicht ne kleine Schaltung mit AVR, die das tut?So könntest du das Signal simulieren, was der Empfänger ausgeben würde.

      Lass so einfach alle 5s einmal Temperatur senden.
      Also Preamble, Dann Daten.

      Deine obige ISR wirs do nie klappen. Du machst dir das Timing selber kaputt durch ungeschickte programmierung.

      Versuchs doch mal mit einer Select Case Struktur in der ISR

      Habe ich auch schon dran gedacht. Nen zweiten NANO auf's Steckbrett als Sender.
      Vielleicht mache ich das die Tage wenn es via ASK-Empfänger dann noch immer nicht gehen sollte.

      Die vorgeschlagene Variante mit der Select Case schleife tippe ich gerade. Vielleicht klappt's damit besser.

      Jürgen
    • Hallo!

      Mitch64 schrieb:

      Schau dir auch das mal an von der Bascom-Hilfe

      Da wird beschrieben, wie man ein Manchester-Signal dekodiert.
      Nein, brauche ich nicht.
      Wie man Manchester decodiert weis ich aus dem FF, hab ich schon gefühlt hunderte male manuell gemacht.
      Nicht schriftlich aus 170Bit Manchester 85 decodierte...dafür hätte ich eine Tapete gebraucht.
      Aber dafür im Texteditor ohne Zeilenumbruch, geht hervorragend.
      Und Bascom hat sogar eine eigene Funktion dafür: Befehl MANCHESTERDEC macht aus einem Manchester-codierten Word ein decodiertes Byte.

      Aber genau da bin ich noch nicht. Erst mal will ich diesen verflixten Manchester-Datenstrom fehlerfrei dedektieren.
      Solange das nicht läuft, erübrigt sich für mich der Gedanke wie ich das anschließend decodiere.

      Tja... und nach Umstellung aus Select-Case wird es nun richtig wuschig:

      BASCOM-Quellcode

      1. ASKvalidierung:
      2. Pulse_neu = ICR1
      3. Pegel1 = TCCR1B.6
      4. Pulse = Pulse_neu - Pulse_alt
      5. Pulse_alt = Pulse_neu
      6. Toggle TCCR1B.6
      7. Pegel = Pegel1
      8. select case Pulse
      9. Case 96 to 125 : Bittime = 1
      10. Case 220 to 260 : Bittime = 2
      11. Case 126 to 219 : Bittime = 0
      12. Case is < 96: Bittime = 0
      13. Case is > 260: Bittime = 0
      14. End Select
      Alles anzeigen
      Plötzlich landen in meinem Array große Ketten aufeinander folgender Bits...126-188 aufeinanderfolgende High und eben so lange Low-Blöcke.
      Puh...wenn ich damit durch bin, gehe ich wieder zu Projekten mit I²C, SPI &Co.

      Jürgen
    • DG7GJ schrieb:

      Nein, brauche ich nicht.
      Wie man Manchester decodiert weis ich aus dem FF, hab ich schon gefühlt hunderte male manuell gemacht.
      Nicht schriftlich aus 170Bit Manchester 85 decodierte...dafür hätte ich eine Tapete gebraucht.
      Du versuchst doch in der isr die Bits rauszulesen und zwar mit einem Controller.
      Aber bitte, wenn du das nicht brauchst, dann machste es eben von Hand, das kannste ja aus dem FF.
    • Mitch64 schrieb:

      Du versuchst doch in der isr die Bits rauszulesen und zwar mit einem Controller.Aber bitte, wenn du das nicht brauchst, dann machste es eben von Hand, das kannste ja aus dem FF.

      Nun, ich kämpfe gerade daran das mein Controller das nachte Bitmuster roh, wie es auch über Funk rein kommt.
      Genauer gesagt, hacke ich das bekannte Bitmuster gerade ein in einen zweiten NANO der als Testsender arbeiten soll.
      Manchester ist nicht mein Problem, sondern die zuverlässige erkennung des asynchronen Datenstroms ohne Start- und Stopbit.


      Das einzige was ich an Aha-Effekt hatte als ich auf den von dir gesetzten Link zu READHITAG ging,
      war die Erkentniss das Bascom auch die invertierte Form von Manchester kennt.
      Die fehlt nämlich bei MANCHESTERDEC


      Manchester Einfach macht aus
      einer 1 eine 10 beim Sender, beim Empfänger aus 10 wieder 1
      einer 0 eine 01 beim Sender, beim Empfänger aus 01 wieder 0


      Manchester Sonderfall macht aus
      einer 1 eine 01 beim Sender, beim Empfänger aus 01 wieder 1
      einer 0 eine 10 beim Sender, beim Empfänger aus 10 wieder 0


      Da ich später beide brauche, hilft mit MANCHESTERDEC nur zur Hälfte.
      Aber davon ab...der Grund weshalb ich das mache ist simpel:
      Ich will die Ergenisse eines Paketes schnell haben.


      Manuell wie bisher würde ich jetzt ein Paket sampeln und frühestens ein einer Stunde herausgetippt haben was da für Daten drinn waren.


      Jürgen
    • Hallo Franz

      Franz schrieb:

      Zeige doch lieber immer ganze Programme. Dann kann man die leichter ausprobieren.
      Lohnt noch nicht.
      Die letzten zwei Stunden habe ich damit verbracht einen zweiten Nano so zu programmieren, das er mir die Sensordaten möglichst exakt in hardware ausgibt.
      Was am längsten davon gedauert hat war der Delay-Abgleich der Shiftout-Funktion.
      Zumal der ASK-Sender den ich zum Abgleich drann hatte ähnliche Probleme macht mit dem Timing wie der RXB6.
      Mit rtl_433 gesampelt liege ich über diesen ASK-Sender bei High-Zeiten zwischen 440 und 480µs und Low-Zeiten 510-590µs je Bit.
      Jetzt probiere ich die erfolgsversprechensten Programmversionen mit diesem Signal aus.
      Ohne AKS-Strecke dazwischen, einfach per Steckdraht als TTL-Signal übertragen dann sauberes Timing:
      Pulsein misst für die einfachen Bitzeiten glatte 50 und doppelte Bitzeiten glatte 100.
      Mein Input-Capture mit Vorteiler 64 und 4µs auflösung misst dabei exakt die gesuchten Werte: 122 (488µs) und 244 (976µs).

      Senderseitig brauchte Shiftout dafür den Delay Wert 240.
      Somit habe ich jetzt einen Testgenerator ohne die Fehlerquelle ASK dazwischen.

      Jürgen
    • DG7GJ schrieb:

      einer 1 eine 10 beim Sender, beim Empfänger aus 10 wieder 1
      einer 0 eine 01 beim Sender, beim Empfänger aus 01 wieder 0
      so kann man das auch sehen. Ich würde sagen eine doppelt langes High bedeutet low/High flanke und ein langes Low eine Hig Low wechsel. Während der Preamble kann die richtige Länge bestimmt werden. Alles was da nicht auf ein paar takte reinpasst war sicher eine Störung. Eine Entscheidung auf der Hälfte ist also ganz sicher falsch. Vielleicht als Error Zähler brauchbar.
      (Wenn DCF ein 150ms Puls ergibt brauch er nicht weiter zuzuhöhren sondern wartet auf nen neuen Start)
      PS Der Code vom Sendersimulator wäre interessant