Dieser Beispielcode verwendet MegaMoto Plus und einen Arduino Uno zur Überwachung des Stroms eines Linearantriebs; es können jedoch auch ähnliche Produkte als Ersatz verwendet werden.

/* 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 man bis zu 4 unserer Linearantriebe mit dem Arduino Uno steuern kann. LC-82 MultiMoto Arduino ShieldÄhnliche Produkte können jedoch als Ersatz verwendet werden. Dieser Code ist ausschließlich für die Verwendung mit Aktuatormodellen vorgesehen, die die aktuellen Beschränkungen der einzelnen Kanäle des MultiMoto, wie beispielsweise PA-14 und PA-14P, einhalten.

/* Beispielcode zur Ansteuerung von bis zu 4 Aktuatoren mit dem Robot Power MultiMoto-Treiber. Hardware: - Robot Power MultiMoto - Arduino Uno Verdrahtung: - Schließen Sie die Aktuatoren an die Anschlüsse M1, M2, M3 und M4 des MultiMoto-Boards an. - Verbinden Sie den Minuspol (schwarz) mit dem rechten und den Pluspol (rot) mit dem linken Anschluss. - Schließen Sie eine 12-Volt-Quelle (mindestens 1 A pro Motor im Leerlauf, 8 A pro Motor unter Volllast) an die BAT-Anschlüsse an. Achten Sie auf die korrekte Polarität. Der Code wurde von Progressive Automations auf Basis des von Robot Power bereitgestellten Beispielcodes modifiziert.  http://www.robotpower.com/downloads/ Robot Power MultiMoto v1.0 demo This software is released into the Public Domain
*/ // include the SPI library: #include 
// L9958 slave select pins for SPI
#define SS_M4 14
#define SS_M3 13
#define SS_M2 12
#define SS_M1 11
// L9958 DIRection 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 Enable for all 4 motors
#define ENABLE_MOTORS 8 int pwm1, pwm2, pwm3, pwm4;
boolean dir1, dir2, dir3, dir4; void setup() { unsigned int configWord; // put your setup code here, to run once: pinMode(SS_M1, OUTPUT); digitalWrite(SS_M1, LOW); // HIGH = not selected 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 DIRection 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 Enable for all 4 motors pinMode(ENABLE_MOTORS, OUTPUT); digitalWrite(ENABLE_MOTORS, HIGH); // HIGH = disabled / /******* Set up L9958 chips ********* ' L9958 Config Register ' Bit '0 - RES '1 - DR - reset '2 - CL_1 - curr limit '3 - CL_2 - curr_limit '4 - RES '5 - RES '6 - RES '7 - RES '8 - VSR - voltage slew rate (1 enables slew limit, 0 disables) '9 - ISR - current slew rate (1 enables slew limit, 0 disables) '10 - ISR_DIS - current slew disable '11 - OL_ON - open load enable '12 - RES '13 - RES '14 - 0 - always zero '15 - 0 - always zero */ // set to max current limit and disable ISR slew limiting configWord = 0b0000010000001100; SPI.begin(); SPI.setBitOrder(LSBFIRST); SPI.setDataMode(SPI_MODE1); // clock pol = 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); //Set initial actuator settings to pull at 0 speed for safety dir1 = 0; dir2 = 0; dir3 = 0; dir4 = 0; // Set direction pwm1 = 0; pwm2 = 0; pwm3 = 0; pwm4 = 0; // Set speed (0-255) digitalWrite(ENABLE_MOTORS, LOW);// LOW = enabled
} // End setup void loop() { dir1 = 1; pwm1 = 255; //set direction and speed digitalWrite(DIR_M1, dir1); analogWrite(PWM_M1, pwm1); // write to pins 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); // wait once all four motors are set 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

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-80Arduino Uno, beliebig Linearantrieb und eine Stromquelle; ähnliche Produkte können jedoch als Ersatz verwendet werden. Weitere Details zum Code und seiner Funktion finden Sie in unserer BlogbeitragDie

//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
}