Actuator Zone

How Stroke Size Effects Overall Actuator Dimensions

Here at Progressive Automations we want to make sure our customers have all the resources necessary to select a linear actuator that fits the needs of whatever their project or application may be. One of the most important steps in finding that perfect actuator is selecting the proper stroke length. We've had many cases where customers know what type of unit they want and how much force they need but when it comes to the stroke size they are not 100% on what will fit to their specifications. That is why we decided to make a video and write this brief instructional guide on how to select a stroke size and how it will effect the dimensions of an actuator.

When selecting the stroke of your actuator you need to take into account the actuators dimensions, specifically the mounting hole to mounting hole length and the end to end length. These dimensions can be found in our actuator technical information PDFs found on actuator product pages and in the Technical Data section. Once you get these dimensions selecting the stroke and determining the overall length of the unit is much easier. For this example we will use a PA-14 mini linear actuator. The PA-14 has a retracted hole to hole length of 4.13" + stroke and an extended hole to hole length of 4.13" + stroke + stroke. It is important to note that stroke size has a direct effect on the total length of the unit.

So if the unit has a stroke length of 2" then you would just add that to the hole to hole length. So if the hole to hole length is 4.13" and the stroke length is 2" then the total retracted length of the unit is 6.13". For the extended length you just add the stroke again, making it 8.13". End to end dimensions are found the same way, just look at our PA-14 Mini Linear Actuator PDF to see the exact numbers. With this information you can now confidently purchase an actuator without worrying whether it will fit your project/application. For more information please take a look at the video below.

READ ARTICLE

Our New Mini Track Linear Actuator

We've recently added another new actuator model to our already diverse selection of electric linear actuators and we wanted to give a little introduction to this new unit. This new actuator is the PA-08 Mini Track Linear Actuator. This mini track actuator model combines the designs of two of our other actuator models to form a versatile new option for our customers.

The mini track incorporates the track design of our PA-18 Track Actuator with the compact size and shape of our PA-14 Mini Linear Actuator. Before you could only find the track design in our PA-18 but now with the PA-08 we offer it in a smaller package for lower force applications. The track design is different from normal actuators extend/retract design because the stroke does not extend out from the unit when activated. Instead the stroke moves back and forth along the length of the actuator rather then extending and retracting.

PA-08-2

This means when your calculating the amount of space needed in your project/application you only need to measure the total length of the unit instead of the taking the fully extended length into account as well. Combine that track design with the small size of our mini actuator and you have the perfect electric linear actuator for projects and applications where saving space is a must.

We've also added a new mounting bracket to go together with the 12V mini track linear actuators. This new bracket, the BRK-08 Mounting Bracket, attaches to the stroke section of the PA-08 to provide a stable and secure mounting option. For mounting on the ends of the actuator just use our BRK-14 mounting brackets since it has the same shape as our PA-14 mini electric actuators.

The specifications for our mini track actuator are as such:

  • Voltage: 12 VDC
  • Stroke: 2-30"
  • Force: 50 lbs
  • Speed: 1.18"/sec
  • Current: 5A

For the full list of specifications as well as a dimensional drawings and a parts list be sure to check out our PA-08 PDF for all the information you need on the electric mini track linear actuator. If you'd like to order one today you can do so online or or by contacting us through email or phone. We also have a staff of experienced engineers to help you find the perfect actuator for whatever you happen to be working as well as answering any other questions you may have.

READ ARTICLE

Intro To MegaMoto Motor Controllers

Two of our most popular motor controllers are the LC-80 MegaMoto Plus H bridge and the LC-81 MegaMoto GT, which act as shields for our Arduinos and can control our linear actuators. They can be configured as a single H-bridge circuit or as two individual half-bridge circuits. They are usable for a wide range of DC loads as long as they stay within the current and voltage limits of your application. They come with built-in current detection as well so you can set maximum limits in your code to keep your application safe.

The MegaMotos use a series of jumper pins to choose which pins to communicate with on the Arduino. This allows a lot of flexibility to control multiple MegaMotos at once. The jumper pins can be explained like this:

ENABLE PINS

This pin turns the board on, making it able to control a motor. For example the motor of one of our linear actuators. If this pin is disabled the motor will stop and you will lose control capabilities.

LC-80-3

PWMA/B PINS

These are the pins that control the movement of a motor, like the extension and retraction of a linear actuator. The extension and retraction limits will depend on how you connect the actuator to the A/B terminals.

SENSOR PINS

The sensor pins have 2 jumpers on them. The first vertical jumper that connects A2 and A3 is used to link the current sensors of the H-bridge together. For high current applications (over 10A) it is recommended to keep this jumper connected to prevent too much current going through the sensors. The second horizontal jumper decides which analog pin the Arduino will monitor feedback from.

LC-81-3

