No results found. Please contact us for assistance.
Ce code d’exemple utilise MegaMoto Plus et un Arduino Uno pour surveiller le courant d’un vérin linéaire; toutefois, des produits similaires peuvent être utilisés en remplacement.
/* Code pour surveiller l’intensité de courant consommée par l’actionneur, et couper l’alimentation si elle
dépasse un certain seuil.
Rédigé par Progressive Automations
19 août 2015
Matériel:
- Cartes de commande RobotPower MegaMoto
- Arduino Uno
- 2 boutons-poussoirs
*/
const int EnablePin = 8;
const int PWMPinA = 11;
const int PWMPinB = 3; // broches pour Megamoto
const int buttonLeft = 4;
const int buttonRight = 5;//boutons pour déplacer le moteur
const int CPin1 = A5; // rétroaction du moteur
int leftlatch = LOW;
int rightlatch = LOW;//verrous du moteur (utilisés pour la logique du code)
int hitLimits = 0;//commencer à 0
int hitLimitsmax = 10;//valeurs pour savoir si les limites de course ont été atteintes
long lastfeedbacktime = 0; // doit être de type long, sinon dépassement
int firstfeedbacktimedelay = 750; //premier délai pour ignorer le pic de courant
int feedbacktimedelay = 50; //délai entre les cycles de rétroaction, fréquence de vérification du moteur
long currentTimefeedback = 0; // doit être de type long, sinon dépassement
int debounceTime = 300; //durée d’anti-rebond des boutons, des valeurs plus faibles rendent les boutons plus sensibles
long lastButtonpress = 0; // minuterie pour l’anti-rebond
long currentTimedebounce = 0;
int CRaw = 0; // valeur d’entrée pour les mesures de courant
int maxAmps = 0; // seuil de déclenchement
bool dontExtend = false;
bool firstRun = true;
bool fullyRetracted = false;//logique du programme
void setup()
{
Serial.begin(9600);
pinMode(EnablePin, OUTPUT);
pinMode(PWMPinA, OUTPUT);
pinMode(PWMPinB, OUTPUT);//Définir les sorties du moteur
pinMode(buttonLeft, INPUT);
pinMode(buttonRight, INPUT);//boutons
digitalWrite(buttonLeft, HIGH);
digitalWrite(buttonRight, HIGH);//activer les pull-up internes
pinMode(CPin1, INPUT);//définir l’entrée de rétroaction
currentTimedebounce = millis();
currentTimefeedback = 0;//Définir les temps initiaux
maxAmps = 15;// DÉFINIR ICI LE COURANT MAXIMUM
}//fin setup
void loop()
{
latchButtons();//vérifier les boutons, voir s’il faut bouger
moveMotor();//vérifier les verrous, faire avancer ou reculer le moteur
}//fin boucle principale
void latchButtons()
{
if (digitalRead(buttonLeft)==LOW)//gauche = avancer
{
currentTimedebounce = millis() - lastButtonpress;// vérifier le temps depuis la dernière pression
if (currentTimedebounce > debounceTime && dontExtend == false)//une fois dontExtend déclenché, ignorer toutes les pressions vers l’avant
{
leftlatch = !leftlatch;// si le moteur est en mouvement, arrêter; s’il est arrêté, démarrer
firstRun = true;// définir l’indicateur firstRun pour ignorer le pic de courant
fullyRetracted = false; // une fois que vous avancez, il n’est plus entièrement rétracté
lastButtonpress = millis();//enregistrer l’heure de la dernière pression sur un bouton
return;
}//fin if
}//fin btnLEFT
if (digitalRead(buttonRight)==LOW)//droite = reculer
{
currentTimedebounce = millis() - lastButtonpress;// vérifier le temps depuis la dernière pression
if (currentTimedebounce > debounceTime)
{
rightlatch = !rightlatch;// si le moteur est en mouvement, arrêter; s’il est arrêté, démarrer
firstRun = true;// définir l’indicateur firstRun pour ignorer le pic de courant
lastButtonpress = millis();//enregistrer l’heure de la dernière pression sur un bouton
return; }//fin if
}//fin btnRIGHT
}//fin latchButtons
void moveMotor()
{
if (leftlatch == HIGH) motorForward(255); //vitesse = 0-255
if (leftlatch == LOW) motorStop();
if (rightlatch == HIGH) motorBack(255); //vitesse = 0-255
if (rightlatch == LOW) motorStop();
}//fin moveMotor
void motorForward(int speeed)
{
while (dontExtend == false && leftlatch == HIGH)
{
digitalWrite(EnablePin, HIGH);
analogWrite(PWMPinA, speeed);
analogWrite(PWMPinB, 0);//déplacer le moteur
if (firstRun == true) delay(firstfeedbacktimedelay); // délai plus long pour ignorer le pic de courant
else delay(feedbacktimedelay); //petit délai pour atteindre la vitesse
getFeedback();
firstRun = false;
latchButtons();//revérifier les boutons
}//fin while
}//fin motorForward
void motorBack (int speeed)
{
while (rightlatch == HIGH)
{
digitalWrite(EnablePin, HIGH);
analogWrite(PWMPinA, 0);
analogWrite(PWMPinB, speeed);//déplacer le moteur
if (firstRun == true) delay(firstfeedbacktimedelay);// délai plus long pour ignorer le pic de courant
else delay(feedbacktimedelay); //petit délai pour atteindre la vitesse
getFeedback();
firstRun = false;
latchButtons();//revérifier les boutons
}//fin while
dontExtend = false;//permettre au moteur de s’étendre à nouveau après rétraction
}//fin motorBack
void motorStop()
{
analogWrite(PWMPinA, 0);
analogWrite(PWMPinB, 0);
digitalWrite(EnablePin, LOW);
firstRun = true;//une fois le moteur arrêté, réactiver firstRun pour tenir compte des pics de courant au démarrage
}//fin stopMotor
void getFeedback()
{
CRaw = analogRead(CPin1); // Lire le courant
if (CRaw == 0 && hitLimits < hitLimitsmax) hitLimits = hitLimits + 1;
else hitLimits = 0; // vérifier si le moteur est aux limites et si le courant s’est arrêté
if (hitLimits == hitLimitsmax && rightlatch == HIGH)
{
rightlatch = LOW; // arrêter le moteur
fullyRetracted = true;
}//fin if
else if (hitLimits == hitLimitsmax && leftlatch == HIGH)
{
leftlatch = LOW;//arrêter le moteur
hitLimits = 0;
}//fin if
if (CRaw > maxAmps)
{
dontExtend = true;
leftlatch = LOW; //arrêter si la rétroaction est supérieure au maximum
}//fin if
lastfeedbacktime = millis();//enregistrer l’heure précédente pour la réception de la rétroaction
}//fin getFeedback
Cet exemple de code montre comment contrôler jusqu’à 4 de nos vérins linéaires avec l’Arduino Uno et le LC-82 MultiMoto Arduino Shield; toutefois, des produits similaires peuvent être utilisés en remplacement. Ce code est uniquement destiné aux modèles d’actionneurs respectant les limites de courant de chaque canal du MultiMoto, tels que les PA-14 et PA-14P.
/* Exemple de code pour piloter jusqu’à 4 actionneurs avec le pilote Robot Power MultiMoto.
Matériel:
- Robot Power MultiMoto
- Arduino Uno
Câblage:
- Connecter les actionneurs aux connexions M1, M2, M3, M4 sur la carte MultiMoto.
- Connecter le négatif (noir) à la borne de droite, le positif (rouge) à celle de gauche.
- Connecter une source 12 volts (minimum 1 A par moteur à vide, 8 A par moteur à pleine charge) aux bornes BAT. Veillez à placer le positif et le négatif aux bons emplacements.
Code modifié par Progressive Automations à partir du code d’exemple fourni par Robot Power
<a href="http://www.robotpower.com/downloads/" rel="nofollow"> http://www.robotpower.com/downloads/</a>
Robot Power MultiMoto v1.0 démo
Ce logiciel est placé dans le domaine public
*/
// inclure la bibliothèque SPI:
#include <SPI.h>
// Broches de sélection esclave L9958 pour SPI
#define SS_M4 14
#define SS_M3 13
#define SS_M2 12
#define SS_M1 11
// Broches de direction L9958
#define DIR_M1 2
#define DIR_M2 3
#define DIR_M3 4
#define DIR_M4 7
// Broches PWM L9958
#define PWM_M1 9
#define PWM_M2 10 // Timer1
#define PWM_M3 5
#define PWM_M4 6 // Timer0
// Activation L9958 pour les 4 moteurs
#define ENABLE_MOTORS 8
int pwm1, pwm2, pwm3, pwm4;
boolean dir1, dir2, dir3, dir4;
void setup() {
unsigned int configWord;
// placez ici votre code d’initialisation, exécuté une seule fois:
pinMode(SS_M1, OUTPUT); digitalWrite(SS_M1, LOW); // HIGH = non sélectionné
pinMode(SS_M2, OUTPUT); digitalWrite(SS_M2, LOW);
pinMode(SS_M3, OUTPUT); digitalWrite(SS_M3, LOW);
pinMode(SS_M4, OUTPUT); digitalWrite(SS_M4, LOW);
// Broches de direction L9958
pinMode(DIR_M1, OUTPUT);
pinMode(DIR_M2, OUTPUT);
pinMode(DIR_M3, OUTPUT);
pinMode(DIR_M4, OUTPUT);
// Broches PWM L9958
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
// Activation L9958 pour les 4 moteurs
pinMode(ENABLE_MOTORS, OUTPUT);
digitalWrite(ENABLE_MOTORS, HIGH); // HIGH = désactivé
/ /******* Configuration des puces L9958 *********
' Registre de configuration L9958
' Bit
'0 - RES
'1 - DR - réinitialisation
'2 - CL_1 - limite de courant
'3 - CL_2 - limite de courant
'4 - RES
'5 - RES
'6 - RES
'7 - RES
'8 - VSR - vitesse de montée en tension (1 active la limitation, 0 la désactive)
'9 - ISR - vitesse de montée du courant (1 active la limitation, 0 la désactive)
'10 - ISR_DIS - désactivation de la limitation de montée du courant
'11 - OL_ON - activation open-load (circuit ouvert)
'12 - RES
'13 - RES
'14 - 0 - toujours zéro
'15 - 0 - toujours zéro
*/ // régler sur la limite de courant maximale et désactiver la limitation de montée ISR
configWord = 0b0000010000001100;
SPI.begin();
SPI.setBitOrder(LSBFIRST);
SPI.setDataMode(SPI_MODE1); // polarité d’horloge = bas, phase = haut
// Moteur 1
digitalWrite(SS_M1, LOW);
SPI.transfer(lowByte(configWord));
SPI.transfer(highByte(configWord));
digitalWrite(SS_M1, HIGH);
// Moteur 2
digitalWrite(SS_M2, LOW);
SPI.transfer(lowByte(configWord));
SPI.transfer(highByte(configWord));
digitalWrite(SS_M2, HIGH);
// Moteur 3
digitalWrite(SS_M3, LOW);
SPI.transfer(lowByte(configWord));
SPI.transfer(highByte(configWord));
digitalWrite(SS_M3, HIGH);
// Moteur 4
digitalWrite(SS_M4, LOW);
SPI.transfer(lowByte(configWord));
SPI.transfer(highByte(configWord));
digitalWrite(SS_M4, HIGH);
// Définir les réglages initiaux de l’actionneur pour tirer à vitesse 0 par sécurité
dir1 = 0; dir2 = 0; dir3 = 0; dir4 = 0; // Définir la direction
pwm1 = 0; pwm2 = 0; pwm3 = 0; pwm4 = 0; // Définir la vitesse (0-255)
digitalWrite(ENABLE_MOTORS, LOW);// LOW = activé
} // Fin setup
void loop() {
dir1 = 1;
pwm1 = 255; //définir la direction et la vitesse
digitalWrite(DIR_M1, dir1);
analogWrite(PWM_M1, pwm1); // écrire sur les broches
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); // attendre une fois que les quatre moteurs sont réglés
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);
}//fin void loop
Cet exemple de code permet de combiner le contrôleur de vitesse monocanal Wasp avec l’Arduino Uno pour contrôler le mouvement d’un vérin linéaire; toutefois, des produits similaires peuvent être utilisés en remplacement.
/*Exemple de code pour le Robot Power Wasp.
Cet ESC est commandé à l’aide de signaux RC, avec des impulsions
allant de 1000 à 2000 microsecondes.
La boucle principale de ce programme maintient l’actionneur immobile pendant 1 seconde, s’étend pendant 2 secondes,
s’arrête 1 seconde, se rétracte 2 secondes, puis répète.
Modifié par Progressive Automations, à partir de l’exemple d’origine « Sweep » des
bibliothèques d’exemples Arduino.
Matériel:
- 1 contrôleur Wasp
- Arduino Uno
Câblage:
Côté commande:
- Connecter le rouge/noir au +5 V et à la masse (GND)
- Connecter le fil jaune à la broche de signal sur l’Arduino (dans cet exemple, la broche 9)
Côté puissance:
- Connecter le +/- de l’alimentation du moteur aux connexions +/- du Wasp
- Connecter le +/- de l’actionneur aux deux connexions restantes
Cet exemple de code est dans le domaine public.
*/
#include <servo.h>
Servo myservo; // créer un objet servo pour piloter un servo
// sur la plupart des cartes, on peut créer douze objets servo
int pos = 0; // variable pour stocker la position du servo
void setup()
{
myservo.attach(9); // associe le servo sur la broche 9 à l’objet servo
}
void loop()
{
myservo.writeMicroseconds(1500); // signal d’arrêt
delay(1000); //1 seconde
myservo.writeMicroseconds(2000); // signal : pleine vitesse avant
delay(2000); //2 secondes
myservo.writeMicroseconds(1500); // signal d’arrêt
delay(1000); // 1 seconde
myservo.writeMicroseconds(1000); // signal : pleine vitesse arrière
delay(2000); //2 secondes
}
Cet exemple de code utilise nos relais et un Arduino Uno pour commander un vérin linéaire; toutefois, des produits similaires peuvent être utilisés en remplacement. Vous pouvez lire notre article de blog complet pour plus de détails.
const int forwards = 7;
const int backwards = 6;//attribuer la broche INx du relais à une broche de l’Arduino
void setup() {
pinMode(forwards, OUTPUT);//définir le relais comme sortie
pinMode(backwards, OUTPUT);//définir le relais comme sortie
}
void loop() {
digitalWrite(forwards, LOW);
digitalWrite(backwards, HIGH);//Activer le relais dans un sens; les niveaux doivent être différents pour déplacer le moteur
delay(2000); // attendre 2 secondes
digitalWrite(forwards, HIGH);
digitalWrite(backwards, HIGH);//Désactiver les deux relais pour freiner le moteur
delay(2000);// attendre 2 secondes
digitalWrite(forwards, HIGH);
digitalWrite(backwards, LOW);//Activer le relais dans l’autre sens; les niveaux doivent être différents pour déplacer le moteur
delay(2000);// attendre 2 secondes
digitalWrite(forwards, HIGH);
digitalWrite(backwards, HIGH);//Désactiver les deux relais pour freiner le moteur
delay(2000);// attendre 2 secondes
}
Cet exemple de code utilise notre LC-80, un Arduino Uno, n’importe quel vérin linéaire et une source d’alimentation. Des produits similaires peuvent toutefois être utilisés en remplacement. Vous pouvez obtenir plus de détails sur le code et son fonctionnement dans notre article de blog.
//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
}
Ce programme permet d’étendre et de rétracter en continu la course d’un vérin linéaire.
SETUP LOOP CODE
void setup() {
Serial.begin(9600); // initialize serial communication at 9600 bits per second
pinMode(out_lim, INPUT_PULLUP); // configures pin 45 as input pin
pinMode(in_lim, INPUT_PULLUP); // configures pin 53 as input pin
pinMode(run_f, OUTPUT); // configures pin 25 as output pin
pinMode(run_r, OUTPUT); // configures pin 30 as output pin
retract(); // retracts the stroke on startup
delay(500);
}
void extend() // this function enables the motor to run
{
digitalWrite(run_f, LOW);
digitalWrite(run_r, HIGH);
}
void retract() // this function reverses the direction of motor
{
digitalWrite(run_f, LOW);
digitalWrite(run_r, LOW);
}
void run_stop() // this function disables the motor
{
digitalWrite(run_f, HIGH);
digitalWrite(run_r, HIGH);
}
void loop() {
int out_lim_state = digitalRead(out_lim); // reads the limit switches and saves its value
int in_lim_state = digitalRead(in_lim);
Serial.print("outer limit switch value "), Serial.println(out_lim_state); // 0 -> limit switch is pressed
Serial.print("inner limit switch value "), Serial.println(in_lim_state); // 1 -> limit switch is not pressed
if (out_lim_state == 0 && in_lim_state == 1) // if outer limit switch is pressed and inner is not (extended all the way)
{
retract(); // retract the stroke
}
else if (out_lim_state == 1 && in_lim_state == 0) // if inner limit switch is pressed and outer is not (reracted all the way)
{
extend(); // extend the stroke
}
else // otherwise do nothing
{
}
delay(5); // delay in between reads for stability
}
Vous trouverez des fiches techniques, des manuels d'utilisation, des modèles 3D, des schémas de câblage et bien plus encore dans nos sections Ressources et Centre d'apprentissage.
Selon votre application, différents critères de spécification sont à prendre en compte pour choisir l' actionneur linéaire adapté. Ces critères incluent la force, la course, la vitesse et les dimensions de montage. Pour des informations détaillées sur l'actionneur, consultez la fiche technique ou le tableau des spécifications disponibles sur la page produit de l'actionneur sélectionné. Vous pouvez également nous contacter pour parler à l'un de nos ingénieurs experts.
Le facteur de marche représente la fraction de la période de fonctionnement pendant laquelle un actionneur linéaire reste actif. Il se calcule à l'aide de la formule suivante : Facteur de marche (%) = (Temps d'activité de l'actionneur linéaire) / (Durée d'une période de fonctionnement).
Par exemple : avec un cycle de service de 25 %, un actionneur peut fonctionner en continu pendant 5 minutes avant de devoir se reposer pendant 15 minutes avant de pouvoir fonctionner à nouveau.
Oui, nos actionneurs sont parfaitement compatibles avec la plupart des applications. N'hésitez pas à nous contacter si vous avez des doutes sur le choix de l'actionneur. Pour vous recommander un actionneur de remplacement, nous vous indiquerons la tension nominale, la force nominale et la course nécessaires.
La course est la distance de déplacement de la tige sortante. Pour déterminer la longueur de course requise, mesurez votre application de la position complètement rentrée à la position complètement sortie. La différence correspondra à la longueur de course nécessaire.
Nous recommandons toujours d'acheter un actionneur dont la force nominale est supérieure à celle requise par l'application. En cas de doute sur la force nécessaire, cet article peut vous aider à la calculer : Comment calculer la force pour trouver l'actionneur linéaire adapté.
Oui. Cependant, il est important de fournir à votre actionneur une tension et un courant suffisants. Voici un article qui pourrait vous être utile : Comment choisir l’alimentation adaptée à votre actionneur linéaire
Pour obtenir une commande de mouvement synchrone, un retour d'information est nécessaire. Nous proposons ce retour d'information sous forme de fins de course internes, de potentiomètres ou de capteurs à effet Hall. L'article suivant présente certains produits de Progressive Automations utilisables pour la commande synchronisée : Commande simultanée de plusieurs actionneurs linéaires
Plusieurs raisons peuvent expliquer le bruit important généré par votre actionneur linéaire : surcharge, charge latérale ou infiltration d'eau. Il est également possible que votre actionneur soit simplement conçu pour une force élevée et présente donc un niveau sonore important. Pour plus d'informations, consultez notre guide sur la réduction du bruit mécanique excessif. Si vous pensez que votre actionneur présente un problème, n'hésitez pas à nous contacter.
La plupart de nos actionneurs linéaires sont personnalisables. Veuillez consulter la fiche technique du produit souhaité pour découvrir toutes les options de personnalisation disponibles. Veuillez noter qu'un délai de production d'environ 20 à 25 jours ouvrables est à prévoir, hors délai de livraison. Des frais supplémentaires s'appliquent pour chaque actionneur modifié. Pour en savoir plus sur les commandes personnalisées, veuillez nous contacter au 1800-676-6123.
Oui, c'est possible. Cependant, cela dépend des unités que vous utilisez actuellement. Pour synchroniser les actionneurs, un système de retour d'information est nécessaire, comme un potentiomètre ou des capteurs à effet Hall. Pour plus d'informations, consultez ci-dessous nos ressources clés concernant la synchronisation des actionneurs linéaires.
Commande simultanée de plusieurs actionneurs linéaires
Comment utiliser les boîtiers de commande FLTCON-2 et FLTCON-4 ?
À l’heure actuelle, nous n’avons pas de kits disponibles. Cependant, si vous souhaitez une recommandation sur la compatibilité de certains vérins linéaires avec des systèmes de commande, veuillez nous envoyer un e-mail à sales@progressiveautomations.com avec les informations suivantes :
• Tension nominale requise
• Longueur de course requise
• Force nominale requise
• Contraintes dimensionnelles de votre application
• Description de votre application dans laquelle les vérins seront installés
La température peut affecter le fonctionnement de votre actionneur linéaire. Veuillez vous assurer d'utiliser votre actionneur conformément aux spécifications indiquées dans la fiche technique du produit. Pour toute question spécifique concernant un actionneur et la température, veuillez Contactez-nous.
Pour ce faire, veuillez vérifier que les spécifications de votre système sont compatibles avec la tension et l'intensité nominales de l'actionneur. Si ces spécifications correspondent, cela est envisageable. N'hésitez pas à nous contacter si vous avez des doutes quant au choix de l'actionneur.
Pour trouver cette information, veuillez consulter la fiche technique de votre produit. Si votre vérin linéaire a été personnalisé, veuillez nous fournir des images du produit, en incluant votre numéro de commande (si possible), et envoyez ces informations par e-mail à sales@progressiveautomations.com
Consultez notre liste de modèles CAO 3D disponibles.
Le boîtier de commande que vous choisirez devra fournir une tension et un courant suffisants à votre actionneur. En cas de doute sur les spécifications, veuillez nous contacter.
Vous pouvez également trouver des boîtiers de commande compatibles sur la page produit de l'actionneur linéaire que vous avez sélectionné.
Pour ce faire, veuillez vérifier que les spécifications de votre système sont compatibles avec les valeurs nominales de tension et de courant du boîtier de commande. Si ces spécifications correspondent, cela est possible. En cas de doute, veuillez nous contacter.
Oui, notre PA-35 peut piloter jusqu'à quatre actionneurs linéaires via un appareil Android/iOS. Pour plus d'informations, consultez notre article détaillé sur l'utilisation de notre boîtier de commande Wi-Fi et de notre application.
Non. Cependant, nous proposons un large choix de boîtiers de commande pour chaque actionneur. Vous pouvez également utiliser des interrupteurs à bascule pour la commande de mouvement.
Oui, cependant vous devez vous assurer que votre boîtier de commande peut fournir un courant suffisant et une tension compatible. Dans le cas contraire, vous risquez d’endommager votre ou vos vérins.
Étant principalement fabricants et distributeurs, nous ne disposons que d'un nombre limité d'exemples de code. Bien que nous ne puissions pas fournir de code spécifique pour votre application, nous proposons une liste croissante d'exemples de code Arduino. Pour y accéder, consultez la page Ressources.
Nous avons une gamme de Alimentations AC/DC Vous avez le choix parmi les modèles disponibles dans notre catalogue. La plupart de nos actionneurs étant alimentés en 12 Vcc, une batterie automobile 12 Vcc convient également. Veuillez vous assurer que les appareils connectés fournissent un courant suffisant à votre installation.
Vous pouvez utiliser votre propre alimentation si elle fournit un courant suffisant et la bonne tension à votre système. Sinon, vous risquez d’endommager votre ou vos vérins et/ou vos boîtiers de commande.
Oui, la plupart de nos alimentations peuvent être converties jusqu'à 230 V CA. Pour consulter notre gamme d'alimentations, cliquez ici.
Bien que cela soit possible, nous recommandons d'utiliser le boîtier de commande fourni avec les ensembles de colonnes de levage. Ces boîtiers sont spécifiquement programmés pour que les colonnes de levage fonctionnent de manière synchrone ; l'utilisation d'une commande tierce pourrait compromettre ce fonctionnement.
Cependant, notre nouveau LG-11 présente de nombreuses caractéristiques similaires au FLT-11 et peut être associé aux boîtiers de commande de la série FLTCON et à la télécommande RT-11 pour permettre le déplacement synchronisé de plusieurs unités. Nous proposons également des systèmes à double colonne de levage, tels que le FLT-06 ou le FLT-10, qui vous permettent d'atteindre une hauteur minimale de 22 po (6,7 m) au-dessus du sol.
Toutes nos colonnes de levage sont équipées de boîtiers de commande et de télécommandes. Pour en savoir plus sur les boîtiers de commande que nous utilisons, veuillez nous contacter.
La seule caractéristique personnalisable de nos élévateurs de table/TV est la tension d’entrée. Veuillez noter qu’un délai de 20 – 25 jours ouvrables est nécessaire pour la production de toutes les commandes personnalisées.
Notre support TV motorisé escamotable peut accueillir des téléviseurs jusqu'à 60 pouces, et nos supports TV rabattables jusqu'à 95 pouces. Découvrez nos supports TV. Pour plus d'informations, consultez notre guide d'utilisation.
La capacité de charge de nos lève-tables dépend du modèle choisi. La capacité de charge minimale de notre lève -table simple FLT-01 est de 80 kg (180 lb). La capacité de charge maximale est de 150 kg (330 lb) pour nos lève-tables FLT-09 et FLT-05 (ensembles de lève-tables).
Non, nos supports de montage sont vendus séparément de nos actionneurs linéaires. Cependant, nous proposons des supports de montage compatibles avec chacun de nos actionneurs linéaires. Pour trouver le support de montage adapté à votre actionneur linéaire, consultez la page produit de l'actionneur sélectionné (l'information y sera indiquée) ou parcourez notre catalogue de supports de montage.
Pour ces informations, veuillez vous référer à nos schémas de câblage.
Veuillez nous envoyer par e-mail des photos de votre configuration de câblage afin que nous puissions examiner cela plus en détail pour vous. L’un de nos ingénieurs commerciaux vous contactera dès que possible.
Email : sales@progressiveautomations.com
Choisir le bon vérin électrique pour votre application est essentiel pour lui donner vie. Vous devez vous assurer qu’il répond à toutes vos spécifications et qu’il est capable de faire exactement ce que vous souhaitez. C’est pourquoi nous avons créé ce petit organigramme pratique pour la sélection d’un vérin linéaire. Il est divisé en quatre sections, chacune présentant différentes options pour nos vérins afin que vous puissiez voir clairement ce qui les différencie :
Le backdriving se produit lorsqu’un vérin commence à glisser vers le bas sous la charge, soit parce qu’il est en surcharge, soit parce que le vérin a été endommagé. Regarder la vidéo.
Que signifient les charges nominales dynamique et statique ?La charge nominale dynamique est la charge qu’un vérin peut tirer ou pousser en toute sécurité lorsqu’il est alimenté. La charge nominale statique est la charge que le vérin peut maintenir ou supporter sans backdriving lorsqu’il n’est pas alimenté. Par exemple, disons que vous avez un vérin installé sur une fenêtre et que la charge nominale statique du vérin est de 100lbs, il pourrait subir du backdriving lors d’un épisode de vents forts, ce qui signifie qu’une pression plus élevée serait exercée sur le vérin et dépasserait la charge nominale de 100lbs du vérin.
Qu’est-ce qu’une charge latérale ?La charge latérale correspond à des forces qui s’exercent sur le vérin depuis le plan latéral. Les vérins ne sont pas conçus pour supporter des forces latérales ; s’ils en subissent, cela risque d’endommager le vérin ou de plier la tige. Il est donc conseillé d’éviter toute force latérale et de toujours s’assurer que le vérin est parfaitement aligné avec votre application, afin qu’il ne subisse aucune autre charge que la charge axiale. Regarder la vidéo.
Les commandes peuvent être passées de l’une des manières suivantes :
En ligne : Utilisez notre processus de commande en ligne avec des options de paiement par carte de crédit ou PayPal.
Téléphone : 1-800 – 676 – 6123
Email : sales@progressiveautomations.com
Oui, des remises sur quantité sont appliquées dès 7 unités d'un même produit acheté. Le détail des remises est indiqué sur chaque page produit. Pour plus d'informations sur notre politique de remises, veuillez nous contacter.
Nous acceptons toutes les principales cartes de crédit, PayPal, les chèques et les virements bancaires. Pour les clients qui souhaitent mettre en place des comptes à terme (Net Terms), veuillez nous envoyer un e-mail pour démarrer le processus de demande.
Email : sales@progressiveautomations.com
Pour consulter les prix en dollars américains, veuillez vous assurer de visiter notre site depuis les États-Unis. Pour consulter les prix en dollars canadiens, veuillez vous assurer de visiter notre site depuis le Canada.
Tous les produits listés sur le site sont en stock et disponibles pour une expédition le jour même si votre commande est passée avant 15 h PST. Si l’un de nos produits est indisponible, nous vous contacterons dès que possible pour vous informer de sa prochaine disponibilité.
Les frais d’expédition de Progressive Automations sont calculés en fonction de divers facteurs, notamment : emplacement, quantités et poids total de votre commande. Les articles plus petits sont expédiés par colis, tandis que les articles plus volumineux et les commandes en gros sont expédiés via un service de transport de fret. Nous nous efforçons toujours d’offrir des tarifs d’expédition compétitifs à tous nos clients.
Les méthodes d’expédition sont disponibles pour les commandes en ligne et par téléphone. Si vous souhaitez obtenir une estimation des frais d’expédition de votre commande, vous pouvez le faire en consultant votre panier final.
Nous expédions vos commandes via plusieurs transporteurs, notamment FedEx, UPS, DHL et USPS. Le transporteur choisi peut varier selon votre adresse. Les commandes importantes sont expédiées par des transitaires.
Veuillez nous contacter si vous avez des questions concernant ces options ou si vous souhaitez expédier votre commande par un autre transporteur/via votre propre compte d'expédition.
Les clients au Canada et aux États-Unis ne paieront ni n’encourront de droits de douane sur leurs commandes. Les clients en dehors de l’Amérique du Nord peuvent être soumis à des droits et frais d’importation. Veuillez contacter votre autorité gouvernementale locale pour obtenir des informations sur les frais et taxes d’importation.
Les retours et les échanges sont acceptés dans les 30 jours suivant la réception de votre commande, à condition que le produit n'ait pas été utilisé, modifié ou endommagé. Pour plus d'informations sur notre politique de retour, veuillez consulter la section « Livraison et retours ».
La livraison vers les États-Unis continentaux peut prendre entre 4 et 10 jours ouvrables. Pour toutes les autres destinations, le délai de livraison est d'environ 10 à 15 jours ouvrables, selon votre lieu de résidence. Veuillez consulter notre politique d'expédition pour plus d'informations : Livraison et retours
Malheureusement, Progressive Automations n’offre pas la livraison gratuite. Cependant, vous pouvez bénéficier d’une remise sur quantité à partir de 7 unités identiques.
Oui, le bureau assis-debout en L est adaptable à l'orientation et peut être installé selon vos préférences. Voici un article pas à pas qui explique comment procéder : Manuel d'utilisation FLT-05
REMARQUE : Les étapes ci-dessous peuvent varier selon le modèle de télécommande que vous possédez. Les instructions suivantes concernent la télécommande standard RT-11. Pour régler la hauteur maximale de votre cadre, allez à la hauteur souhaitée, puis suivez les étapes ci-dessous :
- Appuyez sur M et vérifiez que [5 -] s'affiche à l'écran
- Appuyez sur la touche HAUT et constatez que [5 -] clignote
- Maintenez la touche M enfoncée jusqu'à voir [999] sur l'écran
- La hauteur maximale est maintenant définie
Pour régler la hauteur minimale de votre cadre, allez à la hauteur souhaitée, puis suivez les étapes ci-dessous :
- Appuyez sur M et vérifiez que [5 -] s'affiche à l'écran
- Appuyez sur la touche BAS et constatez que [5 -] clignote
- Maintenez la touche M enfoncée jusqu'à voir [000] sur l'écran
- La hauteur minimale est maintenant définie
Pour réinitialiser les limites, suivez les étapes ci-dessous :
- Appuyez sur M, vérifiez que [5 -] s'affiche à l'écran, puis relâchez
- Maintenez la touche M enfoncée jusqu'à voir [555]
- Les limites ont été réinitialisées
REMARQUE : Les étapes ci-dessous peuvent varier selon le modèle de télécommande que vous possédez. Les instructions suivantes concernent la télécommande standard RT-11.
Si vous devez maintenir les boutons de la télécommande enfoncés pour atteindre votre hauteur préréglée, cela signifie que votre boîtier de commande est en mode momentané. Pour passer votre télécommande en mode non momentané, suivez les étapes ci-dessous
- Assurez-vous qu'il n'y a rien sous votre bureau, car nous devons lancer la procédure de réinitialisation
- Appuyez et maintenez la touche BAS jusqu'à ce que l'écran affiche [ASr]
- Une fois [ASr] affiché, appuyez et maintenez [1] enfoncé et vous pouvez voir deux valeurs :
a. 10.1 = Mode non momentané
b. 10.2 = Mode momentané
- Terminez la procédure de réinitialisation en maintenant la touche BAS enfoncée jusqu'à ce que votre bureau assis-debout s'abaisse légèrement puis se relève.
Nos bureaux assis-debout disposent de 3 réglages pour la détection des collisions, que vous pouvez ajuster selon vos préférences. Procédez comme suit :
- Assurez-vous qu'il n'y a rien sous votre bureau, car nous devons lancer la procédure de réinitialisation
- Appuyez et maintenez la touche BAS jusqu'à ce que l'écran affiche [ASr]
- Une fois [ASr] affiché, appuyez et maintenez la touche HAUT [ ^ ] et vous pouvez voir trois valeurs :
a. 10.5 = 11 lbs
b. 10.6 = 22 lbs
c. 10.7 = 33 lbs
- Terminez la procédure de réinitialisation en maintenant la touche BAS enfoncée jusqu'à ce que votre bureau assis-debout s'abaisse légèrement puis se relève.
Nous avons préparé quelques étapes de dépannage à suivre si vous voyez l'un des codes d'erreur suivants sur les cadres avec boîtiers de commande de la série FLTCON :
Vérifiez le code d'erreur ici.
Si le problème persiste après avoir suivi ces étapes, n'hésitez pas à contacter nos ingénieurs produits au 1-800-676-6123, ou à nous écrire à sales@progressiveautomations.com.