32 Servos an Atmega328

[Lukas D. (programmierer12)]

Hallo allerseits,
ich habe zur Zeit ein kleines Problemchen...
Ich möchte an einem Atmega328 32 Servos betreiben. Ich habe bereits 
etwas rechachiert und bin auf das Breakout des PCA9685 von Adafruit 
gestoßen was mir aber für fast 15€ zu teuer ist und ich eigentlich einen 
Chip auf einer Platine fest einsetzen möchte. Andere Überlegung wäre 
gewesen per SoftwarePWM und MCP23017 die Servos zu steuern, nur habe ich 
da keine Beispiele oder ähnliches gefunden wie das gehen soll.
Nun die Frage: hat vielleicht jemand von euch eine Ahnung oder eine Idee 
wie ich das am einfachsten hinbekommen kann?

MFG
Lukas

[Michael (Gast)]

SoftPWM und so viele Servos ist meist keine gute Idee.
Je nachdem was Dein System macht zittern die Servos wie Fliegen!

[Lukas D. (programmierer12)]

Ja das dachte ich mir eigentlich schon...
Es werden maximal 4 Servos gleichzeitig angetrieben. Ich denke da dürfe 
man nicht so große Probleme mit Geschwindigkeiten bekommen.

[Harry L. (mysth)]

Und warum willst du das bei Adafruit (aka Apotheke) kaufen?
http://www.ebay.de/itm/PCA9685-Servomotor-Driver-16-Kanal-Treiber-Modul-PWM-I2C-Arduino-Raspberry-/162533562184

[Robbe (Gast)]

Schon mal etwas gerechnet?
Glauben hilft da nich viel.

Mit etwas Programmiergeschick wird das zeitlich völlig unkritisch sein.
Nimm einfach 2 Atmegas damit Du genug portpins hast, billiger und 
straiter gehts nicht

[Robbe (Gast)]

Straight...

[Lukas D. (programmierer12)]

Robbe schrieb:
> Schon mal etwas gerechnet?
> Glauben hilft da nich viel.
>
> Mit etwas Programmiergeschick wird das zeitlich völlig unkritisch sein.
> Nimm einfach 2 Atmegas damit Du genug portpins hast, billiger und
> straiter gehts nicht

Du meinst zwei Atmegas per Seriell kommunizieren lassen?

[Martin S. (led_martin)]

Da der Servo-Impuls deutlich kürzer ist, als die Periodendauer, kann man 
das Ausgangssignal von einem Hardware PWM-Ausgang per Dekoder, im 
Zeitmultiplex, auf mehrere Servos verteilen. Das würde auch das Problem 
lösen, das der ATmega328 gar keine 32 Signalausgänge hat. Wobei solche 
Aufgaben mit Software-PWM durchaus lösbar sind, auch ohne Zittern der 
Servos, wenn man entsprechend gut programmieren kann. Wenn Du mit 20ms 
Periodendauer (ist ein gängiger Wert) arbeiten willst, kannst Du gerade 
so 8 Servos (max. 2,5ms Impuls) aus einem PWM-Ausgang bedienen. Die 
Arbeit auf mehrere, eventuelle recht kleine (z.B. ATtiny), 
Mikrocontroller zu verteilen, wäre vielleicht auch noch eine 
Möglichkeit.

Mit freundlichen Grüßen - Martin

[Robbe (Gast)]

Lukas D. schrieb:
> Robbe schrieb:
>> Schon mal etwas gerechnet?
>> Glauben hilft da nich viel.
>>
>> Mit etwas Programmiergeschick wird das zeitlich völlig unkritisch sein.
>> Nimm einfach 2 Atmegas damit Du genug portpins hast, billiger und
>> straiter gehts nicht
>
> Du meinst zwei Atmegas per Seriell kommunizieren lassen?

Wie auch immer, die Stellwerte kommen doch irgendwo her.

[Robbe (Gast)]

Das wird auch völlig trivial mit einfachen Schieberegistern 
funktionieren.
Nimm mal Papier und Bleistift zur Hand und erstelle ein Konzept.

