Servomotor steuern - C Routine von dieser Seite

[Jan H. (janiiix3)]

Guten Morgen,

Ich habe hier eine Routine gefunden, um einen Servomotor zu steuern. Das 
klappt bis jetzt auch ziemlich gut.
Nur löst der leider nicht fein genug auf für meine Zwecke.
Ich benutze einen : BMS-630MG und steuere diesen mit einem MEGA32U4.

Diese Routine verwende ich. Der Quarz ist auf 16MHz festgelegt.

//https://www.mikrocontroller.net/articles/Modellbauservo_Ansteuerung#Signalerzeugung_f.C3.BCr_mehrere_Servos_mittels_Timer_.28C.29

//
// Programm fuer einen ATmega32U4
//
#define F_CPU 16000000UL

#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/delay.h>

//
// Der Prescaler muss so gewählt werden, dass der Ausdruck
// für MILLISEC_BASE einen Wert kleiner als 128 ergibt
// MILLISEC_BASE ist der Timerwert, der 1 Millisekunde Zeitdauer ergeben
// soll.
//
#define PRESCALER      1024
#define PRESCALER_BITS (1<<CS02 | 1<<CS00)

#define MILLISEC_BASE  ( F_CPU / PRESCALER / 1000 )
#define CENTER         ( MILLISEC_BASE / 2 )


#define NR_SERVOS      8
#define SERVO_DDR      DDRD
#define SERVO_PORT     PORTD

uint8_t ServoPuls[NR_SERVOS] = { 
                 1<<PD0,
                 1<<PD1, 
                 1<<PD2, 
                 1<<PD3,
                 1<<PD4, 
                 1<<PD5, 
                 1<<PD6, 
                 1<<PD7 
                };

volatile uint8_t ServoValue[NR_SERVOS];

ISR (TIMER0_COMPA_vect)
{
  static uint8_t ServoId = 0;
  
  SERVO_PORT &= ~ServoPuls[ServoId];
  
  if( ++ServoId >= NR_SERVOS )
  {
    ServoId = 0;    
  }

  SERVO_PORT |= ServoPuls[ServoId];
  
  OCR0A = MILLISEC_BASE + ServoValue[ServoId];
}

void InitServo()
{
  uint8_t i;
  
  SERVO_DDR = (ServoPuls[0] | ServoPuls[1] | ServoPuls[2] | ServoPuls[3] | ServoPuls[4] | ServoPuls[5] | ServoPuls[6] | ServoPuls[7]);
  
  OCR0A   = MILLISEC_BASE + ServoValue[0];
  TIMSK0 |= (1<<OCIE0A);          // OutputCompareMatchEnable
  TCCR0A  = (1<<WGM01);          // CTC mode
  TCCR0B  = (PRESCALER_BITS);        // Prescaler
}

int main(void)
{
  InitServo();
  
  sei();
  
  while( 1 )
  {  
                            // ZUM TEST
    for (uint8_t x = 0 ; x < CENTER * 2 ; x++)
    {
      ServoValue[1] = x;

    }
  }
}

[Karl H. (kbuchegg)]

Jan H. schrieb:

> Nur löst der leider nicht fein genug auf für meine Zwecke.

> //
> // Der Prescaler muss so gewählt werden, dass der Ausdruck
> // für MILLISEC_BASE einen Wert kleiner als 128 ergibt
> // MILLISEC_BASE ist der Timerwert, der 1 Millisekunde Zeitdauer ergeben
> // soll.
> //
> #define PRESCALER      1024
> #define PRESCALER_BITS (1<<CS02 | 1<<CS00)
>
> #define MILLISEC_BASE  ( F_CPU  PRESCALER  1000 )

Das wundert mich nicht, dass du da kaum Auflösung hast. Wenn ich das mal 
mit 16 Mhz durchrechne, dann erhalte ich

16000000 / 1024 -> 15625
15625 / 1000 -> 15

D.h. dein Servo steht bei einem Wert von ca 7 in der Mittelstellung und 
du kannst es gerade mal +- 7 Positionen links bzw. rechts aus dieser 
Mittelstellung rausfahren.

