Du, ich muß eine Stunde weg. ich meld' mich
Druckbare Version
Du, ich muß eine Stunde weg. ich meld' mich
*grüberl*
Sag mal, steht das noch so drin ? (in der timer-isr)
if (bRxFlag & RX_M_RECEIVE)
{
if (bRxCount & 0x080)
das ist katastophal falsch muß heißen :
if (bRxCount & 0x08)
EDIT: Seh grad, du hast jetzt if (rxcount == 9) das ist aber auch eines zu viel, wir haben ja nur 8 datenbits
Hab jetzt ein bischen rumgespielt mit der if-Abfrage
wenn du if(bRxCount & 0x08) machst passts mit der Bit-Kopie inner while() und die y kommen bzw. ab und zu auch mal ein þ.
Wenn du z.b. if(bRxCount & 0x09) oder 0x07 machst dann ist Bit-Kopie nicht mehr ok und y kommen immer noch..... :-s
Morgen, da sind wir wieder !
ist klar, das ist der Unterschied "&" und "==". EgalZitat:
Zitat von schamp
Ein neues Spiel, ein neues Glück:
Wir machen die Counterei zu Fuß, vergleichen dann mit dem Timer-ISR Ergebnis und erhoffen Weisheiten.
Dazu senden wir immer nur das Zeichen 0x55, das ergibt mit start und stop genau das Muster 0 10101010 1, dadurch kriegen wir die Bitwechsel auch ohne Time genau mit. die erste Flanke zum Startbit kriegt ja der INT0, der setzt RX_M_RECEIVE, und dann geht's los
(dabei läuft die Timer0-ISR ganz normal, nur
RX_M_DATA setzt er NICHT und
RX_M_RECEIVE löscht er NICHT, das machen wir jetzt extra)
send_one_byte(bRxCount + 0x30);Code:unsigned char bOld = 0; // wegen den Flanken
unsigned char bCnt = 0; // vergleichszähler
// in der INT0 ISR zusätzlich
bOld = 0;
bCnt = 0;
// in der while(1) -schleife
if (bRXFlag & RX_M_RECEIVE)
{
if ( ( PIND & (1<<PD2)) ^ bOld & (1<<PD2)) // any Flanke ?
{
if (bCnt & 0x08)
{
bRXFlag &= ~RX_M_RECEIVE;
bRXFlag |= RX_M_DATA;
}
else
{
bOld = PIND;
bCnt++;
bRxByte >>= 1;
}
}
if ( PIND & (1<<PD2))
{
PORTD |=(1<<PD4);
bRxByte |=0x80;
}
else
{
PORTD &= ~(1<<PD4);
}
}
if (bRXFlag & RX_M_DATA)
{
bRxFlag &= ~RX_M_DATA;
send_one_byte(bRxCount + 0x30);
}
Wir senden den Byte-Zähler, den die Timer0-ISR zu diesem Zeitpunkt gerade hat. Der sollte ja eigentlich auch ca 8 oder 9 sein. Ist er weiter weg, können wir abschätzen, wo die Differenz liegt
( + 0x30) --> damit das ein druckbares zeichen wird und wir es lesen können.
0x30 ---> "0"
wie gesagt, kann nur funzen, wenn 0x55 = "U" geschickt wird, wegen des Bit musters
Verständlich ?
Aber wie is das dann mit RxByte in der Timer-ISR ?
Wird das dann net überschrieben, wenn du auch RxByte in while setzt ?
Versteh den Ablauf nicht mehr so ganz...
EDIT: 8en kommen wenn die Timer-ISR so aussieht
nya wenn ich so ziemlich alles auskommentier auf Tastendruck immer u0Code:if (bRxFlag & RX_M_RECEIVE) // receive ?
{
if (bRxCount & 0x08) // is this the stop-Bit (9th)
{
bRxFlag &= ~RX_M_RECEIVE; // receiving sequence done
bRxFlag |= RX_M_DATA; // signal data
GICR |= 1<<INT0; // re-enable int0 for next
}
else
{
bRxByte >>= 1; // Shift right data
bRxCount++;
/* if(PIND&(1<<PD2)) //set bit or leave it
{
bRxByte |=0x80;
bRxCount++;
} */
}
}
RxByte: was die TimerISR reinschreibt, wissen wir eh schon (y) daher ausgeliehen für die while-routine
Ich wollte wissen, wenn wir durch ein Spezialzeichen extra die Bits zählen, und nach der 8. Flanke den (parallel)Zähler der TimerISR anschauen, wieweit denn die Timer-Isr gekommen wäre (in der selben Zeit)
Übrigens: Großes (shift) "U" ist gefragt (0x55)
Wenn dir bei der beschriebenen Methode "u0" rauskommt, ("u" ist das Echo, und "0" der iSR-Counter zum selben Zeitpunkt) heißt das ja, daß die Timer-ISR nichteinmal zu zählen begonnen hat, obwohl das Byte schon aus war.
Das müssen wir sicherstellen. Bitte stell den ganzen Code rein.
Code while()
Receive-Routine inner Timer-ISR:Code:while(1)
{
if (bRxFlag & RX_M_RECEIVE)
{
if ( ( PIND & (1<<PD2)) ^ (bOld & (1<<PD2))) // any Flanke ?
{
if (bCnt & 0x08)
{
bRxFlag &= ~RX_M_RECEIVE;
bRxFlag |= RX_M_DATA;
}
else
{
bOld = PIND;
bCnt++;
bRxByte >>= 1;
}
}
if ( PIND & (1<<PD2))
{
PORTD |=(1<<PD4);
bRxByte |=0x80;
}
else
{
PORTD &= ~(1<<PD4);
}
}
if (bRxFlag & RX_M_DATA)
{
bRxFlag &= ~RX_M_DATA;
send_one_byte(bRxCount + 0x30);
}
}
und INT0Code:if (bRxFlag & RX_M_RECEIVE) // receive ?
{
if (bRxCount & 0x08) // is this the stop-Bit (9th)
{
//bRxFlag &= ~RX_M_RECEIVE; // receiving sequence done
//bRxFlag |= RX_M_DATA; // signal data
GICR |= 1<<INT0; // re-enable int0 for next
}
else
{
bRxByte >>= 1; // Shift right data
bRxCount++;
/* if(PIND&(1<<PD2)) //set bit or leave it
{
bRxByte |=0x80;
bRxCount++;
} */
}
}
so wie ichs jetzt hab kommen nur U's (UUUUUUUU usw.)Code:if(!(bRxFlag & RX_M_RECEIVE))
{
GICR = 0; // Disable external interrupt
// bTxFlag &= ~TX_M_SEND; // Deactivate Transmit-Mode
TCNT0 = INT0_PRELOAD; // Set timer reload-value (to 1.5 bit len). 29 = time delay that
// have already been used in this
// interrupt plus the time
// that will be used by the time
// delay between timer interrupt request
// and the actual sampling of the first
// data bit.
TIFR |= (1<<TOV0); // clear T/C0 overflow flag
TIMSK |= (1<<TOIE0); // enable T/C0 overflow interrupt
bRxCount = 0; // Clear Receive Counter
bOld = 0;
bCnt = 0;
bRxFlag |= RX_M_RECEIVE; // Activate Receive-Mode
}
das muß aus der ISR noch raus
bRxByte >>= 1; // Shift right data
In der Main-Routine, sicherheitshalber
if ( PIND & (1<<PD2))
{
PORTD |=(1<<PD4);
bRxByte |=0x80;
}
else
{
PORTD &= ~(1<<PD4);
bRxByte &=~0x80;
}
bleibt bei UUUUUUUU....
D.h bei der Methode wird offenbar RX_M_DATA garnicht gesetzt, sonst müßte er nach jedem "U" ja irgendwas ausgeben.
Da müssen wir kontrollieren, ob die while routine überhaupt die Flanken erkennt
(es ist nur ein "}" anders)Code:while(1)
{
if (bRxFlag & RX_M_RECEIVE)
{
if ( ( PIND & (1<<PD2)) ^ (bOld & (1<<PD2))) // any Flanke ?
{
if (bCnt & 0x08)
{
bRxFlag &= ~RX_M_RECEIVE;
bRxFlag |= RX_M_DATA;
}
else
{
bOld = PIND;
bCnt++;
bRxByte >>= 1;
}
if ( PIND & (1<<PD2))
{
PORTD |=(1<<PD4);
bRxByte |=0x80;
}
else
{
PORTD &= ~(1<<PD4);
bRxByte &= ~0x80;
}
}
}
if (bRxFlag & RX_M_DATA)
{
bRxFlag &= ~RX_M_DATA;
send_one_byte(bRxCount + 0x30);
}
}
in diesem Falle dürft jetzt GARKEIN echo kommen