[Dr. Sommer (Gast)]

Martin S. schrieb:
> Die Arbeit auf mehrere, eventuelle recht kleine (z.B. ATtiny),
> Mikrocontroller zu verteilen, wäre vielleicht auch noch eine
> Möglichkeit.

Viel zu kompliziert. Man nimmt einfach einen Controller der genug 
Hardware PWM Channel hat, wie zB diverse STM32.

[Robbe (Gast)]

Außerdem benötigt der Servo PPM nicht PWM.

Welche Plattform Du nutzt hängt von deinen Kenntnissen ab, Hardware wie 
Software.

Arduino unterstützt, meine ich, bis zu 12 Servos an beliebigen Pins.

[Lukas D. (programmierer12)]

Robbe schrieb:
> Außerdem benötigt der Servo PPM nicht PWM.
>
> Welche Plattform Du nutzt hängt von deinen Kenntnissen ab, Hardware wie
> Software.
>
> Arduino unterstützt, meine ich, bis zu 12 Servos an beliebigen Pins.

Also ich denke die Hardware wäre nicht das Problem nur Software bin ich 
in c nicht grad auf der Höhe.
Noch habe ich alle Projekte mit der Arduino Plattform realisieren 
können...

[Wolfgang (Gast)]

Jeweils 8 Servos kann man doch einfach bedienen, indem man eine "1" 
durch ein Schieberegister schiebt und den Abstand der Taktflanke 
entsprechend der jeweils gewünschten Servopulslänge wählt. Dann braucht 
man als µC auch keinen "100-Füßler".

[Peter D. (peda)]

Wolfgang schrieb:
> indem man eine "1"
> durch ein Schieberegister schiebt

Und wenn man den Takt mit nem PWM-Pin erzeugt, hat man auch keinen 
Jitter durch andere Interrupts.

[Markus (Gast)]

>Noch habe ich alle Projekte mit der Arduino Plattform realisieren
>können...
https://www.arduino.cc/en/Reference/Servo

Die Servo-Library kann scheinbar 12 Servos ansteuern. Du bräuchtest also 
3 Arduino Nanos über eine Schnittstelle verbunden.

Was spricht gegen Multiprozessing?

[Harry L. (mysth)]

Markus schrieb:
> Du bräuchtest also
> 3 Arduino Nanos über eine Schnittstelle verbunden.
>
> Was spricht gegen Multiprozessing?

So einen Schwachsinn können sich auch nur "Arduidioten" ausdenken....

Die PCA9685 waren schon der richtige Ansatz.

[Markus (Gast)]

>Die PCA9685 waren schon der richtige Ansatz.

Das hängt alles von dem Anspruch an den Optimierungsgrad und den genauen 
Anforderungen ab.
Zwei PCA9685 kosten ca. 30 Euro
https://www.adafruit.com/product/815
3 Arduino Nano vom Chinesen kann man für unter 10 Euro erwerben.

>So einen Schwachsinn können sich auch nur "Arduidioten" ausdenken....
Solche Sprüche lassen die Dumpfbacken (TM) im MC-Netz gerne mal los
( ist scheinbar schon seit 2006 aktiv:
Beitrag "Re: Programmierbarer Widerstand?" )

Ich weiß, bei einer Vielzahl an Lösungsmöglichkeiten eines Problems 
kommt eine Dumpfbacke schnell an die Grenzen ihres geistigen Horizonts.

[Harry L. (mysth)]

Markus schrieb:
> Zwei PCA9685 kosten ca. 30 Euro

Wie kommst du da drauf?
http://www.ebay.de/itm/PCA9685-Servomotor-Driver-16-Kanal-Treiber-Modul-PWM-I2C-Arduino-Raspberry-/162533562184

Mit etwas Suche findet man die auch noch erheblich billiger.

[Jobst M. (jobstens-de)]

Der 4017 ist der richtige Baustein. Mit dem wurden früher auch die 
Signale der Mehrkanalfernbedienungen auf Servos verteilt.
Mit 5 Leitungen kann man so bequem 32 Servos ansteuern.