Aber der Timer kann ja auch noch andere Prescaler.
Zum Beispiel einen Prescaler von 256.

Dann würde sich für MILLISEC_BASE immerhin schon ein Wert von

16000000 / 256 -> 62500
62500 / 1000  -> 62

ergeben. Sie Servomittelstellung wäre dann schon bei 31 und du hättest 
links und rechts jeweils 31 anfahrbare Servopositionen.

Der nächst kleinere Prescaler wäre 64. Würde der auch noch gehen?

16000000 / 64   -> 250000
250000 / 1000 -> 250

250 ist schon zu gross. Die Bedingung im Servocode lautet: kleiner als 
128 und das ist nicht erfüllt.

Ohne also den Timer auf einen CTC Modus umzustellen, ist ein Prescaler 
von 256 das Maximum.

#define PRESCALER      256
#define PRESCALER_BITS (1<<CS02)

wenn du noch feiner auflösen willst, müsste man entweder einen der 16 
Bit Timer opfern oder für den 8 Bit Timer mit einem CTC Modus arbeiten 
um sich in der Berechnung so nahe wie möglich an die 128er Grenze 
heranzutasten.

[Karl H. (kbuchegg)]

Karl H. schrieb:

> Der nächst kleinere Prescaler wäre 64. Würde der auch noch gehen?
>

> 16000000 / 64   -> 250000
> 250000 / 1000 -> 250
>

> 250 ist schon zu gross. Die Bedingung im Servocode lautet: kleiner als
> 128 und das ist nicht erfüllt.

Wobei:
Wenn man die ISR überarbeitet und den Puls auf 2 Interrupt Aufrufe 
verteilt, wäre auch das noch machbar, wenn es sonst keine anderen 
Interrupts im System gibt.

[Jan H. (janiiix3)]

Moin,

vielen dank für deine Antwort.
Der 16 Bit Timer ist bis jetzt ohne Nutzung und könnte für diesen Fall 
ruhig herangezogen werden.

Die Berechnung sollte ja fast die gleiche sein.

Da ich zum ersten mal mit Servos arbeite, habe ich noch eine Frage.
Den Servo kann ich manuel mit der Hand nen stückchen weiter drehen als 
ich es mit der Software hinbekomme. Ist das normal ?
Habe es auch hart mal mit delay versucht...

[Thomas W. (Gast)]

Jan H. schrieb:
> Den Servo kann ich manuel mit der Hand nen stückchen weiter drehen als
> ich es mit der Software hinbekomme. Ist das normal ?

Ja, sonst könnte es passieren, dass er bei entsprechenden Steuerpulsen 
in den mechanischen Anschlag fährt und den Motor nicht abschaltet, weil 
er seine Sollposition noch nicht erreicht hat.

[Karl H. (kbuchegg)]

Jan H. schrieb:
> Moin,
>
> vielen dank für deine Antwort.
> Der 16 Bit Timer ist bis jetzt ohne Nutzung und könnte für diesen Fall
> ruhig herangezogen werden.
>
> Die Berechnung sollte ja fast die gleiche sein.

Ja. Ist genau die gleiche.
Nur hast du nicht mehr das Limit aufgrund des Zählumfangs des Timers, 
dass du für 1 Millisekunde einen errechneten Wert kleiner 128 haben 
musst, sondern du kannst den Prescaler soweit verkleinern, bis du einen 
maximalen Millisekundenwert von 32767 hast. Dann hast du massenhaft 
Servopositionen, die das Servo mechanisch wahrscheinlich gar nicht mehr 
exakt anfahren kann :-)

[Jan H. (janiiix3)]

Damit stelle ich jetzt aber nur den Puls (High Zeit) ein oder ? Wie 
generiere ich denn meine ~ 20 ms. Pause ?

Nachtrag:

Habe mir gerade noch einmal den Artikel durchgelesen, es ist also nicht 
"wirklich" wichtig, dass eine Pause von ca. 20 ms. eingehalten wird.

