Hardware PWM Timer1 funktioniert nicht

Erst mal danke für die schnelle Antwort. Ok das man da direkt den Wert 
20000 hin schreiben kann wusste ich nicht. Werd ich gleich mal 
probieren. Phase Corect PWM nehm deshalb weil die fast pwm viel zu 
schnell ist.

Ich hab des jetzt so gemacht wie es der Karl Heinz geschrieben hat.
Also die Werte direkt rein geschrieben (ICR1=20000) und des 
funktioniert. Der Servo fährt dann genau auf die Mittelposition so wie 
ichs berechnet hatte. Das heißt des Problem is gelöst.^^
Jetzt muss ich nur noch des Fahren in mehrere Zwischenschritte 
unterteilen, damit der Servo langsam fährt. Das war des Ziel der ganzen 
Sache. Weil mit Software PWM kann die Schritte net klein genug machen, 
damit der Servo ruckelfrei fährt. Denn Sonst wird die ISR zu oft 
ausgeführt und das Programm zu sehr belastet.
Also nochmal Dnake für eure schnelle Hilfe.

Also hab des ganze jetzt mal so geschrieben:

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

short i=0;

ISR(TIMER1_COMPA_vect) {
  i++;
  if((i==1)&&(!(PINA &(1<<PINA0)))) {    //nach rechts fahren
    OCR1A--;;
  }
  if((i==1)&&(!(PINA &(1<<PINA1)))) {    //nach links fahren
    OCR1A++;
  }
  if(i==1) {
    i=0;
  }
}

int main(void) {

  DDRC = 0b1111111;
  DDRD = 0b1111111;
  DDRB = 0b1111111;
  DDRA = 0b0000000;
  PORTC = 0xFF;
  TCCR1A |= (1<<COM1A0)|(1<<COM1A1)|(1<<WGM11);
  TCCR1B |= (1<<WGM13)|(1<<CS11);
  TIMSK |= (1<<OCIE1A);
  ICR1=10000;
  OCR1A=9450-1;
  sei();

  while(1) {
    if(!(PINA &(1<<PINA0))) {
      PORTC &=~ (1<<PB0);
    }
    if(PINA &(1<<PINA0)) {
      PORTC |= (1<<PB0);
    }

    if(!(PINA &(1<<PINA1))) {
      PORTC &=~ (1<<PB1);
    }
    if(PINA &(1<<PINA1)) {
      PORTC |= (1<<PB1);
    }
  }
}

Zum Testen hab ich mal Taster eingebaut. Ein Taster für jede Richtung.

Der Servo fährt wunderschön. Kann den jetzt richtig langsam fahrn lassen 
ohne das man ein Ruckeln sieht. Wenn man jetzt noch bedenkt das des 
durch die Hardware PWM kaum das Programm belastet.^^
Die ISR wird aber nicht oft genug ausgeführt. Das heißt ich kann den 
Servo mit dieser Ansteuerung nicht schnell fahren lassen. Im Momment 
bestimmt die Variable 'i' wie oft die ISR durchlaufen werden muss bis 
das nächste mal das OCR1A Register erhöht wird. 'i' kann aber nicht 
kleiner sein als 1, also    habe ich mir überlegt den mit dem Timer0 per 
CTC Modus einen Takt zu erzeugen mit dem dann immer das OCR1A Register 
erhöht wird. Ist das eine gute idee oder gibt es da noch eine bessere 
Lösung?

Auch wenn es nichts zum eigentlichen Thema beiträgt:

short i=0;

Globale Variable mit Namen i ist eine grandiose Idee;)

Karl Heinz hat doch geschrieben, wie es schneller geht: Indem Du den 
Wert nicht nur um eins erhöhst sondern einen größeren Wert (STEP).

Achso stimmt daran hab ich gar nimme dran gedacht das ich au die 
Schrittgröße verändern kann. Ok danke für den Hinweis Hans.