Reset aller Bausteine bei 0, wenn die On-Zeit für Servo 1 abgelaufen 
ist, Taktimpuls und die On-Zeit für Servo 2 startet. Wenn die abgelaufen 
ist, wieder einen Taktimpuls und On-Zeit für Servo 3 startet ...

R ___|_______________________________________________________________

T__________|____|___|_______|______|______|____|_____________________
      _____
S1 __|     |_________________________________________________________
            ____
S2 ________|    |____________________________________________________
                 ___
S3 _____________|   |________________________________________________
                     _______
S4 _________________|       |________________________________________

S5 ...

Gruß
Jobst

[Wolfgang (Gast)]

Harry L. schrieb:
> Die PCA9685 waren schon der richtige Ansatz.

8-Bit Auflösung für die Servo-Pulsbreite ist nicht so der Bringer, aber 
möglicherweise reicht das für die angedachte Anwendung.

[Lukas D. (programmierer12)]

Danke schonmal für die ganzen Hilfestellungen. Ich werde jetzt erstmal 
die Möglichkeit mit dem 4017 testen und alternativ das China Board mit 
dem PCA9685 im Auge behalten.

[Zum abschreiben (Gast)]

http://www.photopete.com/swarm/arduino/

[Rangi J. (rangi)]

Also ich habe 24 Servos an einem Mega8515 mit 8Mhz hängen, das geht ganz 
gut.
Ich habe die Servos erstmal in 4 Gruppen aufgeteilt. Für jede Gruppe 
werden die Werte der PWM immer neu vergleichen und gesetzt.
Dann einen Timer verwendet, der die Zeit per Output-Compare auflöst. Um 
die einzelenen Schritte auszurechnen, lasse ich den Timer alle 10µs 
einen Interrupt erzeugen. Dieser beendet dadurch einen Sleep-Befehl. Der 
Code läuft dadurch synchron.

    for(sd_timer=0;sd_timer<SD_TIMER_TOP;sd_timer++)   /*10µs pro loop*/
    {
      SD_SLEEP;   /*timer weckt durch interrupt*/
      if(sd_timer >= val0) { IO_PWM_OUT_00_DIS; } else { IO_PWM_OUT_00_EN; }
      if(sd_timer >= val1) { IO_PWM_OUT_01_DIS; } else { IO_PWM_OUT_01_EN; }
      ...
      if(UCSRA & (1<<RXC)) sio_in_buffer[bptr++]=UDR;   /*Schnittstelle lesen*/

In den Pausen zwischen den 4 Gruppen wird die Position der Servos neu 
berechnet und Kommunikation am laufen gehalten.
Ein paar Sachen muss man optimieren, z.B. die ISR

/*dieser INT reisst den µc aus dem schlaf*/
/*ACHTUNG !!! - Das ist eine pseudo-Interruptroutine*/
/*sie wird korrekt eingetragen, aber es werden keine Register gesichert*/
void TIMER1_COMPA_vect(void)
{
  asm("reti");
}

Eine andere Idee ist, wenn nicht alle Servos gleichzeitig laufen müssen, 
kann man die Servos auch nur dann anschalten, wenn sie gebraucht werden, 
also PWM ausschalten. Dann bleiben sie stehen und werden durchs die 
Getriebe-Übersetzung gehalten. Das sollte man sowieso machen, da ein 
Servo, der immer gegen einen Anschlag drückt warm wird. Deswegen ist bei 
mir mal ein Servo richtig abgebrannt. Durch die Erwärmung verstellt sich 
bei einfachen Typen der Winkel und das kann das Problem verschlimmern.

[Stefan F. (Gast)]

Verteile das auf mehrere Mikrocontroller. Ohne großartige Klimmzüge sind 
10 Servos an einem ATtiny möglich. Nimm vier davon und verbinde sie per 
I2C oder irgend einer anderen seriellen Schnittstelle mit deinem ATmega.

Das Auslagern des zeitkritischen Teils auf separate Controller 
verinfacht auch die Programmierung ganz erheblich.

Zum abgucken: http://stefanfrings.de/servocontroller/index.html

[Stefan F. (Gast)]

> 8-Bit Auflösung für die Servo-Pulsbreite ist nicht so der Bringer

Das dachte ich auch mal. Aber in der Praxis wirst du zwischen 16bit und 
8bit keinen Unterschied bemerken. So genau arbeiten die Dinger ohnehin 
nicht.

[Stefan F. (Gast)]

> Du bräuchtest also 3 Arduino Nanos über eine Schnittstelle verbunden.
> Was spricht gegen Multiprozessing?

Nichts.

> So einen Schwachsinn können sich auch nur "Arduidioten" ausdenken....

Das halte ich ganz und gar nicht für Schwachsinn. Mit Welcher Begründung 
kommst du zu dieser krassen Bemerkung?

> Zwei PCA9685 kosten ca. 30 Euro
> Wie kommst du da drauf? ... (Vorschlag für 2x 5,99)

Arduino Nanos sind immer noch bedeutend billiger, falls es noch keiner 
gemerkt hat. Und die von mir vorgeschlagenen ATtinies kosten bei 
Reichelt noch weniger, und man muss nicht 6 Wochen auf die Lieferung 
warten oder gar zum Zoll fahren.

[Harry L. (mysth)]

Tja, wenn man nicht programmieren kann, nimmt man eben für jede popelige 
Funktion einen eigenen µC - typisch Arduino-Jünger

Dabei vergessen sie meist, daß das Kommunikationsprotokoll zwischen den 
µCs für diese Anfänger i.d.R. die viel grössere Hürde darstellt.

Man muß auch keine 6 Wo. auf den PCA9685 warten.
Mein Link zeigt auf einen deutschen Händler, und da hat man die Teile 
i.d.R. innerhalb von 2-3 Tagen.

[Lukas D. (programmierer12)]

Stefan U. schrieb:
> Verteile das auf mehrere Mikrocontroller. Ohne großartige Klimmzüge sind
> 10 Servos an einem ATtiny möglich. Nimm vier davon und verbinde sie per
> I2C oder irgend einer anderen seriellen Schnittstelle mit deinem ATmega.
>
> Das Auslagern des zeitkritischen Teils auf separate Controller
> verinfacht auch die Programmierung ganz erheblich.
>
> Zum abgucken: http://stefanfrings.de/servocontroller/index.html

Die Lösung klingt nach einem wirklich interessanten Ansatz...
Ich glaube das werde ich mal probieren müssen ;)