Also ist es wirklich nur wichtig, wenn ich eine möglichst feine 
Positions Auflösung haben will, die Zeit so fein auf zu lösen wie es 
geht (was der Servo halt so mit macht), richtig ?

[Jan H. (jan_m_h)]

Jan H. schrieb:
> Habe mir gerade noch einmal den Artikel durchgelesen, es ist also nicht
> "wirklich" wichtig, dass eine Pause von ca. 20 ms. eingehalten wird.

Analoge Servos lassen ihren Regler nur einmal pro Puls durchlaufen, zu 
langsam ist also schlecht für Präzision und reaktionszeit des Servos. Zu 
schnell kommt irgenwann der Servo nicht mehr mit. Also man sollte schon 
grob in der Nähe bleiben.

Edit: nicht verwirren lassen, bin ein anderer Jan H.

[Karl H. (kbuchegg)]

Jan H. schrieb:

> Also ist es wirklich nur wichtig, wenn ich eine möglichst feine
> Positions Auflösung haben will, die Zeit so fein auf zu lösen wie es
> geht (was der Servo halt so mit macht), richtig ?

Richtig.

Die Pause für jedes einzelne Servo ergibt sich dadurch, dass prinzipiell 
8 Servos angesteuert werden. Wenn 1 Servo gerade seinen Puls bekommt, 
haben die jeweils anderen 7 Pause. Die einzelnen Servos erhalten 
nacheinander ihren Puls!. Und wie du schon gelesen hast, ist die Länge 
der Pause nicht wirklich wichtig. Ob das 12 oder 16 oder 20 oder 22 ms 
sind, spielt keine grosse Rolle.

            <----- hier entsteht ganz ---->
                   von alleine eine
                   Pause, weil in dieser
                   Zeit die anderen Servos
                   ihre Pulse erhalten
       
        +--+                               +--+
        |  |                               |  |
  1   --+  +-------------------------------+  +------


           +--+                               +--+
           |  |                               |  |
  2   -----+  +-------------------------------+  +----

              +--+
              |  |
  3   --------+  +---------------------- .....

                 +--+
                 |  |
  4   -----------+  +------------------- .....

.
.
.
                 <-->
           Der Timer muss mit seinem Zählumfang nur diesen Teil
           abdecken können: die maximale Pulslänge.

[Jan H. (janiiix3)]

Verstanden.

Ich will die Positionen über RS232 entgegen nehmen.


Am Anfang will ich via. PC eine default Position in das EEPROM schreiben 
(je nach dem wie viele Servos ich im Einsatz habe).

Also brauche ich schon mal ein Commando für diese Aktion.
Dann will ich die Position der verschiedenen Servos übergeben.

Habe mir gedacht ich werde das so machen :
Ist das eine gute Idee oder sollte man das anderst machen?

                /* commands for default position */
        /************************************************************************    
        *  set default pos for servo:                      *
        *                                    *
        *  first byte = default parameter command , second byte = servo_nr    *
        *                                    *  
        *  servo_pos_0 = 0x11 & 0x00                      *
        *  servo_pos_1 = 0x11 & 0x01                      *
        *  servo_pos_2 = 0x11 & 0x02                      *
        *  servo_pos_3 = 0x11 & 0x03                      *
        *  servo_pos_4 = 0x11 & 0x04                      *
        *  servo_pos_5 = 0x11 & 0x05                      *
        *  servo_pos_6 = 0x11 & 0x06                      *
        *  servo_pos_7 = 0x11 & 0x07                      *
        *                                    *
        ************************************************************************/
        
                /* commands for new position */
        /****************************************************************************************    
        *  set new pos for servo:                                *
        *                                            *
        *  first byte = new position parameter command , second byte = servo_nr , new position *
        *                                            *  
        *  servo_pos_0 = 0x12 & 0x00 & byte_value                        *
        *  servo_pos_1 = 0x12 & 0x01 & byte_value                        *      
        *  servo_pos_2 = 0x12 & 0x02 & byte_value                        *      
        *  servo_pos_3 = 0x12 & 0x03 & byte_value                        *      
        *  servo_pos_4 = 0x12 & 0x04 & byte_value                         *
        *  servo_pos_5 = 0x12 & 0x05 & byte_value                         *
        *  servo_pos_6 = 0x12 & 0x06 & byte_value                         *
        *  servo_pos_7 = 0x12 & 0x07 & byte_value                         *
        *                                             *
        ****************************************************************************************/

