Timer0 Overflow Interrupt löst nicht aus (ATmega16)

**PicNick** · 31.05.2005, 13:05

Du, ich muß eine Stunde weg. ich meld' mich

**PicNick** · 31.05.2005, 15:46

*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 & 0x0

EDIT: Seh grad, du hast jetzt if (rxcount == 9) das ist aber auch eines zu viel, wir haben ja nur 8 datenbits

**schamp** · 01.06.2005, 07:25

Hab jetzt ein bischen rumgespielt mit der if-Abfrage
wenn du if(bRxCount & 0x0

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.....

**PicNick** · 01.06.2005, 08:54

Morgen, da sind wir wieder !

Zitat von schamp

Wenn du z.b. if(bRxCount & 0x09) oder 0x07 machst dann ist Bit-Kopie nicht mehr ok und y kommen immer noch.....

ist klar, das ist der Unterschied "&" und "==". Egal
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)

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);     
}

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 ?

**schamp** · 01.06.2005, 11:52

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

Code:

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++;

            } */

	  }
	}

nya wenn ich so ziemlich alles auskommentier auf Tastendruck immer u0

**PicNick** · 01.06.2005, 12:40

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.

**schamp** · 01.06.2005, 12:51

Code while()

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);
}


  }

Receive-Routine inner Timer-ISR:

Code:

	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++;

            } */

	  }
	}

und INT0

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
  }

so wie ichs jetzt hab kommen nur U's (UUUUUUUU usw.)

**PicNick** · 01.06.2005, 13:06

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;
}

**schamp** · 01.06.2005, 13:18

bleibt bei UUUUUUUU....

**PicNick** · 01.06.2005, 13:33

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

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); 
    } 
  }

(es ist nur ein "}" anders)

in diesem Falle dürft jetzt GARKEIN echo kommen