Dieser Beispielcode verwendet MegaMoto Plus und einen Arduino Uno, um den Strom eines Linearantriebs zu überwachen, jedoch können ähnliche Produkte als Ersatz dienen.

/* Code to monitor the current amp draw of the actuator, and to cut power if it
 rises above a certain amount.

 Written by Progressive Automations
 August 19th, 2015

 Hardware:
 - RobotPower MegaMoto control boards
 - Arduino Uno
 - 2 pushbuttons
 */

const int EnablePin = 8;
const int PWMPinA = 11;
const int PWMPinB = 3; // pins for Megamoto

const int buttonLeft = 4;
const int buttonRight = 5;//buttons to move the motor

const int CPin1 = A5; // motor feedback

int leftlatch = LOW;
int rightlatch = LOW;//motor latches (used for code logic)

int hitLimits = 0;//start at 0
int hitLimitsmax = 10;//values to know if travel limits were reached

long lastfeedbacktime = 0; // must be long, else it overflows
int firstfeedbacktimedelay = 750; //first delay to ignore current spike
int feedbacktimedelay = 50; //delay between feedback cycles, how often you want the motor to be checked
long currentTimefeedback = 0; // must be long, else it overflows

int debounceTime = 300; //amount to debounce buttons, lower values makes the buttons more sensitive
long lastButtonpress = 0; // timer for debouncing
long currentTimedebounce = 0;

int CRaw = 0; // input value for current readings
int maxAmps = 0; // trip limit 

bool dontExtend = false;
bool firstRun = true;
bool fullyRetracted = false;//program logic

void setup()
{
 Serial.begin(9600);
 pinMode(EnablePin, OUTPUT);
 pinMode(PWMPinA, OUTPUT);
 pinMode(PWMPinB, OUTPUT);//Set motor outputs
 pinMode(buttonLeft, INPUT);
 pinMode(buttonRight, INPUT);//buttons
 
 digitalWrite(buttonLeft, HIGH);
 digitalWrite(buttonRight, HIGH);//enable internal pullups
 pinMode(CPin1, INPUT);//set feedback input
 
 currentTimedebounce = millis();
 currentTimefeedback = 0;//Set initial times

 maxAmps = 15;// SET MAX CURRENT HERE

}//end setup

void loop()
{
 latchButtons();//check buttons, see if we need to move

 moveMotor();//check latches, move motor in or out

}//end main loop

void latchButtons()
{
 if (digitalRead(buttonLeft)==LOW)//left is forwards
 {
 currentTimedebounce = millis() - lastButtonpress;// check time since last press
 if (currentTimedebounce > debounceTime && dontExtend == false)//once you've tripped dontExtend, ignore all forwards presses
 {
 leftlatch = !leftlatch;// if motor is moving, stop, if stopped, start moving
 firstRun = true;// set firstRun flag to ignore current spike
 fullyRetracted = false; // once you move forwards, you are not fully retracted
 lastButtonpress = millis();//store time of last button press
 return;
 }//end if
 }//end btnLEFT

 if (digitalRead(buttonRight)==LOW)//right is backwards
 {
 currentTimedebounce = millis() - lastButtonpress;// check time since last press

 if (currentTimedebounce > debounceTime)
 {
 rightlatch = !rightlatch;// if motor is moving, stop, if stopped, start moving
 firstRun = true;// set firstRun flag to ignore current spike
 lastButtonpress = millis();//store time of last button press
 return; }//end if
 }//end btnRIGHT
}//end latchButtons

void moveMotor()
{
 if (leftlatch == HIGH) motorForward(255); //speed = 0-255
 if (leftlatch == LOW) motorStop();
 if (rightlatch == HIGH) motorBack(255); //speed = 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);//move motor
 if (firstRun == true) delay(firstfeedbacktimedelay); // bigger delay to ignore current spike
 else delay(feedbacktimedelay); //small delay to get to speed

 getFeedback();
 firstRun = false;
 
 latchButtons();//check buttons again
 }//end while

}//end motorForward

void motorBack (int speeed)
{
 while (rightlatch == HIGH)
 {
 digitalWrite(EnablePin, HIGH);
 analogWrite(PWMPinA, 0);
 analogWrite(PWMPinB, speeed);//move motor
 if (firstRun == true) delay(firstfeedbacktimedelay);// bigger delay to ignore current spike
 else delay(feedbacktimedelay); //small delay to get to speed
 getFeedback();

 firstRun = false;
 
 latchButtons();//check buttons again

 }//end while

 dontExtend = false;//allow motor to extend again, after it has been retracted

}//end motorBack

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

 digitalWrite(EnablePin, LOW);
 firstRun = true;//once the motor has stopped, reenable firstRun to account for startup current spikes

}//end stopMotor