[Stefan F. (Gast)]

> Dabei vergessen sie meist, daß das Kommunikationsprotokoll zwischen
> den µCs für diese Anfänger i.d.R. die viel grössere Hürde darstellt.

Warum hast du (Harry L) dann den PCA9685 vorgeschlagen?

> Tja, wenn man nicht programmieren kann, nimmt man eben für jede
> popelige Funktion einen eigenen µC

Na und, Hauptsache, die Bastelei funktioniert an Ende.

Ich denke, es wird auch schwierig sein, eine 1-Chip Lösung in Handarbeit 
zu verarbeiten. Da werden ziemlich viele Leitungen sternförmig zum µC 
zusammen laufen. Eine dezentrale Lösung mit I2C Bus und kleineren IC's 
lässt sich viel leichter handhaben.

[Harry L. (mysth)]

Stefan U. schrieb:
>> Dabei vergessen sie meist, daß das Kommunikationsprotokoll zwischen
>> den µCs für diese Anfänger i.d.R. die viel grössere Hürde darstellt.
>
> Warum hast du (Harry L) dann den PCA9685 vorgeschlagen?
>
>> Tja, wenn man nicht programmieren kann, nimmt man eben für jede
>> popelige Funktion einen eigenen µC
>
> Na und, Hauptsache, die Bastelei funktioniert an Ende.
>
> Ich denke, es wird auch schwierig sein, eine 1-Chip Lösung in Handarbeit
> zu verarbeiten. Da werden ziemlich viele Leitungen sternförmig zum µC
> zusammen laufen. Eine dezentrale Lösung mit I2C Bus und kleineren IC's
> lässt sich viel leichter handhaben.