Now that we've briefly gone over the pins and their functions we can show an example on how to program these MegaMoto motor controllers. The code below is an example motion routine that is written with having three boards stacked, however lines are commented out so that only one board will be enabled. This example code will read the sensor pins.

/*  Sample code for the Robot Power MegaMoto.  This board can be stacked up to three
  times to control three motors.  The code is included for each motor in the setup routines,
  uncomment the lines of code to enable the motors you need.

  The main loop of this program ramps the speed of the first board from zero to max (0-255)
  over 1 second, holds it at max speed for 2 seconds, then ramps back down (255-0) for 1 second.
  The pins swap, so the direction changes, and the loop repeats.

  Modified by Progressive Automations, using the original example code from:
   http://www.robotpower.com/downloads/

  Hardware:
  - 1 to 3 RobotPower MegaMoto control boards
  - Arduino Uno
  
  Wiring:
  -Connect the +/- of the actuator to the A/B motor channels
  -Connect the +/- of the power supply to the +/- BAT connections

  This example code is in the public domain.
 */

int EnablePin1 = 8;
//int EnablePin2 = 12;
//int EnablePin3 = 13;
int duty;

//Use the jumpers on the board to select which A and B signals you want
int PWMPinA1 = 11;  // Timer2
int PWMPinB1 = 3;
//int PWMPinA2 = 9;  // Timer0
//int PWMPinB2 = 10;
//  int PWMPinA3 = 6;  // Timer1

//  int PWMPinB3 = 5;

const byte CPin1 = A0;  // analog input channel
//const byte CPin2 = A1;  // analog input channel
//const byte CPin3 = A4;  // analog input channel

int CRaw1;      // raw A/D value
//int CRaw2;
//int CRaw3;

void setup() {

Serial.begin(9600);

  pinMode(EnablePin1, OUTPUT);
  //pinMode(EnablePin2, OUTPUT);
  //pinMode(EnablePin3, OUTPUT);//Enable the boards

  pinMode(PWMPinA1, OUTPUT);
  pinMode(PWMPinB1, OUTPUT);
  //pinMode(PWMPinA2, OUTPUT);
  //pinMode(PWMPinB2, OUTPUT);
  //pinMode(PWMPinA3, OUTPUT);
  //pinMode(PWMPinB3, OUTPUT);//Set motor outputs

}//end setup

void loop() {
  digitalWrite(EnablePin1, HIGH); //enable the board
  analogWrite(PWMPinB1, 0); //Set pinB to 0, when speed is written to pinA the motor will extend
  for (duty = 0; duty <= 255; duty += 5) // ramp up speed
  {
    analogWrite(PWMPinA1, duty);
    delay(5);
  }
  analogWrite(PWMPinA1, 255);//end at max speed
  CRaw1 = analogRead(CPin1);

  Serial.println("Feedback");

 Serial.print(CRaw1);


  delay(2000);//hold speed
  for (duty = 255; duty >= 0; duty -= 5) // ramp down speed
  {
    analogWrite(PWMPinA1, duty);
    delay(20);
  }
  analogWrite(PWMPinA1, 0); //set to 0 speed
  delay(500);
 
  digitalWrite(EnablePin1, LOW);// Toggle enable to reset the power chips if we have had an overcurrent or overtemp fault

  delay(500);  // Swap pins to make the motor change direction
  if (PWMPinA1 == 11)
  {
    PWMPinA1 = 3;
    PWMPinB1 = 11;
  }
  else
  {
    PWMPinA1 = 11;
    PWMPinB1 = 3;
  }

  /*if (PWMPinA2 == 9)
    {
    PWMPinA2 = 10;
    PWMPinB2 = 9;
  }
  else
  {
    PWMPinA2 = 9;
    PWMPinB2 = 10;
  }*/

  /*if(PWMPinA3 == 6)
    {
     PWMPinA3 = 5;
     PWMPinB3 = 6;
   }
   else
   {
     PWMPinA3 = 6;
     PWMPinB3 = 5;
   }*/

}//end main loop

 

This code can be modified to provide a variety of different control options and movement capabilities, including motion control of up to six linear actuators. The MegaMotos can be used and combined with many our of different control systems. If you'd like to learn more about how they work and what can be done with them please contact us to get in touch with one of our highly trained engineers. We can even custom make a control system for you based on your specifications.

READ ARTICLE

Pulse Width Modulation vs Variable Voltage Control

When controlling the speed of a DC motor, like the ones found in our electric linear actuators, it is possible to use both Pulse Width Modulation (PWM) and Analog Voltage Control however there are large benefits to one (PWM) over the other (Analog Voltage). When varying the voltage of a DC motor, it results in large amounts of power dissipation. Sometimes it may even cause the motor to stall due to the loss of torque. This is why it is considered a highly inefficient circuit and the main reason why PWM control is the industry standard.

PWM is able to supply full rated voltage to the motor at all times without having to worry about stalling issues or torque loss. The speed control aspect comes into effect as you vary the duty cycle of the PWM. The diagram below shows how this works.

