RC Schalter Problem oder Fehler

[Mister S. (misterslb)]

Guten Tag

Der Code ist für eine Fernsteuerung gedacht mit attiny13.

Das Problem: ich würde gerne den Code als Schalter benützen verstehe 
aber nicht wie. Der Knüppel nach unten Led1 und Led2 sind an(nicht gut), 
Knüppel mitte keine Led an (Gut so) und Knüppel oben Led1 an (gut). Wie 
kann ich den Code ändern das nur Led1 (oben) und nur Led2 (unten) 
leuchten.

/*
 * AVR_Schalter_Attiny13a_nachbau.c
 *
 * Created: 01.01.2002 00:59:52
 *  Author: Q
 */ 


/************************************************************************************/
// Schalterfunktionalität an einem Empfänger- RC- Ausgang
//
//  -> erprobt mit ATtiny13
//
// Version: 0.2
//
// Datum: 01.02.2010
//
// Hardware bei ATtiny13 (Taktfrequenz (4,8Mhz, CKDIV8 Vorteiler Fuse gesetzt -> 600kHz):
// R/C-Kanal an PB1 (INT0)
// Schalt-LED1 an PB3
// Schalt-LED2 an PB4


/************************************************************************************/
// Compiler- Warnungen

#ifndef F_CPU
#warning "F_CPU not defined"
#define F_CPU 600000UL
#endif

/************************************************************************************/
// Libraries

#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/wdt.h>    // für Watchdog- Funktionen
#include <stdint.h>


/************************************************************************************/
// Pin- Belegung

#define RC_KanalEingang    PINB  // Eingangssignal R/C- Empfänger
#define RC_KanalPin      PINB1  // Pin für Eingangssignal R/C- Empfänger



/************************************************************************************/
// Variablen

static volatile uint8_t Reading;  // Bit- Merker zur Sperrung der Hauptroutine während der erneuten Wertermittlung
// Merker Flanke


static volatile uint8_t RCvalue;  // empfangener Wert von R/C- Empfänger -> wird von Timer runtergezählt

/************************************************************************************/
//Header

void RC_Read();
void RC_Error();

/************************************************************************************/
// Interruptroutinen

/* ISR für INT0 - R/C-Signal mit Timer lesen */
ISR(INT0_vect)
{
  RC_Read();
}


/************************************************************************************/
// Hauptprogramm

int main(void)
{
  DDRB |= (1<<PB3); //LED1
  
  DDRB |= (1<<PB4); //LED2
  
  PORTB |= (1<<PB1);
  
  


  // Initialisierung Interrupteingang INT0
  MCUCR |= (1<<ISC00);  // Interrupt wird bei jedem Pegelwechsel an INT0 ausgelöst
  GIMSK |= (1<<INT0);    // Interrupt INT0 aktivieren

  // Initialisierung Timer0
  TIMSK0 |= (1<<TOIE0);  // Timer0 Interrupt aktivieren
  
  // Initialisierung Watchdog auf 500ms, bedingt #include <avr/wdt.h>
  wdt_enable(WDTO_500MS);

  
  
  
  // globale Interrupptfreigabe
  sei();

  /***********************************************************************************/
  while(1)
  {
    // Watchdog zurücksetzen
    wdt_reset();

    
    
    {
      
      
      // LED- Ausgänge schalten, je Timer- Wert -> erprobt mit ATmega8
      
      
      
      if (RCvalue > 160)
      {
        PORTB &= ~(1<<PB3); //LED1 an
        
      }
          
      else
      {
        PORTB |= (1<<PB3);
      }
      
      
      
      if ((RCvalue > 100))
      {
        PORTB &= ~(1<<PB4); //LED2 an
      }
      
      else
      {
        PORTB |= (1<<PB4);
      }
    
      
          
          
      
  
      

    }
  }
}

/***********************************************************************************/

// ISR für INT0 - R/C-Signal mit Timer lesen
void RC_Read()
{
  // Timer starten mit steigender Flanke
  if(Reading == 0)
  {
    TCCR0B |= (1<<CS01);  // Start Timer0 mit Vorteiler 8
    Reading = 1;    // Merker Flanke setzten
  }
  
  // Timer stoppen mit fallender Flanke
  else
  {
    TCCR0B = 0x00;    // Stop Timer0
    RCvalue = TCNT0;  // Wert von Timer lesen
    TCNT0 = 0x00;    // neuen Startwert für Timer laden
    Reading = 0;    // Merker Flanke setzten
  }

  
}

[Markus F. (mfro)]

Größer als 160 ist auch größer als 100. Gell?

Da fehlt noch ein bißchen was.

[STK500-Besitzer (Gast)]

Wenn dein Messwert >100 ist KANN LED2 leuchten.
Aber nur,  wenn er nicht auch >160 ist.

[Fred (Gast)]

Sollte wohl statt

if ((RCvalue > 100))

eher

if (RCvalue < 140)

heißen.

[Fred (Gast)]

vielleicht hieß das auch vorher:

if ((RCvalue > 100) && RCvalue < 140)

????

wenn kein Signal anliegt liegt der Wert unter 100.
Mittelstellung wäre 150. Also zwischen unterer Position 100 und
fast Mittlestellung 140 soll die LED2 leuchten.

[Mister S. (misterslb)]

Guten Abend

