Potentiometer + Servomotor I Atmega328PB

[Phillip E. (phillipernst1998)]

Guten Tag,

ich bins wieder. Ich habe hier die Erweituerung zu meinem vorherigen 
Beitrag. diesmal muss mit dem Potentiometer ein Servomotor bewegt 
werden. Ich habe den Code so gut es geht vervollständigt nur gibt es 
einige Unstimmigkeiten im Code die ich bis jetzt nicht rausfinden 
konnte. Vielleicht kann hier jemand weiterhelfe, hat dass letzte mal so 
gut geklappt! :D

Ich glaube bei diesen zwei Punkten liegt mein Fehler.

1.

Dazu ist der Timer/Counter 1 so zu konfigurieren, dass er im Fast PWM 
Mode mit
einer Taktteilung im Teilverhältnis von 1/8 betrieben wird, die 
PWM-Frequenz über
OCR1A auf 20 ms eingestellt wird und OCR1B das Tastverhältnis bestimmt.

2.

In den beiden ISRs des Timer/Counter 1 (Overflow und Compare-Match B) 
soll der
für die Poti-Steuerung genutzte Port-Pin jeweils passend zum benötigten 
PWMSignal modifiziert werden.

#define F_CPU 16000000

//Nachfolgend müssen zwei Bibliotheks-Dateien eingebunden werden (bitte Punkte passend ersetzen)
#include <avr/interrupt.h>
#include <avr/io.h>

// Deklaration der globalen Variablen  
int16_t servo_offset;                        // Wert (negativ oder positiv) der als Offset mit dem 
                                  // Mittenpositionswert des Servos verrechnet wird 

//Compare-Register-Werte für PWM-Betrieb
#define SERVO_PERIOD 40000                      // Compare-Wert 40.000 entspricht 20 ms
#define SERVO_PULSE_MAX 4000                    // Compare-Wert 4.000 entspricht 2 ms = Servo-Maximalwert
#define SERVO_PULSE_MID 3000                    // Compare-Wert 3.000 entspricht 1,5 ms = Servo-Mittelstellung
#define SERVO_PULSE_MIN 2000                    // Compare-Wert 2.000 entspricht 1 ms = Servo-Minimalwert

// Interrupt-Service-Routine des ADC
ISR(ADC_vect)        // An dieser Stelle muss die Deklarations-Kopfzeile korrekte vervollständigt werden
{
  
  servo_offset = ADCL;                      // servo_offset aus ADC-Wert berechnen 
  servo_offset +=  (ADCH<<8);                    // im Wertebereich -1024 ... 1023
                                  // (ACHTUNG: ADC-Wert ist unsigned integer)
  
  OCR1B = (2000/1023)* servo_offset + 2000;                        // Compare-Wert für t_high = 1 ... 2 ms aus
                                  // servo_offset berechnen
                                  // (ACHTUNG: OCR1B-Wert ist unsigned integer)
}

// Interrupt-Service-Routine des Timer/Counter 0
ISR(TIMER0_COMPA_vect)        // An dieser Stelle muss die Deklarations-Kopfzeile korrekt vervollständigt werden
{
  ADCSRA |= (1<<ADSC);                          // Neue ADC-Sequenz starten
}

// Interrupt-Service-Routine des Timer/Counter 1 (Startzeitpunkt einer neuen PWM-Periode)
ISR(TIMER1_CAPT_vect)        // An dieser Stelle muss die Deklarations-Kopfzeile korrekt vervollständigt werden
{
  PORTC |= 0xFF;                        // Servo-Ausgang selektiv auf HIGH
}

// Interrupt-Service-Routine des Timer/Counter 1 (Endzeitpunkt der HIGH-Phase einer PWM-Periode)
ISR(TIMER1_CAPT_vect)        // An dieser Stelle muss die Deklarations-Kopfzeile korrekt vervollständigt werden
{
  PORTC &=  ~(1 << 2);                        // Servo-Ausgang selektiv auf LOW
}

int main(void)
{
  // ADC initialisieren
  ADMUX = (1 << REFS0 );                    // ADC Referenzspannung AVcc, rechtsbündige 
                                  // Ausrichtung für 10 Bit, Kanal 0 als ADC-Eingang
                                  // (ACHTUNG: Ausrichtung und Bitbreite sind anders als
                                  // in V3 Teil1 !!!)
  ADCSRA =(1 << ADEN) | (1 << ADIE) |( 1 << ADPS0) | ( 1 << ADPS2);  // ADC aktivieren, ADC Interrupt, Frequenzteiler 32
  
  // Timer/Counter 0 initialisieren: CTC Modus, Prescaler 1/1024, Interrupt-Intervall 10 ms genau wie in V3 Teil1
  TCCR0A = (1<<WGM01);
  TCCR0B = (1<<CS02)|(1<<CS00) ;
  OCR0A =  156 ;                           // s. Formel aus Versuchsbeschreibung zu Versuch 2
  TIMSK0 = (1<<OCIE0A);                      // Compare-Interrupt A freigeben
  
  // Timer/Counter 1 initialisieren als PWM-Generator: Fast PWM, Prescaler 1/8, Compare Match IRQ B, Overflow IRQ 
  // -> t_periode = 20 ms, t_high = 1,5 ms (Servo-Mittelstellung)
  TCCR1A = (1<<WGM10)|(1<<WGM11)  ;
  TCCR1B = (1<<WGM12)|(1<<WGM13)|(1<<CS11);
  OCR1A = SERVO_PERIOD;                      // Bestimmt die PWM-Periodendauer
  OCR1B = SERVO_PULSE_MID;                    // Bestimmt die PWM-Pulsweite für Servo-Mittelstellung
  TIMSK1 = (1<<OCIE1B)|(1<<TOIE1);                // Compare-Interrupt B und Overflow-Interrupt freigeben
  
  // Servo initialisieren
  DDRC |= 0b00000100;                        // Servo-Ausgang selektiv auf OUTPUT
  PORTC &= ~(1 << 2);                        // Servo-Ausgang selektiv auf LOW 
  
  sei();                              // Interrupts global freigeben
  
  while (1)
  {
  // Hier ist kein Code erforderlich  
  }
}

[m.n. (Gast)]

Phillip E. schrieb:
> diesmal muss mit dem Potentiometer ein Servomotor bewegt
> werden.

Das würde ich noch einmal überdenken ;-)

[S: Landolt (Gast)]

> ... beiden ISRs des Timer/Counter 1 (Overflow und Compare-Match B)
Dann ist die Capture-ISR ('ISR(TIMER1_CAPT_vect)') wohl nicht das 
Richtige, siehe Anhang.

> OCR1B = (2000/1023) * ...
Als C-Laie weiß ich nicht, ob mit Brüchen gerechnet werden kann, mein 
avrasm2  kann nur Ganzzahlen, macht also z.B. aus '(2000/1023)*100' 100 
statt dem erwarteten 195.

[S: Landolt (Gast)]

PS:
Also der avrasm2 rechnet schon mit Brüchen, aber das (Zwischen-)Ergebnis 
ist eine ganze Zahl. Man muss gegebenenfalls die Faktoren umstellen.