www.mikrocontroller.net

Forum: Compiler & IDEs RC5-Auswertung Problem


Autor: Alan (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Um rc5-Code auszuwerten verwende ich folgenden Code:
#include "base.h"
#include "uart.h"
#include <avr/interrupt.h>
volatile int oldstate = 0;
volatile int state;
volatile int samples = 0;
volatile int rc5data[29];
volatile int pos = 0;
volatile int complete =0;
volatile int bitcount = 0;

ISR(TIMER0_OVF_vect) 
{
  if(pos != 28) {
    state = !(PINB & (1<<PINB0));
    if(state == oldstate) {
      bitcount++;
    }
    if(state != oldstate) {
      if(12 <= bitcount <=  14)  {
        rc5data[pos] = state;
        pos++;
      }
      if(26 <= bitcount <=  28)  {
        rc5data[pos] = state;
        pos++;
        rc5data[pos] = state;
        pos++;
      }
      bitcount = 0;
      oldstate = state;
    }
  }
  else {
    complete = 1;
  }
    PORTD ^= (1<<PD7);
    
  
}


int main(void) {
  uart_init();
  DDRD |= (1<<PD7);
  TCCR0 |= (1<<CS00);
  sei();
  TIMSK |= (1<<TOIE0);
  uart_putc('a');
  while(complete == 0) {
    asm volatile ("nop");
  }
  TIMSK &= ~(1<<TOIE0);
  uart_putc('b');
  int i = 0;
  while(i != 28) {
    uart_puts(intToString(rc5data[i], 1));
    i++;
  }
  
  
}

Der Ansatz: Der Interrupt wird alle 64us aktiviert und misst die Zeit in 
der das Signal konstant ist.
Das Problem: Wenn ich eine Taste auf der Fernbedienung 1x drücke, 
passiert nix. Erst nach fünfmaligem Drücken erhalte ich Datenmüll. Wo 
liegt der Fehler?
Alles @ Atmega32 @ 4MHz

Autor: Johann L. (gjlayde) Benutzerseite
Datum:

Bewertung
0 lesenswert
nicht lesenswert
1) if(26 <= bitcount <=  28) tut nicht was du denkst
2) 16-Bit-Variablen die zwischen main und ISR geteilt werden müssen 
atomar zugegriffen werden

Autor: Alan (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
1) Was tut der Ausdruck denn dann?
2) wie mache ich das?

Autor: Stefan Ernst (sternst)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Alan wrote:

> 1) Was tut der Ausdruck denn dann?

Das Ergebnis des <=-Operators ist 0 oder 1, und der Linke wird zuerst 
ausgewertet. Dann steht dort also (je nach dem Wert von bitcount)
"(0 <= 28)" oder "(1 <= 28)".
"(26 <= bitcount <=  28)" ist also immer wahr.

> 2) wie mache ich das?

((26 <= bitcount) && (bitcount <= 28))

Autor: Stefan Ernst (sternst)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Ach so, das "wie mache ich das?" bezog sich wohl auf die 
16-Bit-Variablen, sorry. ;-)

Indem du außerhalb der Interrupt-Routine vor dem Zugriff auf die 
Variable die Interrupts sperrst, und danach wieder freigibst. Wenn ich 
das richtig sehe, kannst du aber auch aus allen deinen int einfach 
8-Bit-Variablen machen, dann hast du das Problem nicht.

Autor: Johann L. (gjlayde) Benutzerseite
Datum:

Bewertung
0 lesenswert
nicht lesenswert
3) nach der 2. while-Schleife verlässt Du main(). Danach arbeiten nur 
noch die Interrupts. Nach main() fällt das Prog in eine Endlosschleife 
(_exit).

