Αυτός ο ενδεικτικός κώδικας χρησιμοποιεί το MegaMoto Plus και ένα Arduino Uno για την παρακολούθηση του ρεύματος ενός γραμμικού ενεργοποιητή, ωστόσο, μπορούν να χρησιμοποιηθούν παρόμοια προϊόντα ως αντικαταστάσεις.

/*  Κώδικας για την παρακολούθηση της έντασης ρεύματος του ενεργοποιητή και την αποκοπή τροφοδοσίας, αν
  αυξηθεί πάνω από ένα συγκεκριμένο όριο.

  Συντάχθηκε από την Progressive Automations
  19 Αυγούστου 2015

  Υλικό:
  - Πίνακες ελέγχου RobotPower MegaMoto
  - Arduino Uno
  - 2 κουμπιά (pushbuttons)
 */

const int EnablePin = 8;
const int PWMPinA = 11;
const int PWMPinB = 3; // ακίδες για Megamoto

const int buttonLeft = 4;
const int buttonRight = 5;//κουμπιά για τη μετακίνηση του κινητήρα

const int CPin1 = A5;  // ανάδραση κινητήρα

int leftlatch = LOW;
int rightlatch = LOW;//μανδάλωση κινητήρα (για τη λογική του κώδικα)

int hitLimits = 0;//έναρξη στο 0
int hitLimitsmax = 10;//τιμές για να γνωρίζουμε αν επιτεύχθηκαν τα όρια διαδρομής

long lastfeedbacktime = 0; // πρέπει να είναι long, αλλιώς υπερχειλίζει
int firstfeedbacktimedelay = 750; //πρώτη καθυστέρηση για να αγνοηθεί η αιχμή ρεύματος
int feedbacktimedelay = 50; //καθυστέρηση μεταξύ κύκλων ανάδρασης, πόσο συχνά θέλετε να ελέγχεται ο κινητήρας
long currentTimefeedback = 0; // πρέπει να είναι long, αλλιώς υπερχειλίζει

int debounceTime = 300; //χρόνος αποθορυβοποίησης κουμπιών· χαμηλότερες τιμές τα κάνουν πιο ευαίσθητα
long lastButtonpress = 0; // χρονομέτρηση για αποθορυβοποίηση
long currentTimedebounce = 0;

int CRaw = 0;      // τιμή εισόδου για μετρήσεις ρεύματος
int maxAmps = 0; // όριο ενεργοποίησης 

bool dontExtend = false;
bool firstRun = true;
bool fullyRetracted = false;//λογική προγράμματος

void setup()
{
  Serial.begin(9600);
  pinMode(EnablePin, OUTPUT);
  pinMode(PWMPinA, OUTPUT);
  pinMode(PWMPinB, OUTPUT);//Ορισμός εξόδων κινητήρα
  pinMode(buttonLeft, INPUT);
  pinMode(buttonRight, INPUT);//κουμπιά
  
  digitalWrite(buttonLeft, HIGH);
  digitalWrite(buttonRight, HIGH);//ενεργοποίηση εσωτερικών pullups
  pinMode(CPin1, INPUT);//ορισμός εισόδου ανάδρασης
  
  currentTimedebounce = millis();
  currentTimefeedback = 0;//Ορισμός αρχικών χρόνων

  maxAmps = 15;// ΟΡΙΣΤΕ ΕΔΩ ΤΟ ΜΕΓΙΣΤΟ ΡΕΥΜΑ

}//end setup

void loop()
{
  latchButtons();//ελέγξτε τα κουμπιά, δείτε αν χρειάζεται κίνηση

  moveMotor();//ελέγξτε τις μανδαλώσεις, κινήστε τον κινητήρα εμπρός ή πίσω

}//end main loop