void getFeedback()
{
 CRaw = analogRead(CPin1); // Read current

 if (CRaw == 0 && hitLimits < hitLimitsmax) hitLimits = hitLimits + 1;
 else hitLimits = 0; // check to see if the motor is at the limits and the current has stopped 

 if (hitLimits == hitLimitsmax && rightlatch == HIGH)
 {
 rightlatch = LOW; // stop motor
 fullyRetracted = true;
 }//end if

 else if (hitLimits == hitLimitsmax && leftlatch == HIGH)
 {
 leftlatch = LOW;//stop motor
 hitLimits = 0;
 }//end if

 if (CRaw > maxAmps)
 {
 dontExtend = true;
 leftlatch = LOW; //stop if feedback is over maximum
 }//end if

 lastfeedbacktime = millis();//store previous time for receiving feedback
}//end getFeedback

Dieser Beispielcode zeigt, wie Sie bis zu 4 unserer Linearantriebe mit dem Arduino Uno und dem LC-82 MultiMoto Arduino Shield steuern können; ähnliche Produkte können jedoch als Ersatz verwendet werden. Dieser Code ist nur für die Verwendung mit Linearantriebsmodellen gedacht, die innerhalb der aktuellen Beschränkungen jedes Kanals des MultiMoto liegen, wie PA-14 und PA-14P.

/* Beispielcode zum Steuern von bis zu 4 Aktuatoren mithilfe des Robot Power MultiMoto-Treibers. Hardware: - Robot Power MultiMoto - Arduino Uno Verdrahtung: - Verbinden Sie die Aktuatoren mit den Anschlüssen M1, M2, M3, M4 auf der MultiMoto-Platine. - Verbinden Sie den negativen (schwarz) mit dem rechten Anschluss, den positiven (rot) mit dem linken. - Schließen Sie eine 12-Volt-Quelle (mindestens 1 A pro Motor bei unbelastetem Betrieb, 8 A pro Motor bei vollständig belastetem Betrieb) an die BAT-Klemmen an. Stellen Sie sicher, dass Plus und Minus an den richtigen Stellen angeschlossen sind. Code von Progressive Automations aus dem von Robot Power bereitgestellten Beispielcode angepasst  http://www.robotpower.com/downloads/</a> Robot Power MultiMoto v1,0 Demo Diese Software ist als Public Domain veröffentlicht
*/ // SPI-Bibliothek einbinden: #include 
// L9958 Slave-Select-Pins für SPI
#define SS_M4 14
#define SS_M3 13
#define SS_M2 12
#define SS_M1 11
// L9958 Richtungs-Pins
#define DIR_M1 2
#define DIR_M2 3
#define DIR_M3 4
#define DIR_M4 7
// L9958 PWM-Pins
#define PWM_M1 9
#define PWM_M2 10 // Timer1
#define PWM_M3 5
#define PWM_M4 6 // Timer0 // L9958 Aktivierung für alle 4 Motoren
#define ENABLE_MOTORS 8 int pwm1, pwm2, pwm3, pwm4;
boolean dir1, dir2, dir3, dir4; void setup() { unsigned int configWord; // Setup-Code hier platzieren; wird einmal ausgeführt: pinMode(SS_M1, OUTPUT); digitalWrite(SS_M1, LOW); // HIGH = nicht ausgewählt 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 Richtungs-Pins pinMode(DIR_M1, OUTPUT); pinMode(DIR_M2, OUTPUT); pinMode(DIR_M3, OUTPUT); pinMode(DIR_M4, OUTPUT); // L9958 PWM-Pins 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 Aktivierung für alle 4 Motoren pinMode(ENABLE_MOTORS, OUTPUT); digitalWrite(ENABLE_MOTORS, HIGH); // HIGH = deaktiviert / /******* L9958-Chips einrichten ********* ' L9958 Konfigurationsregister ' Bit '0 - RES '1 - DR - Reset '2 - CL_1 - Strombegrenzung '3 - CL_2 - Strombegrenzung '4 - RES '5 - RES '6 - RES '7 - RES '8 - VSR - Spannungsanstiegsrate (1 aktiviert Anstiegsbegrenzung, 0 deaktiviert) '9 - ISR - Stromanstiegsrate (1 aktiviert Anstiegsbegrenzung, 0 deaktiviert) '10 - ISR_DIS - Anstiegsbegrenzung für Strom deaktivieren '11 - OL_ON - Open-Load aktivieren '12 - RES '13 - RES '14 - 0 - immer Null '15 - 0 - immer Null */ // auf maximale Strombegrenzung setzen und ISR-Anstiegsbegrenzung deaktivieren configWord = 0b0000010000001100; SPI.begin(); SPI.setBitOrder(LSBFIRST); SPI.setDataMode(SPI_MODE1); // Taktpol = low, Phase = high // Motor 1 digitalWrite(SS_M1, LOW); SPI.transfer(lowByte(configWord)); SPI.transfer(highByte(configWord)); digitalWrite(SS_M1, HIGH); // Motor 2 digitalWrite(SS_M2, LOW); SPI.transfer(lowByte(configWord)); SPI.transfer(highByte(configWord)); digitalWrite(SS_M2, HIGH); // Motor 3 digitalWrite(SS_M3, LOW); SPI.transfer(lowByte(configWord)); SPI.transfer(highByte(configWord)); digitalWrite(SS_M3, HIGH); // Motor 4 digitalWrite(SS_M4, LOW); SPI.transfer(lowByte(configWord)); SPI.transfer(highByte(configWord)); digitalWrite(SS_M4, HIGH); // Anfangseinstellungen der Aktuatoren: zum Einziehen bei 0 Geschwindigkeit (Sicherheitsmaßnahme) dir1 = 0; dir2 = 0; dir3 = 0; dir4 = 0; // Richtung festlegen pwm1 = 0; pwm2 = 0; pwm3 = 0; pwm4 = 0; // Geschwindigkeit festlegen (0-255) digitalWrite(ENABLE_MOTORS, LOW);// LOW = aktiviert
} // Ende Setup void loop() { dir1 = 1; pwm1 = 255; // Richtung und Geschwindigkeit setzen digitalWrite(DIR_M1, dir1); analogWrite(PWM_M1, pwm1); // auf Pins schreiben 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); // warten, sobald alle vier Motoren eingestellt sind 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); }//Ende void loop

