servo

Hi an Alle!
Ich arbeite an einem Projekt, wo mein Camcorder per funk gesteuert und bewegt werden soll. Es soll Pan/Tillt mit Zoom steuerung, die auch 2 bis drei Positionen gespeichert und ababrufen werden können. Dass ich ein Anfänger bin, mache ich das in kleinen Schritten. Habe mit zoom steuerung angefangen. Dass ich in den Camcorder nicht aufschrauben möchte, soll ein Servo zum einsatz kommen.
Mit dem Sketch kann ich zoomen, eingestellten zoom speichern, bloss mit abrufen gibt es problemme-es bleibt stehen, tuts garnicht.
Villeicht ist nur Kleinigkeit, weiss ich nicht. Für eure antworten werde mich freuen.
MfG Peter

//Peter
#include <Servo.h>


unsigned long zeit;
 long zoom=0;  // zoom
 long zoom_pos_1=0;      //zoom pos 1 
 long zoom_pos_2=0;
 long zoom_pos_3=0;
 
 long zoom_plus_start=0; //zeit wann taster
 long zoom_plus_stop=0;
 long zoom_plus_jetzt=0;
 long zoom_minus_start=0;
 long zoom_minus_stop=0;
 long zoom_minus_jetzt=0;

int zoom_minus_sw=3;  // taster links   zoom minus
int zoom_plus_sw=4;  // taster rechts    zoom plus

byte val1_zoom_plus_sw_an=1;  //bei gedrückter taste =0
byte val1_zoom_minus_sw_an=1;  //bei gedrückter taste =0
byte val2_zoom_plus_sw_an=1;  //bei gedrückter taste =0
byte val2_zoom_minus_sw_an=1;  //bei gedrückter taste =0

int pos_1_sw=10;  // taster pos 1
int pos_2_sw=11;  // taster pos 2
int pos_3_sw=12;  // taster pos 3
int save_pos_sw=8; // gemeinsam mit taster pos_x speichert die aktuelle pos.

int pos_1=0;
int pos_2=0;
int pos_3=0;
int save_pos=0;

int zoom_minus=50;    //zoom_minus schnelligkeit
int zoom_plus=170;    // zoom_plus

Servo servo_zoom;  // richtet Servo für zoom
void setup()
{
  Serial.begin(9600);
  Serial.println("Zoom für den Camcorder");
  Serial.println();
  
   servo_zoom.attach(9);  // schliesst servo an pin 9
  pinMode(zoom_minus_sw,INPUT); // richtet eingänge ein
  digitalWrite(zoom_minus_sw, HIGH); // pull-up aktiv
  pinMode(zoom_plus_sw,INPUT);
  digitalWrite(zoom_plus_sw, HIGH);
  pinMode(save_pos_sw,INPUT); 
  digitalWrite(save_pos_sw, HIGH);
  
  pinMode(pos_1_sw,INPUT);
  digitalWrite(pos_1_sw, HIGH);
  pinMode(pos_2_sw,INPUT); 
  digitalWrite(pos_2_sw, HIGH);
  pinMode(pos_3_sw,INPUT); 
  digitalWrite(pos_3_sw, HIGH);
  
  servo_zoom.write(40);   // zieht den zoom auf - , ausgang position
  delay (4000);          //  wartet 4 sek. um sicher zu sein, dass wirklich die min pos. erreicht wurde
  servo_zoom.write(90);    // zurück zu null stellung

  
  
  
  
}