void latchButtons()
{
  if (digitalRead(buttonLeft)==LOW)//το αριστερό είναι εμπρός
  {
    currentTimedebounce = millis() - lastButtonpress;// έλεγχος χρόνου από την τελευταία πίεση
    if (currentTimedebounce > debounceTime && dontExtend == false)//αφού ενεργοποιηθεί το dontExtend, αγνοήστε όλες τις πιέσεις για εμπρός
    {
      leftlatch = !leftlatch;// αν ο κινητήρας κινείται, σταματήστε· αν είναι σταματημένος, αρχίστε να κινείτε
      firstRun = true;// ορίστε τη σημαία firstRun για να αγνοηθεί η αιχμή ρεύματος
      fullyRetracted = false; // μόλις κινηθεί εμπρός, δεν είναι πλήρως ανασυρμένο
      lastButtonpress = millis();//αποθήκευση χρόνου τελευταίας πίεσης κουμπιού
      return;
    }//end if
  }//end btnLEFT

  if (digitalRead(buttonRight)==LOW)//το δεξί είναι προς τα πίσω
  {
    currentTimedebounce = millis() - lastButtonpress;// έλεγχος χρόνου από την τελευταία πίεση

    if (currentTimedebounce > debounceTime)
    {
      rightlatch = !rightlatch;// αν ο κινητήρας κινείται, σταματήστε· αν είναι σταματημένος, αρχίστε να κινείτε
      firstRun = true;// ορίστε τη σημαία firstRun για να αγνοηθεί η αιχμή ρεύματος
      lastButtonpress = millis();//αποθήκευση χρόνου τελευταίας πίεσης κουμπιού
      return;    }//end if
  }//end btnRIGHT
}//end latchButtons

void moveMotor()
{
  if (leftlatch == HIGH) motorForward(255); //ταχύτητα = 0-255
  if (leftlatch == LOW) motorStop();
  if (rightlatch == HIGH) motorBack(255); //ταχύτητα = 0-255
  if (rightlatch == LOW) motorStop();

}//end moveMotor

void motorForward(int speeed)
{
  while (dontExtend == false && leftlatch == HIGH)
  {
    digitalWrite(EnablePin, HIGH);
    analogWrite(PWMPinA, speeed);
    analogWrite(PWMPinB, 0);//κινήστε τον κινητήρα
    if (firstRun == true) delay(firstfeedbacktimedelay); // μεγαλύτερη καθυστέρηση για αγνόηση αιχμής ρεύματος
    else delay(feedbacktimedelay); //μικρή καθυστέρηση για να φτάσει στην ταχύτητα

    getFeedback();
    firstRun = false;
    
    latchButtons();//ελέγξτε ξανά τα κουμπιά
  }//end while

}//end motorForward

void motorBack (int speeed)
{
  while (rightlatch == HIGH)
  {
    digitalWrite(EnablePin, HIGH);
    analogWrite(PWMPinA, 0);
    analogWrite(PWMPinB, speeed);//κινήστε τον κινητήρα
    if (firstRun == true) delay(firstfeedbacktimedelay);// μεγαλύτερη καθυστέρηση για αγνόηση αιχμής ρεύματος
    else delay(feedbacktimedelay); //μικρή καθυστέρηση για να φτάσει στην ταχύτητα
    getFeedback();

    firstRun = false;
    
    latchButtons();//ελέγξτε ξανά τα κουμπιά

  }//end while

  dontExtend = false;//επιτρέψτε στον κινητήρα να εκτείνεται ξανά, αφού έχει ανασυρθεί

}//end motorBack

void motorStop()
{
  analogWrite(PWMPinA, 0);
  analogWrite(PWMPinB, 0);

  digitalWrite(EnablePin, LOW);
  firstRun = true;//όταν ο κινητήρας σταματήσει, ενεργοποιήστε ξανά το firstRun για τις αιχμές ρεύματος εκκίνησης

}//end stopMotor

