No results found. Please contact us for assistance.
Cet exemple de code utilise un MegaMoto Plus et un Arduino Uno pour surveiller le courant d'un actionneur linéaire ; cependant, des produits similaires peuvent être utilisés en remplacement.
/* Code pour surveiller la consommation de courant de l'actionneur et couper l'alimentation si elle dépasse un certain seuil. Écrit par Progressive Automations le 19 août 2015. Matériel : - Cartes de contrôle 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 actionner le moteur const int CPin1 = A5; // Retour d'information du moteur int leftlatch = LOW; int rightlatch = LOW; // Verrous du moteur (utilisés pour la logique du code) int hitLimits = 0; // Initialisation à 0 int hitLimitsmax = 10; // Valeurs indiquant si les limites de course ont été atteintes long lastfeedbacktime = 0; // Doit être long, sinon dépassement de capacité 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 long, sinon dépassement de capacité int debounceTime = 300; // Valeur pour l'anti-rebond des boutons, plus la valeur est basse, plus les boutons sont sensibles long lastButtonpress = 0; // Minuteur pour l'anti-rebond long currentTimedebounce = 0; int CRaw = 0; // Valeur d'entrée pour les lectures de courant int maxAmps = 0; // Limite 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); // Configurer les sorties moteur pinMode(buttonLeft, INPUT); pinMode(buttonRight, INPUT); // Boutons digitalWrite(buttonLeft, HIGH); digitalWrite(buttonRight, HIGH); // Activer les résistances de rappel internes pinMode(CPin1, INPUT); // Configurer l'entrée de retour currentTimedebounce = millis(); currentTimefeedback = 0;//Définir les temps initiaux maxAmps = 15;// DÉFINIR LE COURANT MAXIMUM ICI }//fin de la configuration void loop() { latchButtons();//vérifier les boutons, voir si nous devons les déplacer moveMotor();//vérifier les verrous, déplacer le moteur vers l'intérieur ou l'extérieur }//fin de la boucle principale void latchButtons() { if (digitalRead(buttonLeft)==LOW)//gauche est vers l'avant { currentTimedebounce = millis() - lastButtonpress;// vérifier le temps depuis la dernière pression if (currentTimedebounce> debounceTime && dontExtend == false)//une fois que vous avez déclenché dontExtend, ignorer toutes les pressions vers l'avant { leftlatch = !leftlatch;// si le moteur est en mouvement, arrêter, s'il est arrêté, démarrer le mouvement firstRun = true;// définir l'indicateur firstRun pour ignorer le pic de courant fullyRetracted = false; // Une fois que vous avancez, vous n'êtes pas complètement rétracté lastButtonpress = millis();//stocker l'heure du dernier appui sur le bouton return; }//fin si }//fin btnLEFT if (digitalRead(buttonRight)==LOW)//droite est en arrière { currentTimedebounce = millis() - lastButtonpress;// vérifier le temps depuis le dernier appui if (currentTimedebounce> debounceTime) { rightlatch = !rightlatch;// si le moteur est en mouvement, arrêter, s'il est arrêté, démarrer le mouvement firstRun = true;// définir l'indicateur firstRun pour ignorer le pic actuel lastButtonpress = millis();//stocker l'heure du dernier appui sur le bouton return; }//fin si }//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 speed) { while (dontExtend == false && leftlatch == HIGH) { digitalWrite(EnablePin, HIGH); analogWrite(PWMPinA, speed); 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();//vérifier à nouveau les boutons }//fin while }//fin motorForward void motorBack (int speed) { while (rightlatch == HIGH) { digitalWrite(EnablePin, HIGH); analogWrite(PWMPinA, 0); analogWrite(PWMPinB, vitesse); // Déplacer le moteur si (firstRun == true) delay(firstfeedbacktimedelay); // Délai plus long pour ignorer le pic de courant sinon delay(feedbacktimedelay); // Petit délai pour atteindre la vitesse de démarrage getFeedback(); firstRun = false; latchButtons(); // Vérifier à nouveau les boutons } // Fin de la boucle dontExtend = false; // Autoriser le moteur à se déployer à nouveau après sa rétraction } // Fin de 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 de stopMotor void getFeedback() { CRaw = analogRead(CPin1); // Lire le courant si (CRaw == 0 && hitLimits < hitLimitsmax) hitLimits = hitLimits + 1; sinon hitLimits = 0; // Vérifier si le moteur a atteint ses limites et si le courant est arrêté si (hitLimits == hitLimitsmax && rightlatch == HIGH) { rightlatch = LOW; // Arrêter le moteur fullyRetracted = true; }//fin si sinon si (hitLimits == hitLimitsmax && leftlatch == HIGH) { leftlatch = LOW;//Arrêter le moteur hitLimits = 0; }//fin si si (CRaw > maxAmps) { dontExtend = true; leftlatch = LOW; //Arrêter si le retour d'information dépasse le maximum }//fin si lastfeedbacktime = millis();//Stocker l'heure précédente de réception du retour d'information }//fin getFeedback
Cet exemple de code montre comment contrôler jusqu'à 4 de nos actionneurs linéaires avec une carte Arduino Uno et le shield Arduino MultiMoto LC-82. D'autres produits similaires peuvent être utilisés. Ce code est uniquement compatible avec les modèles d'actionneurs respectant les limitations actuelles de chaque canal du MultiMoto, tels que les PA-14 et PA-14P.
/* Exemple de code pour contrôler jusqu'à 4 actionneurs, à l'aide du pilote Robot Power MultiMoto. Matériel : - Robot Power MultiMoto - Arduino Uno Câblage : - Connectez les actionneurs aux bornes M1, M2, M3 et M4 de la carte MultiMoto. - Connectez le fil négatif (noir) à la borne de droite et le fil positif (rouge) à celle de gauche. - Connectez une alimentation 12 V (minimum 1 A par moteur à vide, 8 A par moteur en charge) aux bornes BAT. Assurez-vous que les polarités positive et négative sont correctement branchées. Code modifié par Progressive Automations à partir de l'exemple fourni par Robot Powerhttp://www.robotpower.com/downloads/ Démo Robot Power MultiMoto v1.0 Ce logiciel est placé dans le domaine public. */ // Inclure la bibliothèque SPI : #include// Broches de sélection d'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; // Insérez ici votre code d'initialisation, qui ne s'exécutera qu'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 // L9958 Activation des 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 balayage de la tension (1 active la limite de balayage, 0 la désactive) '9 - ISR - vitesse de balayage du courant (1 active la limite de balayage, 0 la désactive) '10 - ISR_DIS - désactivation du balayage du courant '11 - OL_ON - activation de la charge ouverte '12 - RES '13 - RES '14 - 0 - toujours zéro '15 - 0 - toujours zéro */ // Définir la limite de courant maximale et désactiver la limitation de balayage ISR configWord = 0b0000010000001100; SPI.begin(); SPI.setBitOrder(LSBFIRST); SPI.setDataMode(SPI_MODE1); // horloge pol = 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); // Initialisation des actionneurs à une vitesse nulle pour des raisons de sécurité dir1 = 0; dir2 = 0; dir3 = 0; dir4 = 0; // Définition du sens de rotation pwm1 = 0; pwm2 = 0; pwm3 = 0; pwm4 = 0; // Définition de la vitesse (0-255) digitalWrite(ENABLE_MOTORS, LOW);// LOW = activé } // Fin de la configuration void loop() { dir1 = 1; pwm1 = 255; // Définition du sens de rotation et de la vitesse digitalWrite(DIR_M1, dir1); analogWrite(PWM_M1, pwm1); // Écriture 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 que les quatre moteurs soient configuré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 de la boucle void
Cet exemple de code sert à combiner le contrôleur de vitesse monocanal Wasp avec l'Arduino Uno pour contrôler le mouvement d' un actionneur linéaire ; cependant, des produits similaires peuvent être utilisés en remplacement.
/* Exemple de code pour le Robot Power Wasp. Ce contrôleur de vitesse électronique (ESC) est piloté par signaux RC, avec des impulsions de 1000 à 2000 microsecondes. La boucle principale de ce programme maintient l'actionneur immobile pendant 1 seconde, l'étend pendant 2 secondes, l'arrête pendant 1 seconde, le rétracte pendant 2 secondes, et ainsi de suite. Modifié par Progressive Automations, à partir de l'exemple de code original « Sweep » des bibliothèques Arduino. Matériel : - 1 contrôleur Wasp - 1 Arduino Uno Câblage : Côté commande : - Connectez le fil rouge/noir à +5 V et à la masse (GND). - Connectez le fil jaune à la broche de signal de l'Arduino (dans cet exemple, la broche 9). Côté alimentation : - Connectez le pôle positif/négatif de l'alimentation du moteur aux bornes positives/négatives du Wasp. - Connectez le pôle positif/négatif de l'actionneur aux deux bornes restantes. Cet exemple de code est dans le domaine public. */ #includeServo myservo; // crée un objet servo pour contrôler un servomoteur // douze objets servo peuvent être créés sur la plupart des cartes int pos = 0; // variable pour stocker la position du servomoteur void setup() { myservo.attach(9); // attache le servomoteur sur la broche 9 à l'objet servomoteur } void loop() { myservo.writeMicroseconds(1500); // signal d'arrêt delay(1000); // 1 seconde myservo.writeMicroseconds(2000); // signal de marche avant à pleine vitesse delay(2000); // 2 secondes myservo.writeMicroseconds(1500); // signal d'arrêt delay(1000); // 1 seconde myservo.writeMicroseconds(1000); // signal de marche arrière à pleine vitesse delay(2000); // 2 secondes }
Cet exemple de code utilise nos relais et une carte Arduino Uno pour contrôler un actionneur linéaire ; toutefois, d’autres produits similaires peuvent être utilisés. Pour plus de détails, consultez notre article de blog complet.
const int forwards = 7; const int backwards = 6; // Assigner la broche INx du relais à une broche Arduino void setup() { pinMode(forwards, OUTPUT); // Configurer le relais en sortie pinMode(backwards, OUTPUT); // Configurer le relais en sortie } void loop() { digitalWrite(forwards, LOW); digitalWrite(backwards, HIGH); // Activer le relais dans un sens ; les deux sens doivent être différents pour que le moteur tourne 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 deux sens doivent être différents pour que le moteur tourne 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, une carte Arduino Uno, un actionneur linéaire quelconque et une source d'alimentation. Cependant, des produits similaires peuvent être utilisés. Vous trouverez plus de détails sur le code et son fonctionnement dans notre article de blog.
// Utilisez les cavaliers sur la carte pour sélectionner les broches à utiliser. int EnablePin1 = 13; int PWMPinA1 = 11; int PWMPinB1 = 3; int extendtime = 10 * 1000; // 10 secondes, multiplié par 1000 pour convertir en millisecondes int withdrawtime = 10 * 1000; // 10 secondes, multiplié par 1000 pour convertir en millisecondes int timetorun = 300 * 1000; // 300 secondes, multiplié par 1000 pour convertir en millisecondes int duty; int elapsedTime; boolean keepMoving; void setup() { Serial.begin(9600); pinMode(EnablePin1, OUTPUT);//Activer la carte pinMode(PWMPinA1, OUTPUT); pinMode(PWMPinB1, OUTPUT); // Configurer les sorties moteur elapsedTime = 0; // Initialiser le temps à 0 keepMoving = true; // Le système se déplacera }//fin de la configuration void loop() { if (keepMoving) { digitalWrite(EnablePin1, HIGH); // Activer le moteur pushActuator(); delay(extendtime); stopActuator(); delay(10); // Petit délai avant la rétraction pullActuator(); delay(retracttime); stopActuator(); elapsedTime = millis(); // Combien de temps s'est écoulé ? if (elapsedTime > timetorun) {// Si 300 secondes se sont écoulées, arrêter Serial.print("Le temps écoulé est supérieur à la durée d'exécution maximale. Durée d'exécution maximale : "); Serial.println(timetorun); keepMoving = false; } }//fin du if }//fin de la boucle principale void stopActuator() { analogWrite(PWMPinA1, 0); analogWrite(PWMPinB1, 0); // vitesse 0-255 } void pushActuator() { analogWrite(PWMPinA1, 255); analogWrite(PWMPinB1, 0); // vitesse 0-255 } void pullActuator() { analogWrite(PWMPinA1, 0); analogWrite(PWMPinB1, 255);//vitesse 0-255 }
Ce programme peut être utilisé pour prolonger et rétracter en continu la course d'un actionneur linéaire.
CODE DE BOUCLE DE CONFIGURATION
void setup() {
Série.begin(9600); // initialise la communication série à 9600 bits par seconde
pinMode(out_lim, INPUT_PULLUP); // configure la broche 45 comme broche d'entrée
pinMode(in_lim, INPUT_PULLUP); // configure la broche 53 comme broche d'entrée
pinMode(run_f, SORTIE); // configure la broche 25 comme broche de sortie
pinMode(run_r, SORTIE); // configure la broche 30 comme broche de sortie
se rétracter(); // rétracte le trait au démarrage
retard (500);
}
void extend() // cette fonction permet au moteur de tourner
{
digitalWrite(run_f, LOW);
digitalWrite(run_r, HIGH);
}
void retract() // cette fonction inverse le sens du moteur
{
digitalWrite(run_f, LOW);
digitalWrite(run_r, LOW);
}
void run_stop() // cette fonction désactive le moteur
{
digitalWrite(run_f, HIGH);
digitalWrite(run_r, HIGH);
}
boucle vide() {
int out_lim_state = digitalRead(out_lim); // lit les fins de course et enregistre sa valeur
int in_lim_state = digitalRead(in_lim);
Serial.print("valeur de fin de course extérieure"), Serial.println(out_lim_state); // 0 -> l'interrupteur de fin de course est enfoncé
Serial.print("valeur de fin de course interne"), Serial.println(in_lim_state); // 1 -> l'interrupteur de fin de course n'est pas enfoncé
if (out_lim_state == 0 && in_lim_state == 1) // si l'interrupteur de fin de course extérieur est enfoncé et que l'intérieur ne l'est pas (étendu complètement)
{
se rétracter(); // retire le trait
}
else if (out_lim_state == 1 && in_lim_state == 0) // si l'interrupteur de fin de course intérieur est enfoncé et que l'extérieur ne l'est pas (réactualisé complètement)
{
se déployer(); // prolonge le trait
}
else // sinon ne rien faire
{
}
retard(5); // délai entre les lectures pour la stabilité
}
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 correspond au déplacement de la tige extensible. Pour déterminer la course nécessaire, mesurez la distance entre la position complètement rétractée et la position complètement déployée. La différence correspond à la course requise.
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 ?
Nous n'avons pas de kits disponibles. Toutefois, si vous souhaitez une recommandation sur la compatibilité de certains actionneurs 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
• Limitations dimensionnelles de votre application
• Description de votre application dans laquelle le ou les actionneurs seront installés
La température peut affecter le fonctionnement de votre actionneur linéaire. Veuillez vous assurer de l'utiliser conformément aux spécifications indiquées dans la fiche technique du produit. Pour toute question relative à un actionneur et à la température, veuillez nous contacter.
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 possible. N'hésitez pas à nous contacter si vous avez des doutes quant au choix de l'actionneur.
Pour trouver ces informations, veuillez vous référer à la fiche technique de votre produit. Si votre actionneur linéaire a été fait sur mesure, veuillez nous fournir des images du produit, y compris votre numéro de commande (si possible) et envoyer ces informations par courriel à 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, mais vous devez vous assurer que votre boîtier de commande peut fournir un appel de courant suffisante et une tension compatible. Sinon, vous risquez d'endommager votre ou vos actionneurs.
É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.
Notre catalogue propose une gamme d' alimentations AC/DC. La plupart de nos actionneurs étant alimentés en 12 Vcc, une batterie automobile 12 Vcc constitue également une solution adaptée. Veuillez vous assurer que les appareils connectés fournissent un courant suffisant à votre installation.
Vous pouvez utiliser votre propre source d'alimentation si elle fournit suffisamment de courant et la bonne tension à votre système. Dans le cas contraire, vous courez le risque d'endommager votre(vos) actionneur(s) et/ou votre(vos) boîtier(s) 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 en option sur mesure pour nos systèmes de levage de table/TV est la tension d'entrée. Veuillez noter qu'il y aura un délai de 20 à 25 jours ouvrables pour la production de toutes les commandes sur mesure.
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 courriel des photos de votre configuration de câblage afin que nous puissions l'étudier plus. Un de nos ingénieurs vous contactera dans les plus brefs délais.
Courriel : sales@progressiveautomations.com
La sélection du bon actionneur pour votre application est un élément clé pour son bon fonctionnement. Vous devez vous assurer qu’il répond à toutes vos spécifications et qu’il a la capacité de faire exactement ce que vous voulez qu’il fasse. C'est pourquoi nous avons créé cet organigramme pratique pour sélectionner un actionneur linéaire. Il est divisé en quatre sections, chaque section présente différentes options pour nos actionneurs afin que vous puissiez voir comment ils se différencient les uns des autres :
Le retour arrière se produit lorsqu'un actionneur commence à glisser sous une charge, lorsqu'il est surchargé ou lorsque l'actionneur a été endommagé. Voir la vidéo.
Que signifient les valeurs de charge dynamique et statique ?La charge nominale dynamique est la quantité de poids qu'un actionneur peut tirer ou pousser en toute sécurité lorsqu'il est alimenté. La charge statique est le poids que l'actionneur peut supporter ou supporter sans reculer lorsqu'il n'est pas alimenté. Par exemple, disons simplement que vous avez un actionneur installé sur une fenêtre et que la charge statique de l'actionneur est de 100 lb, il pourrait subir un retour arrière en cas de vent fort, ce qui signifie qu'il y aura plus de pression exercée sur l'actionneur et cela qui dépasser la charge nominale de 100 lb de l’actionneur.
Qu’est-ce que le chargement latéral ?Le chargement latéral se produit lorsque l'actionneur subit des forces latéralement. Les actionneurs ne sont pas du tout destinés à gérer les forces latérales, donc s'ils en subissent, cela les endommagera ou pliera la tige. Il est donc conseillé de ne jamais utiliser de forces latérales et de toujours s'assurer que l'actionneur est entièrement aligné ou synchronisé avec votre application, afin qu'il ne supporte aucune autre charge que la charge axiale. Voir la vidéo.
Les commandes peuvent être passées par l'un des moyens suivants :
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
Courriel : 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 créer des comptes Net Term, veuillez nous envoyer un courriel pour commencer le processus.
Courriel : sales@progressiveautomations.com
Pour les prix en USD, veuillez vous assurer que vous nous visitez à partir de notre site américain. Pour les prix en CAD, veuillez vous assurer que vous nous visitez à partir de notre site canadien.
Tous les produits répertoriés sur le site Web sont en stock et disponibles pour une expédition le jour même si votre commande est passée avant 15 h 00 HNP. Si l'un de nos produits n'est pas disponible, nous vous contacterons dans les plus brefs délais pour vous informer de la disponibilité.
Les frais d'expédition de Progressive Automations sont calculés en fonction de divers facteurs, y compris, mais sans s'y limiter : l'emplacement, les quantités et le poids total de votre commande. Les petits articles sont expédiés par colis tandis que les articles plus volumineux et les commandes de grande quantité sont expédiés via un service de transport de marchandises. Nous nous efforçons toujours de fournir des prix d'expédition compétitifs à tous nos clients.
Les méthodes d'expédition sont disponibles via les commandes en ligne et par téléphone. Si vous souhaitez recevoir 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 canadiens et américains n'auront ni ne paieront as de droits de douane sur leurs commandes. Les clients à l'extérieur de l'Amérique du Nord peuvent être assujettis à des droits de douane et à des frais d'importation. Veuillez contacter votre autorité gouvernementale locale pour plus d'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'un rabais selon la quantité commandée à partir de 7 exemplaires de la même unité.
Oui, le bureau debout en forme de L facilite l'orientation et peut être installé selon vos préférences. Voici un article étape par étape qui explique comment cela est possible : Manuel d'utilisation du FLT-05
REMARQUE : Les étapes ci-dessous peuvent varier en fonction du modèle de télécommande dont vous disposez. Les instructions suivantes ont été faites pour la télécommande RT-11 standard. Pour définir la hauteur maximale de votre cadre, accédez à la hauteur souhaitée que vous souhaitez définir et suivez les étapes ci-dessous :
- Appuyez sur M et voyez [5 -] indiqué sur l'écran
- Appuyez sur le bouton UP et remarquez que [5 -] clignote
- Maintenez le bouton M enfoncé jusqu'à ce que vous voyiez [999] sur l'écran.
- La hauteur maximale a maintenant été définie
Pour définir la hauteur minimale de votre cadre, accédez à la hauteur souhaitée que vous souhaitez définir et suivez les étapes ci-dessous :
- Appuyez sur M et voyez [5 -] indiqué sur l'écran
- Appuyez sur le bouton DOWN et remarquez que [5 -] clignote
- Maintenez le bouton M enfoncé jusqu'à ce que [000] s'affiche à l'écran.
- La hauteur minimale a maintenant été définie
Pour réinitialiser les limites, suivez les étapes ci-dessous :
- Appuyez sur M et voyez [5 -] indiqué sur l'écran et relâchez
- Tenez le M que vous voyez [555]
- Les limites ont été réinitialisées
REMARQUE : Les étapes ci-dessous peuvent varier en fonction du modèle de télécommande dont vous disposez. Les instructions suivantes ont été faites pour la télécommande RT-11 standard.
Si vous devez maintenir enfoncés les boutons de la télécommande pour atteindre votre hauteur prédéfinie, cela signifie que votre boîtier de commande est en contrôle momentané. Pour régler 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 entrer dans la procédure de réinitialisation
- Appuyez et maintenez enfoncé le bouton DOWN jusqu'à ce que l'écran affiche [ASr]
- Une fois que [ASr] est affiché, appuyez et maintenez [1] et vous pouvez voir deux valeurs :
un. 10.1 = Mode non momentané
b. 10.2 = Mode momentané
- Terminez la procédure de réinitialisation en maintenant le bouton BAS jusqu'à ce que votre bureau debout descende et monte légèrement.
Nos bureaux debout disposent de 3 paramètres de détection de collision, qui peuvent être définis selon vos préférences. Pour continuer, suivez les étapes ci-dessous :
- Assurez-vous qu'il n'y a rien sous votre bureau car nous devons entrer dans la procédure de réinitialisation.
- Appuyez et maintenez enfoncé le bouton DOWN jusqu'à ce que l'écran affiche [ASr]
- Une fois que [ASr] est affiché, appuyez et maintenez le bouton UP [ ^ ] et vous pouvez voir trois valeurs :
un. 10,5 = 11 livres
b. 10,6 = 22 livres
c. 10,7 = 33 livres
- Terminez la procédure de réinitialisation en maintenant le bouton BAS jusqu'à ce que votre bureau debout descende et monte légèrement.
Nous avons quelques étapes de dépannage à suivre si vous voyez l'un des codes d'erreur suivants sur les cadres équipés de boîtiers de commande de la série FLTCON :
Vérifiez le code d'erreur ici .
Si le problème que vous rencontrez persiste après avoir suivi ces étapes, n'hésitez pas à contacter nos ingénieurs techniques produits au 1-800-676-6123 ou à nous envoyer un e-mail à sales@progressiveautomations.com .