Nur wie sortiere ich die ganzen Befehle? Wartet man darauf bis es ein 
RX_Int gibt und schreibt das erste Byte (Command?) in eine Variable und 
wartet auf das zweite Byte (Value?) und springt dann je nach Commando in 
die jeweilige Funktion?

[Karl H. (kbuchegg)]

Würde ich  nicht machen.

Es geht zwar aus deinem Beispiel nicht explizit hervor, aber ich würde 
da eine Textschnittstelle machen. Vorteil: kann mit jedem 
Terminalprogramm getestet und in Betrieb genommen werden, ohne dass man 
dazu auf dem PC erst  mal ein Programm (mit seinen eigenen 
Fehlermöglichkeiten) schreiben muss.

Jedes Kommando ist eine Zeile Text, abgeschlossen mit einem Return.
Kommandos sind 1 Buchstabe, nowtwendige weitere Angaben folgen dahinter, 
jeweils mit einem Komma getrennt

Als Kommandos würde ich erst mal vorsehen

L          Load positions from EEPROM
S          Save positions to EEPROM
Pn,m       Position Servo 'n' to position 'm'

Wenn du mal genau überlegst, dann ist zb dein Laden der 
Defaultpositionen nix anderes als erst mal alle 8 Servos auf ihre 
Positionen zu verfahren und dann das Kommando 'S' zu geben, welches die 
Positionen aller 8 Servos speichert. Wenn nur eines eine neue 
Defaultposition kriegen soll, dann geb ich zuerst das Kommando 'L', 
daraufhin fahren alle 8 Servos diese Position an, ich richte sie 
entsprechend mit P Befehlen ein und mit einem S werden alle wieder im 
EEPROM gespeichert.

> Nur wie sortiere ich die ganzen Befehle? Wartet man darauf bis
> es ein RX_Int gibt und schreibt das erste Byte (Command?) in eine
> Variable und wartet auf das zweite Byte (Value?) und springt dann
> je nach Commando in die jeweilige Funktion?

Zum Beispiel. Möglichkeiten gibt es viele. Wenn ich eine 
Textschnittstelle mache, dann lasse ich erst mal eine komplette Zeile 
zusammenkommen und analysiere dann den String was zu tun ist und wie die 
Argumente aussehen. Ganz normale Stringverarbeitung, die hier umso 
einfacher ist, da alle Kommandos nur aus 1 Buchstaben bestehen :-) und 
für die Zahlenwandlung dann eben beispielsweise atoi.

Den Empfang würde ich Interrupt getrieben machen, in der ISR wird das 
jeweils nächste Zeichen in einen Buffer geschrieben, sofern es kein '\n' 
ist. Erkennt die ISR einen '\n' dann setzt sie ein Jobflag und ein 
Teilzweig in der Hauptschleife aktiviert sich und sieht sich den Buffer 
an.

[Jan H. (janiiix3)]

Das mit den ASCII Zeichen ist eine gute Idee. So in der Art hatte ich es 
auch erst angedacht.

Meine default Werte möchte ich aber auch gerne schreiben (vom 
Terminalprogramm z.B)

Also würde ich das am besten so machen (default Werte schreiben):

"S" "1" "80" // S = save default position , 1 = for servo 1, 80 = position

hoffe habe das richtig verstanden.

[Karl H. (kbuchegg)]

Jan H. schrieb:
> Das mit den ASCII Zeichen ist eine gute Idee. So in der Art hatte ich es
> auch erst angedacht.
>
> Meine default Werte möchte ich aber auch gerne schreiben (vom
> Terminalprogramm z.B)
>
> Also würde ich das am besten so machen (default Werte schreiben):
>
>

