Exemple de projet possible - Quadricoptère avec ma bibliothèque (sans Arduino)

[sylvainmahe]

Bonjour

Pour que vous ne soyez pas perdu, ce sujet est la continuité de ce premier sujet d'introduction: http://forums.futura-sciences.com/el...e-arduino.html


Le sujet ici présent: J'ai dernièrement construit un quadricoptère (chassis/carte pcb/électronique/programmation) en utilisant les fonctions de ma bibliothèque (voir sujet en lien ci-dessus), j'aimerais partager avec vous cette expérience car elle peut être intéressante pour ceux qui souhaitent vous lancer dans le quadricoptère fait maison sans utiliser Arduino


Le premier test moteur avec hélices:


Les premiers tests en vol aujourd'hui:


La puissance peut paraître légère (c'est censé être un quadricoptère de voltige), mais pour les premiers tests j'ai réglé la course des gaz à 50% max pour plus de sécurité, ceci explique cela Demain j'essayerais avec 100% de gaz.


Pour commencer, le code source sans ma bibliothèque (le main.cpp), fait seulement 326 lignes, donc sachez qu'un quadricoptère est en ordre de vol avec seulement 326 lignes dans le main, c'est très peu, ceci avec toutes les sécurités d'avant vol au branchement de la batterie lipo avec buzzer de signalement, à savoir:
-vérification que votre radiocommande est bien calibrée
-vérification de l'arrivée du pwm de toutes les voies du récepteur
-vérification de l'inter coupure moteur activé et du manche de gaz inférieur à 10%

Et également avec la musique au démarrage, ce qui n'est pas indispensable vous en conviendrez


Voila la photo du quadricoptère:
DSC01638resized.jpg

La photo de la carte électronique:
DSC01600resized.jpg
DSC01771resized.jpg

Cette carte maison me sert à tous mes projets en électronique, c'est la carte 328P évoquée dans le sujet cité au dessus.
Le plan de celle-ci se trouve dans le sujet cité plus haut, je ne vais pas encombrer celui ci.

La machine pour réaliser le châssis, si vous le réalisez en tube aluminium le mieux est d'avoir une fraiseuse sous la main:
DSC01526resized.jpg
DSC01629resized.jpg


Ceci est une présentation de ce projet, j'attends encore un peu d'avoir testé plus profondément le main.cpp en vol pour le poster en ligne, vous pourrez ainsi réaliser votre propre quadricoptère sans Arduino

Je donne des nouvelles de ce sujet sous peu dès que je finalise mes réglages et mes tests, à bientôt
-----

[invitec9c0a685]

Bonjour, intéressé par ton projet,
je ne parviens pas à t'envoyer des messages personnels
peux tu me laisser ton mail par message personnel pour que je puisse prendre contact avec toi
Cordialement

[sylvainmahe]

Bonjour,

Oui pas de soucis, par contre je partagerais d'autant plus ici pour que les infos soient accessibles à tout le monde bien entendu

Je t’envoie le mail par mp.

[jiherve]

Bonsoir,
jolie réalisation, mais sans Arduino c'est un peu exagéré car en fait c'est l'équivalent home made.
Le code est compact mais la encore c'est du c++ , donc après compilation cela fait combien?
Mais encore bravo.
JR

[A voir en vidéo sur Futura]

[sylvainmahe]

Si tu regardes les fonctions en page référence du site arduino, tu verra qu'a part digitalWrite, pwm, et pinMode, y a pas grand chose lol... Y a même des redondances avec Math.h
Ma bibliothèque n'a rien à voir avec ça, elle automatise bien plus les taches

[jiherve]

Bonjour,
sans aucun doute, mais cela ne répond pas à ma question!
JR

[sylvainmahe]

Bonjour, ta question est sur la taille en bytes une fois dans le 328P?
Cela fait environ 16000 bytes

Mais la chose intéressante, c'est que étant donné que c'est sous forme de classes, une fois qu'on a inclus et utilisé quelques classes, la taille augmente au départ mais pas beaucoup ensuite si on rajoute des choses dans le programme. Du coup tout passe tout le temps dans le 328P, enfin de ce que j'ai pu essayer jusqu’à maintenant

[jiherve]

Ré,
Pas mal en effet.
JR

[F1FNW]

Bonjour,Peut-on avoir le détail des capteurs utilises? Il y a des gyro? Des accéléromètres ? Baromètre ?Merci pour les infos.

[sylvainmahe]

En capteur il y a uniquement le mpu6050: http://fr.farnell.com/invensense/mpu...i2c/dp/1864742

En lisant les registres 8 bits de ce composant j'en déduit les données sur 16 bits signé de:
rotation x
rotation y
rotation z
translation x
translation y
translation z
et température

[invitef625d7cf]

Bonjour,

Très belle réalisation. Juste un mot: bravo !

[invitef86a6203]

Questions sur le gyro 6050;

Sur la lib il s'agit d’accéléromètre !
Translation c est quoi ?

Il n'y a pas de magnétomètre !
Le gyro 6050 est il vraiment fiable?

(ni d'altimètre non plus...donc pas de contrôle Z en hauteur, il peut monter ou descendre à plat et stable)


Chez Adafruit, ils font un calcul savant avec les 3 données gyro, accéléro, magnéto, pour avoir une coordonnée fiable qui d'ailleurs batifole un peu... ( ce n'est pas ce gyro)
D'où ma question, car ça laisse un peu septique sur la fiabilité d'un gyro simple.

D'ailleurs sur les modèles bas de gamme où il mettent gyro écrit sur la boite, c est juste un accéléromètre pour le stabiliser juste le minimum vitale LOL

[sylvainmahe]

Bonjour, merci pour vos commentaires


Pour tes interrogations *freepicbasic:

Le mpu6050 (http://www.invensense.com/products/m...axis/mpu-6050/) est le gyroscope le plus utilisé actuellement dans les applications drones.

Comme capteurs il a uniquement:
1 accéléromètre sur x
1 accéléromètre sur y
1 accéléromètre sur z
1 capteur de température

Et bien-sûr il a un mpu, le processeur de calcul.


Un accéléromètre c'est une sorte de lamelle piezo électrique, qui en se tordant à cause des accélérations, que ce soit de pesanteur avec la gravité ou de changement de vitesse, produit un signal électrique qui est converti par ce mpu en 2 valeurs 8 bit (qu'on transforme après en 16 bit mais peu importe).
Le capteur de température qu'en a lui sert pour compenser la dilatation des lamelles piézo pour avoir des valeurs fiables, et également on peut lire le registre dans lequel est stocké cette température, ça peut être pratique pour certaines applications

Le composant à bien 3 accéléromètres, mais on parle bien de gyroscope 6 axes, parce que les lamelles piézo régissent à toutes les accélérations !

Donc dans ma classe gyro j'ai bien inclu ces 6 axes:
tx ty tz rx ry rz

Ensuite le roll et le pitch, si on veut comme on dit en aviation l'horizon artificiel (ce qui n'est pas mon cas dans ce projet), se calculent grâce au translations ! Et non pas grâce aux rotations !