figure 1

 

Induction of the motor will cause the current to average which will keep the torque in proportion to the current, unlike variable voltage control. By changing the duty cycle you can achieve top quality speed control while maintaining torque and efficiency in the process.

figure 2

 

PWM is not without its faults though, specifically in relation to the frequency of the signal. If the frequency of the pulses is too high or too slow then proper averaging will not happen inside of the motor windings. The figure below shows how important the rise time of the voltage is.

figure 3

 

To make sure the voltage has enough time to reach its steady state calculations can be made in regards to the values of the system. This may be a bit much for most applications, as most frequencies in the range of a few KHz will work just fine, but for applications where precision is key then this calculation will be very important.

If you found this article helpful be sure to look through our blog section for other informative articles like this. If you have any questions about this article or our products please contact us and we'll make sure to help with whatever you need.

READ ARTICLE

Monitoring Actuator Current with an LCD Screen

In this blog post we will be learning how to monitor the current of a linear actuator using an LCD screen. Using an LCD screen is a great option because it lets you see just how much current the actuator is using and also lets you adjust the current limits as needed. First we will go over how to how to use the LCD board and its buttons and how to integrate it with out Arduino microcontroller. Then we'll go over how to write and set values on to the LCD which will allow us to see whats its doing in real time.

For this project we will be using:

Take the LCD screen and you'll see there are six buttons on it; Up, Down, Left, Right, Select and Reset. For this project we will be using the four directional buttons. The Up and Down buttons will be controlling the current limit while the Left and Right buttons will be controlling the actuator. One of the nice things about this LCD board is that all six buttons are put through a digital to analog converter so that they all only take up one pin. The only downside to this is that you need to calibrate each button individually.

IMG_0355

The best way to do this is to use the Arduino AnalogReadSerial example code to see the value of each button press. There are six values that you need to be able to see; the five values of the buttons and the value that you get when you don't press any buttons. Once you get the readings of the button presses you'll want to confirm they are all working by using the provided code below. Some extra comments have been added to it to explain what every line is for. Once everything is tested and all the values are recorded we'll be able to go on to the next step

//Sample using LiquidCrystal library

#include <LiquidCrystal.h>

/*******************************************************

This program will test the LCD panel and the buttons
Mark Bramwell, July 2010

********************************************************

// select the pins used on the LCD panel
LiquidCrystal lcd(8, 9, 4, 5, 6, 7); //rs, enable, d4,d5,d6,d7

// define some values used by the panel and buttons
int lcd_key     = 0;//which button was pressed
int adc_key_in  = 0;//what was the input of the DAC

#define btnRIGHT  0
#define btnUP     1
#define btnDOWN   2
#define btnLEFT   3
#define btnSELECT 4
#define btnNONE   5 //set button return values

const int btnup = 130;
const int btndown = 306;
const int btnleft = 479;
const int btnright = 0;
const int select = 720;
const int none = 127; //Put your button values here
const int threshold = 2; //Put threshold value here

int read_LCD_buttons()
{
 adc_key_in = analogRead(A0);      // read the value from the sensor 
if (adc_key_in > none - threshold && adc_key_in < none + threshold)   return btnNONE; // We make this the 1st option for speed reasons since it will be the most likely result
if (adc_key_in > btnup - threshold && adc_key_in < btnup + threshold)   return btnUP;
if (adc_key_in > btndown - threshold && adc_key_in < btndown + threshold)   return btnDOWN;
if (adc_key_in > btnleft - threshold && adc_key_in < btnleft + threshold)   return btnLEFT;
if (adc_key_in > btnright - threshold && adc_key_in < btnright + threshold)   return btnRIGHT;
if (adc_key_in > select - threshold && adc_key_in < select + threshold)   return btnSELECT;

//if else statements could be used, but since each statement uses return, you don't lose speed for using all if's

 return btnNONE;  // when all others fail, return this...
}//end read_LCD_Buttons

void setup()
{
 lcd.begin(16, 2);              // start the library
 lcd.setCursor(0,0); // Set cursor to upper left corner
 lcd.print("Push the buttons"); // print a simple message
}//end setup
 
void loop()
{
 lcd.setCursor(9,1);            // move cursor to second line "1" and 9 spaces over
 lcd.print(millis()/1000);      // display seconds elapsed since power-up

 lcd.setCursor(0,1);            // move to the begining of the second line
 lcd_key = read_LCD_buttons();  // read the buttons

 switch (lcd_key)               // depending on which button was pushed, we perform an action
 {
   case btnRIGHT:
     {
     lcd.print("RIGHT ");
     break;
     }
   case btnLEFT:
     {
     lcd.print("LEFT   ");
     break;
     }
   case btnUP:
     {
     lcd.print("UP    ");
     break;
     }
   case btnDOWN:
     {
     lcd.print("DOWN  ");
     break;
     }
   case btnSELECT:
     {
     lcd.print("SELECT");
     break;
     }
     case btnNONE:
     {
     lcd.print("NONE  ");
     break;
     }
 }//end switch

}//end loop

Now we'll need to do some wiring with our MegaMoto. Connect your power supply to the BAT +/- terminals and connect the actuator to the MOTA and MOTB terminals. Then set the MegaMoto pins like so: Enable - 13, PWMA - 11, PWMB - 3 and Sensor - A5. With this wiring the Left button should make our actuator extend while the Right button should make it retract. If for some reason the directions are reversed just switch the MOTA and MOTB connections.

IMG_0359

With the buttons configured we'll add the LCD program with four new functions. These functions are Read_LCD_buttons(), updateTrip(), updateLCD() and printFeedback(). Read_LCD_buttons() is the same as the text program and monitors the status of the button presses from the LCD. UpdateTrip() monitors the results of the Up and Down buttons as well as changing the amp limit. UpdateLCD() is the primary writing function and writes all the new information to the screen while PrintFeedback() shows the current amperage on the screen. Now to test everything using the code below.

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

  Written by Progressive Automations
  July 16th, 2015

  Hardware:
  - RobotPower MegaMoto control boards
  - LCD shield
  - Arduino Uno
 */