> 
> "S" "1" "80" // S = save default position , 1 = for servo 1, 80 = 
> position
> 
>

>
> hoffe habe das richtig verstanden.

Das ist doch Quatsch. Du wirst doch  nicht am Terminnal die ganzen 
Gänsefüsschen eingeben.

Am Terminal gibst du ein

S1,80<Return>

(das Return ist ein Druck auf die Enter Taste) und der µC klamüsert sich 
das auseinander. Du wirst dir doch nicht selbst die Eingabe mit lauter 
Sonderzeichen anfüllen, für die du jedesmal auf der Shift-Taste 
rumklopfen musst.

Ist doch nicht schwer

volatile uint8_t haveLine;
volatile uint8_t lineLength;
volatile char line[20];

ISR( UART Empfangs Interrupt )
{
  c = UDR;

  if( haveLine )
    return;       // Hauptschleife hat das vorhergehende noch nicht verdaut

  else if( c == '\r' )
    return;       // ignorieren

  else if( c == '\n' ) {  // Ende der Zeile (Return wurde gedrückt)
    line[lineLength] = '\0';
    haveLine = 1;
    lineLength = 0;
  }

  else if( lineLength < sizeof(line) ) {
    line[lineLength++] = c;
    uart_putc( c );   // eventuell Echo schicken, damit der Benutzer auch was sieht
  }
}