void getFeedback()
{
  CRaw = analogRead(CPin1); // Ανάγνωση ρεύματος

  if (CRaw == 0 && hitLimits < hitLimitsmax) hitLimits = hitLimits + 1;
  else hitLimits = 0; // ελέγξτε αν ο κινητήρας είναι στα όρια και το ρεύμα έχει σταματήσει 

  if (hitLimits == hitLimitsmax && rightlatch == HIGH)
  {
    rightlatch = LOW; // σταματήστε τον κινητήρα
    fullyRetracted = true;
  }//end if

  else if (hitLimits == hitLimitsmax && leftlatch == HIGH)
  {
    leftlatch = LOW;//σταματήστε τον κινητήρα
    hitLimits = 0;
  }//end if

  if (CRaw > maxAmps)
  {
    dontExtend = true;
    leftlatch = LOW; //σταματήστε αν η ανάδραση είναι πάνω από το μέγιστο
  }//end if

  lastfeedbacktime = millis();//αποθήκευση προηγούμενου χρόνου λήψης ανάδρασης
}//end getFeedback

Αυτός ο ενδεικτικός κώδικας δείχνει πώς να ελέγξετε έως και 4 από τους γραμμικούς ενεργοποιητές μας με το Arduino Uno και το LC-82 MultiMoto Arduino Shield, ωστόσο, μπορούν να χρησιμοποιηθούν παρόμοια προϊόντα ως αντικαταστάσεις. Αυτός ο κώδικας προορίζεται μόνο για χρήση με μοντέλα ενεργοποιητών εντός των περιορισμών ρεύματος σε κάθε κανάλι του MultiMoto, όπως τα PA-14 και PA-14P.

/*    Ενδεικτικός κώδικας για τον έλεγχο έως και 4 ενεργοποιητών, χρησιμοποιώντας τον οδηγό Robot Power MultiMoto.
   Υλικό:
    - Robot Power MultiMoto
    - Arduino Uno

    Καλωδίωση:
  - Συνδέστε τους ενεργοποιητές στις συνδέσεις M1, M2, M3, M4 στην πλακέτα MultiMoto.
  - Συνδέστε το αρνητικό (μαύρο) στη δεξιά σύνδεση, το θετικό (κόκκινο) στην αριστερή.
  - Συνδέστε μια πηγή 12 volt (ελάχιστο 1A ανά κινητήρα χωρίς φορτίο, 8A ανά κινητήρα με πλήρες φορτίο) στους ακροδέκτες BAT. Βεβαιωθείτε ότι το θετικό και το αρνητικό έχουν τοποθετηθεί στις σωστές θέσεις.

   Ο κώδικας τροποποιήθηκε από την Progressive Automations από τον ενδεικτικό κώδικα που παρέχεται από την Robot Power
     <a href="http://www.robotpower.com/downloads/" rel="nofollow"> http://www.robotpower.com/downloads/</a>

    Robot Power MultiMoto v1.0 demo
    Αυτό το λογισμικό κυκλοφορεί ως Public Domain
*/

// συμπερίληψη της βιβλιοθήκης SPI:

#include <SPI.h>
// L9958 ακίδες slave select για SPI
#define SS_M4 14
#define SS_M3 13
#define SS_M2 12
#define SS_M1 11
// L9958 ακίδες κατεύθυνσης
#define DIR_M1 2
#define DIR_M2 3
#define DIR_M3 4
#define DIR_M4 7
// L9958 ακίδες PWM
#define PWM_M1 9
#define PWM_M2 10    // Timer1
#define PWM_M3 5
#define PWM_M4 6     // Timer0


// L9958 Enable για όλους τους 4 κινητήρες
#define ENABLE_MOTORS 8

int pwm1, pwm2, pwm3, pwm4;
boolean dir1, dir2, dir3, dir4;