#include <LiquidCrystal.h>


LiquidCrystal lcd(8, 9, 4, 5, 6, 7);// select the pins used on the LCD panel

// define some values used by the panel and buttons
#define btnRIGHT  1
#define btnUP     2
#define btnDOWN   3
#define btnLEFT   4
#define btnSELECT 5
#define btnNONE   0

int lcd_key     = 0;
int adc_key_in  = 0;//value to read LCD button input

const int btnup = 130;
const int btndown = 306;
const int btnleft = 479;
const int btnright = 0;
const int select = 720;
const int none = 1023;
const int threshold = 2;//Analog values for LCD buttons

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

const int CPin1 = A5;  // motor feedback

int button = 0;//value to read LCD buttons

int leftlatch = LOW;
int rightlatch = LOW;//motor latches

int hitLimits = 0;
int hitLimitsmaxfront = 10;
int hitLimitsmaxback = 5;//values to know if travel limits were reached

long lastfeedbacktime = 0;
int firstfeedbacktimedelay = 750; //first delay to ignore current spike
int feedbacktimedelay = 50; //delay between feedback cycles
long currentTimefeedback = 0;

int debounceTime = 500; //amount to debounce
long lastButtonpress = 0; // timer for debouncing
long currentTimedebounce = 0;

int CRaw = 0;      // raw A/D value

int maxAmps = 0; // trip limit

long currentTimetrip = 0;
long lastUpdate = 0;
int updateTime = 100;//how fast can trip values update

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

char* title[] = {"  PROGRESSIVE", "  AUTOMATIONS"};        //Power on title

void setup()
{
  Serial.begin(9600);

  pinMode(EnablePin, OUTPUT);
  pinMode(PWMPinA, OUTPUT);
  pinMode(PWMPinB, OUTPUT);//Set motor outputs

  pinMode(CPin1, INPUT);//set feedback input

  lcd.begin(16, 2);// start the library
  lcd.setCursor(0, 0), lcd.print(title[0]), lcd.setCursor(0, 1), lcd.print(title[1]); //Print title
  delay(2000);//show title for 2 seconds

  currentTimetrip = millis();
  currentTimedebounce = millis();
  currentTimefeedback = 0;//Set initial times

  lcd.setCursor(0, 0);
  lcd.print("Amps Feedback"); // print the menu message

  updateLCD(); //write new values to the screen

}//end setup

void loop()
{
  //Serial.println("Main loop");

  updateTrip();//check buttons, update amperage

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

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

}//end main loop

void updateLCD()
{
  lcd.setCursor(0, 1);
  lcd.print("Amps:  0");

  lcd.setCursor(8, 1);
  lcd.print("Trip:  0");

  lcd.setCursor(13, 1);
  lcd.print("   ");//clear old value

  if (maxAmps > 99) lcd.setCursor(13, 1);
  else if (maxAmps > 9) lcd.setCursor(14, 1);
  else lcd.setCursor(15, 1);

  lcd.print(maxAmps);//write new value

}//end updateLCD

void latchButtons()
{
  button = read_LCD_buttons();

  if (button == btnLEFT && rightlatch != HIGH)//left is forwards
  {
    currentTimedebounce = millis() - lastButtonpress;
    if (currentTimedebounce > debounceTime && dontExtend == false)//once you've tripped dontExtend, ignore all forwards presses
    {
      leftlatch = !leftlatch;
      button = btnNONE;
      firstRun = true;
      lastButtonpress = millis();
      return;
    }//end if
  }//end btnLEFT

  if (button == btnRIGHT && leftlatch != HIGH)//right is backwards
  {
    currentTimedebounce = millis() - lastButtonpress;
    if (currentTimedebounce > debounceTime)
    {
      rightlatch = !rightlatch;
      button = btnNONE;
      firstRun = true;
      lastButtonpress = millis();
      return;
    }//end if
  }//end btnRIGHT
}//end latchButtons

