Atmega88 Servo mit Poti steuern

[Christian (Gast)]

Hallo zusammen,

ich hab mal wieder ne Frage.
Ich möchte einen Servomotor über ein Poti an meinem Atmega88 steuern.
Momentan habe ich ein Programm geschrieben, das über den Ausgang OC1A 
den Servomotor vom Linksanschlag zum Rechtsanschlag und zurück fahren 
lässt. Der Servo wird mit einem 50Hz Signal angesteuert. Jetzt wollte 
ich den Ausgang OC1A so lassen und den OC1B so programmieren, dass er 
ich den Motor über ein Poti steuern kann.
Nur leider bewegt sich der Servo nicht, wenn ich ihn an den OC1B Ausgang 
anschließe. Ich weis aber nicht warum.
Mein Atmega88 läuft mit 8MHz und der Timer1 wird mit 8fach Prescaler 
betrieben.
Der Wert ADC_C0 ist eine 16Bit Variable in der der Wert vom ADC 
gespeichert wird. Der ADC teil funktioniert, und der Wert wird mir auch 
auf einem LCD ausgegeben.

Hier mein Code:

int main(){

DDRB |= 1<<PINB1 | 1<<PINB2;

  TCCR1A |= 1<<WGM11 | 1<<COM1A1 | 1<<COM1A0 | 1<<COM1B0 | 1<<COM1B1;
  TCCR1B |= 1<<WGM12 | 1<<WGM13 | 1<<CS11;
  ICR1 = 19999;


while(1){
  OCR1A = ICR1 - 1000;
  OCR1B = ICR1 - (850 + (ADC_C0 * 1,26));
  _delay_ms(500);
  OCR1A = ICR1 -2000;
  OCR1B = ICR1 - (850 + (ADC_C0 * 1,26));
  _delay_ms(500);
}

}

[MWS (Gast)]

Sollte da für die Floatkonstante statt dem Komma nicht ein Punkt rein 
gehören? Außerdem, bei einer Integermultiplikation mit einer 
Floatkonstante wird nur der Vorkommateil der Konstante berücksichtigt. 
Gab's da keine Warnungen?

[Christian (Gast)]

Erstmal danke für die schnelle Antwort.
Das Atmelstudio 6 hat keine Fehlermeldung gebracht.
Dann müsste es doch funktionieren, wenn ich den Code so schreibe

OCR1B = ICR1 - (850 + ADC_C0);

[MWS (Gast)]

Wie wird ADC gesampelt?

[Christian (Gast)]

uint16_t ADC_C0;




ADMUX &= ~(1<<MUX0);
  ADCSRA |= (1<<ADSC);
  while (ADCSRA & (1<<ADSC)){}
    ADCL_C0 = ADCL;
    ADCH_C0 = ADCH;
  
  ADMUX |= (1<<MUX0);
  ADCSRA |= (1<<ADSC);
  while (ADCSRA & (1<<ADSC)){}
    ADCL_C1 = ADCL;
    ADCH_C1 = ADCH;
  
  ADC_C0 = ADCL_C0 + (ADCH_C0 * 256);
  ADC_C1 = ADCL_C1 + (ADCH_C1 * 256);

[Christian (Gast)]

Ich habe mal ausprobiert mit einen normalen C++ compiler eine Berechnung 
mit einer int Variable zu machen. Es hat funktioniert. Allerdings nur 
wenn der Multiplikator so geschrieben wird 1.26 und nicht 1,26. Also 
müsste es so auch funktionieren.

OCR1B = ICR1 - (850 + (ADC_C0 * 1.26));

[MWS (Gast)]

Ja, die Routine sieht brauchbar aus, aber wo rufst Du die in der >while< 
s.o. auf?

[Christian (Gast)]

Hier mal der ganze Code:

#define F_CPU 8000000


#include <avr/io.h>
#include <util/delay.h>
#include <lcd-routines.h>
#include <lcd-routines.c>
#include <stdint.h>




uint16_t ADC_C0;
uint16_t ADC_C1;
uint8_t ADCL_C0;
uint8_t ADCH_C0;
uint8_t ADCL_C1;
uint8_t ADCH_C1;
char ADC_StringC0 [16];
char ADC_StringC1 [16];