Merkst du gar nicht, wie du dir widersprichst?
Oder kennst du einfach den PCA9685 nicht?

Aber Hauptsache man gibt seinen Senf dazu....

[Stefan F. (Gast)]

Der PCA9685 wird über eine I2C Schnittstelle angesteuert.

Du hast argumentiert, "daß das Kommunikationsprotokoll zwischen den
µCs für diese Anfänger i.d.R. die viel grössere Hürde darstellt."

Dann sollte man "diesem Anfänger" doch wohl eher nicht diesen Chip 
empfehlen, oder?

Ich würde ihm allerdings schon dazu raten, sich mit dem I2C Protokoll zu 
beschäftigen, denn ich finde den von Dir vorgeschlagenen Chip für diesen 
Fall sehr gut. Ich habe ja auch nicht von I2C abgeraten.

[AntiMaker (Gast)]

Stefan U. schrieb:
> Dann sollte man "diesem Anfänger" doch wohl eher nicht diesen Chip
> empfehlen, oder?

Warum? für den PCA gibt's das Kommunikationsprotokoll über I2C fix und 
fertig implementiert als Arduino-Bibliothek. Ziemlich Deppen- und 
Maker-Sicher.

https://github.com/adafruit/Adafruit-PWM-Servo-Driver-Library


Bei einer eigenen Multi-µC-Lösung muss er selber ein Protokoll entwerfen 
und implementieren.

[Stefan F. (Gast)]

> für den PCA gibt's das Kommunikationsprotokoll über I2C fix und
> fertig implementiert als Arduino-Bibliothek.

> Bei einer eigenen Multi-µC-Lösung muss er selber ein Protokoll
> entwerfen und implementieren.

Ich stimme Dir zu.

[Markus (Gast)]

>Bei einer eigenen Multi-µC-Lösung muss er selber ein Protokoll entwerfen
>und implementieren.

Wahrscheinlich ein kaum zu lösende Aufgabe,

#include <Servo.h>

#define PIN_SERVO0 8
#define PIN_SERVO1 9
#define PIN_SERVO2 10

Servo servo0;
Servo servo1;
Servo servo2;

void setup()
{
  servo0.attach(PIN_SERVO0);
  servo1.attach(PIN_SERVO1);
  servo2.attach(PIN_SERVO2);
    
  Serial.begin(115200);
  while (!Serial) {
    ; // wait for serial port to connect. Needed for native USB port only
  }
}

uint8_t getChar()
{
  while (Serial.available() == 0);
  return Serial.read();
}

void loop()
{
  uint8_t c = 0;
  uint8_t servoNumber;
  uint8_t servoVal;

  do
  {
    c = getChar();
  } while (c != 's');
  
  servoNumber = getChar();
  servoVal    = getChar();

  if(servoNumber==0) servo0.write(servoVal);
  if(servoNumber==1) servo1.write(servoVal);
  if(servoNumber==2) servo2.write(servoVal);


}

[Stefan F. (Gast)]

Ähnlich simpel ist auch meine Lösung mit dem ATtiny, die wire Library 
von Arduino macht es einem leicht:

Wire.beginTransmission(0x1E); // adresse
Wire.write(94); // erster Servo in die Mitte
Wire.write(94); // zweiter Servo in die Mitte
Wire.write(125); // dritter Servo nach rechts
Wire.write(62); // vierter Servo nach links
Wire.endTransmission();

[Markus (Gast)]

OK, kann man auch machen. Je nachdem, welche Schnittstelle man 
bevorzugt.
Bei der seriellen wäre es eine Eindrahtschnittstelle: TX

Interessant wäre vielleicht auch die Verwendung eines BluePills:
http://wiki.stm32duino.com/index.php?title=Blue_Pill

Der hat mehr Pins, damit könnte man vielleicht auch 16 Servos betreiben, 
wenn das mit 3.3V geht.