void loop()
{
  Serial.print("Zeit: ");
zeit=millis();
  Serial.println(zeit);
  
  
 
  
   val1_zoom_plus_sw_an=digitalRead(zoom_plus_sw);
   if(!val1_zoom_plus_sw_an)
     {
       delay(20);
       val2_zoom_plus_sw_an=digitalRead(zoom_plus_sw);
       if(!val1_zoom_plus_sw_an)
         {
           zoom_plus_start= millis();
           servo_zoom.write(zoom_plus);
           do{
           } while(!digitalRead(zoom_plus_sw));
           
           servo_zoom.write(90);
           zoom_plus_stop= millis();
           zoom_plus_jetzt =(zoom_plus_stop-zoom_plus_start);
            zoom=(zoom_plus_jetzt+zoom);
            Serial.print("Zoom in der schleife: ");
            Serial.println(zoom_plus_jetzt);
            zoom_plus_jetzt=0;
         
           
         }
     }
  
  
  
  
  
        val1_zoom_minus_sw_an=digitalRead(zoom_minus_sw);
   if(!val1_zoom_minus_sw_an)
     {
       delay(20);
       val2_zoom_minus_sw_an=digitalRead(zoom_minus_sw);
       if(!val1_zoom_minus_sw_an)
         {
           zoom_minus_start= millis();
           servo_zoom.write(zoom_minus);
           do{
           } while(!digitalRead(zoom_minus_sw));
           
           servo_zoom.write(90);
           zoom_minus_stop= millis();
           zoom_minus_jetzt =(zoom_minus_stop-zoom_minus_start);
           
            if ((zoom-zoom_minus_jetzt)>0)
                 {
                   zoom=(zoom-zoom_minus_jetzt);
                 }
             else
             {
             (zoom=0);
           }
            
            Serial.print("Zoom in der schleife: -");
            Serial.println(zoom_minus_jetzt);
            zoom_minus_jetzt=0;
         
           
         }
     }
     Serial.println("================================= ");
     Serial.println("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx ");
       pos_1=digitalRead(pos_1_sw);
        pos_2=digitalRead(pos_2_sw);
        pos_3=digitalRead(pos_3_sw);
        save_pos=digitalRead(save_pos_sw);
         Serial.print("taster pos 1:    ");
        Serial.println(pos_1);
         Serial.print("taster pos 2:    ");
        Serial.println(pos_2);
         Serial.print("taster pos 3:    ");
        Serial.println(pos_3);
         Serial.print("taster  save pos :    ");
        Serial.println(save_pos);
        Serial.println("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx ");
        Serial.println("================================= ");
        
        if((pos_1!=1)&&(save_pos!=1))   //speichert eingestellten zoom als pos 1
        
            {
            zoom_pos_1=zoom;
            }
        
        
        if((pos_2!=1)&&(save_pos!=1))   //speichert eingestellten zoom als pos 2
            {
            zoom_pos_2=zoom;
            }
            
            if((pos_3!=1)&&(save_pos!=1))  //speichert eingestellten zoom als pos 3
            {
            zoom_pos_3=zoom;
            }
           
           
           
           if(pos_1!=1)    //wenn taster pos 1gedrückt wird
           {
             
               if(zoom_pos_1>zoom)  //bestimmt die richtung
                 {
                 
                 servo_zoom.write(zoom_plus);    //stellt den servo
                 delay (zoom_pos_1-zoom);      //für die zeit - unterschied zw. pzoom und pos 1
                 servo_zoom.write(90);          //stellt den servo in der mittelstellung
                 zoom=zoom_pos_1;                //glechit zoom mit pos 1 aus
                 do{
                 } while(zoom_pos_1==zoom);
           
                 }
              
              else  (zoom_pos_1<zoom); //bestimmt die richtung
                 {
                 
                 servo_zoom.write(zoom_minus);    //stellt den servo
                 delay (zoom-zoom_pos_1);      //für die zeit - unterschied zw. zoom und pos 1
                 servo_zoom.write(90);          //stellt den servo in der mittelstellung
                 zoom=zoom_pos_1;                //glechit zoom mit pos 1 aus
                 do{
                 } while(zoom_pos_1==zoom);
                 
                 }
           }
           
  
  
  
  
  
  
  
  Serial.println("================================= ");
  Serial.println("================================= ");
  
  Serial.print("Zoom: ");
  Serial.println(zoom);
  Serial.print("pos 1: ");
  Serial.println(zoom_pos_1);
  Serial.print("Pos 2: ");
  Serial.println(zoom_pos_2);
  Serial.print("Pos 3: ");
  Serial.println(zoom_pos_3);
  Serial.print("Zeit: ");
  zeit=millis();
  Serial.println(zeit);
  Serial.println("================================= ");
  delay(2000);  // delay um ausgabe am bildschirm besser verfolgen zu können
}