pitch = (atan2 (tyAccelerometerRaw, tzAccelerometerRaw) * 32767) / M_PI;
roll = (atan2 (-txAccelerometerRaw, sqrt ((tyAccelerometerRaw * tyAccelerometerRaw) + (tzAccelerometerRaw * tzAccelerometerRaw))) * 32767) / M_PI;

Pour résumer, le tx ty tz, ce sont les valeurs brutes des accéléromètres, et le rx ry rz ce sont les valeurs brutes des accéléromètres nettoyés des translations qu'on ne veut pas par le mpu !
Par contre on fait bien le pitch roll avec le tx ty tz.


Pour les questions d'altimètre (le baromètre) ou de magnétomètre, on peut les rajouter sur le bus TWI à coté du mpu6050 sans problème, mais faut en avoir l'utilité

Étant donné que je pilote depuis plus de 10 ans je n'ai pas besoin de ces assistances: https://www.youtube.com/watch?v=YWiQU__JSdM

Mais je vais très certainement créer le bout de code qu'il faut dans mon main avec l'horizon artificiel car un ami qui débute l'hélico est intéressé par ma carte et il veut se créer un quadri un peu comme le mien

[sylvainmahe]

L'intérieur du mpu6050:



On peut y voir les accéléromètres

[sylvainmahe]

Les réglages du quadri avancent

J'ai passé un flip/looping aujourd'hui sans soucis, mise à part qu'il y a encore pas assez de débattements, je vais être obligé de mettre de l'expo car quand on augmente trop les débattements c'est tellement sensible que ca en devient pas très pilotable autour du neutre.