Ja klar möchte ich im fertigen Programm nicht solange fahren wie ich 
einen Taster gedrückt halte. Das ist ja nur ein einfaches Programm um 
die Servo Ansteuerung zu testen.
Das soll irgendwann mal wenn es eben so weit fertig ist einen Hexapod 
steuern (mit 18 Modellbauservos). Denn bisher läuft der Hexapod mit 
einem Atmega32. Dieser erzeugt mithilfe des Timer0 die 18 Servosignale 
Software mäßig(CTC-Modus). Jetzt möchte ich aber das Projekt erweitern 
und dazu will ich die Servos wahlweise schnell und langsam fahrn lassen 
können und auch die Position über den internen Potti der Servos abfragen 
können(über ADC). Bisher kann ich die Servos in 0,1ms Schritten 
anteuern. Das sind natürlich viel zu große Schritte um den Servo 
anständig langsam fahren zu lassen. Also habe ich mir überlegt ein 
Bussystem aufzubauen. Mit 6 atmega8 als Slave und jeder bekommt jeweils 
3 Servos zum ansteuern. Als Master nehm ich einen Atmega16/32 der dann 
den Slaves immer die positionen für die Servos schickt. Dann muss ein 
Chip nicht wie vorher die Signale für 18 Servos sondern nur noch für 3 
Servos erzeugen. Ein weiterer Vorteil des Bussytems ist das ich durch 
die Slaves viel mehr ADC Pins habe. Das Problem ist dann gleich gelöst. 
Meine aktuelle Planung war diese 6 atmega8 ihre drei Servos mit Soft PWM 
ansteuern zu lassen. Da das aber immer noch ein bisschen ruckelt, trotz 
einer Ansteuerung in 0,01ms Schritten, beim langsam fahren möchte ich 
doch auf die Hardware PWM umsteigen.
Problem hierbei ist allerdings das der atmega8 nur zwei Pins besitzt, 
die mit dem Timer1 also sprich mit einem 16bit verbunden sind
(8 bit Timer reicht nicht von der Auflösung). Das heißt im Endeffekt 
mehr Aufwand. Denn ich brauch anstatt 6 chip jetzt 9 (2 Servos pro 
chip). Das heist dann auch mehr Platinen und mehr Arbeit und mehr Geld. 
Darum wollte ich nun prüfen ob es sich lohnt auf die Hardware PWM 
umzusteigen.
Vielleicht habt ihr noch ein paar Ideen wie ich das lösen könnte. Hab 
mir schon überlegt anstatt ein atmega8 ein atmega1284p als Slave zu 
verwenden. Dieser Besitzt 4Pins die mit einem 16bit Timer verbunden 
sind. Der kostet aber beim pollin 6€ das Stück.
Hoffe das ich euch nicht zu sehr zu getextet hab und das mein Problem 
verständlich ist. Danke schon mal im voraus.

Also hab im Anhang mal des Programm mit der Ansteuerung, die mit 0,1ms 
Schritten arbeitet. Eben das Programm mit dem der Hexapod seither 
betrieben wird(ohne langsam Fahrt der Servos -> die fahren also immer 
Vollgas).
Zu groben Erklärung wie ich in deisem Programm die Signale erzeugt habe:
Also in der ISR wird die Variable i alle 0,1ms erhöt. Bei i=0 werden die 
ersten 6 Pins an denen Servos hängen auf high gesetzt und je nach 
Position einzeln wieder auf low. Das läuft dann bei den anderen Servos 
genauso (die nächsten 6 bei i=25 und die letzten 6 bei i=50) bis i 
wieder 0 ist. i wird immer bei 100 wieder auf 0 gesetzt -> das 
entspricht 100Hz.
Wenn ich alle auf einmal anteuern würde gehts nicht weil der chip zu 
langsam ist(sollte vielleicht erwähnen das der mit 16MHz läuft->also 
maximum). Mit zu langsam mein ich bevor alle if Befehle zum rücksetzten 
der Pins ausgeführt werden wird i wieder erhöht und der Pin bleibt 
solange high bis irgendwann mal zufällig die Zahl erwischt die er zum 
rüclsetzen braucht. Also das habe probiert und nur die ersten paar 
Servos fahren dann richtig und der Rest macht auser zucken nichts. Jetzt 
stell dir mal vor der timer läuft 10mal schneller (0,01ms Schritte).