habt ihr keine Idee?

else  (zoom_pos_1<zoom); //bestimmt die richtung

Im else kannst Du keine Bedingung angeben. Wennschon mußt Du ein else { if()…} oder elseif() benutzen.

servo_zoom.write(zoom_plus);    //stellt den servo
                 delay (zoom_pos_1-zoom);      //für die zeit - unterschied zw. pzoom und pos 1
                 servo_zoom.write(90);          //stellt den servo in der mittelstellung
                 zoom=zoom_pos_1;

Ich habe nicht verstanden wieso Du zuerst die gespeicherte Position anfährst und dann wieder zurück auf 90 fährst.

if(pos_1!=1)    //wenn taster pos 1gedrückt wird
           {
             
               if(zoom_pos_1>zoom)  //bestimmt die richtung
                 {                 
                 servo_zoom.write(zoom_plus);    //stellt den servo
                 delay (zoom_pos_1-zoom);      //für die zeit - unterschied zw. pzoom und pos 1
                 servo_zoom.write(90);          //stellt den servo in der mittelstellung
                 zoom=zoom_pos_1;                //glechit zoom mit pos 1 aus
                 do{
                 } while(zoom_pos_1==zoom);           
                 }              
              else  (zoom_pos_1<zoom); //bestimmt die richtung
                 {                 
                 servo_zoom.write(zoom_minus);    //stellt den servo
                 delay (zoom-zoom_pos_1);      //für die zeit - unterschied zw. zoom und pos 1
                 servo_zoom.write(90);          //stellt den servo in der mittelstellung
                 zoom=zoom_pos_1;                //glechit zoom mit pos 1 aus
                 do{
                 } while(zoom_pos_1==zoom);                 
                 }
           }

Ich verstehe auch nicht dden Unterschied ob du nach rechts oder nach links fahren mußt.

do{   } while(zoom_pos_1==zoom);

Was soll diese Schleife machen? Wenn die Bedingung wahr ist kommst Du nicht mehr raus.

Ich weiß nicht ob noch mehr Fehler drin sind. Ich hab mal im Moment genug gesucht. Mehr nach Deiner Antwort/Revision des Sketches.
Grüße Uwe

Vorerst danke für Deine Antwort!

Ich habe nicht verstanden wieso Du zuerst die gespeicherte Position anfährst und dann wieder zurück auf 90 fährst

Der Servo zieht den Zoomhebel z.b. auf zoomen, wartet die gespeicherte zeit, und fährt wieder in die mittelstellung, nachteil ist, dass zoomen nur mit einer Geschwindigkeit möglich ist, es reicht mir aber aus.

Ich verstehe auch nicht den Unterschied ob du nach rechts oder nach links fahren mußt.

rechts=zoomen, links=entfernen, kann es auch umgekehrt werden, je nach einbauposition.

do{ } while(zoom_pos_1==zoom); Was soll diese Schleife machen? Wenn die Bedingung wahr ist kommst Du nicht mehr raus.

ja.... dass ist wahrscheinlich der Fehler! werde es morgen ändern! DANKE!

Danke für die Erklährung:
korrigiere bitte auch

else  (zoom_pos_1<zoom); //bestimmt die richtung

Grüße Uwe

ES funktioniert!!!
Danke für Deine Hilfe.
Hier nochmal der Code

//Peter
#include <Servo.h>


unsigned long zeit;
 long zoom=0;  // zoom
 long zoom_pos_1=0;      //zoom pos 1 
 long zoom_pos_2=0;
 long zoom_pos_3=0;
 
 long zoom_plus_start=0; //zeit wann taster
 long zoom_plus_stop=0;
 long zoom_plus_jetzt=0;
 long zoom_minus_start=0;
 long zoom_minus_stop=0;
 long zoom_minus_jetzt=0;

int zoom_minus_sw=3;  // taster links   zoom minus
int zoom_plus_sw=4;  // taster rechts    zoom plus

byte val1_zoom_plus_sw_an=1;  //bei gedrückter taste =0
byte val1_zoom_minus_sw_an=1;  //bei gedrückter taste =0
byte val2_zoom_plus_sw_an=1;  //bei gedrückter taste =0
byte val2_zoom_minus_sw_an=1;  //bei gedrückter taste =0