void setup() {
  unsigned int configWord;

  // τοποθετήστε εδώ τον κώδικα setup, για εκτέλεση μία φορά:
  pinMode(SS_M1, OUTPUT); digitalWrite(SS_M1, LOW);  // HIGH = δεν έχει επιλεγεί
  pinMode(SS_M2, OUTPUT); digitalWrite(SS_M2, LOW);
  pinMode(SS_M3, OUTPUT); digitalWrite(SS_M3, LOW);
  pinMode(SS_M4, OUTPUT); digitalWrite(SS_M4, LOW);

  // L9958 ακίδες κατεύθυνσης
  pinMode(DIR_M1, OUTPUT);
  pinMode(DIR_M2, OUTPUT);
  pinMode(DIR_M3, OUTPUT);
  pinMode(DIR_M4, OUTPUT);

  // L9958 ακίδες PWM
  pinMode(PWM_M1, OUTPUT);  digitalWrite(PWM_M1, LOW);
  pinMode(PWM_M2, OUTPUT);  digitalWrite(PWM_M2, LOW);    // Timer1
  pinMode(PWM_M3, OUTPUT);  digitalWrite(PWM_M3, LOW);
  pinMode(PWM_M4, OUTPUT);  digitalWrite(PWM_M4, LOW);    // Timer0

  // L9958 Enable για όλους τους 4 κινητήρες
  pinMode(ENABLE_MOTORS, OUTPUT); 
 digitalWrite(ENABLE_MOTORS, HIGH);  // HIGH = απενεργοποιημένο

/ /******* Ρύθμιση των L9958 chips *********
  ' L9958 Μητρώο ρυθμίσεων
  ' Bit
  '0 - RES
  '1 - DR - επαναφορά
  '2 - CL_1 - περιορισμός ρεύματος
  '3 - CL_2 - περιορισμός_ρεύματος
  '4 - RES
  '5 - RES
  '6 - RES
  '7 - RES
  '8 - VSR - ρυθμός μεταβολής τάσης (1 ενεργοποιεί τον περιορισμό, 0 απενεργοποιεί)
  '9 - ISR - ρυθμός μεταβολής ρεύματος (1 ενεργοποιεί τον περιορισμό, 0 απενεργοποιεί)
  '10 - ISR_DIS - απενεργοποίηση περιορισμού ρυθμού ρεύματος
  '11 - OL_ON - ενεργοποίηση open-load
  '12 - RES
  '13 - RES
  '14 - 0 - πάντα μηδέν
  '15 - 0 - πάντα μηδέν
  */  // ορίστε στο μέγιστο όριο ρεύματος και απενεργοποιήστε τον περιορισμό ρυθμού ISR
  configWord = 0b0000010000001100;

  SPI.begin();
  SPI.setBitOrder(LSBFIRST);
  SPI.setDataMode(SPI_MODE1);  // πολ. ρολογιού = low, φάση = high

  // Κινητήρας 1
  digitalWrite(SS_M1, LOW);
  SPI.transfer(lowByte(configWord));
  SPI.transfer(highByte(configWord));
  digitalWrite(SS_M1, HIGH);
  // Κινητήρας 2
  digitalWrite(SS_M2, LOW);
  SPI.transfer(lowByte(configWord));
  SPI.transfer(highByte(configWord));
  digitalWrite(SS_M2, HIGH);
  // Κινητήρας 3
  digitalWrite(SS_M3, LOW);
  SPI.transfer(lowByte(configWord));
  SPI.transfer(highByte(configWord));
  digitalWrite(SS_M3, HIGH);
  // Κινητήρας 4
  digitalWrite(SS_M4, LOW);
  SPI.transfer(lowByte(configWord));
  SPI.transfer(highByte(configWord));
  digitalWrite(SS_M4, HIGH);

  //Ορίστε αρχικές ρυθμίσεις ενεργοποιητή ώστε να τραβά με ταχύτητα 0 για λόγους ασφαλείας
  dir1 = 0; dir2 = 0; dir3 = 0; dir4 = 0; // Ορισμός κατεύθυνσης
  pwm1 = 0; pwm2 = 0; pwm3 = 0; pwm4 = 0; // Ορισμός ταχύτητας (0-255)

digitalWrite(ENABLE_MOTORS, LOW);// LOW = ενεργοποιημένο
} // End setup