int read_LCD_buttons()
{
  adc_key_in = analogRead(A0);      // read the value from the sensor
  delay(20);

  if (adc_key_in > none - threshold && adc_key_in < none + threshold)   return btnNONE;
  if (adc_key_in > btnup - threshold && adc_key_in < btnup + threshold)   return btnUP;
  if (adc_key_in > btndown - threshold && adc_key_in < btndown + threshold)   return btnDOWN;
  if (adc_key_in > btnleft - threshold && adc_key_in < btnleft + threshold)   return btnLEFT;
  if (adc_key_in > btnright - threshold && adc_key_in < btnright + threshold)   return btnRIGHT;
  if (adc_key_in > select - threshold && adc_key_in < select + threshold)   return btnSELECT;

  return btnNONE;  // when all others fail, return none

}//end readLCD

void updateTrip()
{
  if (button == btnUP)
  {
    currentTimetrip = millis() - lastUpdate;
    if (currentTimetrip > updateTime)
    {
      maxAmps = maxAmps + 1;

      if (maxAmps > 999) maxAmps = 0;//check for rollover

      lcd.setCursor(13, 1);
      lcd.print("   ");//clear old value

      if (maxAmps > 99) lcd.setCursor(13, 1);
      else if (maxAmps > 9) lcd.setCursor(14, 1);
      else lcd.setCursor(15, 1);//set cursor accordingly

      lcd.print(maxAmps);//write new value

      lastUpdate = millis();
    }//end if
  }//end if btnUP

  else if (button == btnDOWN)
  {
    currentTimetrip = millis() - lastUpdate;
    if (currentTimetrip > updateTime)
    {
      maxAmps = maxAmps - 1;

      if (maxAmps < 0) maxAmps = 999;//check for rollover

      lcd.setCursor(13, 1);
      lcd.print("   ");//clear old value

      if (maxAmps > 99) lcd.setCursor(13, 1);
      else if (maxAmps > 9) lcd.setCursor(14, 1);
      else lcd.setCursor(15, 1);//set cursor accordingly

      lcd.print(maxAmps);//write new value

      lastUpdate = millis();
    }//end if
  }//end else if btnDOWN

}//end updateTrip

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)
  {
    //Serial.println("Moving forwards");
    digitalWrite(EnablePin, HIGH);
    analogWrite(PWMPinA, speeed);
    analogWrite(PWMPinB, 0);//move motor
    if (firstRun == true) delay(firstfeedbacktimedelay);
    else delay(feedbacktimedelay); //small delay to get to speed

    getFeedback();

    firstRun = false;

    latchButtons();
  }//end while

}//end motorForward

void motorBack (int speeed)
{
  while (rightlatch == HIGH)
  {
    //Serial.println("Moving Back");
    digitalWrite(EnablePin, HIGH);
    analogWrite(PWMPinA, 0);
    analogWrite(PWMPinB, speeed);//move motor
    delay(3); //small delay to get to speed

    currentTimefeedback = millis() - lastfeedbacktime;

    if (firstRun == true && currentTimefeedback > firstfeedbacktimedelay) getFeedback(); //if it hasnt been long enough, do nothing
    if (firstRun == false && currentTimefeedback > feedbacktimedelay) getFeedback(); //if it hasnt been long enough, do nothing

    firstRun = false;

    latchButtons();

  }//end while

  dontExtend = false;

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

  if (CRaw == 0 && hitLimits < hitLimitsmaxback) hitLimits = hitLimits + 1;
  else if (CRaw == 0 && hitLimits < hitLimitsmaxfront) hitLimits = hitLimits + 1;
  else hitLimits = 0;

  if (hitLimits == hitLimitsmaxback)
  {
    rightlatch = LOW;
  }//end if

  if (hitLimits == hitLimitsmaxfront)
  {
    leftlatch = LOW;
    hitLimits = 0;
  }//end if

  if (CRaw > maxAmps)
  {
    dontExtend = true;
    leftlatch = LOW;
  }//end if

  printFeedback();

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

void printFeedback()
{
  lcd.setCursor(5, 1);
  lcd.print("   ");

  if (CRaw > 99) lcd.setCursor(5, 1);
  else if (CRaw > 9) lcd.setCursor(6, 1);
  else lcd.setCursor(7, 1);
  lcd.print(CRaw);

}//end printFeedback

IMG_0350

With that you should be able to monitor the force feedback of the linear actuator with the LCD screen. Everything used in this project can be found on our website and is in stock and ready to ship. If you'd like to order any of the products used here or want to learn more about them please contact us by phone or email.

READ ARTICLE

Position Control of a Linear Electric Actuator w/ Analog Sensor

In today's post we will be going over how to control the position of a linear electric actuator by utilizing an analog sensor, in this case a potentiometer. For this example we'll be using one of our PA-14P electric actuators,  an Arduino Uno, a MegaMoto motor controller, a separate potentiometer and a breadboard. Before we do anything we will need to wire everything together in order for it to function. The wiring procedure goes like this:

position

1) Connect the MegaMoto motor controller to the Arduino Uno

