Actuator Zone

Full Guide on TV Lifts: Types, Usage, How It Works

A TV/home entertainment display has become an integral part of a living room or parlor. However, it does not mean that this device cannot be installed in other rooms. In fact, the role of digital screens in our life is rather significant since people prefer to obtain information in visual form nowadays. So regardless of the content you choose, it can be better to watch it on a large screen.

At the same time, this state-of-the-art technological solution is not always a fit to a rooms interior design. Would you agree that a new LCD or LED looks out of the picture if placed in a room with vintage cabinetry? Other design styles may also reject a TV due to its incompatibility to an overall environment. In such cases, it is absurd to remove a display from a room and take it back when you need to watch the news or movies. In cases like that many people wish there were a possibility to hide TV on occasion. Sometimes our dreams come true.

The solution is called a lift mechanism for TV. You might have seen television displays sliding up or down in various movies or series. Such a mechanism is a great way to combine high-tech innovation with an old-time atmosphere of a room. If you thought that this innovation was only available for some extraordinary people, we would like to share some ways you can have such a mechanism at your place.

TV Lift Mechanism: What is it and how does it work?

You enter a room with no displays on the walls or anywhere else. A simple click on a remote control induces a smart mechanism called a lifting actuator and a display appears as if out of nowhere. Such a situation may seem a bit fantastic it is very real. Nowadays, anyone can implement a TV lift system for their own needs.
Continue reading

READ ARTICLE

Information on Linear Actuators

The modern times can be characterized as the era of digitization. Numerous gadgets and smart devices have become an integral part of an ordinary person’s life. People often forget about the simpler but not less important devices utilized in the daily practice. Some of them even have a mechanical drive, which the young generation can consider as an outdated technology. Anyhow, such devices or mechanisms do exist and occupy their niche in the whirl of the state-of-the-art innovations. The present article is dedicated to the range of products named linear actuators and their practical usefulness.

What Is an Actuator?

A synonym to the word “actuator” is a “mover”. Actuating means inducing a movement. When we talk about a linear actuator, we mean a device inducing a motion in a straight line. The word "motion" can envisage different meanings: closing/opening, lifting/descending, pushing/pulling, blocking/ejecting etc.

Such mechanisms are widely used at industrial facilities and in household applications. Everything set in motion is impossible without an actuator. So, this product deserves a title of a significant device in the modern life.

Types of Actuators

Based on the energy type, the actuators are divided into various types. The categorization of actuators depends on the type of energy applied to cause a motion. Currently, this mechanism can convert mechanical energy, power from electricity, air, and liquid into a motion. Different types of actuators have different advantages and disadvantages. Let’s have a look at each one separately. Continue reading

READ ARTICLE

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

Items 1 to 10 of 72 total

Please wait...