void loop() {
    dir1 = 1;
    pwm1 = 255; //ορισμός κατεύθυνσης και ταχύτητας 
    digitalWrite(DIR_M1, dir1);
    analogWrite(PWM_M1, pwm1); // εγγραφή στις ακίδες

    dir2 = 0;
    pwm2 = 128;
    digitalWrite(DIR_M2, dir2);
    analogWrite(PWM_M2, pwm2);

    dir3 = 1;
    pwm3 = 255;
    digitalWrite(DIR_M3, dir3);
    analogWrite(PWM_M3, pwm3);

    dir4 = 0;
    pwm4 = 128;
    digitalWrite(DIR_M4, dir4);
    analogWrite(PWM_M4, pwm4);

    delay(5000); // περιμένετε μόλις ρυθμιστούν και οι τέσσερις κινητήρες

    dir1 = 0;
    pwm1 = 128;
    digitalWrite(DIR_M1, dir1);
    analogWrite(PWM_M1, pwm1);

    dir2 = 1;
    pwm2 = 255;
    digitalWrite(DIR_M2, dir2);
    analogWrite(PWM_M2, pwm2);

    dir3 = 0;
    pwm3 = 128;
    digitalWrite(DIR_M3, dir3);
    analogWrite(PWM_M3, pwm3);

    dir4 = 1;
    pwm4 = 255;
    digitalWrite(DIR_M4, dir4);
    analogWrite(PWM_M4, pwm4);

   delay(5000); 

}//end void loop

Αυτός ο ενδεικτικός κώδικας προορίζεται για τον συνδυασμό του μονοκάναλου ρυθμιστή ταχύτητας Wasp με το Arduino Uno, ώστε να ελέγχει την κίνηση ενός γραμμικού ενεργοποιητή, ωστόσο, μπορούν να χρησιμοποιηθούν παρόμοια προϊόντα ως αντικαταστάσεις.

/*Ενδεικτικός κώδικας για το Robot Power Wasp. 

 Αυτός ο ESC ελέγχεται με σήματα RC, με παλμούς
  στο εύρος 1000 - 2000 μικροδευτερόλεπτα.

  Η κύρια βρόχος του προγράμματος κρατά τον ενεργοποιητή ακίνητο για 1 δευτερόλεπτο, εκτείνει για 2 δευτερόλεπτα,
  σταματά για 1 δευτερόλεπτο, ανασύρει για 2 δευτερόλεπτα και επαναλαμβάνει.

  Τροποποιήθηκε από την Progressive Automations, χρησιμοποιώντας τον αρχικό ενδεικτικό κώδικα "Sweep" από τις 
  βιβλιοθήκες παραδειγμάτων του Arduino. 
  
  Υλικό:
  - 1 ελεγκτής Wasp
  - Arduino Uno
  
  Καλωδίωση:
  Πλευρά ελέγχου:
  - Συνδέστε τα κόκκινο/μαύρο στο +5v και στο GND
  - Συνδέστε το κίτρινο καλώδιο στο pin σήματος στο Arduino (σε αυτό το παράδειγμα, pin 9)
  Πλευρά ισχύος:
  - Συνδέστε το +/- του τροφοδοτικού του κινητήρα στις συνδέσεις +/- στο Wasp
  - Συνδέστε το +/- του ενεργοποιητή στις δύο υπόλοιπες συνδέσεις

  Αυτός ο ενδεικτικός κώδικας είναι δημόσιο κτήμα.
*/ 

#include <servo.h>  
Servo myservo;  // δημιουργήστε αντικείμενο servo για έλεγχο ενός σερβο 
                // στα περισσότερα boards μπορούν να δημιουργηθούν δώδεκα αντικείμενα servo
 
int pos = 0;    // μεταβλητή για αποθήκευση θέσης του servo 
 
void setup() 
{ 
  myservo.attach(9);  // αντιστοιχίζει το servo στο pin 9 στο αντικείμενο servo 
} 
 
void loop() 
{ 
 
    myservo.writeMicroseconds(1500); // σήμα διακοπής
    delay(1000);  //1 δευτερόλεπτο
    
    myservo.writeMicroseconds(2000); // σήμα: πλήρης ταχύτητα εμπρός
    delay(2000); //2 δευτερόλεπτα  
    
    myservo.writeMicroseconds(1500); // σήμα διακοπής
    delay(1000);  // 1 δευτερόλεπτο
    
    myservo.writeMicroseconds(1000); // σήμα: πλήρης ταχύτητα ανάστροφα
    delay(2000); //2 δευτερόλεπτα   

}