-Connect the Enable jumper pin to D8

-Connect PWM pin A to D11

-Connect PWM pin B to D3

-Make sure your sensor is not on A0 or A1.

2) With your 12V power supply connect the BAT+ to Vin

3) Connect your linear electric actuator to the MOTA and MOTB points.

4) For this next part we recommend using a breadboard to make the next connections much simpler. Connect the electric actuators POT wires like so:

-Connect the Yellow wire to 5V

-Connect the White wire to GND

-Connect the Blure wire to A1

5) With the separate potentiometer we want to connect it like so:

-Connect one side to 5V

-Connect other side to GND

-Connect the middle pin to A0.

6) Finally connect the 12V power supply to the BAT+ and BAT- points on the MegaMoto motor controller.

position2

With the wiring finished we can know start the programming aspect of this example. With this program the goal is get a reading of the potentiometer and the actuators position, then compare them. If the positions are different then all you need to do is extend or retract the actuator until they match. Use this code below to view the potentiometers position and match it up with the actuator.

const int feedback = A0; //potentiometer from actuator
const int pot = A1; //pot from throttle

const int enable = 8;
const int PWMA = 11;
const int PWMB = 3;

int actMax = 760;
int actMin = 250;//positions of actuator

int potMin = 0;
int potMax = 1023;

int precision = 2;//how close to final value to get
int checkingInterval = 50;//how often position is checked (milliseconds)

int rawcurrentPosition = 0;
int currentPosition = 0;
int rawdestination = 0;
int destination = 0;
int difference = 0;//values for knowing location

void setup()
{
  pinMode(feedback, INPUT);//feedback from actuator
  pinMode(pot, INPUT);//feedback from potentiometer
  pinMode(enable, OUTPUT);
  pinMode(PWMA, OUTPUT);
  pinMode(PWMB, OUTPUT);//three pins for MegaMoto
  digitalWrite(enable,HIGH);
  Serial.begin(9600);
}

void loop()
{   
    destination = getDestination(); 
    currentPosition = analogRead(feedback);//check where you are
    Serial.print("Position    ");
    Serial.println(analogRead(feedback));
    difference = destination - currentPosition;//find out how far you are from the destination
    if (currentPosition > destination) pullActuatorUntilStop(destination);// choose what action to take
    else if (currentPosition < destination) pushActuatorUntilStop(destination);
    else if (difference < precision && difference > -precision) stopActuator();
}//end void loop

int getDestination()
{
    rawdestination = analogRead(pot);//read the potentiometer to get the destination
    destination = map(rawdestination, potMin,potMax,actMin,actMax);//convert the potentiometer feedback to match the actuator
    return(destination);
}//end getDestination

void pushActuatorUntilStop(int destination)
{
  destination = getDestination();
  int temp = analogRead(feedback); 
  difference = destination - temp;//check difference to see if continue moving, or stop

  while (difference > precision || difference < -precision)
  {
    destination = getDestination();
    temp = analogRead(feedback); //continue checking difference
    difference = destination - temp;
    pushActuator();
  }//end while
  
  delay(25);
  stopActuator();
}//end pushActuatorUntilStop

void pullActuatorUntilStop(int destination)
{
  destination = getDestination();
  int temp = analogRead(feedback); //check difference to see if continue moving, or stop
  difference = destination - temp;

  while (difference > precision || difference < -precision)
  {
    destination = getDestination();
    temp = analogRead(feedback); //continue checking difference
    difference = destination - temp;
    pullActuator();
  }//end while
  
  delay(25);
  stopActuator();
}//end pullActuatorUntilStop

void stopActuator()
{
  analogWrite(PWMA,0);
  analogWrite(PWMB,0);
}//end stopActuator

void pushActuator()
{ 
  analogWrite(PWMB,255);
  analogWrite(PWMA,0);
}//end pushActuator

void pullActuator()
{
  analogWrite(PWMB,0);
  analogWrite(PWMA,255);
}//end pullActuator

 

This was a basic overview of position control of a linear actuator. If you'd like to purchase anything we used in this example you can order online or contact us to order by phone. Please do not hesitate to contact us if you have any questions or concerns about our products as well, we are always ready and able to help with whatever you have in mind.

 

READ ARTICLE

Wiring Rocker Switches with Linear Actuators

