Co Re Jo

Banc de test pour Hélice

Traction / consommation / vitesse de rotation

Le banc de test présenté ici permet de tester l’efficacité ou le rendement d’une hélice. Il s’agit d’hélice de modèle réduit d’avion ou de drone. Le système mesure la traction en gramme de l’hélice en fonction du courant consommé. Un fichier de valeurs est généré pour faire des comparaisons. Ce banc a été réalisé pour tester un nouveau type d’hélice dites « Toroidale ». Ces hélices sont dessinées sur Fusion 360 et fabriquées avec une imprimante 3D filaire en PLA puis sur une imprimante 3D résine. Les pièces pour réaliser ce banc sont téléchargeables sur le site www.Cults3D.com (rechercher : « Banc de test pour hélice » )

La création et les tests sont très rapides. Il faut compter 1 heure pour la conception de l’hélice sur Fusion 360, 1 heure pour la réalisation en impression 3D et 1/4 d’heure pour les tests.

Ici vous trouverez les différents tests réalisés : Résultats

(New) Autopsie d’une hélice de drone : Autopsie

Liste des principaux éléments du banc de test :

Module d’alimentation (régulation) MP1584EN. Ce module sert à alimenter les autres modules en 5 volts à partir de l’accumulateur 3S y compris l’Arduino.

La capteur de traction est un module HX711. Il permet de mesurer une traction ou une pression jusqu’à 2 Kg, ce qui est amplement suffisant.

La mesure du courant est faite avec un module ACS712.

La vitesse du moteur est directement contrôlée via un port PWM.

La carte de commande est du type Arduino Nano.

Les valeurs sont affichées sur un écran OLED 128 x 64 connecté en I2C.

Ajout d’un module LM293 pour récupérer la vitesse de rotation. (voir fin de page)

L’écran affiche l’état des boutons à gauche et à droite on a en premier la consommation en mA, les volts et la traction en gramme.

Chariot moteur : Il est constitué de deux axes de 8 mm avec deux glissières à roulements.

Modification du banc pour tester des hélices utilisées sur un drone DJI. Le chariot a été supprimer. La barre de pression est montée directement sur le moteur pour éliminer toutes les contraintes (celles générées par les glissières). Ici c’est le moteur d’un drone DJI Mini 3 Pro.

Le test de référence a été réalisé avec les hélices standards de ce type de drone.

Moteur DJI Mini 3 Pro

Exemples d’hélices testées :

Référence




Plan de câblage :

Listing du code utilisé :

#include « HX711.h »
#include <OLED_I2C.h>
#include « ACS712.h »
#include « Servo.h »

Servo controleur ; // création de l’objet « servo »
int ESC = 1000 ;

ACS712 mySensor( A1 );
float temp ;
int val11 ;
int val2 ;

OLED myOLED( SDA , SCL , 8 ) ;

extern uint8_t SmallFont[];
extern uint8_t MediumNumbers[];
extern uint8_t BigNumbers[];

HX711 scale;
float traction = 0.0 ;
float old_traction = 0.0 ;
int position = 0 ;

uint8_t bt_1 = 4 ;
uint8_t bt_2 = 5 ;
uint8_t bt_3 = 6 ;
uint8_t bt_4 = 7 ;

boolean etat_1 = false ;
boolean etat_2 = false ;
boolean etat_3 = false ;
boolean etat_4 = false ;

boolean sw_affichage = false ;
boolean reaff = false ;

uint8_t dataPin = 3 ; // 6 ;
uint8_t clockPin = 2 ; // 7 ;

uint8_t ampere = 1 ; // A1
uint8_t volt = 0 ; // A0

int retval_menu_1 = 0 ;