Αυτός ο ενδεικτικός κώδικας αξιοποιεί τα ρελέ μας και ένα Arduino Uno για να ελέγξει έναν γραμμικό ενεργοποιητή· ωστόσο, μπορούν να χρησιμοποιηθούν παρόμοια προϊόντα ως αντικαταστάσεις. Μπορείτε να διαβάσετε την πλήρη ανάρτηση στο blog για περισσότερες λεπτομέρειες.

const int forwards = 7;
const int backwards = 6;//αντιστοιχίστε το pin INx του ρελέ σε pin του arduino

void setup() {
 
pinMode(forwards, OUTPUT);//ορίστε το ρελέ ως έξοδο
pinMode(backwards, OUTPUT);//ορίστε το ρελέ ως έξοδο

}

void loop() {
  
 digitalWrite(forwards, LOW);
 digitalWrite(backwards, HIGH);//Ενεργοποιήστε το ρελέ προς μία κατεύθυνση· πρέπει να είναι διαφορετικά για να κινηθεί ο κινητήρας
 delay(2000); // περιμένετε 2 δευτερόλεπτα

 digitalWrite(forwards, HIGH);
 digitalWrite(backwards, HIGH);//Απενεργοποιήστε και τα δύο ρελέ για φρενάρισμα του κινητήρα
 delay(2000);// περιμένετε 2 δευτερόλεπτα
 
 digitalWrite(forwards, HIGH);
 digitalWrite(backwards, LOW);//Ενεργοποιήστε το ρελέ προς την άλλη κατεύθυνση· πρέπει να είναι διαφορετικά για να κινηθεί ο κινητήρας
 delay(2000);// περιμένετε 2 δευτερόλεπτα

 digitalWrite(forwards, HIGH);
 digitalWrite(backwards, HIGH);//Απενεργοποιήστε και τα δύο ρελέ για φρενάρισμα του κινητήρα
 delay(2000);// περιμένετε 2 δευτερόλεπτα

}

Αυτός ο ενδεικτικός κώδικας χρησιμοποιεί το LC-80 μας, Arduino Uno, οποιονδήποτε γραμμικό ενεργοποιητή και μία πηγή τροφοδοσίας· ωστόσο, μπορούν να χρησιμοποιηθούν παρόμοια προϊόντα ως αντικαταστάσεις. Μπορείτε να βρείτε περισσότερες λεπτομέρειες για τον κώδικα και τη λειτουργία του στην ανάρτηση στο blog μας.

//Χρησιμοποιήστε τα jumpers της πλακέτας για να επιλέξετε ποια pins θα χρησιμοποιηθούν
int EnablePin1 = 13;
int PWMPinA1 = 11;
int PWMPinB1 = 3;


int extendtime = 10 * 1000;  // 10 δευτερόλεπτα, επί 1000 για μετατροπή σε milliseconds
int retracttime = 10 * 1000; // 10 δευτερόλεπτα, επί 1000 για μετατροπή σε milliseconds
int timetorun = 300 * 1000; // 300 δευτερόλεπτα, επί 1000 για μετατροπή σε milliseconds


int duty;
int elapsedTime;
boolean keepMoving;