Mais sinon rien à signaler, le code marche bien, la carte aussi, tout ca est robuste. En l'air j'essaye vraiment de chercher des configurations de vol ou sa demande beaucoup de corrections, pour l'instant l'algorithme ne me créé pas de problème en vol donc c'est tout bon

Le seul hic c'est la visualisation de 4 bouts de tube carré avec un pcb au centre, mais ca je m'en doutais. Faudra peut être rajouter un fuselage non symétrique pour mieux repérer le sens...

[f6bes]

Le seul hic c'est la visualisation de 4 bouts de tube carré avec un pcb au centre, mais ca je m'en doutais. Faudra peut être rajouter un fuselage non symétrique pour mieux repérer le sens...

Bjr à toi,
En général on choisit une AUTRE couleur pour un des bras afin de connaitre l'AVANT ( ORANGE pour l'avant, NOIR pour les 3
autres)..Bon WE

[sylvainmahe]

Tout à fait, ou quand on a un ami qui fait des fuselages à l'aérographe on peut éventuellement aller vers ce genre de chose:

****

Pour être conformes à l'épinglé : http://forums.futura-sciences.com/el...-sabonner.html, les pièces jointes doivent être hébergées sur le serveur du forum.

[antek]

Le seul hic c'est la visualisation de 4 bouts de tube carré avec un pcb au centre, mais ca je m'en doutais. Faudra peut être rajouter un fuselage non symétrique pour mieux repérer le sens...

Des feux de navigation + phare d'atterrissage !

[sylvainmahe]