Autor: Alan (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Der TimerInterrupt sollte doch schon dadurch
TIMSK &= ~(1<<TOIE0);
 außer Gefecht gesetzt werden. Oder lauern da noch weitere GCC-Fallen?

Autor: Alan (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Nun? Findet wer auch noch logische Fehler, denn nun wird gar nichts mehr 
ausgegeben :(

Autor: Stefan Ernst (sternst)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Dann poste mal den aktuellen Code.

Autor: Alan (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
#include "base.h"
#include "uart.h"
#include <avr/interrupt.h>
volatile int oldstate = 0;
volatile int state;
volatile int samples = 0;
volatile int rc5data[29];
volatile int pos = 0;
volatile int complete =0;
volatile int bitcount = 0;

ISR(TIMER0_OVF_vect) 
{
  if(pos != 28) {
    state = !(PINB & (1<<PINB0));
    if(state == oldstate) {
      bitcount++;
    }
    if(state != oldstate) {
      if((12 <= bitcount) && (bitcount <=  14))  {
        rc5data[pos] = state;
        pos++;
      }
      if((26 <= bitcount) && (bitcount <=  28))  {
        rc5data[pos] = state;
        pos++;
        rc5data[pos] = state;
        pos++;
      }
      bitcount = 0;
      oldstate = state;
    }
  }
  else {
    complete = 1;
  }
    PORTD ^= (1<<PD7);
    
  
}


int main(void) {
  uart_init();
  DDRD |= (1<<PD7);
  TCCR0 |= (1<<CS00);
  sei();
  TIMSK |= (1<<TOIE0);
  uart_putc('a');
  while(complete == 0) {
    asm volatile ("nop");
  }
  TIMSK &= ~(1<<TOIE0);
  uart_putc('b');
  int i = 0;
  while(i != 28) {
    uart_puts(intToString(rc5data[i], 1));
    i++;
  }
  


bittesehr :)

Autor: Karl Heinz (kbuchegg) (Moderator)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Irgendwie sind mir die hier geforderten Timings
      if((12 <= bitcount) && (bitcount <=  14))  {
        rc5data[pos] = state;
        pos++;
      }
      if((26 <= bitcount) && (bitcount <=  28))  {

viel zu strikt.
Du erlaubst gerade mal eine Variation in bitcount von 3 Einheiten.
Bei einem voll laufenden 8-Bit Timer sind das gerade mal ~750
Takte. Nicht gerade viel Spielraum für den Sender um das Timing
einzuhalten.

Warum gehst du nicht einfach her und sagst:
Wenn der bitcount < 20 ist, dann werte ich das als Zustand 1
und alles darüber ist Zustand 2.

In deinem Programm passiert ja soweiso nichts, wenn das Timing
ausserhalb der von dir eingeführten Grenze liegt. Wenigstens
eine Fehlerled würde ich anmachen, damit man auch verfolgen kann,
dass das Timing nicht gestimmt hat.

Autor: Alan (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Jetzt bekomme ich: 1011011011011011011011011011 und das egal, welche 
Taste gedrückt wurde. Manchmal passiert auch gar nichts, wenn die taste 
nur kurz gedrückt wurde, wenn ich sie lang drücke, kommt wieder das 
obige :(

Autor: Alan (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Jetzt hab ich nen 16MHz Quarzoszillator genommen (Int wird alle 16us 
aufgerufen) , den code angepasst und es geht immer noch nich :(
#include "base.h"
#include "uart.h"
#include <avr/interrupt.h>
volatile int oldstate = 0;
volatile int state;
volatile int samples = 0;
volatile int rc5data[29];
volatile int pos = 0;
volatile int complete =0;
volatile int bitcount = 0;

ISR(TIMER0_OVF_vect) 
{
  if(pos != 28) {
    state = !(PINB & (1<<PINB0));
    if(state == oldstate) {
      bitcount++;
    }
    if(state != oldstate) {
      if(bitcount < 83)  {
        rc5data[pos] = state;
        pos++;
      }
      if(bitcount > 83)  {
        rc5data[pos] = state;
        pos++;
        rc5data[pos] = state;
        pos++;
      }
      bitcount = 0;
      oldstate = state;
    }
  }
  else {
    complete = 1;
  }
    PORTD ^= (1<<PD7);
    
  
}


int main(void) {
  uart_init();
  DDRD |= (1<<PD7);
  TCCR0 |= (1<<CS00);
  sei();
  TIMSK |= (1<<TOIE0);
  /*while(complete != 1) {
    asm volatile ("nop");
  }
  uart_puts("complete!");
  asm volatile ("nop");
  int j = 0;
  uart_puts("\n\r");
  while(j < 128) {
    uart_puts(intToString(rc5data[j], 1));
    j++;
  }*/
  uart_putc('a');
  while(complete == 0) {
    asm volatile ("nop");
  }
  TIMSK &= ~(1<<TOIE0);
  uart_putc('b');
  int i = 0;
  while(i != 28) {
    uart_puts(intToString(rc5data[i], 1));
    i++;
  }
  //asm volatile ("nop");
  
  
}


Autor: Alan (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
push
Ich bin am verzweifeln... warum geht das nicht?

Autor: Karl Heinz (kbuchegg) (Moderator)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Ich kann dir nicht mehr viel weiterhelfen, weil ich die
Signalform nicht kenne.

Das wirds zwar nicht sein, da du hast mir ein paar if
zuviel, die eigentlich nicht nötig sind.

   if( a == b )
     ...

   if( a != b )
     ...

Das zweite if ist unnötig

  if( a == b )
    ...

  else
    ...

macht dasselobe und ist simpler.

Genauso hier (da ist auch ein kleiner Fehler drin)

   if( a < 81 )
     ...

   if( a > 81 )
     ...

Das > muesste natürlich >= lauten. Aber abgesehen davon,
wenn a nicht kleiner als 81 ist, dann muss a größer/gleich
81 sein. Was solls denn sonst sein?
Also

   if( a < 81 )
     ...

   else
     ...

Ich denke aber nicht, dass das mit deinem eigentlichen Problem
zu tun hat (bitcount exakt 81 könnte aber tatsächlich ein
Problem sein, wenn auch eher unwahrscheinlich)

Bleibt nur noch: Timing noch mal checken. Timereinstellungen.
Läuft der µC auch wirklich mit der Taktfrequenz die du glaubst
und mit der du die Timereinstellungen ausgerechnet hast.

Sonst fällt mir auch nichts ein.

PS: Stimmt da eigentlich, dass eine 1 immer doppelt ins Array
kommt? Schaut irgendwie seltsam aus.

Edit: Ich würde mir höchstens mal die gemessenen bitcount Werte
ausgeben lassen. Vielleicht sieht man da was.

Autor: Karl Heinz (kbuchegg) (Moderator)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Moment.

Die Information steckt doch in der Pulslänge. Oder irre ich mich
da?
Warum speicherst du dann state?
Das ist doch Nonsense. state sagt dir doch nur wie das Signal
zur Zeit aussieht. Klar das das immer abwechselnd 0 oder 1 sein
muss. Was solls denn sonst sein?

Bei der steigenden Flanke setzt du bitcount auf 0, denn da
beginnt der Puls und bei der fallenden Flanke wertest du den
bitcount aus
    if( state != oldstate ) {    // eine Flanke

                                 // welche wars?
      if( state )                // es war eine steigende
        bitcount = 0;

      else {                     // es war eine fallende Flanke
        if( bitcount < 83 )      // war es ein kurzer 0 Puls ?
          rc5data[pos] = 0;
        else                     // oder war es ein langer 1 Puls ?
          rc5data[pos] = 1;
        pos++;
      }
    }

    else
      bitcount++;

Kann natürlich sein, dass ich völlig falsch liege. Denn wie gesagt:
Ich kenne die Signalcodierung nicht.

Autor: Stefan Ernst (sternst)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Was mir noch auffällt, ist folgendes:
  if(pos != 28) {
...
      if(bitcount > 83)  {
        rc5data[pos] = state;
        pos++;
        rc5data[pos] = state;
        pos++;
      }
...
  }
  else {
    complete = 1;
  }

pos = 28 soll wohl die Abbruchbedingung sein. Da pos aber in einem Int 
auch um 2 erhöht werden kann, kann diese Grenze "übersprungen" werden. 
Ich vermute allerdings (genau wie Karl Heinz), dass dieses doppelte 
Abspeichern falsch ist. Es führt ja z.B. auch dazu, dass eine 
unterschiedliche Anzahl an Bits gesampelt wird, je nach dem wie das 
Verhältnis von Nullen zu Einsen ist. Und ich kann mir nicht so recht 
vorstellen, dass das so gewollt ist.

Autor: Alan (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Also erstmal danke für die Mühe...
Den Vorschlag von kbuchegg kann ich nur nicht ganz nachvollziehen.
Hier mal der relevante Code mit Kommentaren
  state = !(PINB & (1<<PINB0));
    if(state == oldstate) { //keine Flanke
      bitcount++;     //bitcount hochzählen
    }
    if(state != oldstate) { //Flanke
      if(bitcount <= 83)  { //kurzer "Puls" vorher
        rc5data[pos] = state;  //an der Position den aktuellen Status abspeichern
        pos++; //Position inkrementieren
      }
      else  { //langer Puls
        rc5data[pos] = state; //siehe Oben
        pos++; //s.o.
        rc5data[pos] = state; //s.o.
        pos++; //s.o.
      }
      bitcount = 0; //Bitcount zurücksetzen
      oldstate = state; //alter Status = neuer Status
    }
  }

Entweder habe ich die manchester-Kodierung falsch verstanden oder es hat 
sich ein anderer Fehler eingeschlichen.

Autor: Stefan Ernst (sternst)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Alan wrote:

> Entweder habe ich die manchester-Kodierung falsch verstanden ...

Kommt darauf an, was du eigentlich machen willst. In mir keimt nämlich 
jetzt der Verdacht, dass du das gar nicht dekodieren, sondern eher 
"aufzeichnen" willst. In dem Fall ist aber dein Ansatz, pos als 
Abbruchbedingung heranzuziehen, untauglich.

Autor: Karl Heinz (kbuchegg) (Moderator)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Alan wrote:
> Also erstmal danke für die Mühe...
> Den Vorschlag von kbuchegg kann ich nur nicht ganz nachvollziehen.

Ich wusste bis vor 30 Sekunden nicht, dass du einen Manchester
Code auswerten willst. Ich ging von einem Pulscode aus, der 1/0
über die Pulslänge ermittelt.

Mein Fehler: Ich hätte mich über den RC5 informieren sollen,
bevor ich hier loslege.

Autor: Karl Heinz (kbuchegg) (Moderator)
Datum:

Bewertung
0 lesenswert
nicht lesenswert

Autor: Alan (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Fällt mir auch erst jetzt auf, dass das "Auswerten" im Threadtitel ein 
bisschen deplatiert ist ...

Das Auswerten macht dann eine andere Funktion, mir geht es erstmal ums 
Aufzeinchen

Ne fertige Lib nehmen kann ja jeder, mir geht's u.a. um den Lerneffekt 
(weshalb ich BASCOM verabscheue)...

Autor: Stefan Ernst (sternst)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Nach etwas Überlegung muss ich meine obige Aussage revidieren. Dein 
Ansatz sollte prinzipiell funktionieren. Du hast allerdings einen Fall 
nicht abgedeckt. Wenn im letzten Bit der Flankenwechsel zum Ruhepegel 
hin geht, dann hast du nach dem Bit keinen Flankenwechsel mehr. Das 28. 
"Halbbit" ist dann also nicht durch eine Flanke "abgeschlossen".

Autor: Alan (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Vielleicht so lösen: Wenn bitcount größer 240, dann ende?

Autor: Stefan Ernst (sternst)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Ist auch problematisch, oder ist die Pause zwischen zwei Bitfolgen auf 
jeden Fall mindestens so groß?

Ich würde die Tatsache ausnutzen, dass zwischen pos 26 und 27 immer ein 
Flankenwechsel sein muss.
Also etwa so:
ISR(TIMER0_OVF_vect) 
{
  if (pos >= 28)
    return;

  state = !(PINB & (1<<PINB0));
  if(state == oldstate)
    bitcount++;
  else {
    ...
    (hier Pulslaenge bestimmen und speichern)
    ...
    if (pos >= 27) {
      rc5data[pos] = !state;
      complete = 1;
    }
  }

  PORTD ^= (1<<PD7);
}

Autor: Alan (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
3840 uS dürften wohl genug Pause sein...

Autor: neuer (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
so sieht es in bascom aus ohne eine lib.
eine routine handgeschnitzt von einem user :

'Der Timer wird nicht ausschliesslich für den RC5 benutzt, läuft also immer mit 8kHz durch.
'Es wird in Impuls_laenge nur die Anzahl der overflows festgehalten.
'Außerdem kann man festlegen, ob mehrfach Empfang ohne loslassen erlaubt ist (wiederholen_erlaubt=1)
'oder nicht (wiederholen_erlaubt=0).
'Eingehende Impulse werden nach Länge überprüft und dann in die Variable Temp_daten geschoben,
'also 14-bit bei einem korrekten Befehl.
'Wenn man sich die möglichen Zeiten zwischen zwei steigenden Flanken ansieht,
'stellt man fest, dass es drei verschiedenen geben kann:
'kurze Impulselänge (1,778ms ~ 14 Überläufe) ->
'gleicher Wert empfangen wie beim letzten Impuls, also vorher 0 jetzt 0 oder vorher 1 und jetzt 1
'lange Impulselänge (2,677ms ~ 21 Überläufe) ->
'vorher war es eine 0, jetzt kommt eine 1 und eine 0 (also 2 bit zusammen)
'mittl Impulselänge (3,556ms ~ 28 Überläufe) ->
'entweder war es vorher eine 0, dann jetzt eine 1 oder vorher eine 1 dann jetzt eine 1 und eine 0
'Wenn dann 14 bit zusammen sind, extrahiere ich daraus die Adresse und den Befehl und überprüfe, ob die Sinn machen.
'Dann wird der Befehl ausgegeben, falls er ungleich dem letzten Befehl ist bzw. wiederholen erlaubt ist.

$regfile = "m32def.dat"
$framesize = 32
$swstack = 32
$hwstack = 64
$crystal = 8000000
$baud = 19200

Dim Impuls_laenge As Word , Bit_nummer As Byte , Temp_daten As Word
Dim Befehl As Byte , Adresse As Byte , Empfangs_fehler As Byte , Wiederholen_erlaubt As Byte
Dim Letzte_adresse As Byte , Letzter_befehl As Byte , Startwert As Byte
Dim Interrupt_vektor As Byte

Config Lcdpin = Pin , Db4 = Portc.2 , Db5 = Portc.3 , Db6 = Portc.4 , Db7 = Portc.5 , E = Portc.6 , Rs = Portc.7
Config Lcd = 20 * 2
Config Timer0 = Timer , Prescale = 8

On Ovf0 Tim0_isr
Enable Timer0
Startwert = 125                         '8000000/8/(256-125)=8000 Überläufe pro Sekunde,
Timer0 = Startwert                      'also alle 0,125ms, Impulslänge bei RC5 1,778ms, also ca. 14

Config Int0 = Rising                    'externer interrupt, dauernd high, falls Signal dann low
                                         'falls dauernd low, dann auf falling ändern und PORTD.2=0 setzen
On Int0 Get_rc5_isr
Enable Int0

Ddrd.2 = 0                              'ausgang des RC5-empfängers
Portd.2 = 1                             'Pullup ein, auf Pulldown ändern, wenn dauernd low kommt

Wiederholen_erlaubt = 1                 'auf 1 setzen, wenn wiederholen erlaubt sein soll, sonst 0

Enable Interrupts

Do
   If Interrupt_vektor.7 = 1 Then
      Select Case Impuls_laenge
         Case Is > 1500:                '-> startimpuls, nach empgfangsfehler muss immer erst ein solcher kommen.
            Bit_nummer = 1
            Temp_daten = 1
            Empfangs_fehler = 0
         Case 26 To 29:                 '-> große Länge: vorher 0, jetzt 1 + 0
            If Empfangs_fehler = 0 Then
               Shift Temp_daten , Left  'hinzufügen einer 0
               Incr Temp_daten          'umwandeln in 1
               Shift Temp_daten , Left  'hinzufügen einer 0
               Incr Bit_nummer          'bei Kombination '10' fehlt ein Impuls
            End If
         Case 19 To 22:                 '-> mittlere Länge: vorher 1, jetzt 1 + 0 oder vorher 0 jetzt 1
            If Empfangs_fehler = 0 Then
               Shift Temp_daten , Left  'hinzufügen einer 0
               Incr Temp_daten          'umwandeln in 1
               If Temp_daten.1 = 1 Then 'vorher gab es eine 1
                  Shift Temp_daten , Left       'hinzufügen einer 0
                  Incr Bit_nummer       'bei Kombination '10' fehlt ein Impuls
               End If
            End If
         Case 12 To 15:                 '-> kleine Länge     --> gleicher Wert wie vorher
            If Empfangs_fehler = 0 Then
               Shift Temp_daten , Left , 1       'hinzufügen einer 0
               If Temp_daten.1 = 1 Then 'vorher gab es eine 1
                  Incr Temp_daten       'umwandeln in 1
               End If
            End If
         Case Is > 400:                 'aber kleiner 1500, dann war's eine Pause zwischen Befehlen beim Dauerdrücken
            If Empfangs_fehler = 1 Or Wiederholen_erlaubt = 1 Then
               Bit_nummer = 1
               Temp_daten = 1
               Empfangs_fehler = 0
            End If
         Case Else
            Empfangs_fehler = 1
      End Select
      If Bit_nummer = 14 Then
         Befehl = Temp_daten And &B00111111
         Shift Temp_daten , Right , 6
         Adresse = Temp_daten
         If Befehl < 64 Then
            If Wiederholen_erlaubt = 1 Or Befehl <> Letzter_befehl Or Adresse <> Letzte_adresse Then
               Letzter_befehl = Befehl
               Letzte_adresse = Adresse
               Cls
               Lcd "Befehl=" ; Befehl
            End If
         End If
      End If
      Impuls_laenge = 0
      Interrupt_vektor.7 = 0
   End If
Loop

End

Tim0_isr:
   Timer0 = Startwert
   Incr Impuls_laenge
   If Impuls_laenge > 65000 Then        berlauf von Impuls_laenge verhindern (nach 65535 kommt 0),
                                        'damit Start (Impuls_laenge > 500) sicher erkannt wird
      Impuls_laenge = 1501
   End If
Return

Get_rc5_isr:                            'RC5 Impuls erkannt
   Incr Bit_nummer
   Interrupt_vektor.7 = 1
Return

Autor: Denny (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Vielen Dank für den Code!
So eine Lösung habe ich schon lange gesucht!
Perfekt...

Autor: Di Pi (drpepper) Benutzerseite
Datum:

Bewertung
0 lesenswert
nicht lesenswert

Autor: Denny (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Es geht mir aber um das Bascom.
Ich habe noch eine sehr wichtige Frage:
Oben steht:
Startwert = 125                         '8000000/8/(256-125)=8000 Überläufe pro Sekunde,
Timer0 = Startwert                      'also alle 0,125ms, Impulslänge bei RC5 1,778ms, also ca. 14

Die Impluslänge ist 1.778ms
14Bits

1.778 / 14 = 0.127ms pro Bit

0.127ms = 0.000127s

1 / 0.000127 = 7874
Wieso steht oben 8000 Überläufe pro Sekunde??
Wie kann ich das auf meinen 14745600MHz Quarz umrechnen?

Danke

Autor: Denny (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Wenn ich das umrechne komme ich an 230
Geht aber nicht.

Autor: Denny (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Mit dem Wert 26 geht es aber ich hab das Gefühl, dass er nicht jeden 
Tastendruck mitbekommt.

Autor: Denny (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hallo könnt ihr mir biiiitte helfen??
Ich bin am Verzweifeln, weil ich nicht den richtigen Wert herausbekomme!

Autor: Di Pi (drpepper) Benutzerseite
Datum:

Bewertung
0 lesenswert
nicht lesenswert
schau dir halt mal die lösungen an, die ich dir geschrieben habe.

vielleicht lässt sich ja etwas auf dieses seltsame "Bascom" übertragen.

Autor: Denny (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Egal wie ich es rechne, ich komme immer an 231 oder 26.
Leider funktioniert es aber nicht!

Wann soll der Timer einen Überlauf-Interrupt machen?
Nach 1.778ms oder nach 0.125ms??

Ich denke nach 1.778ms...

Antwort schreiben

Die Angabe einer E-Mail-Adresse ist freiwillig. Wenn Sie automatisch per E-Mail über Antworten auf Ihren Beitrag informiert werden möchten, melden Sie sich bitte an.

Wichtige Regeln - erst lesen, dann posten!

  • Groß- und Kleinschreibung verwenden
  • Längeren Sourcecode nicht im Text einfügen, sondern als Dateianhang

Formatierung (mehr Informationen...)

  • [c]C-Code[/c]
  • [avrasm]AVR-Assembler-Code[/avrasm]
  • [code]Code in anderen Sprachen, ASCII-Zeichnungen[/code]
  • [math]Formel in LaTeX-Syntax[/math]
  • [[Titel]] - Link zu Artikel
  • Verweis auf anderen Beitrag einfügen: Rechtsklick auf Beitragstitel,
    "Adresse kopieren", und in den Text einfügen




Bild automatisch verkleinern, falls nötig
Bitte das JPG-Format nur für Fotos und Scans verwenden!
Zeichnungen und Screenshots im PNG- oder
GIF-Format hochladen. Siehe Bildformate.
Hinweis: der ursprüngliche Beitrag ist mehr als 6 Monate alt.
Bitte hier nur auf die ursprüngliche Frage antworten,
für neue Fragen einen neuen Beitrag erstellen.

Mit dem Abschicken bestätigst du, die Nutzungsbedingungen anzuerkennen.