Wiring together parts can sometimes be a difficult procedure if you don’t have experience with it so we’ve decided show you how. In this case we will show the steps needed in order to wire together some of our rocker switches with our linear actuators. The rocker switches we will be using are the RC-03, RC-07 and RC-08. There are two main types of rocker switches, momentary and non-momentary (also referred to as latching and non-latching). Momentary means you have to hold down the switch in order to maintain the connection while non-momentary means you just have to press it once to start and once to stop. We have rocker switch models of both the momentary and non-momentary variety but in this case we will stick to the momentary switches.

We’ll start with the simplest wiring procedure first, which is the RC-03. The two connectors in the center, T2 & T5, are the common connectors in this case. Now in order to control the linear actuator with this rocker switch we’ll need to begin wiring. This is a relatively simple wiring procedure that only takes three steps (refer to this diagram for clarification):

  1. Connect the T3 and T4 connectors to the negative terminal (GND) on the power supply.
  2. Connect the T1 and T6 connectors to the positive terminal (12V) on the power supply.
  3. Connect the T2 and T5 connectors to the linear actuator wires.

IMG_0121

Once everything is connected you can press the switch to apply 12V to the actuator which should make it extend. When you press the switch to the opposite side then the actuator should retract. Now we’ll move on to the wiring of the RC-07.

This round, push-button rocker switch uses different switches then the RC-03 that we just wired. It has two switches with each having a Normally Open (NO) and Normally Closed (NC) connection. It also features a 12V LED that lights up to let you know everything is wired and ready to go. Another thing that differentiates the RC-07 from the RC-03 is that fact that it has a lower current limit. We’d recommend using a relay if you plan on controlling more than 2A, you can refer to our last post for more information on how to wire a 12V relay, but for now we will just focus on wiring the rocker switch. For this switch we will wire it so that the actuator will extend when you press the button, then retract after releasing the button. To do so follow these steps:

  1. Connect the T1 and T7 connectors to the negative terminal (GND) on the power supply
  2. Connect the T3 and T5 connectors to the positive terminal (12V) on the power supply
  3. Connect the T2 and T4 connectors to one actuator wire
  4. Connect the T6 and T8 connectors to the other actuator wire.

IMG_0124

Finally we’ll go over the procedure for wiring our RC-08 joystick, which has four NO switches. For example when you move the joystick to the right the right switch will close, when you move it down the lower switch closes etc. In this example we’ll use the joystick to control 2 actuators, having the left/right movements controlling one and the up/down movements controlling the other. This means that when the joystick is in its neutral position (the middle) the actuators won’t move. When you move it to the left actuator 1 will extend and when you move it to the right it will retract. When you move it up actuator 2 will extend and when you move it down it will retract. Take a look at our handy wiring diagram to see how to get this done. Notice that we are using relays in the diagram so you can change the directions if need be.

IMG_0131

As always if you have questions regarding our products or would simply like to make an order you can contact us today, we’re always ready to help with whatever you have in mind. Hopefully you found this useful and be sure to Follow, Like and Subscribe if you want to stay up to date on all of our latest content.

READ ARTICLE

Microcontrollers and their Applications

In recent months you may have noticed we've added a bunch of exciting new products to our inventory, none more so than our selection of microcontrollers and their accessories. These compact devices allow for more control options with our linear actuators, and other technological applications, than you have ever had before. They can combine with our other standard control systems as well to make some truly inventive projects and designs. Any type of advanced motion control is made possible with these controllers such as creating timers, counters or routines for your actuators to extend and retract to. One thing that really separates them from most control systems is that they allow multiple input and output arrangements whereas most control systems are designed with only one input and output.

arduino_leonardo_LC-057-2

Our selection of microcontrollers, including Arduino microcontrollers, offer many different input options for controlling your units. You can control them based on sound, motion, temperature, NFC (near field communication) and humidity just to name a few options. To go with our microcontrollers we also have many accessories and attachments including H-bridge shieldsUSB shields, an LCD keypad and lead extensions. We wanted to make sure our customers have everything they need when it comes to their control systems and our wide selection reflects that. We even offer custom programming options for our microcontroller boards, where are highly skilled engineer staff will custom build a control system using all these pieces of technology to make whatever type of motion control you have in mind. We house all this tech in a custom enclosure designed to keep your system safe and secure.

arduino_uno_lc_066-2

An example of custom motion control using our new technology would be having linear actuators extend based on custom time requirements. This means that you can have the actuators extend to a certain point in their cycle, pause in the middle of its motion cycle, then resume moving again at the specific user inputted time. For example it could start extending, then pause halfway, and after lets say 5 seconds, be able to start moving again. You can do that when its extending or retracting as well. This is just one example of almost endless possibilities that you can take advantage of with these advanced motion controllers.