Habe das Problem oben gelöst jetzt habe aber gemerkt das ich 2 Timer 
brauche, für das verwende ich jetzt einen atMega8. Der 1 Timer 
funktioniert mit int0 aber der 2 Timer mit int1 funktioniert nicht.

Kann man überhaupt 2 Timer mit Interrupt benutzen?????

Vielen Vielen Dank für die Hilfe.

PEACE

// ISR für INT0 - R/C-Signal mit Timer lesen
void RC_Read()
{
  // Timer starten mit steigender Flanke
  if(Reading == 0)
  {
    TCCR0 |= (1<<CS01);  // Start Timer0 mit Vorteiler 8
    Reading = 1;    // Merker Flanke setzten
  }
  
  // Timer stoppen mit fallender Flanke
  else
  {
    TCCR0 = 0x00;    // Stop Timer0
    RCvalue = TCNT0;  // Wert von Timer lesen
    TCNT0 = 0x00;    // neuen Startwert für Timer laden
    Reading = 0;    // Merker Flanke setzten
  }

  Error = 0;      // Error- Merker zurücksetzen
}

//into1
void RC_Reada()
{
  // Timer starten mit steigender Flanke
  if(Readinga == 0)
  {
    TCCR2 |= (1<<CS01);  // Start Timer0 mit Vorteiler 8
    Readinga = 1;    // Merker Flanke setzten
  }
  
  // Timer stoppen mit fallender Flanke
  else
  {
    TCCR2 = 0x00;    // Stop Timer0
    RCvaluea = TCNT2;  // Wert von Timer lesen
    TCNT2 = 0x00;    // neuen Startwert für Timer laden
    Readinga = 0;    // Merker Flanke setzten
  }

  Errora = 0;      // Error- Merker zurücksetzen
}


// ISR für Timer0 - Fehlerhandling Timeroverflow
void RC_Error()
{
  TCCR0 = 0x00;      // Stop Timer0
  RCvalue = 0;      // Wert für Ausgänge annehmen
  TCNT0 = 0x00;      // neuen Startwert für Timer zurücksetzen
  Reading = 0;      // Merker Flanke setzten
  Error = 1;        // Error- Merker setzen
}

// ISR für Timer1 - Fehlerhandling Timeroverflow
void RC_Errora()
{
  TCCR2 = 0x00;      // Stop Timer2
  RCvaluea = 0;      // Wert für Ausgänge annehmen
  TCNT2 = 0x00;      // neuen Startwert für Timer zurücksetzen
  Readinga = 0;      // Merker Flanke setzten
  Errora = 1;        // Error- Merker setzen
}

[Karl H. (kbuchegg)]

Mister S. schrieb:
> Guten Abend
>
> Habe das Problem oben gelöst jetzt habe aber gemerkt das ich 2 Timer
> brauche,


Wozu?


Was du hättest merken sollem, das ist, dass das ständige Timer 
starten/stoppen unsinnig ist.

Wenn du für einen Fahrradfahrer die Rundenzeit stoppen sollst, dann kann 
man dafür selbst verständlich eine Stoppuhr nehmen. Man kann aber auch 
eine stink normale Uhr nehmen.
Man merkst sich, wenn der Fahrer über die Startlinie geht, zb um 
17:47:12 und wann er die Ziellinie passiert, zb um 17:53:15. Die 
Differenz, 00:06:03 (oder in Sekunden 363 Sekunden) ist die Laufzeit.

Genauso auch hier:

Kein Mensch muss hier ...

> // ISR für INT0 - R/C-Signal mit Timer lesen
> void RC_Read()
> {
>   // Timer starten mit steigender Flanke
>   if(Reading == 0)
>   {
>     TCCR0 |= (1<<CS01);  // Start Timer0 mit Vorteiler 8

... den Timer ständig starten ...

>     Reading = 1;    // Merker Flanke setzten
>   }
>
>   // Timer stoppen mit fallender Flanke
>   else
>   {
>     TCCR0 = 0x00;    // Stop Timer0
>     RCvalue = TCNT0;  // Wert von Timer lesen

... oder stoppen.

Es reicht völlig, wenn man sich den Zählerstand im Falle Reading==0 
merkt und hier dann ganz einfach die Differenz dazu nimmt. Schon hat man 
genau dieselbe Information.

ABER!

Da der Timer da ständig durchläuft und niemals gestoppt wird, können da 
auch 86 Interrupts die Werte von 86 RC-Kanälen auswerten, wenn du das 
willst.

> Kann man überhaupt 2 Timer mit Interrupt benutzen?????

Natürlich kann man. Du wirst halt mal wieder irgendwo in der Copy&Paste 
Programmierung etwas übernommen haben, was für den anderen Timer etwas 
anders funktioniert.
Aber wie gesagt: Mit ein wenig Überlegen ist das gar nicht notwendig. 1 
Timer reicht völlig aus. Und einfacher wird das Programm dann auch noch.

[Mister S. (misterslb)]

Hallo

DAnke für den Tipp ein Timer reicht. Habe jetzt INT0 und INT1 mit 
Timer1, den Timer Starte und Stoppe ich immer noch versuche aber noch 
den Timer durchlaufen zu lassen.

Programm Funktioniert. DAnke für die Hilfe. Peace.

[Tom (Gast)]

hi,
kannst du deinen code mal zeigen?