void setup() {
  Serial.begin(9600);
  pinMode(EnablePin1, OUTPUT);//Ενεργοποίηση της πλακέτας
  pinMode(PWMPinA1, OUTPUT);
  pinMode(PWMPinB1, OUTPUT);//Ορισμός εξόδων κινητήρα
  elapsedTime = 0; // Ορισμός χρόνου στο 0
  keepMoving = true; //Το σύστημα θα κινηθεί
  
}//end setup
void loop() {
  if (keepMoving) 
  {
    digitalWrite(EnablePin1, HIGH); // ενεργοποίηση κινητήρα
    pushActuator();
    delay(extendtime);
    stopActuator();
    delay(10);//μικρή καθυστέρηση πριν την ανάσυρση
    
    pullActuator();
    delay(retracttime);
    stopActuator();
    
    elapsedTime = millis();//πόση ώρα πέρασε;
    if (elapsedTime > timetorun) {//αν έχουν περάσει 300 δευτερόλεπτα, σταματήστε

      Serial.print("Ο καταγεγραμμένος χρόνος ξεπέρασε τον μέγιστο χρόνο λειτουργίας. Μέγιστος χρόνος: ");
      Serial.println(timetorun);
      keepMoving = false;  
    }
  }//end if
}//end main loop


void stopActuator() {
  analogWrite(PWMPinA1, 0);
  analogWrite(PWMPinB1, 0); // ταχύτητα 0-255
}


void pushActuator() {
  analogWrite(PWMPinA1, 255);
  analogWrite(PWMPinB1, 0); // ταχύτητα 0-255
}


void pullActuator() {
  analogWrite(PWMPinA1, 0);
  analogWrite(PWMPinB1, 255);//ταχύτητα 0-255
}

Αυτό το πρόγραμμα μπορεί να χρησιμοποιηθεί για συνεχή επέκταση και ανάσυρση της διαδρομής ενός γραμμικού ενεργοποιητή.

ΚΩΔΙΚΑΣ SETUP LOOP
void setup() {
  Serial.begin(9600);  // αρχικοποίηση σειριακής επικοινωνίας στα 9600 bits ανά δευτερόλεπτο

  pinMode(out_lim, INPUT_PULLUP); // ρυθμίζει το pin 45 ως είσοδο
  pinMode(in_lim, INPUT_PULLUP); // ρυθμίζει το pin 53 ως είσοδο
  pinMode(run_f, OUTPUT); // ρυθμίζει το pin 25 ως έξοδο
  pinMode(run_r, OUTPUT); // ρυθμίζει το pin 30 ως έξοδο
  
  retract(); // ανασύρει τη διαδρομή κατά την εκκίνηση
  delay(500);
}
void extend() // αυτή η συνάρτηση επιτρέπει στον κινητήρα να λειτουργεί
{
  digitalWrite(run_f, LOW);
  digitalWrite(run_r, HIGH);
}

void retract() // αυτή η συνάρτηση αντιστρέφει την κατεύθυνση του κινητήρα
{
  digitalWrite(run_f, LOW);
  digitalWrite(run_r, LOW);
 }

void run_stop() // αυτή η συνάρτηση απενεργοποιεί τον κινητήρα
{
  digitalWrite(run_f, HIGH);
  digitalWrite(run_r, HIGH);
}
void loop() {
  int out_lim_state = digitalRead(out_lim);     // διαβάζει τους τερματικούς διακόπτες και αποθηκεύει την τιμή τους
  int in_lim_state = digitalRead(in_lim);

  Serial.print("τιμή εξωτερικού τερματικού διακόπτη "), Serial.println(out_lim_state); // 0 -> ο τερματικός διακόπτης είναι πατημένος
  Serial.print("τιμή εσωτερικού τερματικού διακόπτη "), Serial.println(in_lim_state);  // 1 -> ο τερματικός διακόπτης δεν είναι πατημένος
  
  if (out_lim_state == 0 && in_lim_state == 1) // αν ο εξωτερικός τερματικός διακόπτης είναι πατημένος και ο εσωτερικός όχι (πλήρως εκτεταμένο)
  {
    retract(); // ανάσυρε τη διαδρομή
  }
 
else if (out_lim_state == 1 && in_lim_state == 0) // αν ο εσωτερικός τερματικός διακόπτης είναι πατημένος και ο εξωτερικός όχι (πλήρως ανασυρμένο)
  {
    extend(); // επέκτεινε τη διαδρομή
  }

  else // διαφορετικά, μην κάνεις τίποτα
  {
    
  }
delay(5);        // καθυστέρηση μεταξύ αναγνώσεων για σταθερότητα
}