int pos_1_sw=10;  // taster pos 1
int pos_2_sw=11;  // taster pos 2
int pos_3_sw=12;  // taster pos 3
int save_pos_sw=8; // gemeinsam mit taster pos_x speichert die aktuelle pos.

int pos_1=0;
int pos_2=0;
int pos_3=0;
int save_pos=0;

int zoom_minus=50;    //zoom_minus schnelligkeit
int zoom_plus=170;    // zoom_plus

Servo servo_zoom;  // richtet Servo für zoom
void setup()
{
  Serial.begin(9600);
  Serial.println("Zoom für den Camcorder");
  Serial.println();
  
   servo_zoom.attach(9);  // schliesst servo an pin 9
  pinMode(zoom_minus_sw,INPUT); // richtet eingänge ein
  digitalWrite(zoom_minus_sw, HIGH); // pull-up aktiv
  pinMode(zoom_plus_sw,INPUT);
  digitalWrite(zoom_plus_sw, HIGH);
  pinMode(save_pos_sw,INPUT); 
  digitalWrite(save_pos_sw, HIGH);
  
  pinMode(pos_1_sw,INPUT);
  digitalWrite(pos_1_sw, HIGH);
  pinMode(pos_2_sw,INPUT); 
  digitalWrite(pos_2_sw, HIGH);
  pinMode(pos_3_sw,INPUT); 
  digitalWrite(pos_3_sw, HIGH);
  
  servo_zoom.write(40);   // zieht den zoom auf - , ausgang position
  delay (4000);          //  wartet 4 sek. um sicher zu sein, dass wirklich die min pos. erreicht wurde
  servo_zoom.write(90);    // zurück zu null stellung

  
  
  
  
}