[Stefan F. (Gast)]

> wenn das mit 3.3V geht.

Hat bei mir bisher immer geklappt.

[Stefan F. (Gast)]

Eine Korrektur:

Wire.beginTransmission(0x0F); // 7bit Adresse
Wire.write(94); // erster Servo in die Mitte
Wire.write(94); // zweiter Servo in die Mitte
Wire.write(125); // dritter Servo nach rechts
Wire.write(62); // vierter Servo nach links
Wire.endTransmission();

Ich habe den Schaltplan schön gezeichnet:
http://stefanfrings.de/servocontroller/schematics.png

Die Firmware kannst du als hex File runterladen.
http://stefanfrings.de/servocontroller/ServoController.zip

Du wirst noch einen ISP Programmieradapter brauchen. Zur Not eignet sich 
dazu ein Arduino mit dem ISP Sketch.

Ich würde die Variante mit ATtiny2313 bevorzugen, da dieser mehr Pins 
zur Adress-Codierung bereit stellt.

[Frank K. (fchk)]

Stefan U. schrieb:

>> Zwei PCA9685 kosten ca. 30 Euro
>> Wie kommst du da drauf? ... (Vorschlag für 2x 5,99)
>
> Arduino Nanos sind immer noch bedeutend billiger,

Also bei Digikey kosten PCA9685PW 2.03€ aktuell. Und wer keine PCB 
machen will, findet unter 1528-1068-ND ein Dreierpack TSSOP28->DIL28 
Breakout-Boards für 4.34€.

Und alles lieferbar.

fchk

[Stefan F. (Gast)]

Ich finde ziemlich krass, wie unterschiedlich die Verkaufpreise dieser 
Chips sind.

Wenn man die bisherigen Vorschläge so anschaut, scheint I2C schonmal 
fest zu stehen.

[Horst S. (h3aau)]

// hier mal das ganze über den Timer. es können alle Pins verwendet 
werden.
String cmd="";
String sservo="";
char fbuffer[100];
unsigned int xxx=123;
unsigned int yyy=00;

#define IndexMax 6                          // Anzahl der servos
#define ServoMIN 500                       // Mittelwert des Servos in 
usec
#define ServoMAX 2500                       // Mittelwert des Servos in 
usec
#define ServoHome 1500                      // Mittelwert des Servos in 
usec
#define INTERVAL 20000                      // 20ms
//int S[IndexMax]={A3,A2,A1,A0,A4,A5};          // Pins für die Servos;
int S[IndexMax]={A3,A2};          // Pins für die Servos;
volatile int W[IndexMax];                            // Impulswerte der 
Servos in usec
volatile int  Index=0;                      // Zeiger auf Servo/Daten
volatile int  Index1=0;                     // Zeiger auf Servo/Daten

void Servo_init(void)
{
  int i;
  for (i=0;i<IndexMax;i++)
    {
    pinMode(S[i], OUTPUT);    // Pins als Ausgang definieren
    W[i]=ServoHome;           // vorbelegung der Servos
    sprintf(fbuffer, "Pin %i ist Servo %i",S[i],i);
    Serial.println(fbuffer);
    }

// Timer 1
  noInterrupts();           // Alle Interrupts temporär abschalten
  TCCR1A = 0;               // Register löschen
  TCCR1B = 0;               // Register löschen
  TCNT1 = 100000;           // Timer vorbelegen, beliebig
  TCCR1B |= (1 << CS11);    // 8 als Prescale-Wert = 500nsec Takt
  TIMSK1 |= (1 << TOIE1);   // Timer Overflow Interrupt aktivieren
  interrupts();             // alle Interrupts scharf schalten
}