int main()
{
  ....

  while( 1 ) {

    if( haveLine ) {      // Benutzer will was

      if( line[0] == 'S' ) {     // Servo soll neue Position kriegen
        actServo = line[1] - '0';
        if( line[2] == ',' )
          servoPos[actServo] = atoi( &line[3] );
      }

      else if( line[0] == '+' )
        servoPos[actServo]++;

      else if( line[0] == '-' )     
        servoPos[actServo]--;

      else if( line[0] == '? ) {
        itoa( tmp, servoPos[actServo], 10 );
        uart_puts( tmp );
      }

      haveLine = 0;     // alles bearbeitet, ISR darf wieder empfangen
    }

    .....
}

(Fehlerbehandlung könnte besser sein :-)

[Jan H. (janiiix3)]

Ich hätte es jetzt so versucht :

  while(1)
  {    
    if (uart_getc() > 1)
    {
      static uint8_t in_cnt;
      
      in_cnt++;
      
      switch(in_cnt)
      {
        case 1 : {received_data[0] = uart_getc();}break;
        case 2 : {received_data[1] = uart_getc();}break;
        case 3 : {received_data[2] = uart_getc();}break;
        case 4 : {received_data[3] = uart_getc();}break;
        default:{in_cnt = 0;}break;
      }
    }
    
    if (received_data[3] == '\n')
    {
      switch(received_data[0])
      {
          case 'S' : {write_default_position_eeprom();}break;
          case 'P' : {set_servo_position(received_data[4], received_data[3]);}break;    
      }

    }
  }

[Karl H. (kbuchegg)]

Jan H. schrieb:

>     if (received_data[3] == '\n')

Du willst das nicht an fixe Zeilenlängen koppeln, wenn es nicht sein 
muss.

>           case 'P' : {set_servo_position(received_data[4],
> received_data[3]);}break;

genausowenig, wie du hier davon ausgehen willst, dass die 
Positionsangabe immer 2 stellig ist. Mach einen String draus und setz 
atoi darauf an. Das kann damit umgehen.
Wie man das ganze ohne Annahme einer Nachrichtenlänge macht, hab ich dir 
ja schon gezeigt. Character von der UART rein und solange es kein \n 
ist, kommt er in ein Array hinten drann.

Ob man diese Character_Sammel_Sache in einer ISR macht oder direkt in 
der Hauptschleife, spielt erst mal weniger die grosse Rolle. In einer 
ISR hat es halt den Vorteil, dass es auch dann funktioniert, wenn der µC 
gerade anderweitig beschäftigt ist.

Edit:
ach ja. Den Backspace Character sollte man auch noch auswerten, damit 
ein Benutzer an einem Terminal auch eine Chance hat eine ungültige 
Eingabe zu korrigieren.

ISR( UART Empfangs Interrupt )
{
  c = UDR;

  if( haveLine )
    return;       // Hauptschleife hat das vorhergehende noch nicht verdaut

  else if( c == '\r' )
    return;       // ignorieren

  else if( c == '\b' ) {  // Backspace
    if( lineLength > 0 )
      lineLength--;
    uart_puts( "\b \b" );  // Echo, damit auch am Terminal ausradiert wird
  }

  else if( c == '\n' ) {  // Ende der Zeile (Return wurde gedrückt)
    line[lineLength] = '\0';
    haveLine = 1;
    lineLength = 0;
  }

  else if( lineLength < sizeof(line) ) {
    line[lineLength++] = c;
    uart_putc( c );   // eventuell Echo schicken, damit der Benutzer auch was sieht
  }
}

[Jan H. (janiiix3)]

Damit ich nicht immer 'P' senden muss, sende ich ein "+" oder "-" an 
erster stelle um zu incrementieren oder dekrementieren, richtig?

[Karl H. (kbuchegg)]

Jan H. schrieb:
> Damit ich nicht immer 'P' senden muss, sende ich ein "+" oder "-" an
> erster stelle um zu incrementieren oder dekrementieren, richtig?

Ja, zum Beispiel.
Ich hab mir einfach überlegt, wie ich das wohl machen würde, wenn ich 
ein Servo an eine bestimmte Position einrichten möchte.
Da werde ich ganz sicher nicht dauernd

P5,80
P5,81
P5,82
P5,83

tippen wollen (ich bin ja faul), sondern ich hab mir überlegt das sich 
das Positionierkommando das zuletzt benutzte Servo merken könnte. Auch 
will ich das Positionierkommando auch ohne Angabe einer Position 
benutzen können, um es sozusagen einfach nur als das zuletzt benutzte 
Servo bekannt zu machen um es dann in weiterer Folge ansprechen zu 
können. Dann kann ich einfach tippen

P5,80
+
+
+
-

oder wenn ich die aktuelle Position des Servos gar nicht kenne

P5
+
+
+
-
-
+

und das Servo verfährt.
+ und - hab ich genommen, weil sie am Zehnerblock so schön daliegen.

Denk dir was aus! Auf deinem µC bist du Gott! Was immer dir gefällt 
kannst du implementieren.

[Jan H. (janiiix3)]

Was genau machst du hier?
Eine art Convertierung?

actServo = line[1] - '0';

[Karl H. (kbuchegg)]

Jan H. schrieb:
> Was genau machst du hier?
> Eine art Convertierung?
>
>

> actServo = line[1] - '0';
>

Aus dem Buchstaben '3' die Zahl 3

Wie gesagt: man sollte da die Fehlerbehandlung noch etwas verbessern.

[Jan H. (janiiix3)]

if( line[2] == ',' )

Und das soll wohl ein Zeichen dafür sein, dass danach ein neuer 
Parameter kommt oder ?

[Karl H. (kbuchegg)]

genau. Nicht mehr Aufwand als notwendig.

Der Unterschied zwischen

P5,80

und

P5

besteht augenscheinlich darin, dass hier

P5
  ^
  |

kein ',' eingegeben wurde

Das ist nicht 100% nach den Regeln der Kunst, für eine einfache 
Testumgebung, bei der das Programm nicht gleich bei jeder Falscheingabe 
auf die Nase fällt, sollte es aber reichen.

[Jan H. (janiiix3)]

Also bräuchte ich diese Abfrage nicht unbedingt?

[Karl H. (kbuchegg)]

Jan H. schrieb:
> Also bräuchte ich diese Abfrage nicht unbedingt?

mach wie ud es für richtig hältst. Es ist dein Programm.

[Jan H. (janiiix3)]

Vielen dank. Du hast mir extem geholfen!

[Jan H. (janiiix3)]

Kann es sein das ich für die Funktion

atoi

noch eine Bibliothek einbinden muss?

Mein Compiler meckert :

    if( haveLine ) // Benutzer will was
    {      

      if( received_data[0] == 'S' ) // Servo soll neue Position kriegen
      {    
        servo_nr_tmp  = atoi(&received_data[1]);
        servo_pos_value = atoi(&received_data[2]);
        
        set_servo_position(servo_nr_tmp, servo_pos_value);
      }
      else if(received_data[0] == '+' )
      {
        set_servo_position(servo_nr_tmp, servo_pos_value++);
      }
      else if( received_data[0] == '-' )
      {
        set_servo_position(servo_nr_tmp, servo_pos_value--);
      }
      else if( received_data[0] == '?' ) 
      {

      }
    }

      haveLine = 0;     // alles bearbeitet, ISR darf wieder empfangen

  }

