Machbarkeitsfrage

Hallo zusammen!

Ich hätte ien paar Fragen zu Voraussetzungen die ich für die Realisation meines Projektes eines fahrenden Roboters der Ferngestuert werden kann bräuchte:

Vorgesehen war eines der rn-control boards:

Als Sprache dachte ich an Bascom da es dort einfach ist Impulse zu messen.

Es müssten 3 Kanäle eines PPM RC Empängers ausgewertet werden.

Ist das möglich die 3 Impulse gleichzeitig auszuwerten da es in etwa echtzeit sein sollte was natürlich nie ganz geht....?

Wenn mit Interrupts gearbeitet würde, würde es ja das Programm immer wieder unterbrechen ... und das würde ja gar nicht richtig voran kommen im Hauptprogramm oder she ich da etwas falsch ?

Mfg pascalu

Hallo pascalu,

das Auswerten des PPM-Signals dürfte nahezu jeder Atmel-uC leisten.
Wenn du die Motorsteuerung auf einem Board haben willst, sieh dir die RNBFRA 1.22 an. Ich bin damit gut zufrieden.
Die Auswertung der RC-Signale könnte auf diesem Board z.B. der Coprozessor Tiny2313 übernehmen.

Gruß Dirk

Hallo

Zitat:

---

Als Sprache dachte ich an Bascom da es dort einfach ist Impulse zu messen.

---

Es ist auch in C einfach: https://www.roboternetz.de/phpBB2/vi...=328950#328950

Das kann ein RN-Board natürlich auch - dein Projekt ist also durchaus realisierbar.

Gruß

mic

Erstmal danke für die schnelle antwort . Es ist ja so, dass alle 22.5 ms ein signal vom empfänger kommt, müsste dann damit das board immer die neuesten Emüfängerdaten hat das Programm innerhalb von 22.5ms durchgearbeitet haben, was ja hiesse, dass keine warte x sekunden anweisungen folgen dürften. Oder wie müsste man das realisieren ? mfg

Hallo pascalu,

Zitat:

---

damit das board immer die neuesten Emüfängerdaten hat das Programm innerhalb von 22.5ms durchgearbeitet haben, was ja hiesse, dass keine warte x sekunden anweisungen folgen dürften.

---

Das PPM-Signal würde z.B. in einer Interrupt-Routine abgetastet und die Länge der Impulse ermittelt. Das Bascom-Programm würde durch den Interrupt regelmäßig unterbrochen, aber das macht nix. Das wird man i.d.R. kaum merken. Auch Wartezyklen sind im Hauptprogramm möglich.

Gruß Dirk

Dann sollte einfach eine Auswertung stattgefunden haben bis das neue Signal kommt oder ?

Die Messung der Impulslängen geschied im Hintergrund mit einem Timer und einer Interruptroutine. Die ISR wartet natürlich nicht die gesamte Dauer eines Impulses ab, vielmehr prüft sie in kurzen Abständen ob der Impuls noch ansteht. Die Impulsdauer errechnet sich dann aus der Anzahl der Interupts mit gesetztem Eingang in Folge. Das Hauptprogramm wertet immer (wenn es mal dazu Zeit oder Lust hat) den letzten gemessenen Wert aus und reagiert entsprechend. Da kommen ca. 50 Werte in der Sekunde pro Kanal! Die brauchst du aber nicht alle auswerten. Erfassen kannst du sie ohne Probleme, interessant ist aber eben immer nur der letzte.

uh klingt kompliziert also pulsmesung ist ja im Artikel bereich ist es ja so beschrieben:
Do
Pulsein Rckanal , Pind , 2 , 1 'Messung Zeit zwischen 1 und 0 Pegel
Print "RC Signal: " ; Rckanal ; "0 uS"
unter Bascom

Hast du eventuell ein beispiel evtl Sourcecode wo diese von dir Beschriebene Methode angewendet wird, würde es dann vielleicht verstehen... mfg