Die Positionsabfrage der Servos will ich deshalb machen weil irgendwann 
soll des Ding sich ja auch Bewegen. Dazu muss bei einer sehr einfachen 
Bewegung das Bein angehoben werden, danach nach vorne bewegt werden und 
dann wieder abgesetzt werden. Also fang ich an mit Bein anheben. Die 
entsprechenden Servos benötigen jetzt aber Zeit diese neue Position 
anzufahren. Wie lange braucht er? Oder anderst gefragt wann ist er an 
der Soll position angekommen? Sprich wann kann der nächste Servo das 
Bein nach vorne Bewegen. Dies soll ja erst geschehen wenn das Bein oben 
ist und nicht früher aber auch nicht später. Bisher hab ich das so 
gelöst das immer ein Timer Takt den nächsten Schritt eingeleitet hat. 
Das ist aber ungenau und mir zu blöd. Vorallem wenn dann noch schnell 
langsam fahren dazu kommt. Oder mal komplexere Bewegungen realisiert 
werden sollen. Dann komm ich da eigentlich nicht um die Positionsabfrage 
rum wenn ich das anständig machen will.

Als nächstes kann ich noch sagen das die Ansteuerung des Servos mit 
16bit Timer WESENTLICH ruhiger ist als mit der Soft PWM und 0,001 
Schritte. Das liegt wahrscheinlich daran das ich bei so kleinen 
Schritten nicht alle 10 oder 20ms ein update mache sondern halt alle 
50-100ms.(je nach Geschwindigkeit).

...ups hab die datei vergessen^^

OK. Also ich muss ehrlich sagen das ich das Programm nicht so ganz 
verstehe, weil die alles mit so blöden #define dingern da machen. Dann 
muss man immer schauen was des jetzt bedeuten soll.  Wie funktioniert da 
genau die Signal Erzeugung. Vielleicht könnstest du mir das mal erklären 
oder einen stark vereinfachten Programm code für einen Servo schicken 
ohne die ganze #define Befehle.

....Achso. Also wenn ich das richtig verstehe machen die des so das die 
ein Pin von einem Servo auf high setzen und dann den Timer so einstellen 
das die interrupt routine nach der gewünschten Zeit für die Position 
also z.b. 1,5ms (für Mittelposition) wieder ausgeführt wird. Und dann 
wird der Pin gelöscht. Richtig?
Das is ja ne geile Idee. Gefällt mir richtig gut. Aber an den Bus werd 
ich trotzdem nicht vorbei kommen wegen der Positionsabfrage. Aber das 
macht ja auch nichts das war ja icht das Problem.

Jetzt hätt ich aber doch noch ein Bedenken und zwar wenn ich jetzt 
langsam fahren will dann warte ich ja nicht zum Beispiel um von Position 
ist (1,0ms)
auf Position soll (2,0ms) zu kommen eine millisekunde sondern ich fahr 
ja in kleinen schritten das bedeutet z.b. wie es jetzt beim 16bit 
Hardware Timer is 0,0005 ms Schritte. Dann würde ja auch die ISR, wenn 
ich es so mach wie auf der Seite von dem Link beschrieben, alle 0,5µs 
ausgeführt werden. Versteh ich das richtig so?
Dann hab ich doch wieder das Problem das die ISR viel zu oft ausgeführt 
wird und der Chip nebenher nichts mehr anderes tun kann oder nicht?

