[Attiny85] 2x Modellbau-Empfängersignal auswerten

[Heiko P. (doomgiver)]

Hallo,

ich bin neu hier und möchte mich kurz vorstellen. Mein Name ist Heiko, 
ich komme aus der schönen(?) Sprottenstadt Kiel. Elektronik bzw. 
Elektrik verwende ich in meinem Hobby Modellbau, weswegen da auch der 
Schwerpunkt liegt. Hauptsächlich Lichtsteuerungen für Raumschiffe und 
Steuermodule für meine RC-Modelle. Angefangen habe ich da mit der 
Arduino-Umgebung, was auch ganz gut klappte und die Scheu vor den 
"nackten" AVRs nahm (Stichwort Fuses). Irgendwann war mir das aber 
zuviel Gekrücke, vor allem wenn ich einfachere Sachen nur mit Attinys 
machen wollte. Daher erfolgte vor kurzem der Sprung auf die "echte" 
AVR-Umgebung (Atmel Studio 6.2, AVRISP MkII, etc.).

Nun zu meinem Problem: Ich versuche über einen Attiny85 zwei Signale 
eines Empfängers einzulesen und entsprechend weiterzuverarbeiten. Im 
ersten Anlauf will ich nur das empfangene Signal eines Kanals zum testen 
ausgeben, wenn das vernünftig funktioniert geht es weiter.
Kern sind die beiden Timer. Timer0 läuft im CTC-Modus und erhöht alle 
8µs einige Zähler um 1. Timer1 ist nur dafür da, alle 20ms die 
Signalausgabe neu zu starten (habe ich auch nur dank dieses Treads zum 
laufen bekommen: Beitrag "ATtiny25, TimerCounter1, CTC-Mode: Bug?").

Der Signalstart alle 20ms funktioniert auch tadellos, nur das 
auszugebende Signal klappt gar nicht. Wenn kein Empfänger angeschlossen 
ist, soll der Start- bzw. letzte gültige Wert zwischen 1000-2000µs 
ausgegeben werden. Stattdessem wandert das Signal förmlich, beginnend 
bei ca. 3200µs langsam runter auf 2000µs und dann wieder von vorne. Kann 
ich auf meinem Spielzeug-Taschen-Oszi richtig schön beobachten.

Ich bin da jetzt langsam etwas ratlos, kaue schon seit einigen Tagen 
daran herum. Die Suche ergab leider nicht so furchtbar viel (mal mit 
PC-Interrupt, mal ohne, oft nur ein Kanal, etc.), auch wenn das Thema 
"Servosignal" offenbar ganze Seiten füllt.

#include <avr/interrupt.h>
#include <avr/io.h>

#define pin_benedini PB0                  // Anschluss für Benedini-Modul
#define pin_drehgeber PB1                  // Anschlüss für Poti-Geber vom Empfänger
#define pin_taster PB2                    // Anschluss für Tast-Geber vom Empfänger
#define pin_led PB4                      // Anschluss für Status-LED

volatile uint16_t zeit = 0;                  // aktuelle Ausgabedauer für Benedini-Modul
volatile uint16_t zeit_empfaenger[2] = {188, 188};      // Signaldauer der empfangenen Empfängersignale
uint16_t zeit_ausgabe[2] = {188, 188};            // auszugebende Signaldauer für Benedini und LED
uint8_t pin_empfaenger[2] = {pin_taster, pin_drehgeber};  
uint8_t pinb_alt = 0;                    // Zustand von PINB vor Änderung von PORTB

int main(void)
{  
  DDRB |= ((1 << pin_benedini) | (1 << pin_led));      // Benedini und LEd als Ausgang definieren
  
  TCCR0A |= (1 << WGM01);                  // CTC-Mode aktiviert
  TCCR0B |= (1 << CS00);                  // Prescaler = 1
  OCR0A = 63;                        // 8µs
  TIMSK |= (1 << OCIE0A);                  // Interrupt aktivieren

  TCCR1 |= ((1 << CS13) | (1 << CS11) | (1 << CS10) | (1 << PWM1A) | (1 << CTC1));  // Prescaler für Timer1 = 1024; CTC aktiviert
  OCR1C = 154;                      // 19840µs Periodendauer = 20ms für Servosignal
  TIMSK |= (1 << TOIE1);                  // Interrupt aktivieren

  sei();                          // globale Interrupts aktivieren
  
    while(1)
    {
    for(uint8_t i = 0; i < 2; i++){
      if(PINB & (1 << pin_empfaenger[i]) && !(pinb_alt & (1 << pin_empfaenger[i]))){    // steigender Pegel, Zeitmessung wird gestartet
        zeit_empfaenger[i] = 0;
        pinb_alt |= (1 << pin_empfaenger[i]);
      }
      
      if(!(PINB & (1 << pin_empfaenger[i])) && pinb_alt & (1 << pin_empfaenger[i])){    // fallender Pegel, Zeitmessung wird beendet
        if(zeit_empfaenger[i] >= 109 && zeit_empfaenger[i] <= 266){            // Zeitdauer ist gültig, als Ausgangsdauer festlegen
          zeit_ausgabe[i] = zeit_empfaenger[i];
        }
        pinb_alt &= ~(1 << pin_empfaenger[i]);
      }
        
    }
    
    if(zeit > zeit_ausgabe[0] && PINB & (1 << pin_led)){                  // Wenn Dauer der Ausgabe >= geplante Signallänge, Signal abschalten
      cli();
      PORTB &= ~((1 << pin_led) | (1 << pin_benedini));
      sei();
    }
    }
}

ISR(TIMER0_COMPA_vect){
  zeit++;
  zeit_empfaenger[0]++;
  zeit_empfaenger[1]++;
}

ISR(TIMER1_OVF_vect){
  PORTB |= ((1 << pin_led) | (1 << pin_benedini));                      // Alle 20ms die Signalausgabe neu starten
  zeit = 0;
}

Heiko

[STK500-Besitzer (Gast)]

Dein Hauptprogramm hat also 64 Taktzyklen, um das ganze Geraffel in der 
Hauptschleife abzuarbeiten. Dazu kommt dann noch, dass zwischendurch der 
eine odere andere Takt übersehen werden könnte, weil die Interrupts 
abgeschaltet wurden.
Das ist verdammt sportlich.

Du solltest einen Timer durchlaufen lassen und in der Hauptschleife den 
Zustand der Portpins überprüfen. Wenn es eine Flanke gab, speichert man 
den Wert des Timers und berechnet ggf. die Pulslänge.

Die 20ms sind alter Kram, den man nicht unbedingt umsetzen muss.