edit : hat jemand die Abmessungen der rn control Platine wäre auch hilfreich

Zitat:

---

Es müssten 3 Kanäle eines PPM RC Empängers ausgewertet werden.

Ist das möglich die 3 Impulse gleichzeitig auszuwerten da es in etwa echtzeit sein sollte was natürlich nie ganz geht....?

---

Soweit ich weiss, kommen die Signale der verschiedenen Kanäle bei einem RC Empfänger nicht gleichzeitig, sondern nacheinander an.

jah stimmt ... für 8 kanäle hintereinander sind es 22.5 ms jeder Impuls eines Kanals hat eine bestimmte Länge je nach Knüppelposition anschliessend kommt eine 0.3ms lange Stoppinformation und dann kommt der nächste Kanal.

Ich find eden Aspekt von radbruch gut, dass die Prüfung der Impulse im Hintergrund liefe.. Verstehe leider nicht genau wie es gemeint ist

mfg

Zitat:

---

Ich find eden Aspekt von radbruch gut, dass die Prüfung der Impulse im Hintergrund liefe.. Verstehe leider nicht genau wie es gemeint ist

---

Um das zu verstehen müsstest du dich mal über die Funktion von Timern und Interrupts bei Mikrocontrollern schlau machen.

Ein Timer zählt im Prinzip die Takte die der Controller ausführt. Mit 8 bit kann man die dezimalen Zahlen von 0 bis 255 abbilden, daher kann ein 8 bit Timer nur bis 255 hochzählen und fängt dann wieder bei 0 an. Wenn der Timer von 255 auf 0 zurückspringt, wird ein sogenannter Interrupt ausgelöst.
In seinem Programm kann man dann eine Routine definieren die immer von diesem Interrupt aufgerufen wird.

Egal, was du den Controller sonst noch alles in deinem Programm machen lässt, der Timer zählt immer weiter und die Interrupt-Routine wird automatisch in festen Intervallen aufgerufen.

Daher spricht man hier auch davon, dass das was du in deiner Interrupt-Routine definiert hast "im Hintergrund" abläuft.

Ja, es ist schwierig mit Worten zu erklären. Der Timer wird so initialisiert, dass die ISR (interruptserviceroutine) ca. alle 0,01ms (100kHz, bei 8MHz prescaller=/8 und ocr=9)) aufgerufen wird (häufiger oder seltener beeinflußt den Wertebereich/die Auflösung der Positionen). In der ISR macht man dann mit den (Start-)Variablen rc_count=0 und rc_pos=0 und rc_(Eingangs)pin folgendes:

isr(TIMER0_COMP_vect)
{
if (rc_pin) rc_count++; else if (rc_count) { rc_pos=rc_count; rc_count=0; }
}

Ab dem ersten Impuls (man könnte nach der Initialisierung kurz warten bis der erste gültige Wert ansteht: while(!rc_pos); ) kann dann das Hauptprogramm mit rc_pos arbeiten. Das basiert übrigens auf dem Servo-Beispielcode im RN-Wissen...

mic

ok dann werde ich mal etwas mit timern und iterrupts üben...
mfg

Wenn ich richtig gerechnet habe gitb es wenn es alle 22.5 us unterbrechen soll
eine Frequenz von 44444.4444 also 8 bit Timer....

Hallo

Ich weiß nicht, wie du auf die 22,5 kommst (es sind wohl ms), aber löse dich davon. Um die Position des Steuerknüppels erkennen zu können ist es nahezu unerheblich in welchem Abstand die Impulse kommen, die Dauer der Impulse ist das Entscheidende. Auch für den Intervall des Timers ist die Impulsdauer uninteressant, er muss nur in regelmäßigen Abständen (das "regelmäßig" wiederrum ist wichtig) den Pin abfragen an dem das RC-Signal anliegt. Je schneller das geschied, umso größer sind die Werte der gemessenen Impulslängen und umso genauer die Position (und umso weniger Zeit bleibt für's Hauptprogramm. Bei 8MHz und 100kHz Timerfrequenz werden Impulslängen von ca. 50-200 gemessen, das passt wunderbar. Es bleiben dann 80 Taktzyklen zwischen den Interrupts minus den Zyklen während des Interrupts für's Hauptprogramm) .