Natürlich stimmt. War ein Denkfehler von mir. Die Schrittgröße wird ja 
auf die Ist Position des Servos drauf addiert. Dann wäre also bei meinen 
Servos der kürzeste Zeitraum von ISR Aufruf bis zum nächsten ISR Aufruf 
0,6ms(ganz links)+"die schrittgröße(z.b. 0,5µs)" und nicht wie ich 
vorhin gedacht hab nur die Schrittgröße allein.
Und wenn ich in meinem Hexapod Projekt nur drei Servos pro chip zum 
ansteuerun hab, bau ich mir einfach einen "Leerlauf"(also ich mein ein 
Zeitraum in dem nichts angesteuert wird) ein, damit die Frequenz nicht 
zu hoch wird; oder meinst du das macht den servos nichts aus?
Dann kann der chip das ganze sogar so berechnen, dass die Frequenz immer 
die gleiche ist und abhänig von den einzelnen Impulslängen der Servos.
Wenn das jetzt so funktioniert wie ich mir das im Momment vorstell und 
überlegt hab dann ist richtig gut.

Vielen Dank Karl Heinz. Das hat mir sehr geholfen, denn ich glaub ich 
wäre mit den beiden Methoden(1.meine HW PWM, die zu viel Chips 
gebraucht hätte und 2. meine schlechte eigene Soft PWM -> sollte ich 
vielleicht auch noch dazu sagen das diese Programm vor einem Jahr 
entstanden ist, kurz nachdem ich mit C Programmierung und 
Mikrocontroller Programmierung begonnen hatte), die ich mir zu Beginn 
überlegt hatte nicht besonders glücklich geworden.

So. Hab jetzt mal ein Testprogramm geschrieben. Die Anteuerung 
funktioniert genauso wie in dem Link beschrieben ist. Nur hab ich noch 
etwas eingefügt das die Frequenz immer gleich halten soll. Weil sie ja 
sonst von den einzelnen Impulsen abhängt. Das macht zwar den Servos 
nichts aus aber wenn ich den Servo langsam fahren lasse, also jedesmal 
wenn die ISR ausgeführt die Positions variable erhöhe dann wird der 
Servo je näher er seinem Ziel kommt immer langsamer. Weil ja durch die 
längeren Impulse auch die Zeit zwischen den ISR Aufrufen erhöht wird und 
damit auch das Positions Update. Allerdings funktioniert das Programm 
nicht so wirklich.
Also die Überlegung ist sobald alle 8 Servo Signale einmal ausgegeben 
sind soll der Timer1 abgeschalten werden und der Timer0 die restliche 
bis 20ms (für 50Hz) so zu sagen füllen oder überbrücken. Also z.B. wenn 
jetzt alle Signale für die 8 Servos 1,5ms betragen, dauert es ja 12ms 
dann würde es wieder von vorne beginnen. Dann hätte ich aber eine 
Frequenz von über 50Hz. Jetzt kommt der Timer0 ins spiel. Der soll nach 
der letzten Signalausgabe gestartet werden und in diesem Falle 8ms 
laufen. In dieser Zeit soll dann kein Servo Singal ausgegeben werden. 
Wenn dann nach den 8ms der Timer1 wieder von vorne beginnt mit der 
Ausgabe der Signale habe ich genau die 50Hz.

Schaut euch mal das Programm an, vielleicht habt ihr ja noch andere 
Verbesserungsvorschläge oder findet noch mehr Fehler. Danke schon mal im 
Voraus.

Karl Heinz mal wieder Danke für die schnelle Antwort.  Aber ich versteh 
nicht ganz wie du das meinst. Timer1 macht die Pulse für die Servos und 
Timer 0 ist unter anderem dafür zuständig, dass die Servopositionen 
regelmässig korrekt und in der richtigen Geschwindigkeiten an die 
jeweilige Zielpositionen nachgeführt werden. Könntest du mir das 
vielleicht ein bisschen genauer erklären?