[Jan H. (janiiix3)]

Sorry.

Das Array sollte man auch als "Char" deklarieren :-P.

[Jan H. (janiiix3)]

Mit deiner Abfrage klappt es nicht.
Ohne klappt es 1 x und dann nicht wieder.

   if( haveLine )
   { //
        }

[Jan H. (janiiix3)]

Es scheint mir auch so als wenn er nur das erste Zeichen betrachten 
würde und das wars dann. Die anderen Bytes werden nicht ausgewertet.

    if( received_data[0] == 'P' )
    {
      servo_nr_tmp    = received_data[1];
      servo_pos_value_tmp = received_data[2];
      
      servo_nr_tmp    = atoi(&servo_nr_tmp);
      servo_pos_value_tmp = atoi(&servo_pos_value_tmp);
      set_servo_position(servo_nr_tmp, servo_pos_value_tmp);
    }
    else if(received_data[0] == '+' )
    {
      set_servo_position(servo_nr_tmp, 88);
    }
    else if( received_data[0] == '-' )
    {
      set_servo_position(servo_nr_tmp, servo_pos_value_tmp--);
    }
    else if(received_data[0] == 'S')
    {
      servo_nr_tmp    = received_data[1];
      servo_pos_value_tmp = received_data[2];
      
      servo_nr_tmp    = atoi(&servo_nr_tmp);
      servo_pos_value_tmp = atoi(&servo_pos_value_tmp);
          
      write_default_position_eeprom(servo_nr_tmp,servo_pos_value_tmp);
    }

[Jan H. (janiiix3)]

Also wenn ich via. Terminal 1 x P sende klappt das. Sende ich jetzt aber 
1 x S, so reagiert er einfach nicht drauf und überschreibt P nicht...
An was kann das liegen?

unsigned int uart_getc (void)
{    
    unsigned char tmptail;
    unsigned char data;


    if ( UART_RxHead == UART_RxTail ) {
        return UART_NO_DATA;   /* no data available */
    }
    
    /* calculate /store buffer index */
    tmptail = (UART_RxTail + 1) & UART_RX_BUFFER_MASK;
    UART_RxTail = tmptail; 
    
    /* get data from receive buffer */
    data = UART_RxBuf[tmptail];
    
    data = (UART_LastRxError << 8) + data;
    UART_LastRxError = 0;
  

  if(haveLine)
  {
    return(0);
  }
  else if( data == '\r' )
  {
    return(0);
  }
  else if( data == '\n' )
  {
    received_data[lineLength] = '\0';
    haveLine = 1;
    lineLength = 0;
  }
  else if( lineLength < sizeof(received_data) )
  {
    received_data[lineLength++] = data;
  }
  

    return data;

}/* uart_getc */

[Jan H. (janiiix3)]

Wenn ich ASCII "50" sende, dann brauche ich doch 2 Bytes um den Wert auf 
dem MEGA zu speichern oder nicht?

[Daniel A. (daniel-a)]

Jan H. schrieb:
> Wenn ich jetzt im Terminal folgendes als ASCII Sende :

P 1 50

>
> Übergebe ich meiner
> Funktionset_servo_position(servo_nr_tmp,servo_pos_value_tmp);
>
> folgende Werte