Die ISR funktioniert so (in Worten, wenn man den Code oben nicht versteht):

Solange das Signal am Pin low ist(=kein Impuls), passiert nichts. Sobald es nach High wechselt, wird jedesmal wenn die ISR den Pin abfragt ein Zähler erhöht (rc_count im Beispiel oben) und das solange wie der Pegel auf high bleibt. Wenn nun der Pegel am Pin wieder low wird (=Impuls zu Ende) erkennt dies der nächste Aufruf der ISR. Nun hat der Zähler einen Wert (if (rc_count)...) der der Impulsdauer entspricht (abhängig vom Intervall des Timers). Dieser Wert wird gespeichert (rc_pos) und der Zähler gelöscht. Ab jetzt "warten" wir wieder bis die ISR den Start des nächsten Impuls erkennt.

Da in rc_pos immer die zuletzt gemessene Impulslänge gespeichert ist, kann man diesen Wert dann im Hauptprogramm auswerten. Bei meiner Fernbedienung sind die Mitte-Werte ca. 130 (Gesamtbereich 90-170). Ob das an meinem Code oder an der Fernbedienung liegt kann ich noch nicht sagen, ist aber unerheblich, wenn man die Werte kennt.

Vielleicht noch ein Versuch die Funktion der ISR zu veranschaulichen:

Ein Lattenzaun hat einige Lücken, wieviele Bretter fehlen jeweils in den Lücken(=Impulsdauer)?. Mit geschlossenen Augen laufen wir im Tangoschritt(=Hauptprogramm) am Zaun entlang und klopfen (=wir sind die ISR) gleichmaßig schnell (=Timerintervall) gegen den Zaun (=fragen den Pin ab). Sobald wir das erste Mal in eine Lücke hauen(=Impulsstart), beginnen wir zu zählen(=rc_count) wie oft wir ins Leere hauen. Wir tanzen, klopfen und zählen weiter, bis wir wieder auf eine Latten treffen(=Impulsende). Viele fehlende Latten(=lange Impulse) ergeben hohe Zählwerte, wenige fehlende Latte ergeben niedrige Zählwerte.

Wenn wir schneller klopfen erhöhen sich alle Zählwerte(=höhere Timerfrequenz), klopfen wir langsamer, werden die Werte kleiner(=kleinere Timerfrequenz). Wenn wir zu langsam klopfen, könnten wir eine Lücke überspringen, wenn wir zu schnell klopfen, werden wir stolpern, weil wir keine Zeit mehr haben, mit den Beinen Tango zu tanzen.

mic

Ich hätt´ noch einen ganz anderen Ansatz zum Nachdenken anzubieten, der bei mir in einer Modellbau-Anwendung tadellos funktioniert:

Du generiertst mit dem Timer-Interrupt nicht ein Zeit-Raster, in dem der Eingangspin abgefragt wird, sondern Du lässt bei jeder steigenden Flanke auf dem Eingangspin einen Timer starten, und bei der fallenden Flanke wieder stoppen. Nach jedem Stoppen weist Du den gemessenen Timer-Stand einer Variablen zu (Impulslänge), die Du als Array anlegst und durchzählen lässt.
Die Timer-Dimensionierung sollte so ergfolgen, dass der Timer bei Positiv-Impulsdauern über 5ms überläuft. Dadurch kannst Du am Timer-Interrupt den (30ms-) Synchronisationsimpuls erkennen, denn "normale" Steuerimpulse sind eigentlich nie länger als 2,5ms.
Mit 3,6864 MHz und Prescale=1 läuft der 16-Bit-Timer z.B. nach ca. 18ms über - ein idealer Wert!

Code:

---


$Crystal=3686400