Dieser Beispielcode dient dazu, den Wasp‑Einkanal‑Geschwindigkeitsregler mit dem Arduino Uno zu kombinieren, um einen Linearantrieb anzusteuern; ähnliche Produkte können jedoch als Ersatz verwendet werden.

/*Beispielcode für den Robot Power Wasp. Dieser ESC wird mit RC-Signalen gesteuert, mit Pulsen im Bereich von 1000 - 2000 Mikrosekunden. Die Hauptschleife dieses Programms hält den Antrieb 1 Sekunde an, fährt 2 Sekunden aus, stoppt 1 Sekunde, fährt 2 Sekunden ein und wiederholt sich. Von Progressive Automations angepasst, basierend auf dem ursprünglichen Beispielcode „Sweep“ aus den Arduino-Beispielbibliotheken. Hardware: - 1 Wasp-Controller - Arduino Uno Verdrahtung: Steuerseite: - Rot/Schwarz an +5v und GND anschließen - Das gelbe Kabel mit dem Signalausgang am Arduino verbinden (in diesem Beispiel, Pin 9) Leistungsseite: - Das +/- der Motorstromversorgung an die +/- Anschlüsse des Wasp anschließen - Das +/- des Antriebs an die beiden verbleibenden Anschlüsse anschließen Dieser Beispielcode ist gemeinfrei.
*/ #include  Servo myservo; // Servo-Objekt zum Ansteuern eines Servos erstellen // Auf den meisten Boards können zwölf Servo-Objekte erstellt werden int pos = 0; // Variable zum Speichern der Servo-Position void setup() { myservo.attach(9); // ordnet den Servo an Pin 9 dem Servo-Objekt zu } void loop() { myservo.writeMicroseconds(1500); // Stopp-Signal delay(1000); //1 Sekunde myservo.writeMicroseconds(2000); // Signal: volle Geschwindigkeit vorwärts delay(2000); //2 Sekunden myservo.writeMicroseconds(1500); // Stopp-Signal delay(1000); // 1 Sekunde myservo.writeMicroseconds(1000); // Signal: volle Geschwindigkeit rückwärts delay(2000); //2 Sekunden }

Dieses Beispiel nutzt unsere Relais und ein Arduino Uno, um einen Linearantrieb zu steuern; ähnliche Produkte können als Ersatz verwendet werden. Weitere Details finden Sie in unserem vollständigen Blogbeitrag.

const int forwards = 7;
const int backwards = 6;//Relais-INx-Pin dem Arduino-Pin zuweisen void setup() { pinMode(forwards, OUTPUT);//Relais als Ausgang setzen
pinMode(backwards, OUTPUT);//Relais als Ausgang setzen } void loop() { digitalWrite(forwards, LOW); digitalWrite(backwards, HIGH);//Relais in eine Richtung aktivieren; die Pegel müssen unterschiedlich sein, damit sich der Motor bewegt delay(2000); // 2 Sekunden warten digitalWrite(forwards, HIGH); digitalWrite(backwards, HIGH);//Beide Relais deaktivieren, um den Motor zu bremsen delay(2000);// 2 Sekunden warten digitalWrite(forwards, HIGH); digitalWrite(backwards, LOW);//Relais in die andere Richtung aktivieren; die Pegel müssen unterschiedlich sein, damit sich der Motor bewegt delay(2000);// 2 Sekunden warten digitalWrite(forwards, HIGH); digitalWrite(backwards, HIGH);//Beide Relais deaktivieren, um den Motor zu bremsen delay(2000);// 2 Sekunden warten }