void setup()
{
Serial.begin( 115200 ) ;
Serial.println( __FILE__ ) ;
Serial.println( HX711_LIB_VERSION ) ;
Serial.println() ;

controleur.attach( 10 ) ;
controleur.writeMicroseconds( ESC ) ;

pinMode( bt_1 , INPUT ) ;
pinMode( bt_2 , INPUT ) ;
pinMode( bt_3 , INPUT ) ;
pinMode( bt_4 , INPUT ) ;

pinMode( ampere , INPUT ) ;
pinMode( volt , INPUT ) ;

scale.begin( dataPin, clockPin ) ;

// TODO find a nice solution for this calibration..
// load cell factor 20 KG
// scale.set_scale(127.15);

// load cell factor 5 KG
// scale.set_scale(420.0983); // TODO you need to calibrate this yourself.
// scale.set_scale( 1086.520263 ) ; // TODO you need to calibrate this yourself.
// 64.66
// scale.set_scale( 1086.520263 ) ; // 63.96
// scale.set_scale( 1086 ) ; // 64
// scale.set_scale( 1085 ) ; // 64.10
// scale.set_scale( 1080 ) ; // 64.35
scale.set_scale( 1075 ) ; // 64.64

// reset the scale to zero = 0
scale.tare(20);

myOLED.begin() ;
// myOLED.setFont(SmallFont);

myOLED.setFont( MediumNumbers ) ;
myOLED.setFont( SmallFont ) ;

myOLED.clrScr() ;

myOLED.fillScr() ;
myOLED.update() ;
// delay( 2000 ) ;

myOLED.print( « HX711_OLED » , LEFT , 0 ) ;
myOLED.update() ;
delay( 2000 ) ;

}

void ligne( int x , int y , String chaine , boolean ok_display )
{
// display.setCursor( x * 6 , y * 8 ) ;
// display.print( chaine ) ;
myOLED.print( chaine , x , y ) ;
if ( ok_display ) myOLED.update() ; //display.display() ;
}