Dim Impuls(3) as Word
Dim N as Byte
N=1

Config timer1=Timer, prescale = 1
on timer1 Synchronisationsimpuls  'ISR bei Timer-Overflow
Enable timer1

Config IntX = Change
On IntX Flanke  'ISR bei Flankenwechsel
Enable IntX
Enable Interrupts


Do
...
Loop  'Hier läuft Dein Hauptprogramm


Flanke:
If PinX.Y = 1 then '(PinX.Y = der Interrupt-Pin!)
  start timer1
Else
  Stop timer1
  Impulsdauer(N) = Timer1
  N=N+1
  Timer1=0
End if
Return

Synchronisationsimpuls:
N=1
return

---

...nur so als Beispiel :-b
Dein gesamtes Programm kann unbeeinträchtigt weiterlaufen. Die Flanken starten und stoppen den Zähl-Timer, und wenn er überläuft war der Impuls länger als 18ms, so dass die Zählvariable N einfach nur auf 1 zurückgesetzt werden muss.

Hallo

Zitat:

---

Ich hätt´ noch einen ganz anderen Ansatz zum Nachdenken anzubieten

---

Das würde ich ablehnen, weil für jeden RC-Eingangskanal ein Timer belegt werden muss. Oder sehe ich das falsch?

Was mir sehr gut gefällt ist die schlanke Formulierung des Codes. Ich kenne bascom nicht, dachte aber, der Zugriff auf Interrupts und Timer wäre komplizierter.

mic

Zitat:

---

weil für jeden RC-Eingangskanal ein Timer belegt werden muss. Oder sehe ich das falsch?

---

Ich glaube, schon =P~
Zumindestens komt dieser Code mit genau einem Timer aus, wenn man die einzelnen Impulse nacheinander als ein einzige serielles Signal verbindet, was ja z.B. durch oder-Verknüpfen mit Dioden ein leichtes ist.

Über einen Eingangspin gehen alle Impulse nacheinander seriell rein, und bei jeder Low-Phase dazwischen wird der Zähler "N" eins weitergestellt.

@ Sauerbruch in deiner Lösung kämen alle Signal Kabel auf einem PIN sehe ich das richtig ? Wäre sicher praktisch da dann nnoch viele frei bleiben mfg

Zitat:

---

Zumindestens komt dieser Code mit genau einem Timer aus, wenn man die einzelnen Impulse nacheinander als ein einzige serielles Signal verbindet, was ja z.B. durch oder-Verknüpfen mit Dioden ein leichtes ist.

---

Ich glaube, wenn man das Signal an der richtigen Stelle am Empfänger abgreift, kann man sich das sparen, da es eigentlich schon ein serielles Signal ist.
Dieses serielle Signal wird dann im Empfänger für die verschiedenen Servo-Kanäle aufgesplittet und auf die Stecker nach aussen verteilt.

D.h. man muss eigentlich nur den richtigen Kontakt finden um das gesamte Signal abzugreifen und dabei kann eine Suche hier im Forum oder auch über Google sicherlich behilflich sein.

ja von dem habe ich glaub ich auch schon gehört nennt sich summensignal ? oder so ..
Aber wie soll man umsetzen das der richtige Impulse in die richtige Variable kommt ist dann die Frage bei dieser Lösung..

Bin im Moment an der Auswertung vom Impuls vom Servo und der Ansteuerung des Servos ...

Servo Puls sei zwischen 1 und 2 ms 1.5 ist mittelstellung

bei dder Servo ansteuerung sei 50 linker Anschlag 100 Mitte und 150 rechter Anschlag

dann könnte man theorethisch mit dieser Gleichung den Wert zur Servoausgabe berechnen:
((Puls -1 ) *100) + 50
Alle Werte liegen für Puls
zwischen 0 und 1 da -1 gerechnet wird

oder überlege ich da zu weit und es gäbe eine einfachere Lösung
mfg

Das geschieht automatisch durch die "Synchonitätsimpuls". Praktisch genauso wie es der Empfänger auch macht.