void loop()
{
  Serial.print("Zeit: ");
zeit=millis();
  Serial.println(zeit);
  
  
 
  
   val1_zoom_plus_sw_an=digitalRead(zoom_plus_sw);
   if(!val1_zoom_plus_sw_an)
     {
       delay(20);
       val2_zoom_plus_sw_an=digitalRead(zoom_plus_sw);
       if(!val1_zoom_plus_sw_an)
         {
           zoom_plus_start= millis();
           servo_zoom.write(zoom_plus);
           do{
           } while(!digitalRead(zoom_plus_sw));
           
           servo_zoom.write(90);
           zoom_plus_stop= millis();
           zoom_plus_jetzt =(zoom_plus_stop-zoom_plus_start);
            zoom=(zoom_plus_jetzt+zoom);
            Serial.print("Zoom in der schleife: ");
            Serial.println(zoom_plus_jetzt);
            zoom_plus_jetzt=0;
         
           
         }
     }
  
  
  
  
  
        val1_zoom_minus_sw_an=digitalRead(zoom_minus_sw);
   if(!val1_zoom_minus_sw_an)
     {
       delay(20);
       val2_zoom_minus_sw_an=digitalRead(zoom_minus_sw);
       if(!val1_zoom_minus_sw_an)
         {
           zoom_minus_start= millis();
           servo_zoom.write(zoom_minus);
           do{
           } while(!digitalRead(zoom_minus_sw));
           
           servo_zoom.write(90);
           zoom_minus_stop= millis();
           zoom_minus_jetzt =(zoom_minus_stop-zoom_minus_start);
           
            if ((zoom-zoom_minus_jetzt)>0)
                 {
                   zoom=(zoom-zoom_minus_jetzt);
                 }
             else
             {
             (zoom=0);
           }
            
            Serial.print("Zoom in der schleife: -");
            Serial.println(zoom_minus_jetzt);
            zoom_minus_jetzt=0;
         
           
         }
     }
     Serial.println("================================= ");
     Serial.println("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx ");
       pos_1=digitalRead(pos_1_sw);
        pos_2=digitalRead(pos_2_sw);
        pos_3=digitalRead(pos_3_sw);
        save_pos=digitalRead(save_pos_sw);
         Serial.print("taster pos 1:    ");
        Serial.println(pos_1);
         Serial.print("taster pos 2:    ");
        Serial.println(pos_2);
         Serial.print("taster pos 3:    ");
        Serial.println(pos_3);
         Serial.print("taster  save pos :    ");
        Serial.println(save_pos);
        Serial.println("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx ");
        Serial.println("================================= ");
        
        if((pos_1!=1)&&(save_pos!=1))   //speichert eingestellten zoom als pos 1
        
            {
            zoom_pos_1=zoom;
            }
        
        
        if((pos_2!=1)&&(save_pos!=1))   //speichert eingestellten zoom als pos 2
            {
            zoom_pos_2=zoom;
            }
            
            if((pos_3!=1)&&(save_pos!=1))  //speichert eingestellten zoom als pos 3
            {
            zoom_pos_3=zoom;
            }
           
           // geschpeicherte position abrufen
           
           if(pos_1!=1)    //wenn taster pos 1gedrückt wird
           {
             
               if(zoom_pos_1>zoom)  //bestimmt die richtung
                 {
                 
                 servo_zoom.write(zoom_plus);    //stellt den servo
                 delay (zoom_pos_1-zoom);      //für die zeit - unterschied zw. pzoom und pos 1
                 servo_zoom.write(90);          //stellt den servo in der mittelstellung
                 zoom=zoom_pos_1;                //glechit zoom mit pos 1 aus
                
           
                 }
              
             if  (zoom_pos_1<zoom); //bestimmt die richtung
                 {
                 
                 servo_zoom.write(zoom_minus);    //stellt den servo
                 delay (zoom-zoom_pos_1);      //für die zeit - unterschied zw. zoom und pos 1
                 servo_zoom.write(90);          //stellt den servo in der mittelstellung
                 zoom=zoom_pos_1;                //glechit zoom mit pos 1 aus
                 
                 
                 }
           }
            // geschpeicherte position abrufen
            if(pos_2!=1)    //wenn taster pos 2 gedrückt wird
           {
             
               if(zoom_pos_2>zoom)  //bestimmt die richtung
                 {
                 
                 servo_zoom.write(zoom_plus);    //stellt den servo
                 delay (zoom_pos_2-zoom);      //für die zeit - unterschied zw. pzoom und pos 2
                 servo_zoom.write(90);          //stellt den servo in der mittelstellung
                 zoom=zoom_pos_2;                //glechit zoom mit pos 2 aus
                
           
                 }
              
             if  (zoom_pos_2<zoom); //bestimmt die richtung
                 {
                 
                 servo_zoom.write(zoom_minus);    //stellt den servo
                 delay (zoom-zoom_pos_2);      //für die zeit - unterschied zw. zoom und pos 2
                 servo_zoom.write(90);          //stellt den servo in der mittelstellung
                 zoom=zoom_pos_2;                //glechit zoom mit pos 2 aus
                 
                 
                 }
           }
  
           // geschpeicherte position abrufen
            if(pos_3!=1)    //wenn taster pos 3 gedrückt wird
           {
             
               if(zoom_pos_3>zoom)  //bestimmt die richtung
                 {
                 
                 servo_zoom.write(zoom_plus);    //stellt den servo
                 delay (zoom_pos_3-zoom);      //für die zeit - unterschied zw. pzoom und pos 3
                 servo_zoom.write(90);          //stellt den servo in der mittelstellung
                 zoom=zoom_pos_3;                //glechit zoom mit pos 3 aus
                
           
                 }
              
             if  (zoom_pos_3<zoom); //bestimmt die richtung
                 {
                 
                 servo_zoom.write(zoom_minus);    //stellt den servo
                 delay (zoom-zoom_pos_3);      //für die zeit - unterschied zw. zoom und pos 3
                 servo_zoom.write(90);          //stellt den servo in der mittelstellung
                 zoom=zoom_pos_3;                //glechit zoom mit pos 3 aus
                 
                 
                 }
           }
  
  
  
  
  
  Serial.println("================================= ");
  Serial.println("================================= ");
  
  Serial.print("Zoom: ");
  Serial.println(zoom);
  Serial.print("pos 1: ");
  Serial.println(zoom_pos_1);
  Serial.print("Pos 2: ");
  Serial.println(zoom_pos_2);
  Serial.print("Pos 3: ");
  Serial.println(zoom_pos_3);
  Serial.print("Zeit: ");
  zeit=millis();
  Serial.println(zeit);
  Serial.println("================================= ");
  delay(2000);  // delay um ausgabe am bildschirm besser verfolgen zu können
}