Voila après une 30ène de vols de tests le code source final sans horizon artificiel (pour l'instant):
Main.cpp

#include "../library/Timer.h"
#include "../library/Delay.h"
#include "../library/Random.h"
#include "../library/Math.h"
#include "../library/Buzzer.h"
#include "../library/Servo.h"
#include "../library/Cycle.h"
#include "../library/Gyroscope.h"

using namespace std;

int main()
{
	uint8_t n = 0;
	Gyroscope mpu6050 = Gyroscope (0);
	Cycle channelThrottle = Cycle (1, false);
	uint16_t slowChannelThrottle = 0;
	uint16_t centerChannelThrottle = 0;
	Cycle channelPitch = Cycle (2, false);
	uint16_t centerChannelPitch = 0;
	Cycle channelRoll = Cycle (3, false);
	uint16_t centerChannelRoll = 0;
	Cycle channelYaw = Cycle (4, false);
	uint16_t centerChannelYaw = 0;
	Cycle channelHold = Cycle (5, false);
	uint16_t centerChannelHold = 0;
	Cycle channelOption = Cycle (6, false);
	uint16_t centerChannelOption = 0;
	Servo motor1 = Servo (7, 0, 0, 0);
	Servo motor2 = Servo (8, 0, 0, 0);
	Servo motor3 = Servo (9, 0, 0, 0);
	Servo motor4 = Servo (10, 0, 0, 0);
	Delay delaySoundStartCondition = Delay (1000, false);
	uint16_t mixThrottle = 0;
	int16_t mixThrustPitchGain = 0;
	int16_t mixThrustRollGain = 0;
	int16_t mixInertiaYawGain = 0;
	int16_t mixMinClearancePitch = 0;
	int16_t mixMaxClearancePitch = 0;
	int16_t mixMinClearanceRoll = 0;
	int16_t mixMaxClearanceRoll = 0;
	int16_t mixMinClearanceYaw = 0;
	int16_t mixMaxClearanceYaw = 0;
	const uint16_t SPEED_GYRO = 1000;
	int16_t speedPitch = 0;
	int16_t speedRoll = 0;
	int16_t speedYaw = 0;
	int16_t mixPitchOffsetGyro = 0;
	int16_t mixRollOffsetGyro = 0;
	int16_t mixYawOffsetGyro = 0;
	uint8_t thrustGainPitch = 0;
	uint8_t thrustGainRoll = 0;
	uint8_t inertiaGainYaw = 0;
	uint16_t gainMinRxGyro = 0;
	uint16_t gainMaxRxGyro = 0;
	uint16_t gainMinRyGyro = 0;
	uint16_t gainMaxRyGyro = 0;
	uint16_t gainMinRzGyro = 0;
	uint16_t gainMaxRzGyro = 0;
	int16_t mixMinRxGyro = 0;
	int16_t mixMaxRxGyro = 0;
	int16_t mixMinRyGyro = 0;
	int16_t mixMaxRyGyro = 0;
	int16_t mixMinRzGyro = 0;
	int16_t mixMaxRzGyro = 0;
	uint16_t mixMotor1 = 0;
	uint16_t mixMotor2 = 0;
	uint16_t mixMotor3 = 0;
	uint16_t mixMotor4 = 0;
	const uint16_t SETUP_MIN_CHANNEL_THROTTLE = 1000;
	const uint16_t SETUP_MAX_CHANNEL_THROTTLE = 2000;
	const uint16_t SETUP_MIN_CHANNEL_PITCH = 1000;
	const uint16_t SETUP_MAX_CHANNEL_PITCH = 2000;
	const uint16_t SETUP_MIN_CHANNEL_ROLL = 1000;
	const uint16_t SETUP_MAX_CHANNEL_ROLL = 2000;
	const uint16_t SETUP_MIN_CHANNEL_YAW = 1000;
	const uint16_t SETUP_MAX_CHANNEL_YAW = 2000;
	const uint16_t SETUP_MIN_CHANNEL_HOLD = 1000;
	const uint16_t SETUP_MAX_CHANNEL_HOLD = 2000;
	const uint16_t SETUP_MIN_CHANNEL_OPTION = 1500;
	const uint16_t SETUP_MAX_CHANNEL_OPTION = 2000;
	const int16_t SETUP_ZERO_PITCH = 38;
	const int16_t SETUP_ZERO_ROLL = -11;
	const int16_t SETUP_ZERO_YAW = -46;
	const uint16_t SETUP_FREQUENCY_ESC = 100;
	const uint16_t SETUP_HOLD_ESC = 950;
	const uint16_t SETUP_MIN_ESC = 1050;
	const uint16_t SETUP_MAX_ESC = 1950;
	const uint16_t SETUP_TRAVEL_PITCH = 300;
	const uint16_t SETUP_TRAVEL_ROLL = 300;
	const uint16_t SETUP_TRAVEL_YAW = 300;
	const uint16_t SETUP_SPEED_PITCH = 300;
	const uint16_t SETUP_SPEED_ROLL = 300;
	const uint16_t SETUP_SPEED_YAW = 200;
	const uint8_t SETUP_GAIN_PITCH = 87;
	const uint8_t SETUP_GAIN_ROLL = 83;
	const uint8_t SETUP_GAIN_YAW = 92;
	const uint8_t SETUP_THRUST_PROPELLER = 60;
	const uint8_t SETUP_INERTIA_PROPELLER = 100;
	
	Timer::pause (1000);
	
	slowChannelThrottle = round (double (SETUP_MIN_CHANNEL_THROTTLE) + ((double (SETUP_MAX_CHANNEL_THROTTLE) - double (SETUP_MIN_CHANNEL_THROTTLE)) / double (10)));
	centerChannelThrottle = round (double (SETUP_MAX_CHANNEL_THROTTLE) - ((double (SETUP_MAX_CHANNEL_THROTTLE) - double (SETUP_MIN_CHANNEL_THROTTLE)) / double (2)));
	centerChannelPitch = round (double (SETUP_MAX_CHANNEL_PITCH) - ((double (SETUP_MAX_CHANNEL_PITCH) - double (SETUP_MIN_CHANNEL_PITCH)) / double (2)));
	centerChannelRoll = round (double (SETUP_MAX_CHANNEL_ROLL) - ((double (SETUP_MAX_CHANNEL_ROLL) - double (SETUP_MIN_CHANNEL_ROLL)) / double (2)));
	centerChannelYaw = round (double (SETUP_MAX_CHANNEL_YAW) - ((double (SETUP_MAX_CHANNEL_YAW) - double (SETUP_MIN_CHANNEL_YAW)) / double (2)));
	centerChannelHold = round (double (SETUP_MAX_CHANNEL_HOLD) - ((double (SETUP_MAX_CHANNEL_HOLD) - double (SETUP_MIN_CHANNEL_HOLD)) / double (2)));
	centerChannelOption = round (double (SETUP_MAX_CHANNEL_OPTION) - ((double (SETUP_MAX_CHANNEL_OPTION) - double (SETUP_MIN_CHANNEL_OPTION)) / double (2)));
	
	Buzzer::pin (11);
	
	while (centerChannelThrottle == 0 || centerChannelPitch == 0 || centerChannelRoll == 0 || centerChannelYaw == 0 || centerChannelHold == 0 || centerChannelOption == 0)
	{
		delaySoundStartCondition.state();
		
		if (delaySoundStartCondition.update == true)
		{
			Buzzer::play (200, 100);
		}
	}
	
	delaySoundStartCondition.reset();
	
	Cycle::start (100);
	
	while (channelThrottle.us == 0 || channelPitch.us == 0 || channelRoll.us == 0 || channelYaw.us == 0 || channelHold.us == 0 || channelHold.us == 0)
	{
		channelThrottle.state();
		channelPitch.state();
		channelRoll.state();
		channelYaw.state();
		channelHold.state();
		channelOption.state();
		
		delaySoundStartCondition.state();
		
		if (delaySoundStartCondition.update == true)
		{
			Buzzer::key (200, 100);
			Buzzer::key (0, 100);
			Buzzer::key (200, 100);
			Buzzer::playKey();
		}
	}
	
	delaySoundStartCondition.reset();
	
	while (channelThrottle.us > slowChannelThrottle || channelHold.us < centerChannelHold)
	{
		channelThrottle.state();
		channelHold.state();
		
		delaySoundStartCondition.state();
		
		if (delaySoundStartCondition.update == true)
		{
			Buzzer::key (200, 100);
			Buzzer::key (0, 100);
			Buzzer::key (200, 100);
			Buzzer::key (0, 100);
			Buzzer::key (200, 100);
			Buzzer::playKey();
		}
	}
	
	Random::seed (15);
	
	for (n = 0; n < 16; n++)
	{
		if (n != 0)
		{
			Buzzer::key (0, Random::integer (25, 75));
		}
		
		Buzzer::key (Random::integer (70, 3000), Random::integer (25, 75));
	}
	
	Buzzer::playKey();
	
	speedPitch = Math::curve (0, SETUP_SPEED_PITCH, SPEED_GYRO, 0, 32767, 0);
	speedRoll = Math::curve (0, SETUP_SPEED_ROLL, SPEED_GYRO, 0, 32767, 0);
	speedYaw = Math::curve (0, SETUP_SPEED_YAW, SPEED_GYRO, 0, 32767, 0);
	
	thrustGainPitch = Math::curve (0, SETUP_THRUST_PROPELLER, 100, 0, SETUP_GAIN_PITCH, 0);
	gainMinRxGyro = Math::curve (0, thrustGainPitch, 100, 32767, 0, 0);
	gainMaxRxGyro = Math::curve (0, SETUP_GAIN_PITCH, 100, 32767, 0, 0);
	
	thrustGainRoll = Math::curve (0, SETUP_THRUST_PROPELLER, 100, 0, SETUP_GAIN_ROLL, 0);
	gainMinRyGyro = Math::curve (0, thrustGainRoll, 100, 32767, 0, 0);
	gainMaxRyGyro = Math::curve (0, SETUP_GAIN_ROLL, 100, 32767, 0, 0);
	
	inertiaGainYaw = Math::curve (0, SETUP_INERTIA_PROPELLER, 100, 0, SETUP_GAIN_YAW, 0);
	gainMinRzGyro = Math::curve (0, inertiaGainYaw, 100, 32767, 0, 0);
	gainMaxRzGyro = Math::curve (0, SETUP_GAIN_YAW, 100, 32767, 0, 0);
	
	mpu6050.setZero (SETUP_ZERO_PITCH, SETUP_ZERO_ROLL, SETUP_ZERO_YAW);
	
	motor1.hold (SETUP_HOLD_ESC);
	motor1.min (SETUP_MIN_ESC);
	motor1.max (SETUP_MAX_ESC);
	motor2.hold (SETUP_HOLD_ESC);
	motor2.min (SETUP_MIN_ESC);
	motor2.max (SETUP_MAX_ESC);
	motor3.hold (SETUP_HOLD_ESC);
	motor3.min (SETUP_MIN_ESC);
	motor3.max (SETUP_MAX_ESC);
	motor4.hold (SETUP_HOLD_ESC);
	motor4.min (SETUP_MIN_ESC);
	motor4.max (SETUP_MAX_ESC);
	
	motor1.moveHold();
	motor2.moveHold();
	motor3.moveHold();
	motor4.moveHold();
	
	Servo::start (SETUP_FREQUENCY_ESC);
	
	while (true)
	{
		mpu6050.state();
		channelThrottle.state();
		channelPitch.state();
		channelRoll.state();
		channelYaw.state();
		channelHold.state();
		channelOption.state();
		
		if (channelHold.us > centerChannelHold)
		{
			motor1.moveHold();
			motor2.moveHold();
			motor3.moveHold();
			motor4.moveHold();
		}
		else
		{
			mixThrottle = Math::curve (SETUP_MIN_CHANNEL_THROTTLE, channelThrottle.us, SETUP_MAX_CHANNEL_THROTTLE, SETUP_MIN_ESC, SETUP_MAX_ESC, 0);
			
			mixMotor1 = mixThrottle;
			mixMotor2 = mixThrottle;
			mixMotor3 = mixThrottle;
			mixMotor4 = mixThrottle;
			
			mixMinClearancePitch = Math::curve (SETUP_MIN_CHANNEL_THROTTLE, channelThrottle.us, SETUP_MAX_CHANNEL_THROTTLE, 0, SETUP_TRAVEL_PITCH, 0);
			mixMaxClearancePitch = Math::curve (SETUP_MIN_CHANNEL_THROTTLE, channelThrottle.us, SETUP_MAX_CHANNEL_THROTTLE, SETUP_TRAVEL_PITCH, 0, 0);
			mixPitchOffsetGyro = Math::curve (SETUP_MIN_CHANNEL_PITCH, channelPitch.us, SETUP_MAX_CHANNEL_PITCH, -speedPitch, speedPitch, 0);
			mixThrustPitchGain = Math::curve (SETUP_MIN_CHANNEL_THROTTLE, channelThrottle.us, SETUP_MAX_CHANNEL_THROTTLE, gainMaxRxGyro, gainMinRxGyro, 0);
			mixMinRxGyro = Math::wurve (-mixThrustPitchGain, mpu6050.rx + mixPitchOffsetGyro, mixThrustPitchGain, -mixMaxClearancePitch, 0, mixMinClearancePitch, 0, 0);
			mixMaxRxGyro = Math::wurve (-mixThrustPitchGain, mpu6050.rx + mixPitchOffsetGyro, mixThrustPitchGain, -mixMinClearancePitch, 0, mixMaxClearancePitch, 0, 0);
			
			mixMotor1 -= mixMinRxGyro;
			mixMotor2 -= mixMinRxGyro;
			mixMotor3 += mixMaxRxGyro;
			mixMotor4 += mixMaxRxGyro;
			
			mixMinClearanceRoll = Math::curve (SETUP_MIN_CHANNEL_THROTTLE, channelThrottle.us, SETUP_MAX_CHANNEL_THROTTLE, 0, SETUP_TRAVEL_ROLL, 0);
			mixMaxClearanceRoll = Math::curve (SETUP_MIN_CHANNEL_THROTTLE, channelThrottle.us, SETUP_MAX_CHANNEL_THROTTLE, SETUP_TRAVEL_ROLL, 0, 0);
			mixRollOffsetGyro = Math::curve (SETUP_MIN_CHANNEL_ROLL, channelRoll.us, SETUP_MAX_CHANNEL_ROLL, -speedRoll, speedRoll, 0);
			mixThrustRollGain = Math::curve (SETUP_MIN_CHANNEL_THROTTLE, channelThrottle.us, SETUP_MAX_CHANNEL_THROTTLE, gainMaxRyGyro, gainMinRyGyro, 0);
			mixMinRyGyro = Math::wurve (-mixThrustRollGain, mpu6050.ry - mixRollOffsetGyro, mixThrustRollGain, -mixMaxClearanceRoll, 0, mixMinClearanceRoll, 0, 0);
			mixMaxRyGyro = Math::wurve (-mixThrustRollGain, mpu6050.ry - mixRollOffsetGyro, mixThrustRollGain, -mixMinClearanceRoll, 0, mixMaxClearanceRoll, 0, 0);
			
			mixMotor1 -= mixMinRyGyro;
			mixMotor2 += mixMaxRyGyro;
			mixMotor3 -= mixMinRyGyro;
			mixMotor4 += mixMaxRyGyro;
			
			mixMinClearanceYaw = Math::curve (SETUP_MIN_CHANNEL_THROTTLE, channelThrottle.us, SETUP_MAX_CHANNEL_THROTTLE, 0, SETUP_TRAVEL_YAW, 0);
			mixMaxClearanceYaw = Math::curve (SETUP_MIN_CHANNEL_THROTTLE, channelThrottle.us, SETUP_MAX_CHANNEL_THROTTLE, SETUP_TRAVEL_YAW, 0, 0);
			mixYawOffsetGyro = Math::curve (SETUP_MIN_CHANNEL_YAW, channelYaw.us, SETUP_MAX_CHANNEL_YAW, -speedYaw, speedYaw, 0);
			mixInertiaYawGain = Math::curve (SETUP_MIN_CHANNEL_THROTTLE, channelThrottle.us, SETUP_MAX_CHANNEL_THROTTLE, gainMaxRzGyro, gainMinRzGyro, 0);
			mixMinRzGyro = Math::wurve (-mixInertiaYawGain, mpu6050.rz + mixYawOffsetGyro, mixInertiaYawGain, -mixMaxClearanceYaw, 0, mixMinClearanceYaw, 0, 0);
			mixMaxRzGyro = Math::wurve (-mixInertiaYawGain, mpu6050.rz + mixYawOffsetGyro, mixInertiaYawGain, -mixMinClearanceYaw, 0, mixMaxClearanceYaw, 0, 0);
			
			mixMotor1 -= mixMinRzGyro;
			mixMotor2 += mixMaxRzGyro;
			mixMotor3 += mixMaxRzGyro;
			mixMotor4 -= mixMinRzGyro;
			
			motor1.pulse (mixMotor1);
			motor2.pulse (mixMotor2);
			motor3.pulse (mixMotor3);
			motor4.pulse (mixMotor4);
		}
	}
	
	return 0;
}

Pour quadricoptère avec:
Moteur1 = avant gauche
Moteur2 = avant droit
Moteur3 = arrière gauche
Moteur4 = arrière droit

Les paramètres à adapter selon votre quad commencent par le préfixe SETUP.
La gestion des moteurs prends en compte le rendement des hélices (paramètre THRUST), cette gestion est asymétrique de sorte que vous avez votre plein ralenti et plein gaz avec 100% des ordres pitch/roll/yaw disponible même manche de gaz (THROTTLE) en butée mini ou maxi.

Le quad est très verrouillé sur ses axes, la voltige passe sans aucune difficulté, j'ai testé pleins de choses: plein gaz vers le bas, boucles carrés, etc...

Il y a bien-sûr les trois sécurités d'avant démarrage que j'ai cité dans ce sujet.

Ma config actuelle est:
tiger motors mn2206
kiss esc 18A
lipo 4s 2200mAh
hélices hq 6x4.5"


Le code est très robuste, vous pouvez-y aller sans problème N'hésitez pas si vous avez un soucis ou des questions.

[sylvainmahe]

Nouvelle vidéo avec un peu de voltige
(soyez indulgents c'est pas facile de piloter avec les pouces gelés )




****

Pour être conformes à l'épinglé : http://forums.futura-sciences.com/el...-sabonner.html, les pièces jointes doivent être hébergées sur le serveur du forum.

N'hésitez pas si vous avez des interrogations coté réalisation ou autre.

[sylvainmahe]

Après quelques mois de recherches infructueuses en ce qui concerne le nom et le logo de mon projet cartes+bibliothèque, j'ai finalement réussi à en dessiner un qui me convient:

logo module small.jpg

Module integrated = module intégré (pour les non anglophones)
Module pour modulable, mais aussi pour génération de signal modulé (pulse width modulation), d’où la forme du logo (onde carrée). GPL pour General Public Licence (https://fr.wikipedia.org/wiki/Licenc...%C3%A9rale_GNU).

J'ai aussi travailler sur le site aujourd'hui pour que cela soit cohérent niveau formes et couleurs, mais il me faudra d'autres week-end pour finaliser ce site
http://sylvainmahe.xyz/


Photo du quadricoptère:
DSC01904resized.jpg


Encore une fois n'hésitez pas pour les commentaires et si vous avez des questions pour le fonctionnement de la bibliothèque, et/ou idées que vous pouvez apporter