öhm unter synchronisationsimpuls steht nur n =1 bewirkt das etwas?

öhm andere frage tendiere ja im Moment auf ein rn control board da dies hier sehr verbreitet sei und ich auch eher Support finden werde:
Jetzt kommt die Qual der Wahl
bin eher beschränkt mit der grösse der platine
RN-Control 1.4 Mega32 taster und leds wären praktisch daran..

oder rn mini control

wer würde welches der beiden empfehlen oder allefalls ein anderes ?
mfg

Zitat:

---

Zitat von PASCALU

öhm unter synchronisationsimpuls steht nur n =1 bewirkt das etwas?

---

Davor ist eine Sprungmarke. Wird ein Syncroimpuls entdeckt, wird dadurch der Zähler N auf eins zurück gesetzt. Ansonsten wird er mit N=N+1 jeweils um eins hochgezählt, wenn eine abfallende Flanke entdeckt wird.

ah ja genau verstehe ich es jetz glaube zumindest also lse
Stop timer1
Impulsdauer(N) = Timer1
N=N+1
Timer1=0
End if
Return
n= n+1 bewirkt dass es zum Beispiel von Impulsdauer1 auf Impulsdauer2 wechselt also wie kanal1 und kanal2...

((Puls -1 ) *100) + 50
Alle Werte liegen für Puls
zwischen 0 und 1 da -1 gerechnet wird

würde das stimmen zur Servo ansteuerung ?
mfg

@ PASCALU:

Wie Du mit ein paar Dioden und einem Widerstand aus den einzelnen Signalen ein Summensignal machen kannst, hab´ ich mal aufgezichnet. Ein Bild sagt mehr als tausend Worte. Bestimmt kann man das Summensignal auch irgendwo im Empfänger abgreifen (@ recycle), aber vielleicht ist es nicht jedermanns Sache, in (SMD-) Emfängern mit Oszi und Lötkolben auf Spurensuche zu gehen O:)

Das N sorgt dafür, dass Du bei z.B. drei überwachten Kanälen auch 3 auseinanderhaltbare Impulsdauern bekommst: Impulsdauer(1), -(2) und -(3). Nach jeder Messung wird N um eins erhöht, und wenn der Synchronimpuls kommt wird N auf 1 zurückgesetzt, weil dann ja alles wieder von vorne anfängt.

Ich hab´ allerdings einen kleinen Denkfehler gemacht, da ich das Summensignal im Sender auswerte. Der Unterschied ist der, dass senderseitig nach dem letzten Impuls das Signal auf high geht. Den Synchronisationsimpuls erkennt man hier also an einem High > 2,5ms. Empfängerseitig ist das natürlich nicht so. D.h. man müsste beim Übergang auf Low nicht nur den ersten Timer anhalten, sondern tatsächlich einen 2. Timer starten, der beim Überlauf dann den Synchronisationsimpuls erkennt. Sorry für eventuell entstandene Verwirrung... :-b

Danke aber ich habe das Glück das mein Empfänger einen Anschluss für ein Summensignal hat , danke trotzdem !

Hm und wie stimmt man dann ab dass kanal 3 auch kanal 3 ist weil ja einfach der erste impuls in die impulslänge 1 kommt gibt der Empfänger eventuell ein Start Signal oder ähnlich aus ?

mfg

Die Signalfolge besteht aus 8 Kanalimpulsen -> Synchosignal -> 8 Kanalinpulse usw..

Das heißt zwischen den Kanalimpulsen kommt immer ein Synchrosignal. Ob ich das jetzt als Stop oder Startsignal betrachte ist eigentlich egal. Aber programmtechnisch ist es eleganter es als Stopsignal zu verwenden und die erste Impulsfolge als ungültig zu verwerfen.
Das Problem behebt sich mit der 2. Signalfolge.

Eventuell ist aber eine Programmanpassung notwendig, wenn der Sender nicht in der Lage ist 8 Kanäle zu übertragen.