Dieser Beispielcode verwendet unseren LC-80, ein Arduino Uno, einen beliebigen Linearantrieb und eine Stromquelle; ähnliche Produkte können jedoch als Ersatz verwendet werden. Weitere Details zum Code und seiner Funktionsweise finden Sie in unserem Blogbeitrag.

//Use the jumpers on the board to select which pins will be used
int EnablePin1 = 13;
int PWMPinA1 = 11;
int PWMPinB1 = 3; int extendtime = 10 * 1000; // 10 seconds, times 1000 to convert to milliseconds
int retracttime = 10 * 1000; // 10 seconds, times 1000 to convert to milliseconds
int timetorun = 300 * 1000; // 300 seconds, times 1000 to convert to milliseconds int duty;
int elapsedTime;
boolean keepMoving; void setup() { Serial.begin(9600); pinMode(EnablePin1, OUTPUT);//Enable the board pinMode(PWMPinA1, OUTPUT); pinMode(PWMPinB1, OUTPUT);//Set motor outputs elapsedTime = 0; // Set time to 0 keepMoving = true; //The system will move }//end setup
void loop() { if (keepMoving) { digitalWrite(EnablePin1, HIGH); // enable the motor pushActuator(); delay(extendtime); stopActuator(); delay(10);//small delay before retracting pullActuator(); delay(retracttime); stopActuator(); elapsedTime = millis();//how long has it been? if (elapsedTime > timetorun) {//if it's been 300 seconds, stop Serial.print("Elapsed time is over max run time. Max run time: "); Serial.println(timetorun); keepMoving = false; } }//end if
}//end main loop void stopActuator() { analogWrite(PWMPinA1, 0); analogWrite(PWMPinB1, 0); // speed 0-255
} void pushActuator() { analogWrite(PWMPinA1, 255); analogWrite(PWMPinB1, 0); // speed 0-255
} void pullActuator() { analogWrite(PWMPinA1, 0); analogWrite(PWMPinB1, 255);//speed 0-255
}

Mit diesem Programm lässt sich die Hublänge eines Linearantriebs kontinuierlich aus- und einfahren.

SETUP-LOOP-CODE
void setup() {
 Serial.begin(9600); // initialisiert die serielle Kommunikation mit 9600 Bit pro Sekunde

 pinMode(out_lim, INPUT_PULLUP); // konfiguriert Pin 45 als Eingangspin
 pinMode(in_lim, INPUT_PULLUP); // konfiguriert Pin 53 als Eingangspin
 pinMode(run_f, OUTPUT); // konfiguriert Pin 25 als Ausgangspin
 pinMode(run_r, OUTPUT); // konfiguriert Pin 30 als Ausgangspin
 
 retract(); // fährt die Hublänge beim Start ein
 delay(500);
}
void extend() // diese Funktion lässt den Motor laufen
{
 digitalWrite(run_f, LOW);
 digitalWrite(run_r, HIGH);
}

void retract() // diese Funktion kehrt die Richtung des Motors um
{
 digitalWrite(run_f, LOW);
 digitalWrite(run_r, LOW);
 }

void run_stop() // diese Funktion deaktiviert den Motor
{
 digitalWrite(run_f, HIGH);
 digitalWrite(run_r, HIGH);
}
void loop() {
 int out_lim_state = digitalRead(out_lim); // liest die Endschalter und speichert deren Wert
 int in_lim_state = digitalRead(in_lim);

 Serial.print("Wert des äußeren Endschalters "), Serial.println(out_lim_state); // 0 -> Endschalter ist gedrückt
 Serial.print("Wert des inneren Endschalters "), Serial.println(in_lim_state); // 1 -> Endschalter ist nicht gedrückt
 
 if (out_lim_state == 0 && in_lim_state == 1) // wenn der äußere Endschalter gedrückt ist und der innere nicht (vollständig ausgefahren)
 {
 retract(); // Hublänge einfahren
 }
 
else if (out_lim_state == 1 && in_lim_state == 0) // wenn der innere Endschalter gedrückt ist und der äußere nicht (vollständig eingefahren)
 {
 extend(); // Hublänge ausfahren
 }

 else // andernfalls nichts tun
 {
 
 }
delay(5); // Verzögerung zwischen den Lesevorgängen für Stabilität
}