void loop()
{
// boolean debug_loop = false ;
boolean debug_loop = true ;

// myOLED.clrScr() ;

if ( scale.is_ready() )
{
// Serial.println(scale.get_units( 10 ));
myOLED.clrScr() ;
myOLED.setFont( MediumNumbers ) ;
// myOLED.printNumI( analogRead( ampere ) , RIGHT , 0 ) ;
myOLED.printNumI( mySensor.mA_AC() , RIGHT , 0 ) ;

val11 = analogRead( volt) ;
temp = val11 / 4.092 ;
val11 = (int) temp ;
val2 = ( ( val11 %100 ) /10 ) ;
// myOLED.printNumI( analogRead( volt ) , RIGHT , 20 ) ;
myOLED.printNumI( val2 , RIGHT , 20 ) ;

traction = scale.get_units(1) ;
myOLED.printNumI( traction , RIGHT , 40 ) ;
myOLED.setFont( SmallFont ) ;
myOLED.update() ;

// génération pour fichier Excel
if ( abs( traction – old_traction ) > 1.0 )
{ // Serial.println( String( traction ) + « ; » + String( mySensor.mA_AC() ) ) ;
position = int( abs( traction ) ) ;
// Serial.println( String( position ) + « ; » + String( int( mySensor.mA_AC() ) ) ) ;
}

old_traction = traction ;
}

/*
etat_4 = digitalRead( bt_4 ) ; // Haut
if ( etat_4 )
{ Serial.println( String( position ) + « ; » + String( int( mySensor.mA_AC() ) ) ) ;
}
*/

etat_1 = digitalRead( bt_1 ) ; // retour arrière
etat_2 = digitalRead( bt_2 ) ; // validation
etat_3 = digitalRead( bt_3 ) ; // Bas
etat_4 = digitalRead( bt_4 ) ; // Haut

myOLED.setFont( SmallFont ) ;

if ( etat_1 ) // retour arrière
{ myOLED.print( « bt 1 ON » , LEFT , 0 ) ;
ESC = 1000 ;
controleur.writeMicroseconds( ESC ) ;
if ( debug_loop ) Serial.println( « bt 1 ON » );
}
else
{ myOLED.print( « bt 1 OFF » , LEFT , 0 ) ;
// if ( debug_loop ) Serial.println( « bt 1 OFF » );
}

if ( etat_2 ) // validation
{ myOLED.print( « bt 2 ON » , LEFT , 10 ) ;
if ( debug_loop ) Serial.println( « bt 2 ON » );

// acquisition des points
traction = 0 ;
old_traction = 0 ;
ESC = 1065 ;
int cpt_excel = 10 ;
for ( int cpt = 10 ; cpt < 120 ; cpt += 5 )
{ // il faut atteindre la traction en augmentant le PWM
while( traction <= cpt )
{ ESC ++ ;
if ( ESC > 2000 ) ESC = 2000 ;
controleur.writeMicroseconds( ESC ) ;
// Serial.println(  » T =  » + String( int( traction ) ) +  » cpt =  » + String( cpt ) + « IN ESC =  » + String( int( ESC ) ) ) ;
delay( 250 ) ;
traction = scale.get_units(1) ;

// emergency
etat_1 = digitalRead( bt_1 ) ;
if ( etat_1 ) break ;
}

myOLED.setFont( MediumNumbers ) ;
myOLED.printNumI( traction , RIGHT , 40 ) ;
// myOLED.setFont( SmallFont ) ;
myOLED.update() ;

// bouche les trous
// if ( traction > old_traction + 1 ) Serial.println( String( int( old_traction + 1 ) ) + « ; » + String( int( mySensor.mA_AC() ) ) +  » *** » ) ;

// Serial.println( String( int( traction ) ) + « ; » + String( int( mySensor.mA_AC() ) ) ) ;
Serial.println( String( cpt_excel ) + « ; » + String( int( mySensor.mA_AC() ) ) ) ;
// Serial.println( « out ESC =  » + String( int( ESC ) ) +  » T =  » + String( int( traction ) ) +  » cpt =  » + String( cpt ) ) ;
cpt_excel += 5 ;

old_traction = traction ;
traction = scale.get_units(1) ;
// traction = cpt ;

if ( ESC >= 2000 ) break ;

// emergency
etat_1 = digitalRead( bt_1 ) ;
if ( etat_1 ) break ;

}

// arret moteur
ESC = 1000 ;
controleur.writeMicroseconds( ESC ) ;

}
else
{ myOLED.print( « bt 2 OFF » , LEFT , 10 ) ;
// if ( debug_loop ) Serial.println( « bt 2 OFF » );
}

if ( etat_3 ) // bas
{ myOLED.print( « bt 3 ON  » + String( ESC ) , LEFT , 20 ) ;
ESC -= 5 ;
if ( ESC < 1000 ) ESC = 1000 ;
// controleur.write( ESC ) ;
controleur.writeMicroseconds( ESC ) ;
if ( debug_loop ) Serial.println( « bt 3 ON » );
}
else
{ myOLED.print( « bt 3 OFF » , LEFT , 20 ) ;
// if ( debug_loop ) Serial.println( « bt 3 OFF » );
}

if ( etat_4 ) // haut
{ myOLED.print( « bt 4 ON  » + String( ESC ) , LEFT , 30 ) ;
ESC += 5 ;
if ( ESC > 2000 ) ESC = 2000 ;
// controleur.write( ESC ) ;
controleur.writeMicroseconds( ESC ) ;
if ( debug_loop ) Serial.println( « bt 4 ON » );
}
else
{ myOLED.print( « bt 4 OFF » , LEFT , 30 ) ;
// if ( debug_loop ) Serial.println( « bt 4 OFF » );
}

myOLED.update() ;
delay( 100 ) ;

}

Bilan :

Les hélices ont été réalisées avec une imprimante 3D filaire. Ce type d’imprimante ne permet de réaliser des formes inclinées à plus de 50° sans supports. Les versions suivantes ont été réalisées avec une imprimante 3D résine. Avec laquelle on peut avoir des angles beaucoup plus élevés. Les supports sont beaucoup plus facile à gérer. Les hélices imprimées en résine sont plus lisses que celle en PLA et ont un meilleur rendement. Pour les hélices du drone DJI le rendement est très dépendant de l’épaisseur des pales. Il faut les faire les plus fines possibles. Ne pas dépasser 1 mm.

Ajout d’un module LM293 pour récupérer la vitesse de rotation :

Retour