32 Servos an Atmega328

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.

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 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?

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 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 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 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 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.

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 ...

1

R ___|_______________________________________________________________

2

3

T__________|____|___|_______|______|______|____|_____________________

4

      _____

5

S1 __|     |_________________________________________________________

6

            ____

7

S2 ________|    |____________________________________________________

8

                 ___

9

S3 _____________|   |________________________________________________

10

                     _______

11

S4 _________________|       |________________________________________

12

13

S5 ...

Gruß
Jobst

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.

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.

1

    for(sd_timer=0;sd_timer<SD_TIMER_TOP;sd_timer++)   /*10µs pro loop*/

2

    {

3

      SD_SLEEP;   /*timer weckt durch interrupt*/

4

      if(sd_timer >= val0) { IO_PWM_OUT_00_DIS; } else { IO_PWM_OUT_00_EN; }

5

      if(sd_timer >= val1) { IO_PWM_OUT_01_DIS; } else { IO_PWM_OUT_01_EN; }

6

      ...

7

      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

1

/*dieser INT reisst den µc aus dem schlaf*/

2

/*ACHTUNG !!! - Das ist eine pseudo-Interruptroutine*/

3

/*sie wird korrekt eingetragen, aber es werden keine Register gesichert*/

4

void TIMER1_COMPA_vect(void)

5

{

6

  asm("reti");

7

}

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.

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.

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 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 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

// 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");
     }
  }
}

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.

nimm einfach einen atmega2560, der hat genug freie pins.

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.