Ok habe mich beschlossen das ganze modular aufzubauen !

Programiere gerade in Visual Studio von MS eine Programm zur graphischen Auswertung von Signalen am COM Port, werde anschliessend Auf der Platine die Empfänger anschliessen und über COM Port "drucken" lassen. Dann Werde ich das Programm erweitern um Servos anzusteuern. Und am Schluss werde ich den fahrenden Roboter konstruieren. Werde allerdings noch anstatt ein 2. Servo ein RC Regler ansteuern müssen ...
mfg

Hall zusammen habe mich in den letzten Tagen noch einmal mit dem Thema auseinandergesetzt :
Dabei ist jetzt folgende Frage aufgetreten :
es braucht ja für den syncimpuls einen zusätzlichen timer dei startet wenn und wenn der impuls länger als 2.5 auf high bleibt überläuft.
Welche werte müsste dann der Timer haben , mein e nbisherigen berechnungen scheiterten
und wäre es auch möglich einen 16mhz quarz zu verwenden ? wie müsste dann der andere timer sein ?
viele fragen hoffe mir kann jemand helfen

Das kann man ganz einfach überschlagen:

16 MHz und ein Prescaler Prescaler von 256 ergeben eine Timer-Taktfrequenz von 62,5 kHz. Damit zählt der Timer alle 16µs um einen Schritt hoch. Nach einer Laufdauer von 2,5ms wäre er damit bei 156, und ein 8-bit-Timer würde nach ca. 4,1 ms überlaufen. Damit würde einer der beiden "kleinen" Timer reichen, und Du bräuchtest den Timer nach einem Überlauf noch nichtmal auf einen bestimmten Vorwert einzustellen sondern hättest sogar noch etws "Luft", falls einzelne Servo-Impulse vielleicht doch mal länger sind als 2,5ms.

Du musst aber natürlich wissen, ob der Ruhe-Pegel nach dem letzten Servo-Impuls High oder Low ist.

so was ich rausgefunden habe ist der pegel high .. habe es jetz mal soweit so gelöst timer1 für syncimpuls timer 0 für servoimpuls timer1 mit timervorgabe timer 0 mit prescaler da mir das gerade einfacher erschien. Wenn das Signal auf high geht wird auch timer 0 gestartet überläuft er war der iMpuls länger als 2.5 ms.

Code:

---

Dim Impulsdauer(3) As Word
Dim N As Byte
N = 1
Const Timervorgabe = 216

Config Timer1 = Timer , Prescale = 1
Config Timer0 = Timer , Prescale = 256
On Timer1 Timer_irq                          'sync impuls bei overflow
Enable Timer1
Enable Timer0

Config Int1 = Change
On Int1 Flanke                                              'ISR bei Flankenwechsel
Enable Int1
Enable Interrupts


Do

Loop                                                        'Hier läuft Dein Hauptprogramm


Flanke:
If Pinb.0 = 1 Then
Start Timer1
Start Timer0



Else
  Stop Timer1
  Stop Timer0

  Impulsdauer(n) = Timer0
  N = N + 1
 
End If

Return



Timer_irq:

Timer1 = 65496
N = 1                                                ' Wenn Timer überläuft handelt es sich um synchronisationsimpuls



Stop Timer0
Return

---

stimmt das in etwa ?
mfg

Zitat:

---

stimmt das in etwa ?

---

Fast... =P~

Bis auf 2 Stellen:

1.: Nach der Sequenz

Code:

---

Impulsdauer(n) = Timer0
  N = N + 1

---

musst Du unbedingt beide Timer auf Null setzen - sonst zählen sie einfach von ihrem Zwischenstand weiter, und Du bekommst nicht nur falsche Impulslängen-Ergebnisse, sondern auch vermeintliche Synchronisationsimpulse, wo eigentlich gar keine waren.

