11 réponses à ce sujet

[FiringFox]

Bonjour,
Pour un projet j'ai besoin de ceci : http://cgi.ebay.fr/2200KV-Brushless-Motor-A2212-6-ESC-30A-Speed-Controller-/310380962080?pt=FR_YO_Jeux_RadioComRobots_VehiculesRadiocommandes&hash=item484425a120

Il va me falloir brancher le variateur de vitesse du moteur (aussi appelé ESC) à la carte Arduino pour pouvoir contrôler en temps réel le régime du moteur, mais voilà même après des recherches je ne sais pas trop comment faire les branchements, ni de quelle donnée l'ESC a besoin pour varier la vitesse.

Merci beaucoup !

[FiringFox]

Dans mes recherches je suis tombé sur cet article qui répond à quelques questions : http://blog.ianlee.info/2011/08/controlling-brushless-motor-with-netmf.html

Mais ce qui m'embête c'est ce driver (à vrai dire je ne pensais pas que faire tourner un moteur brushless serait aussi costaud (je pensais plutôt à faire rentrer une simple valeur dans l'ESC comme un pourcentage, bref)). Celui-ci est pour les cartes NETMF et quand je vois le code j'ai un peu de mal à reconnaître mes bases de C++... Vous y comprenez quelque chose ?

using GHIElectronics.NETMF.Hardware;

namespace QuadroLib.Acuator {
    /// <summary>
    /// Class to controll an Electronic Speed Controler (ESC) for Airplanes (NO REVERSE)
    /// </summary>
    public class BrushlessMotor {
        protected static uint Period;
        protected const uint Max = 20 * 100 * 1000;
        protected const uint Min = 10 * 100 * 1000;

        // Scale
        private uint Precalc = (Max - Min) / _scale;
        private uint _scale = 100; 
        public uint Scale {
            get {
                return _scale;
            }
            set {
                Stop();
                _scale = value;
                Precalc = (Max - Min) / _scale;
            }
        }

        private readonly PWM _pwmPin;

        /// <summary>
        /// Uses 50Hz
        /// </summary>
        /// <param name="pin">PWM Pin</param>
        public BrushlessMotor(PWM.Pin pin)
            : this(pin, Periods.P50Hz) {
        }

        /// <summary>
        /// Use higher period, means faster response, not supported by all ESC
        /// </summary>
        /// <param name="pin">PWM pin</param>
        /// <param name="period">Period</param>
        public BrushlessMotor(PWM.Pin pin, Periods period) {
            Period = (uint)period;
            this._pwmPin = new PWM(pin);
            this._pwmPin.SetPulse(Period, Min);
        }

        /// <summary>
        /// Sets the outputpower, from 0 to "Scale"
        /// </summary>
        /// <param name="power">0..."Scale"</param>
        public void SetPower(int power) {
            uint highTime = (uint)(Min + (Precalc * Constrain(power, 0, _scale)));
            this._pwmPin.SetPulse(Period, highTime);
        }

        public void Stop() {
            this._pwmPin.SetPulse(Period, Min);
        }

        public void Full() {
            this._pwmPin.SetPulse(Period, Max);
        }

        private static int Constrain(int x, int a, int <img src='http://www.robot-maker.com/forum/public/style_emoticons/<#EMO_DIR#>/cool.gif' class='bbc_emoticon' alt='B)' /> {
            if (x > a && x < <img src='http://www.robot-maker.com/forum/public/style_emoticons/<#EMO_DIR#>/cool.gif' class='bbc_emoticon' alt='B)' /> {
                return x;
            }
            if (x < a) {
                return a;
            }
            return b;
        }
    }

    public enum Periods : uint {
        /// <summary>
        /// Standard rate 50Hz
        /// </summary>
        P50Hz = 20 * 1000000,
        /// <summary>
        /// Turbo PWM 400Hz
        /// </summary>
        P400Hz = 25 * 100000,
        /// <summary>
        /// Turbo PWM 500Hz
        /// </summary>
        P500Hz = 2 * 1000000,
    }
}

Merci

[FiringFox]

Apparemment personne n'a envie d'utiliser des brushless ici
Une vraie galère ces recherches mais j'ai quand même appris des choses utiles:
-les brushless se contrôlent avec la librairie Arduino pour servos (Arduino servos))
-Le problème est que les ESC ont des systèmes de sécurité pour empêcher le moteur d'être à 100% au démarrage et d'autres trucs comme ça. Donc sans initialisation à 0%, le moteur refuse de démarrer.
-les moteurs brushless se contrôlent par PWM : on leur envoie des impulsions électriques, plus elles sont longues, plus le moteur va tourner vite et réciproquement. L'intervalle est souvent défini entre 700µs et 2300µs (1500µs étant la position neutre (0%) mais ce n'est pas le cas pour tous les ensembles moteur/ESC. Si ce n'est pas marqué sur le manuel ou la fiche, il faut le déterminer mais c'est assez laborieux et risqué pour le moteur/ESC.

J'ai trouvé cet article en anglais que je trouve bien explicite : Driving a brushless DC motor using an Arduino
sur lequel ce code nous est fourni (j'ai supprimé les fonctions qui servaient à afficher à l'écran des valeurs et j'ai traduit/ajouté certains commentaires pour n'avoir que ce qui nous intéresse):

#include <Servo.h> // Pour contrôler le moteur on utilise la librairie servo.

Servo mServo; // Déclaration de la variable du moteur (semblable à celle d'un servo).

int inPotPin = 1; // Analog input pin #1 reads pot value (ici l'auteur du code emploie un potentiomètre pour réguler le régime de son brushless)
int outPinPPM = 11; // PPM output pin #11 (sortie prochainement attachée au moteur).

int throttlePulse = 1500; // Valeur de la largeur des impulsions, 1500 = 0%

int pulseDelay = 300; // Délais entre chaque impulsion (cette valeur varie-t-elle selon les moteurs/ESC ?)
int pulseMin = 700; // Largeur d'impuslion minimale, 700 = -100%
int pulseMax = 2300; // Largeur d'impulsion maximale, 2300 = +100%

void setup()
{
mServo.attach(outPinPPM, pulseMin, pulseMax); // Attache le moteur à outPinPPM (sortie 11), et déclare la fourchette de largeur d'impulsion.
mServo.writeMicroseconds(throttlePulse); // Initialise le moteur en régime neutre (0%) pour que la sécurité embarquée dans l'ESC ne refuse pas le démarrage du moteur.

}

void loop()
{
throttlePulse = map(analogRead(inPotPin), 0, 1023, pulseMin, pulseMax); // Etalonne la valeur sortante du pot pour correspondre à la fourchette de largeur d'impulsion.
mServo.writeMicroseconds(throttlePulse); // Envoie la valeur de largeur d'impulsion voulue à l'ESC pour obtenir la vitesse moteur souhaitée.
delayMicroseconds(pulseDelay); // Delais entre cette impulsion et la suivante.
}

Je n'ai pas encore reçu mon matériel alors je ne peux pas affirmer que cela marche, mais dés que possible je teste et poste mes résultats Si tout se passe bien je ferai un tutorial.

Vive les monologues !

[seb03000]

Salut moi perso je ne connais pas , et je pense içi aussi il dois avoir pas mal de monde qui ne connaisse pas non plus , c'est

pour cela que personne ne répond.

Mes tien nous au courent de tes avancer si cela et possible , je suivrai ton projet de très près pour comprendre.

@Cordialement.

[FiringFox]

En effet je me suis aperçu dans mes recherches que c'était peu pertinent ^^
Quand j'aurai fini (si tout works well) je pense aussi faire une librairie "brushlessMotor" car vu comment c'est galère de trouver quelque chose de simple sur ce sujet, les prochains seront sûrement contents d'avoir le travail mâché, et ils auraient raison !

Merci seb03000 au moins je sais que je parle pas dans le vide

[Gab]

Bonjour avez vous réussi a créer votre librairie "brushlessMotor" car
j'aimerais aussi contrôler des moteurs brushless avec ma carte Arduino et
avant d'en acheter j'aimerais être sur que cela soit faisable.

Merci Gabriele

[FiringFox]

Navré mais après plusieurs essais je n'ai pas réussi à en faire marcher un... Donc pas de librairie

[Gab]

ok merci quan-même

[Mike118]

Navré mais après plusieurs essais je n'ai pas réussi à en faire marcher un... Donc pas de librairie

Salut !

Dis moi, est ce que tu as un servo moteur ?

Si oui, Est ce que tu sais le faire tourner ?
Si la réponse et oui,

est ce que tu as un variateur adapté à ton moteur ?

Comme tes recherches l'ont idiquées, oui un variateur se controle comme un servomoteur à la différence près des sécurités supplémentaires.

Si tu sais faire bouger un servo de sa distance min à sa distance max très doucement, je te suggère de juste remplacer le servo par l'ensemble variateur + moteur bruschless.

Tu vas alors entendre à un moment un "biiiip " ( signification que les ESC se sont initialisé ) et juste après les moteurs vont partir. Si tu as des moteurs rapides la première fois c'est assez surprenant ! x) Du coup pense à bien fixer ton moteur !

à bientôt !

[ChristianR]

J'avais pas vu passer ce post.

Oui, c'est possible de piloter un moteur brushless avec son ESC depuis une carte Arduino.



La librairie à inclure : #include <Servo.h>
http://arduino.cc/en/reference/servo

Il faut envoyer au contrôleur (ESC) du moteur brushless des durées de signaux en ms, au lieu d'angles comme on le fait habituellement pour un servo.
http://arduino.cc/en/Reference/ServoWriteMicroseconds

SERVO_MIN et SERVO_MAX seront à adapter en fonction de l'ESC utilisé.
On sépare les commandes par un PULSE_DELAY pour laisser le temps au contrôleur de digérer les commandes successives.

[hmnrobots]

En fonction de l utilisation, du type de moteur (outrunner , inrunner) il peut être nécessaire de programmer l'ESC (tutos youtube) .si démarrage en charge alors , pour ma part, je démarre à 1150us car l'ESC peut ne pas détecter le démarrage et s 'arrêter

[nono le petit robot]

Bonjour à tous,

Je suis débutant avec l'ARDUINO.

Je voudrais commander mon ESC par l'arduino, j'ai lu plusieurs commentaires sur le forum et quelques schémas de câblage.

J'ai le schéma de câblage avec les bornes GND et la PIN 9 de l'arduino uno çà c'est "OK".

Par contre le programme reste flou certain rajoute un potentiomètre d'autre pas.

Pouvez vous me guider sur une piste d'un programme à tester?

Merci de votre aide.