Hum. Roboterhand Part II: codeeffektive kontinuierliche Servoansteuerung

Alex schrieb:
> Wenn ich eine position vorgebe,
> fährt der servo ja mit maximaler geschwindigkeit an seine position - wie
> (geht das?) kann ich die geschwindigkeit verringern?

Ich habe zwar keine große Erfahrung bei der Ansteuerung von Servos.
Die Geschwindigkeit selber kann man jedenfalls nicht verringern.
Jedoch musst Du ja nicht die entgültige Endposition angeben, sondern 
Dich in kleinen Schritten dieser annähern. Aber das hast Du ja bereits 
so gemacht.

Du solltest Dich aber dringend über Timer schlau machen. Vor allem das 
Stichwort PWM ist hier wichtig. Denn damit macht der Prozessor das ganze 
Timing ohne große Programmierung selber.

Mit PWM musst Du nur noch eine Variable von der Istposition zur 
Sollposition durchzählen (eventuell mit einer gewissen Zeit zwischen den 
Schritten).

Geschwindigkeit von Modellbauservos ändern geht, wie Christian auch 
schon angemerkt hat, eigendlich nicht.

Was mich aber interessieren würde, wie steuerst du die Servos überhaupt 
an?

Ich würde einen internen 16bit Timer mit Output Capture verwenden um die 
PWM zu erzeugen.
Diese auf eine beliebige Anzahl kaskatierte 4017 Counter geben zum 
demultiplexen. Jeder Counter kann dabei 10 Servos bedienen.
Dazu reichen 2 Pins am AVR.

Alex schrieb:

> durch addition zum istzustandspuls verändere, (momentan mache ich die
> pulsweite über delay routinen weil ich mit dem internen timer noch nicht
> vertraut bin)

Das muss sich ändern.
Die Pulsausgabe an die Servos muss losgelöst von allem anderen 
funktionieren.

Hier mal Code, mit dem ich auf einem Mega128 mit 16Mhz 12 Servos 
ansteuere.
Dass die Servos auf PortF und PortC verteilt sind, hat keinen tieferen 
Grund, ausser dass auf meiner Platine die Anschlüsse günstig lagen.
Jeweils 6 Servos sind auf F und 6 Servos sind auf C.

1

#define F_CPU  16000000UL

2

3

#include <avr/io.h>

4

#include <avr/interrupt.h>

5

#include <util/delay.h>

6

7

#define SERVO_ANZAHL 12

8

9

#define CENTER 30

10

11

volatile uint8_t value[SERVO_ANZAHL] =

12

   { CENTER, CENTER, CENTER,

13

     CENTER, CENTER, CENTER,

14

15

     CENTER, CENTER, CENTER,

16

     CENTER, CENTER, CENTER

17

   };

18

19

ISR (TIMER2_COMP_vect) 

20

{

21

  static uint8_t ServoId = SERVO_ANZAHL;

22

23

  if( ++ServoId >= SERVO_ANZAHL )

24

    ServoId = 0;

25

26

  if( ServoId == 0 ) {

27

    PORTF = 0x01;

28

    PORTC = 0x00;

29

  }

30

  else if( ServoId < 6 )

31

    PORTF <<= 1;

32

33

  else if( ServoId == 6 ) {

34

    PORTF = 0x00;

35

    PORTC = 0x01;

36

  }

37

  else

38

    PORTC <<= 1;

39

40

  OCR2 = 57 + value[ServoId];  // die 57 sind der 'Zeitoffset' für ca. 1ms

41

}

42

43

44

void InitServo()

45

{

46

  TCCR2 = (1<<WGM21) | (1<<CS22);  //Prescale von 256 und CTC mode

47

  OCR2 = value[0];

48

  TIMSK |= (1<<OCIE2);

49

}

50

51

int main(void)

52