This is just the beginning of our foray into these advanced motion controllers and we will be updating our inventory later this year with even more exciting new technology. If you'd like to get in touch with one of our engineers and get started on your own custom control system then contact us today. Check out the video below to see an example of the type of project that can be made possible using these advanced motion controls together with our actuators.

READ ARTICLE

Outdoor Automation Opportunities

The spring season is in full effect with summer getting closer by the day and that means time to head outside and enjoy the beautiful weather. Now you may think that linear actuators are designed for only inside jobs away from potentially harsh weather and outdoor climate, but you would be wrong. In fact electric actuators have many different functions that can be applied for outdoor use, once again proving just how durable and diverse they really are. They can be used not only for helping you complete outdoor chores but can also help you sit back and relax the sun after all that work.

One example of them helping with your chores is their implementation into a lawn mower, specifically one of the more modern sit down models. Actuators can be installed into these lawnmowers to help automate processes that would otherwise have to be done manually such as opening and closing the engine hatch or re-positioning the steering wheel depending on who is using it. Automating the cutter blades is another option, giving you the ability to adjust the heights and position of the blades without getting off the mower and manually adjusting them. This example not only speeds up the process but also saves you from potentially hurting yourself when trying to modify the sharp blades. From this example it’s fairly plain to see that pretty much any form outdoor machinery can be automated for improving productiveness.

Riding lawnmower

Another reason why you should turn to electric linear actuators for all your outdoor needs is because they not only make the jobs easier, but make the machines doing them more effective and reliable. In the past, and even still today, most outdoor machinery is powered by hydraulic systems. Now hydraulic systems may have their benefits but when compared with an electric actuator it is really a no-brainer as to which system is better. Hydraulic systems require much more maintenance and energy in order to function properly than actuators do. They also come with a risk of oil leaks and take up more space with all those pumps, filters and tanks used to hold that oil. As if that wasn't enough the actuator system comes at a much cheaper price as well.

Now that we've covered how they help with outdoor work, let’s go over some examples how they can help you relax outside. One is installing or automating and already installed awning over your backyard/deck. Instead of climbing a ladder opening it manually you can install some actuators so the awning can extend and retract at the press of a button. To further your relaxation experience, why not automate your outdoor dining furniture as well. If you want to really make it something special you can even install the table to extend and retract from the deck itself like this example provided by Dr. Decks, one of our many happy customers.

If this post has sparked your interest in automating your backyard, or you’d just like to take a look at what we have in stock be sure to take a look at our great selection of linear actuators. If you’d like to get in touch to order or learn more about our products give us a call today, we’d be happy to help.

READ ARTICLE

Robotic Automation

Linear actuators and robotics are becoming more prevalent than ever 

With technology constantly improving and upgrading nowadays, the robotics industry has started to become more and more popular. Technology has never been more advanced than it is now and shows no signs of slowing down and same could be said of robotics. It honestly feels like fully automated robots aren’t that far off anymore, while in the past they felt centuries away. And a major factor in the growth of technology and robotics just so happens to be linear actuators.

Robotics (and automation in general) is a great way to help eliminate the risk of human error for jobs and projects of all types. They can also be used for safety reasons as well, going into areas that would otherwise be dangerous or even impossible to get to by normal means. And with the technology behind them always getting better it’s only natural that they start being used in more and more environments. One of these environments is the welding and manufacturing industry. Welding and manufacturing requires steady and consistent performance over long periods of time and even though humans are capable, this is the type of job that is much more suited for linear actuator powered robotics. The actuators give precise control of the force and speed required to apply high quality welds and ensure a longer lifespan of the welded product.

They can also be used for safety reasons as well, going into areas that would otherwise be dangerous or even impossible to get to by normal means. Some great examples of this would be sending a remote controlled robot into a nuclear power plant to collect samples, or even sending one into a warzone to disarm a bomb.  Linear actuators are primarily used for the arm portion of robotic mechanisms because of their (usually) long, tubular design. With that actuator powered arm the robot has the ability to extend its reach and fit into tight spaces and complete tasks such measuring the amount of radiation in a power plant.

Machine vs human

Perhaps the most exciting thing about the rise of robotics is its ability to give people a second chance at things they may have thought would never be possible again. I am referring to robotic prosthetics, which are slowly getting closer and closer to becoming a real, functional replacement to traditional prosthetics. In today’s technological landscape it is now possible for robotic prosthetics to perform tasks like picking up a glass of water. This is made possible through neural signs that are sent from the brain to the arm with sensors that are hooked up to the prosthetic. An actuators role in this process is helping the prosthetic make these motions, with linear movement perfect for repetitive motions like opening and closing a hand.

If you'd like to learn more about linear actuators and some of the other interesting projects or jobs that they are used for then take a look at our Youtube channel. If you are interested in purchasing linear actuators or motion control systems from Progressive Automations please contact us today!

READ ARTICLE

Items 1 to 10 of 70 total

Please wait...