void ADC_Init (void)
{
  
  ADMUX |= (1<<REFS0);
  ADCSRA |= (1<<ADPS2) | (1<<ADPS1) | (1<<ADEN) | (1<<ADSC);
  
  while (ADCSRA & (1<<ADSC));
  ADCL_C0 = ADCL;
  ADCH_C0 = ADCH;
  
}


void ADC_Read (void)
{
  
  ADMUX &= ~(1<<MUX0);
  ADCSRA |= (1<<ADSC);
  while (ADCSRA & (1<<ADSC)){}
    ADCL_C0 = ADCL;
    ADCH_C0 = ADCH;
  
  ADMUX |= (1<<MUX0);
  ADCSRA |= (1<<ADSC);
  while (ADCSRA & (1<<ADSC)){}
    ADCL_C1 = ADCL;
    ADCH_C1 = ADCH;
  
  ADC_C0 = ADCL_C0 + (ADCH_C0 * 256);
  ADC_C1 = ADCL_C1 + (ADCH_C1 * 256);
  
}



void LCD_Write (void)
{
  lcd_clear();
  
  itoa (ADC_C0, ADC_StringC0, 10);
  itoa (ADC_C1, ADC_StringC1, 10);
  
  lcd_setcursor(0,1);
  lcd_string("ADC0      ADC1");
  lcd_setcursor(0,2);
  lcd_string(ADC_StringC0);
  lcd_setcursor(9,2);
  lcd_string(ADC_StringC1);
  
  
  
  
}


void AVR_init (void)
{
  DDRC |= 1<<PINC4 | 1<<PINC5;
  PORTC |= 1<<PINC2 | 1<<PINC3;
  DDRB |= 1<<PINB1 | 1<<PINB2;
  
}


void PWM_init (void)
{

  TCCR1A |= 1<<WGM11 | 1<<COM1A1 | 1<<COM1A0 | 1<<COM1B0 | 1<<COM1B1;
  TCCR1B |= 1<<WGM12 | 1<<WGM13 | 1<<CS11;
  ICR1 = 19999;
  
  
}


void PWM_Funktion (void)
{
  OCR1A = ICR1 - 1000;
  OCR1B = ICR1 - (850 + (ADC_C0 * 1.26));
  _delay_ms(500);
  OCR1A = ICR1 -2000;
  OCR1B = ICR1 - (850 + (ADC_C0 * 1.26));
  _delay_ms(500);
  
  
}


int main(void)
{  
  AVR_init();
  ADC_Init();
  lcd_init();
  PWM_init();
   
  
  
  
    while(1)
    {
        ADC_Read();
    LCD_Write();
    PWM_Funktion();
    
      
    
    
    }
}

[MWS (Gast)]

Christian schrieb:
> Ich habe mal ausprobiert mit einen normalen C++ compiler eine
> Berechnung
> mit einer int Variable zu machen. Es hat funktioniert. Allerdings nur
> wenn der Multiplikator so geschrieben wird 1.26 und nicht 1,26. Also
> müsste es so auch funktionieren.
> OCR1B = ICR1 - (850 + (ADC_C0 * 1.26));

Beim AVR GCC ist der Default für die Berechnung ein Integer, damit wird 
sich das so verhalten, wie von mir oben beschrieben.

Im AVR-Studio kannst Du Deinen Code auch simulieren und die Variablen 
untersuchen, stell dafür auf keine Optimierung, -O0.

[Magnus M. (magnetus)]

Nimms mir bitte nicht übel, aber hast du schon mal was von kommentiertem 
Code gehört?

[Christian (Gast)]

Wie ganau mache ich das?

[MWS (Gast)]

Ich gehe davon aus, dass Du OCR1B genauso wie ..A getestet hast, lass 
doch mal die Floatkonstante völlig weg, Du müsstest trotzdem irgendeine 
Reaktion bekommen.

[Christian (Gast)]

Normalerweise kommentiere ich den Code, aber das ist eigentlich nur ein 
Testprogramm, daher habe ich die Kommis weggelassen.