ISR(TIMER1_OVF_vect)               // Interrupt Timer/Counter1 OVERFLOW
{
int i,T1wert;
  digitalWrite(S[Index1],LOW);     // aktuellen Servo abschalten
  if (Index<IndexMax)
     {
     digitalWrite(S[Index],HIGH);  // neuen Servo anschalten
     T1wert=65535-(W[Index]*2);    // anzahl der Takte berechnen
     Index1=Index;
     Index++;
     }
  else
     {
     Index=0;
     T1wert=65535-(INTERVAL*2);
     for (i=0;i<IndexMax;i++) T1wert+=(W[i]*2);
     }
  TCNT1H = (uint8_t) (T1wert >>8 );  // Timer mit neuer Impulszeit 
starten
  TCNT1L = (uint8_t) (T1wert     );
}

void setup()
{
  // put your setup code here, to run once:
  Serial.begin(115200);
  Serial.println("Starting...");
  Servo_init();
}


void loop() {

int i;

  if (Serial.available() > 0)
  {
    cmd = Serial.readStringUntil(10);
    Serial.println(cmd);




    //Serial.print("Moving Servo to: ");
    //Serial.println(cmd);

    //2-120
    sservo = cmd.substring(0,1);
    cmd = cmd.substring(2);
    yyy=sservo.toInt();
    xxx=cmd.toInt();

    if ((xxx >= ServoMIN) && (xxx <= ServoMAX) && (yyy < IndexMax))
      {
      sprintf(fbuffer, "Moving servo %2d to %3d test",yyy, xxx);
      Serial.println(fbuffer);
      W[yyy]=xxx;
      }
    else
      {
      Serial.println("Value out of range");
     }
  }
}

[Stefan F. (Gast)]

> hier mal das ganze über den Timer

Toll, noch eine Variante davon. Und so Zeitnah. Wie steuerst du damit 32 
Servos?

Mein vor 3 Monaten genannter Vorschlag konnte schon 10 Servos ansteuern 
und lässt sich immer noch ganz leicht auf 20 erweitern.

Wir waren aber schon längst bei der Erkenntnis, dass dieser PCA9685 die 
bessere Wahl ist.

[m.n. (Gast)]

Horst S. schrieb:
> TCNT1 = 100000;           // Timer vorbelegen, beliebig

Das merkt man ;-)

[Peter D. (peda)]

Jobst M. schrieb:
> Der 4017 ist der richtige Baustein.

Nö.
Der kann nur 9 Servos ansteuern und läßt sich nicht kaskadieren.

Besser nimmt man daher 4 Stück 74HC164 kaskadiert. Die brauchen 
insgesamt 2 Outputs des MCs, wovon der Takt ein Compare-Output ist, 
damit jitterfrei.
Der Timerinterrupt lädt dann den nächsten Servowert aus nem 32Byte-Array 
nach und schiebt bei jedem ersten Wert das 1Bit raus.

[Horst S. (h3aau)]

nimm einfach einen atmega2560, der hat genug freie pins.

[Retro N. (retronerd)]

Mit einem ATMega328 kannst Du keine 32 Servos direkt ansteuern, 8 via 
Multiplexing aber schon:
https://www.mikrocontroller.net/articles/Modellbauservo_Ansteuerung#Signalerzeugung_f.C3.BCr_mehrere_Servos_mittels_Timer_.28C.29

Das kannst Du dann mit einem 24 Channel Breakout-Board

https://eckstein-shop.de/Adafruit-24-Channel-12-bit-PWM-LED-Driver-SPI-Interface?curr=EUR&gclid=EAIaIQobChMIpd74g9WY1wIVyqgYCh0UQQCzEAQYAiABEgIm5_D_BwE

kombinieren, denn der 328 hat bei der Ansteuerung per SPI sowieso nix zu 
tun. Zusammen mit einem Arduino Nano Clone liegst Du dann bei unter 20 
EUR.

[Stefan F. (Gast)]

> Mit einem ATMega328 kannst Du keine 32 Servos direkt ansteuern,
> 8 via Multiplexing aber schon

8 ist aber wenig. Mein Code steuert mittels Multiplexing 10 Servos mit 
einem Timer an. Der ATMega328 hat 3 Timer, was demnach für 30 Servos 
reicht. So viele I/O Pins hat der Chip aber gar nicht.

http://stefanfrings.de/servocontroller/index.html