2.: Wenn Du Timer 1 mit 65496 vorlädst, läuft er schon nach 40 Takten über. Bei 16 MHz und einem Prescaler von 1 wäre das nach 2,5 Mikrosekunden. Da er aber erst nach 2,5 Millisekunden überlaufen soll, muss er bis 40.000 zählen, also von einem Ausgangswert von etwa 25000 starten.

Ganz allgemein könntest Du (bei positivem Synchronisationssignal) mit einem Timer auskommen: Wenn er vor dem Überlauf angehalten wird (d.h. Impuls kleiner als 2,5ms) wertest Du den Zählerstand als Impulslänge aus, und wenn er überläuft (Impuls länger als 2,5ms) wird das als Synchronisationsimpuls gewertet (und N=1 gesetzt). Aber das ist halt eine Frage des Umgangs mit Ressourcen O:)

Und es ist etwas uneffektiv, den wesentlich höher auflösenden 16-Bit-Timer 1 für so etwas "grobes" zu verwenden wie die Entscheidung, ob der Impuls länger als 2,5ms ist, während die Impulslänge selbst von dem wesentlich ungenauer auflösenden 8-Bit-Timer gemessen wird. Aber auch das ist eine Frage der "B-Note" - funktionieren sollte Dein Code mit den genannten Änderungen trotzdem!

Habe es jetzt noch mal mit 2 timern gemacht um zu schauen ob ich die richtigen werte bekomme lasse ich mal die werte printen
$regfile = "m32def.dat"
$crystal = 3686400
Dim Impulsdauer(3) As Word
Dim N As Byte
N = 1
Const Timervorgabe = 216

Config Timer1 = Timer , Prescale = 1
Config Timer0 = Timer , Prescale = 256

On Timer0 Timer_irq
'sync bei Timer-Overflow
Enable Timer1
Enable Timer0
Stop Timer0



Config Int1 = Change
On Int1 Flanke 'ISR bei Flankenwechsel
Enable Int1
Enable Interrupts


Do

Loop 'Hier läuft Dein Hauptprogramm


Flanke:
If Pinb.0 = 1 Then
Start Timer1
Start Timer0



Else
Stop Timer1
Stop Timer0

Impulsdauer(n) = Timer1
Print Impulsdauer(n)
N = N + 1
End If
Print "flanke"
Timer0 = 100
Timer1 = 25536

Return

Synchronisationsimpuls: 'Wechselt Kanal zutück auf 1
Print "sync"
Return

Timer_irq:
Stop Timer0
Timer0 = 100
N = 1 ' Wenn Timer überläuft handelt es sich um synchronisationsimpuls


Print "timer irq"
Stop Timer1
Stop Timer0
Return
Die Werte für Timer1 bleiben erst ein paar mal unverändert dann plötzlich ist timer1 = 0 und beim nächsten mal stimmt es wieder ..
ideen?
mfg
EDIT : DUMMER FEHLER !! liegtt daran dass es verscheidene impulsdauern gibt (1,2,3)

So muss den Thread mal wieder etwas ausgraben..
Habe in den letzten Wochen etwas rumexperimentiert.

Habe mal nur mit einem Kanal experimientiert und mit diesem Code
'Pin D3 wird mit Empfänger verkabelt



$regfile = "m32def.dat" ' bei Mega 16 $regfile = "m16def.dat"
$framesize = 32
$swstack = 32
$hwstack = 32

$crystal = 16000000 'Quarzfrequenz
$baud = 9600
Dim Impulsdauer As Single
Dim Puls As Word


Config Int1 = Change
On Int1 Flanke 'ISR bei Flankenwechsel
Enable Int1
Enable Interrupts



Do

Print Puls
Loop 'Hier läuft Dein Hauptprogramm


Flanke:
Pulsein Puls , Pind , 3 , 1
Return

Leider kommt das Programm gar nie zum Hauptteil also zur ausgabe der Pulslänge sondern ist immer bei der Flanke am messen ?!

Gibt es irgendwelche Lösungen oder Ahnungen woran das das liegen könnte ?
mfg