Natürlich kann auch die serielle ausgabe gelöscht werden.
Als nächster Schritt werde ich mein Projekt um zwei Schrittmotoren erweitern, um den Camcorder beweglich zu machen. Ich werde Euch noch sicherlich um Hilfe bitten müssen :slight_smile:

falls der code jemand nutzen möchte, das gleiche noch mal , aber die positionen werden zusätzlich im eeprom gespeichert, und natürlich bei start abgerufen, so dass die nach einem neustart nicht verloren gehen.

pampalini: falls der code jemand nutzen möchte, das gleiche noch mal , aber die positionen werden zusätzlich im eeprom gespeichert, und natürlich bei start abgerufen, so dass die nach einem neustart nicht verloren gehen.

Wo?

Entschuldige , der code war zu lang, hier ist teil 1

#include <EEPROM.h>

//Peter

#include <Servo.h>


  
  
unsigned long zeit;
 long zoom=0;  // zoom
 
byte zoom_pos_1_hb= EEPROM.read(401);      //liest  gespeicherte pos vom speicher, je 2 byte
 byte zoom_pos_1_lb= EEPROM.read(402);
 byte zoom_pos_2_hb= EEPROM.read(407);     // adressen zw. 403 und 406 sind für schrittmotoren reserviert
 
 byte zoom_pos_2_lb= EEPROM.read(408);     
 byte zoom_pos_3_hb= EEPROM.read(413);      // adressen zw. 409 und 412 sind für schrittmotoren reserviert
byte zoom_pos_3_lb= EEPROM.read(414);
 
 
 
 long zoom_pos_1= (zoom_pos_1_hb*256)+zoom_pos_1_lb;      //rechnet  
 long zoom_pos_2= (zoom_pos_2_hb*256)+zoom_pos_2_lb;
 long zoom_pos_3= (zoom_pos_3_hb*256)+zoom_pos_3_lb;
 
 long zoom_plus_start=0; //zeit wann taster
 long zoom_plus_stop=0;
 long zoom_plus_jetzt=0;
 long zoom_minus_start=0;
 long zoom_minus_stop=0;
 long zoom_minus_jetzt=0;

int zoom_minus_sw=3;  // taster links   zoom minus
int zoom_plus_sw=4;  // taster rechts    zoom plus

byte val1_zoom_plus_sw_an=1;  //bei gedrückter taste =0
byte val1_zoom_minus_sw_an=1;  //bei gedrückter taste =0
byte val2_zoom_plus_sw_an=1;  //bei gedrückter taste =0
byte val2_zoom_minus_sw_an=1;  //bei gedrückter taste =0

int pos_1_sw=10;  // taster pos 1
int pos_2_sw=11;  // taster pos 2
int pos_3_sw=12;  // taster pos 3
int save_pos_sw=8; // gemeinsam mit taster pos_x speichert die aktuelle pos.

int pos_1=0;
int pos_2=0;
int pos_3=0;
int save_pos=0;

int zoom_minus=50;    //zoom_minus schnelligkeit
int zoom_plus=170;    // zoom_plus

Servo servo_zoom;  // richtet Servo für zoom
void setup()
{
  Serial.begin(9600);
  Serial.println("Zoom für den Camcorder");
  Serial.println();
  
   servo_zoom.attach(9);  // schliesst servo an pin 9
  pinMode(zoom_minus_sw,INPUT); // richtet eingänge ein
  digitalWrite(zoom_minus_sw, HIGH); // pull-up aktiv
  pinMode(zoom_plus_sw,INPUT);
  digitalWrite(zoom_plus_sw, HIGH);
  pinMode(save_pos_sw,INPUT); 
  digitalWrite(save_pos_sw, HIGH);
  
  pinMode(pos_1_sw,INPUT);
  digitalWrite(pos_1_sw, HIGH);
  pinMode(pos_2_sw,INPUT); 
  digitalWrite(pos_2_sw, HIGH);
  pinMode(pos_3_sw,INPUT); 
  digitalWrite(pos_3_sw, HIGH);
  
  servo_zoom.write(40);   // zieht den zoom auf - , ausgang position
  delay (4000);          //  wartet 4 sek. um sicher zu sein, dass wirklich die min pos. erreicht wurde
  servo_zoom.write(90);    // zurück zu null stellung

  
  
  
  
}