P 49 ???

>
> Ich kann doch in ASCII keine 50 angeben ?!

Du vermischt in der zweiten Ausgabe dezimal und asccii, das ist 
verwirrend. Wenn das Erste wirklich genauso eingegeben wurde, ist 
received_data[1] der Abstand, und du verwendest atoi falsch, dass nimmt 
ein  nullterminiertes array von chars, deins ist nicht nullterminiert. 
Wenn du 2 zahlen in ascii hast, sind diese in 2 chars, dann rechnet man 
erste Zahl mal 10 plus zweite zahl, so macht das auch atoi und 
wiederholt es nis zum ersten nullbyte.

[Jan H. (janiiix3)]

Okay...

Also für meine Werte erwarte ich :

    1        2       3
S oder P , 0-8 , 0 - 255

das heißt (Würde ich es in ASCII eingeben)

received_data[0] = S | P; (erster Parameter)

received_data[1] = 0-8; (zweiter Parameter)

received_data[2] = 0-9; (dritter Parameter)
received_data[3] = 0-9;

sehe ich das richtig?

[Jan H. (janiiix3)]

Danke für die Anregung!
Habe es jetzt so gelöst.

      received_data[1] -= 48;
      received_data[2] -= 48;
      received_data[3] -= 48;

      received_data[2] *= 10;
      received_data[2] += received_data[3];

Nur wie mache ich das wenn ich einen Wert > 100 habe?

[Daniel A. (daniel-a)]

Jan H. schrieb:
> Nur wie mache ich das wenn ich einen Wert > 100 habe?

Du musst dir ein geschicktes Dateiformat überlegen, bei dem erkennbar 
ist wo etas Anfängt und wo etwas Aufhört. Dann kannst du so lange die 
Nächste Zahl zum Zwischenergebnis addieren, bis die Endbedungung 
Auftritt, z.B. das Zeichen keine zahl mehr ist oder es das letzte 
Zeichen war, etc.

[Jan H. (janiiix3)]

Wenn die Eingabe zuende ist bekomme ich ein '\n'.

[Daniel A. (daniel-a)]

Ich würde einfach eine Funktion schreiben die Zahlen parst, und einen 
Iterator verwenden:

// ungetestet
int parseInt( char** data, unsigned max_len, bool allow_sign ){
  int res = 0;
  bool sign = false;
  if( max_len && allow_sign && **data=='-' ){
    sign = true;
    (*data)++;
    if( ~max_len )
      max_len--;
  }
  for(; max_len && **data >= '0' && **data <= '9'; (*data)++,  ~max_len && max_len-- ){
    res *= 10;
    if(sign)
      res -= **data;
    else
      res += **data;
  }
  return res;
}

Das könnte man dann so anwenden:

  char* it = received_data;
  switch(*it++){
    case 'P': {
      servo_nr_tmp = parseInt(&it,1,false);
      servo_pos_value_tmp = parseInt(&it,~0,false); 
      set_servo_position(servo_nr_tmp, servo_pos_value_tmp); 
    } break;
    case '+': {
...

[Jan H. (janiiix3)]

Hallo ;)

Ich sende jetzt einfach als letztes Byte die Potenz des Wertes mit. 
Klappt prima ;)

    if( received_data[0] == 'P' ) // set new position
    {
      received_data[1] -= 48;
      received_data[2] -= 48;
      received_data[3] -= 48;
      received_data[4] -= 48;
      received_data[5] -= 48;
      
      if (received_data[5] == 1) // one
      {
        set_servo_position(received_data[1], received_data[4]);
      }else if(received_data[5] == 2) // ten
      {
        received_data[3] *= 10;
        received_data[3] += received_data[4];
        
        set_servo_position(received_data[1], received_data[3]);
      }else if(received_data[5] == 3) // hounder
      {
        received_data[2] *= 100;
        received_data[3] *= 10;
        received_data[2] += (received_data[3]) + received_data[4];
      
        set_servo_position(received_data[1], received_data[2]);
      }  
    }