{

53

  uint8_t i;

54

55

  DDRF = 0xFF;

56

  DDRC = 0xFF;

57

58

  PORTF = 0x00;

59

60

//  TCCR0 =(1<<WGM01) |(1<<CS00)|(1<<CS01);

61

//  OCR0=125;

62

//  TIMSK|=(1<<OCIE0);

63

64

  InitServo();

65

66

  sei();

67

68

  ....

69

70

  // ab hier reicht es an value[x] einen neuen Wert zuzuweisen und

71

  // das jeweilige Servo Nr x. fährt in die Richtige Position

72

73

  ...

Die 12 Servos steuern die Beine eines Hexapods (daher auch 6+6 für die 
Servos der Ober- und der Unterarme).

Um zb einen Schritt auszuführen benutze ich zb

1

    for( i = 0; i < 10; ++i ) {

2

      // angehobene Beine nach vorne

3

4

      value[ 0] = CENTER + i;

5

      value[ 1] = CENTER - i;

6

      value[ 2] = CENTER + i;

7

      value[ 3] = CENTER + i;

8

      value[ 4] = CENTER - i;

9

      value[ 5] = CENTER + i;

10

      _delay_ms( 100 );

11

    }

mit dem delay stellt man dann die Geschwindigkeit ein. Die 
Pulsgenerierung selbst im Interrupt braucht so gut wie keine Zeit.

Michael L. schrieb:
> @Karl Heinz:
>
> Merkt man in der Praxis den Zeitversatz zwischen den einzelnen Servos?

Bei mir spielt das keine Rolle.

Im schlimmsten Fall ist die Pause zwischen den Updates eines Servos ja 
maximal
12 * 2ms = 24ms
gross. Also sogar relativ nahe an den 20ms die sonst so genommen werden.
Im besten Fall kriegt jedes Servo so alle 10ms einen neuen 
Positionspuls.

> Die bekommen ihr Steuersignal ja quasi nicht 'synchron', oder ist das
> kein Problem?

Macht ja nichts. In einer Fernsteuerung bekommen sie ja auch nicht alle 
gleichzeitig ihren jeweils nächsten Puls sondern reihum eines nach dem 
anderen. Genau daraus (und aus ein wenig Spielraum um den Anfang einer 
Sequenz bestimmen zu können) resultieren ja die 20ms in der 
Wiederholrate.

> Bzw. würdest du ab einer bestimmten Anzahl Servos da etwas
> in der Richtung vermuten?

Da musst du schon sehr viele Servos haben

Dass dein Code riesig wird, dürfte daran liegen, dass du eine 
_delay_us-() "Funktion" mit Nichtkonstanten aufrufst - hab ich Recht?

Das sind nämlich keine Funktionen, sondern Makros, die _always_inline_ 
in deinen Code eingebettet werden. Sprich: bei jeder Ausführung liegt 
dieses Stückchen Code wieder im Programmspeicher.
Das bläst natürlich deine Schleife mächtig auf.

Umgehen kannst du das Ganze, indem du z.B. folgende Funktion baust:

1

void warte_10us(unsigned char wartezeit)

2

{

3

   while(wartezeit)

4

   {

5

       wartezeit--;

6

       _delay_us(10);

7

   }

8

}

Davon darfst du jetzt aber keine präzise 10us Zeitbasis erwarten, weil 
neben der eigentlichen Wartezeit z.B. noch Sprünge zur 
Schleifenabarbeitung "Rechenzeit" brauchen.

Alex schrieb:
> (also zB _delay_ms(10+i) gemeint. Dann ist der code
> plötzlich nicht mehr 5 sonder 25% des vorhandenen flashes groß

Das ist genau das, was Michael H. schreibt:

Michael H. schrieb:
> Dass dein Code riesig wird, dürfte daran liegen, dass du eine
> _delay_us-() "Funktion" mit Nichtkonstanten aufrufst - hab ich Recht?

Hej! Cooles Projekt! Muss schon sagen!
Wie lange beschäftigst du dich schon mit der Hand?

@funky:
Kunststoff (nicht Plastik, denn Plastik ist PVC ;)) ist erst bei höheren 
Temperaturen verformbar.
PMMA (als Plexiglas/Acrylglas bekannt) ist ca ab 100-120°C verformbar.. 
also schon etwas "unangenehm" heißer :)

MfG
Philipp9494

ServoInteressierter schrieb:
^
> Ich habe Zweifel, ob man mit dieser Methode viele Servos gleichzeitig
> "weich" steuern kann. Sieht fuer mich so aus, als bekaeme alle
> nacheinander ihren Wert. Ist das in der Praxis dann gleichzeitig genug

Ich würde sagen: Wenn du einen Versatz von 20 bis 30 Millisekunden in 
den Sercobewegungen wahrnehmen kannst, dann bist du Superman.

Könnte das nicht doch auf Probleme rauslaufen bei z.B. einem recht 
komplexen Bein wo wirklich für flüssig aussehende Bewegung einige Servos 
drin sind.
Bei, ich sag mal ohne nachdenken 24, Servos addiert sich ein Versatz 
dann irgendwie doch schon und ich könnte mir bei der Modellierung einer 
Bewegung vorstellen, daß das mühsahm ausgeglichen werden muss?

Clemens M. schrieb:
> Könnte das nicht doch auf Probleme rauslaufen bei z.B. einem recht
> komplexen Bein wo wirklich für flüssig aussehende Bewegung einige Servos
> drin sind.
> Bei, ich sag mal ohne nachdenken 24, Servos addiert sich ein Versatz
> dann irgendwie doch schon und ich könnte mir bei der Modellierung einer
> Bewegung vorstellen, daß das mühsahm ausgeglichen werden muss?

Irgendwann ist natürlich Schluss, dass ist schon klar.
24 * 2 Millisekunden sind 48 Millisekunden, die im Extremfall 
zusammenkommen. 48 Millisekunden sind aber immer noch erst 5 Hunderstel 
Sekunden und das ist dann auch noch 'im schlimmsten Fall'.