void loop()
{
  Serial.print("Zeit: ");
zeit=millis();
  Serial.println(zeit);
  
  
 
  
   val1_zoom_plus_sw_an=digitalRead(zoom_plus_sw);
   if(!val1_zoom_plus_sw_an)
     {
       delay(20);
       val2_zoom_plus_sw_an=digitalRead(zoom_plus_sw);
       if(!val1_zoom_plus_sw_an)
         {
           zoom_plus_start= millis();
           servo_zoom.write(zoom_plus);
           do{
           } while(!digitalRead(zoom_plus_sw));
           
           servo_zoom.write(90);
           zoom_plus_stop= millis();
           zoom_plus_jetzt =(zoom_plus_stop-zoom_plus_start);
            zoom=(zoom_plus_jetzt+zoom);
            Serial.print("Zoom in der schleife: ");
            Serial.println(zoom_plus_jetzt);
            zoom_plus_jetzt=0;
         
           
         }
     }
  
  
  
  
  
        val1_zoom_minus_sw_an=digitalRead(zoom_minus_sw);
   if(!val1_zoom_minus_sw_an)
     {
       delay(20);
       val2_zoom_minus_sw_an=digitalRead(zoom_minus_sw);
       if(!val1_zoom_minus_sw_an)
         {
           zoom_minus_start= millis();
           servo_zoom.write(zoom_minus);
           do{
           } while(!digitalRead(zoom_minus_sw));
           
           servo_zoom.write(90);
           zoom_minus_stop= millis();
           zoom_minus_jetzt =(zoom_minus_stop-zoom_minus_start);
           
            if ((zoom-zoom_minus_jetzt)>0)
                 {
                   zoom=(zoom-zoom_minus_jetzt);
                 }
             else
             {
             (zoom=0);
           }
            
            Serial.print("Zoom in der schleife: -");
            Serial.println(zoom_minus_jetzt);
            zoom_minus_jetzt=0;
         
           
         }
     }
     Serial.println("================================= ");
     Serial.println("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx ");
       pos_1=digitalRead(pos_1_sw);
        pos_2=digitalRead(pos_2_sw);
        pos_3=digitalRead(pos_3_sw);
        save_pos=digitalRead(save_pos_sw);
         Serial.print("taster pos 1:    ");
        Serial.println(pos_1);
         Serial.print("taster pos 2:    ");
        Serial.println(pos_2);
         Serial.print("taster pos 3:    ");
        Serial.println(pos_3);
         Serial.print("taster  save pos :    ");
        Serial.println(save_pos);
        Serial.println("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx ");
        Serial.println("================================= ");
        
        if((pos_1!=1)&&(save_pos!=1))   //speichert eingestellten zoom als pos 1
        
            {
            zoom_pos_1=zoom;
            zoom_pos_1_hb=zoom_pos_1/256;
            zoom_pos_1_lb=zoom_pos_1%256;
            EEPROM.write(401, zoom_pos_1_hb);
            EEPROM.write(402, zoom_pos_1_lb);
            }
        
        
        if((pos_2!=1)&&(save_pos!=1))   //speichert eingestellten zoom als pos 2
            {
            zoom_pos_2=zoom;
            zoom_pos_2_hb=zoom_pos_2/256;
            zoom_pos_2_lb=zoom_pos_2%256;
            EEPROM.write(407, zoom_pos_2_hb);
            EEPROM.write(408, zoom_pos_2_lb);
            }
            
            if((pos_3!=1)&&(save_pos!=1))  //speichert eingestellten zoom als pos 3
            {
            zoom_pos_3=zoom;
            zoom_pos_3_hb=zoom_pos_3/256;
            zoom_pos_3_lb=zoom_pos_3%256;
            EEPROM.write(413, zoom_pos_3_hb);
            EEPROM.write(414, zoom_pos_3_lb);
            }

und teil 2

 // geschpeicherte position abrufen
           
           if(pos_1!=1)    //wenn taster pos 1 gedrückt wird
           {
             
               if(zoom_pos_1>zoom)  //bestimmt die richtung
                 {
                 
                 servo_zoom.write(zoom_plus);    //stellt den servo
                 delay (zoom_pos_1-zoom);      //für die zeit - unterschied zw. pzoom und pos 1
                 servo_zoom.write(90);          //stellt den servo in der mittelstellung
                 zoom=zoom_pos_1;                //glechit zoom mit pos 1 aus
                
           
                 }
              
             if  (zoom_pos_1<zoom); //bestimmt die richtung
                 {
                 
                 servo_zoom.write(zoom_minus);    //stellt den servo
                 delay (zoom-zoom_pos_1);      //für die zeit - unterschied zw. zoom und pos 1
                 servo_zoom.write(90);          //stellt den servo in der mittelstellung
                 zoom=zoom_pos_1;                //glechit zoom mit pos 1 aus
                 
                 
                 }
           }
            // geschpeicherte position abrufen
            if(pos_2!=1)    //wenn taster pos 2 gedrückt wird
           {
             
               if(zoom_pos_2>zoom)  //bestimmt die richtung
                 {
                 
                 servo_zoom.write(zoom_plus);    //stellt den servo
                 delay (zoom_pos_2-zoom);      //für die zeit - unterschied zw. pzoom und pos 2
                 servo_zoom.write(90);          //stellt den servo in der mittelstellung
                 zoom=zoom_pos_2;                //glechit zoom mit pos 2 aus
                
           
                 }
              
             if  (zoom_pos_2<zoom); //bestimmt die richtung
                 {
                 
                 servo_zoom.write(zoom_minus);    //stellt den servo
                 delay (zoom-zoom_pos_2);      //für die zeit - unterschied zw. zoom und pos 2
                 servo_zoom.write(90);          //stellt den servo in der mittelstellung
                 zoom=zoom_pos_2;                //glechit zoom mit pos 2 aus
                 
                 
                 }
           }
  
           // geschpeicherte position abrufen
            if(pos_3!=1)    //wenn taster pos 3 gedrückt wird
           {
             
               if(zoom_pos_3>zoom)  //bestimmt die richtung
                 {
                 
                 servo_zoom.write(zoom_plus);    //stellt den servo
                 delay (zoom_pos_3-zoom);      //für die zeit - unterschied zw. pzoom und pos 3
                 servo_zoom.write(90);          //stellt den servo in der mittelstellung
                 zoom=zoom_pos_3;                //glechit zoom mit pos 3 aus
                
           
                 }
              
             if  (zoom_pos_3<zoom); //bestimmt die richtung
                 {
                 
                 servo_zoom.write(zoom_minus);    //stellt den servo
                 delay (zoom-zoom_pos_3);      //für die zeit - unterschied zw. zoom und pos 3
                 servo_zoom.write(90);          //stellt den servo in der mittelstellung
                 zoom=zoom_pos_3;                //glechit zoom mit pos 3 aus
                 
                 
                 }
           }
  
  
  
  
  
  Serial.println("================================= ");
  Serial.println("================================= ");
  
  Serial.print("Zoom: ");
  Serial.println(zoom);
  Serial.print("pos 1: ");
  Serial.println(zoom_pos_1);
  Serial.print("Pos 2: ");
  Serial.println(zoom_pos_2);
  Serial.print("Pos 3: ");
  Serial.println(zoom_pos_3);
  Serial.print("Zeit: ");
  zeit=millis();
  Serial.println(zeit);
  Serial.println("================================= ");
  delay(2000);  // delay um ausgabe am bildschirm besser verfolgen zu können
}

noch mal danke.
Jetzt will ich das ganze um 2 Schrittmotoren erweitern um Camcorder schwenken und neigen zu können. Mal schauen , was daraus wird.
Peter