Voir le flux RSS

rokag3

CNC écrire un système de mesure d'outils en rotation par shadow laser et quadrant photodiode

Noter ce billet
par , 10/09/2018 à 04h39 (122 Affichages)
Bonjour,

Le projet consiste à mesurer le diamètre et la longueur d'un outil en rotation sans contact en obscurcissant (shadowing) un laser.
La vitesse de rotation est connue et stable à 1%
La vitesse de translation est connue et précise à une valeur proche de 100%
La précision dépend de l'encodeur linéaire monté sur la fraiseuse en général 5 microns ou 1 micron
La précision souhaité est <= 1/100 de mm fiable
La répétabilité doit permettre de valider une mesure au 1/100 de mm
L'outil doit couter à la fabrication moins de 100€
Le prototype est en plaque d'acier de 20mm pour la base et 10mm pour les murs
l'outil définitif sera en granit epoxy et vendu moins de 500€ avec le filtre à air comprimé les protections anti liquides et les valves disponible aussi en open source.
On s'amusera ensuite à compter les dents et les mesurer ainsi que la digitalisation du profile, du faux rond et de l'usure (développement ultérieur)

Le principe.
un laser rouge à 1€ alimenté de façon stable raisonnablement réglé passe à travers un trou lissé et fraisé de 1.5 mm de diamètre puis passe 20 cm dans l'air puis repasse à travers une loupe (ou pas) et atterrit sur une photodiode en quadrant S5980 ici http://images.100y.com.tw/pdf_file/2...5981-S5870.pdf
J'en ai eu 2 gratos merci Hamamatsu mais c'est un composant assez onéreux de l'ordre de 15€ unitaire pour un achat de 1000
Je les ai monté en phototransistor avec des BC547c avec une résistance de 1k sur l'émetteur alimenté en 5V et cela fonctionne très bien.
le premier essai avait été fait avec une arduino, je passe maintenant sur NUCLEO-F401-RE

Mon premier essai avait été fait avec un phototransistor en quadrant récupéré sur un encodeur de photocopieuse xerox et cela fonctionnait très bien aussi, et il était probablement moins cher , malheureusement je n'ai jamais réussie à en trouver d'autre .

le montage est fixé sur la fraiseuse perpendiculaire à l'axe des X, l'outil est en rotation 600RPM (il faudra peut être faire un sélectioneur de vitesse 300 rpm pour les grosses fraises 600 et 900rpm )

la première stratégie consistait à considérer que si 3 fenêtres sur 4 voyaient leur valeur tomber sous leurs valeurs minimum alors la tangente de l'outil en rotation avait dépassé le centre (de peu)

on étalonne chaque quadrant du phototransistor en cherchant la valeur minium sur 1000 mesures
lorsque l'on détecte que deux femêtres sont en dessous de leur valeur minimum on active le signal de probe qui vas dérouler le programme Gcode retrait de 1mm puis avance en vitesse lente .5mm sec
lorsque l'on a la 3ième fenêtre en dessous de son minimum on envoie le signal de probe on soustrait la largeur du séparateur + une valeur déterminée par comparaison avec l'éétalon dans le Vcode de la CNC....job done



Hélas, si les précisions pouvaient se révéler remarquable la répétabilité était lamentable en dehors de toute possibilité de trimming

Donc le principe simple très simple était....trop simple.


Ou j'en suis

définir un nouveau principe de fonctionnement

Même avec des collets de précision il est pratiquement impossible d'avoir un faux rond inférieur à 1 micron, hors mes photo diodes "voient" une variation de 1 micron chaque photodiode mesure 2.5mm le convertisseur analogique digital du NUCLEO-F401-RE est- sur 12bits soit 4096 2.5mm cela fait 2500 microns on a donc 610 nanomètre par point.

Bien entendu on aura pas de stabilité avec une telle valeur mais on devrait pouvoir déterminer une variation cyclique.
Disons le tout net, des collets de cette précision sont très couteux et leurs possesseurs s'achèterons des outils de métrologie à plus de 10000€ susceptible de les satisfaire.

je dois chercher une variation cyclique
lorsqu'une de mes fenêtres passe en dessous de son minimum je déclenche un T.start
si ma valeur n'augmente pas dans le temps nécessaire pour faire 1tour je fais un T.reset cela signifie qu'une poussière est passée devant une fenêtre sinon je vais affiner mes calculs de variation cyclique.
évidemment sur autre chose qu'un mandrin lisse j'aurai plusieurs cycles en fonction du nombre de dents
je prendrai la plus grande variation qui est censée être la première entrée dans le laser
Je calcule le temps qu'il lui faudra pour atteindre le centre de ma cellule (la partie aveugle fait 3/100ème de mm)
j'envoie le signal probe moins le temps de traitement de ma CNC au moment calculé
Je peux éventuellement vérifier la validité de ma mesure en regardant si la 3ième fenêtre sera atteinte au moment prévue .

Je cherche des gens qui seraient intéressés pour développer cela avec moi .
On travaillera en spooling les routines de calculs de périodicités seront coupés pour faire des appels de lecture sur les photodiodes, cela évitera les empilages couteux en temps des interruptions (à moins que cela ne coute rien, je suis obsolète dans mes connaissances mais je doute que l'on puisse faire des interruptions sans bouffer un max de cycles).

Tout repose sur la vitesse de la conversion analogique digitale . A ce sujet j'ai unsigned short read_u16 () ou float read () Je srai bien sur tenté d'utiliser l'unsigned short mais j'i ocru lire que le float était plus rapide sur le STM32 alors float ou integer ?

Je vais avoir un axe de test (ce sera l'outil qui se déplacera au lieu de l'inverse)
Pour l'instant je vais commencer à faire mes tests sur l'ancien photo transistor.
J'ai testé le Hamamatsu pour faire un logiciel d'alignement dont je vais fournir le source

Vos questions et vos objections sont les bienvenues
Merci d''être allé au bout

Envoyer le billet « CNC écrire un système de mesure d'outils en rotation par shadow laser et quadrant photodiode » dans le blog Viadeo Envoyer le billet « CNC écrire un système de mesure d'outils en rotation par shadow laser et quadrant photodiode » dans le blog Twitter Envoyer le billet « CNC écrire un système de mesure d'outils en rotation par shadow laser et quadrant photodiode » dans le blog Google Envoyer le billet « CNC écrire un système de mesure d'outils en rotation par shadow laser et quadrant photodiode » dans le blog Facebook Envoyer le billet « CNC écrire un système de mesure d'outils en rotation par shadow laser et quadrant photodiode » dans le blog Digg Envoyer le billet « CNC écrire un système de mesure d'outils en rotation par shadow laser et quadrant photodiode » dans le blog Delicious Envoyer le billet « CNC écrire un système de mesure d'outils en rotation par shadow laser et quadrant photodiode » dans le blog MySpace Envoyer le billet « CNC écrire un système de mesure d'outils en rotation par shadow laser et quadrant photodiode » dans le blog Yahoo

Mis à jour 11/09/2018 à 09h41 par kolodz

Catégories
Programmation , C++

Commentaires

  1. Avatar de rokag3
    • |
    • permalink
    A cet adresse vous pouvez trouver une thèse sur le sujet de la mesure (gratuit )

    Fang, Zixi (2015) Research and Application of the Cutter Geometry On-Machine Measurement Using Laser Tool Setters. Masters thesis, Concordia University.

    https://spectrum.library.concordia.ca/979713/
    Mis à jour 10/09/2018 à 21h10 par rokag3
  2. Avatar de rokag3
    • |
    • permalink
    Cette image est une image de cible
    le code est écris pour processing 3.3.5 et ne présente aucune difficultée particulière




    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    /**
     * prog name lirelaser
     * vizualize laser
     * work with adatestquadrants 
     * processing 3.3.5 
     *  
     */
    PImage img;
    PFont f;
    float mx;
    float my;
    float easing = 0.05;
    int radius = 50;
    int edge = 100;
    int inner = edge + radius;
    import processing.serial.*;
    int testi;
    
    Serial myPort;  // Create object from Serial class
    float valX,valY,valA,valB,valC,valD;      // Data received from the serial port
    int c;
    void setup() {
      // I know that the first port in the serial list on my mac
      // is always my  FTDI adaptor, so I open Serial.list()[0].
      // On Windows machines, this generally opens COM1.
      // Open whatever port is the one you're using.
      String portName = Serial.list()[2];
      myPort = new Serial(this, portName, 19200);
      size(800, 800);
      noStroke(); 
      ellipseMode(RADIUS);
      rectMode(CORNERS);
      //printArray(PFont.list());
      f = createFont("DialogInput.bolditalic", 24);
      textFont(f);
      textAlign(CENTER, CENTER);
      img = loadImage("5323_Steiner-5x25-56mm-reticle.jpg");  //https://www.outdoorsbay.com/gallery-1/originals/5323_Steiner-5x25-56mm-reticle.jpg
    }
    
    void draw() { 
     
      background(51);
      if ( myPort.available() > 0 && ( testi++>=2)) {
       testi=2;
         String inBuffer = myPort.readStringUntil('\n');
         //print(inBuffer);
         if (inBuffer != null) {
          //String myString = new String(inBuffer);
          //println(myString);
          float[] val = float(inBuffer.split(",", 12));  
         //val = new float[6];
          // float val[] = float(split(inBuffer,','));
           valX=val[0];
           valY=val[1];
           valA=int(val[2]);
           valB=int(val[3]);
           valC=int(val[4]);
           valD=int(val[5]);
     //String texta="A";
            // read it and store it in val
      }
      if (abs(valX - mx) > 0.1) {
        mx = mx + (valX - mx) * easing;
     
      }
      if (abs(valY - my) > 0.1) {
        my = my + (valY- my) * easing;
     
      }
      
      mx = constrain(mx, inner, width - inner);
      my = constrain(my, inner, height - inner);
      fill(76);
      rect(edge, edge, width-edge, height-edge);
      image(img, 0, 0); 
      //rect(edge, edge, width-edge, height-edge);
      //fill(128);
      fill(255, 0, 0);
      text(valA,50, 25);
      text("QUAD A",50, 125);
      text(valB,675, 25);
      text("QUAD B",700, 125);
      text(valC,50, 730);
      text("QUAD C",50, 610);
      text(valD,680, 730);
      text("QUAD D",700, 610);
      text(valY,500, 60);
      text(valX,150, 280);
      fill(255,0,0);
    
     
    stroke(255,0,0);
    noFill();
    ellipse((width/2)-valX-(radius/2),height/2- valY-(radius/2) , 90, 90);
    
    fill(255,0,0);
     ellipse((width/2)-valX-(radius/2),height/2- valY-(radius/2), radius, radius); 
     fill(0,255,0);
    rect(0,height/2-5,valA/8,height/2-45);  
    rect((width/2)-50,0,width/2,valB/8);
    rect(width/2,height-51,width/2-50,height-51-valC/8);
    rect(width-(50+valD/8),height/2-45,width-50,height/2-5);
    ///upper left x,upper left y,width,height
    }}

    Le programme arduino

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    /**
     * prog name adatestquadrants
     * vizualize laser
     * work with  lirelaser processing 3.3.5
     * this program for arduino transmit the position of the lazer spot on a target
     *  
     */
     
    String quadrant[4] ;
    String touslesquadrant,xystring ;
    int abcd[4];
    int Oldmina,Oldmaxa,Oldminb,Oldmaxb,Oldminc,Oldmaxc,Oldmind,Oldmaxd;
    float x,y;
    int intrusion;
    int ledRed=9;//intrusion detected
    int ledGreen=8 ;//probe signal
    void setup() {
    // initialize the serial communication:
    Serial.begin(9600);
    Oldmaxa=analogRead(0);//lecture du quadrant A
    Oldmina =Oldmaxa; //initialisation des minimax
    Oldmaxb=analogRead(1);//lecture du quadrant B
    Oldminb =Oldmaxb;
    Oldmaxc=analogRead(2);//lecture du quadrant C
    Oldminc =Oldmaxc;
    Oldmaxd=analogRead(3);//lecture du quadrant D
    Oldmind =Oldmaxd;
    pinMode(ledGreen, OUTPUT); // 
    pinMode(ledRed, OUTPUT); 
          digitalWrite(ledRed, HIGH) ;
          digitalWrite(ledGreen,HIGH);
    
    for (int i=0 ;i<3000;i++){ //determination des variations maximums
    int maxa=analogRead(0);
    if(maxa < Oldmina){
    Oldmina =maxa;}
    if(maxa > Oldmaxa){
    Oldmaxa =maxa;}
    delay(3);  
    // je doit déterminer si l'utilisation d'une matrice ne serait pas plus économe 
    int maxb=analogRead(1);
    if(maxb < Oldminb){
    Oldminb =maxb;}
    if(maxb > Oldmaxb){
    Oldmaxb =maxb;}
    delay(3); 
    int maxc=analogRead(2);
    if(maxc < Oldminc){
    Oldminc =maxc;}
    if(maxc > Oldmaxc){
    Oldmaxc =maxc;}
    delay(3); 
    int maxd=analogRead(3);
    if(maxd < Oldmind){
    Oldmind =maxd;}
    if(maxd > Oldmaxd){
    Oldmaxd =maxd;}
    delay(3); 
    
    } 
    delay(5000);//time to vizualize the control leds
    
    Serial.print(" A-=");
    Serial.print(Oldmina);
    Serial.print(" A+=");
    Serial.println(Oldmaxa);
    
    Serial.print(" B-=");
    Serial.print(Oldminb);
    Serial.print(" B+=");
    Serial.println(Oldmaxb);
    
    Serial.print(" C-=");
    Serial.print(Oldminc);
    Serial.print(" C+=");
    Serial.println(Oldmaxc);
    Serial.println(touslesquadrant);
    
    Serial.println(touslesquadrant);
    Serial.print(" D-=");
    Serial.print(Oldmind);
    Serial.print(" D+=");
    Serial.println(Oldmaxd);
    
    pinMode(ledGreen, OUTPUT); // 
    pinMode(ledRed, OUTPUT); 
          digitalWrite(ledRed, LOW) ;
          digitalWrite(ledGreen, LOW);
    delay(5000);
    }
    
    void loop() {
    
    // send the value of analog input 0:
    for (int i = 0; i < 4; i++){
    abcd[i]=analogRead(i); 
    (touslesquadrant+quadrant[i]);
    Serial.print(" quadrant " ); 
    Serial.print(i);
    Serial.print("=" );
    Serial.print(abcd[i]); 
    };
    Serial.print(" maxa=" ); 
    Serial.print(Oldmaxa);
    Serial.print(" maxb=" ); 
    Serial.print(Oldmaxb);
    Serial.print(" maxc=" ); 
    Serial.print(Oldmaxc);
    Serial.print(" maxd=" ); 
    Serial.print(Oldmaxd);
    Serial.print(" intrusion=" ); 
    Serial.print(intrusion);
    Serial.println(" fin");
    x=(abcd[0]+abcd[1]);
    x=x-(abcd[2]+abcd[3]);
    x=x/(abcd[0]+abcd[1]+abcd[2]+abcd[3]+.001);// prevenir la division par zero
    int xx=int(x*1000);
    y=(abcd[1]+abcd[3]);
    y=y-(abcd[1]+abcd[2]);
    y=y/(abcd[0]+abcd[1]+abcd[2]+abcd[3]+.001);
    int yy=int(y*1000);
    intrusion=0;
    
    if (abcd[0]<Oldmina)intrusion++;//  routine de détection d'intrusion, ne sert à rien dans ce programme
    if (abcd[1]<Oldminb)intrusion++;// mais permet de vérifier sans charger le programme définitif
    if (abcd[2]<Oldminc)intrusion++;// permet aussi de comprendre le principe des 3 fenêtres
    if (abcd[3]<Oldmind)intrusion++;
    
      switch (intrusion) {
        case 1:
          digitalWrite(ledRed, HIGH) ;
          digitalWrite(ledGreen, LOW);
          break;
        case 2:
         digitalWrite(ledRed, HIGH) ;
         digitalWrite(ledGreen, LOW);
          break;
           case 3:
          digitalWrite(ledRed, HIGH) ;
          digitalWrite(ledGreen, HIGH);
          break;
           case 4:
          digitalWrite(ledRed, HIGH) ;
          digitalWrite(ledGreen, HIGH);
          break;
        default:
          digitalWrite(ledRed, LOW) ;
          digitalWrite(ledGreen, LOW);
          break;
      }               
    
    
    Serial.print(" xx=" );
    Serial.print(xx);
    Serial.print(" yy=" );
    Serial.println(yy);
    
    
    }
  3. Avatar de rokag3
    • |
    • permalink
    Doit on utiliser l'integer ou le float pour la fonction .read() lorsque l'on utilise le convertisseur analogique/digital si l'on souhaite aller plus vite ?
  4. Avatar de rokag3
    • |
    • permalink
    Définitivement l'utilisation d'un uint16_t avec l'instruction analog_valueA.read_u16() est beaucoup plus rapide et surtout beaucoup plus stable.
    reste que je trouve bizarre de trouver des valeurs de 16 bis issues d'un convertisseur analogique digital de 12 bits mais bof pourquoi pas !
    Il semble qu'il faille utiliser un timing à peu près identique entre les mesures avec celle qui ont servis pour l'étalonnage .
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    /*probelasernoprint
    ** very beginning 
    **9/13/2018 in Athens Greece
    **rokag3
    ** this software should detect an intrusion of an object in rotation (or not)
    ** check the position of the tooth the most eccentric (mostEccentricTooth)
    ** calculate the time it wil be in the center of the lazer and send a probe flag
    ** 
    **public domain
    /*
    
    #include "mbed.h"
     
    AnalogIn analog_valueA(A0);//blue wire     attach the 1st channel of your oscilloscope
    AnalogIn analog_valueB(A1);//orange        in the window the most susceptible to be shadowed
    AnalogIn analog_valueC(A2);//vert
    AnalogIn analog_valueD(A3);//jaune
    DigitalOut ledGreen (PA_9); //The 2nd channel oscilloscope must be attached here it is True if any delta with unshaded diode 
    DigitalOut ledRed (PC_7);//probe signal
    
    Serial pc(USBTX,USBRX,115200); //  baud rate
    
    uint16_t abcd[4];
    uint16_t Oldmina,Oldmaxa,Oldminb,Oldmaxb,Oldminc,Oldmaxc,Oldmind,Oldmaxd;
     
    uint16_t iduty,windowduty;
    uint16_t intrusion;
    uint16_t valdeA;
    uint16_t valdeB;
    uint16_t valdeC;
    uint16_t valdeD;
    uint16_t stabilizeTime=1;
    
    void CheckIntrusion()
    {
        intrusion=0;
        windowduty=0;
        if (valdeA<Oldmina){intrusion++;windowduty=1;}// windowduty to know which diode is shadowed
        if (valdeB<Oldminb){intrusion++;windowduty+=2;}//
        if (valdeC<Oldminc){intrusion++;windowduty+=4;}
        if (valdeD<Oldmind){intrusion++;windowduty+=8;}
        
    
        switch (intrusion) {
            case 1:
                ledRed=0 ;
                ledGreen=1;//one window has been hit here the timing routines to validate or void the intrusion must be called 
                break;
            case 2:
                ledRed=0 ;
                ledGreen=1;
                break;
            case 3:
                ledRed=1 ;
                ledGreen=1;
                break;
            case 4:
                ledRed=1 ;
                ledGreen=1;
                break;
            default:
                ledRed=0 ;
                ledGreen=0;
                break;
        }
    }
    
    
    
    int main()
    {
    //initialisation des minimax
        Oldmaxa=0;// val maxi du window A après initialisation
        Oldmina =65535; //val mini du window A après initialisation
        Oldmaxb=0;// val maxi du window B après initialisation etc...
        Oldminb =65535;
        Oldmaxc=0;
        Oldminc =65535;
        Oldmaxd=0;
        Oldmind =65535;
    
        ledRed= 1 ;// to check if the calibration is over
        ledGreen = 1;
    
        for (iduty=0 ; iduty<10000; iduty++) { //determination des variations maximums 10000 tests
            uint16_t maxa=analog_valueA.read_u16();
            if(maxa < Oldmina) {Oldmina =maxa;}
            if(maxa > Oldmaxa) {Oldmaxa =maxa;}
            wait_us(1);
            uint16_t maxb=analog_valueB.read_u16();
            if(maxb < Oldminb) {Oldminb =maxb;}
            if(maxb > Oldmaxb) {Oldmaxb =maxb;}
            wait_us(1);
            uint16_t maxc=analog_valueC.read_u16();
            if(maxc < Oldminc) {Oldminc =maxc;}
            if(maxc > Oldmaxc) {Oldmaxc =maxc;}
            wait_us(1);
            uint16_t maxd=analog_valueD.read_u16();
            if(maxd < Oldmind) {Oldmind =maxd;}
            if(maxd > Oldmaxd) {Oldmaxd =maxd;}
            wait_us(1);
        }
    
        ledRed= 0 ;
        ledGreen = 0;
    
        while(1) { //spool
    
            valdeA = analog_valueA.read_u16();// 
            wait_us(stabilizeTime);
            valdeB = analog_valueB.read_u16();
            wait_us(stabilizeTime);
            valdeC = analog_valueC.read_u16();
            wait_us(stabilizeTime);
            valdeD = analog_valueD.read_u16();
            wait_us(stabilizeTime);
    
    CheckIntrusion();
    
    // display values
    if((iduty++>1000)||(intrusion>0)){ 
            printf("  %d  %d  %d  %d  %d\n", intrusion, Oldmina, Oldminb, Oldminc, Oldmind);
            printf("I=%dA=%dB=%dC=%dD=%dW=%d\n", intrusion , valdeA, valdeB, valdeC, valdeD,windowduty);
            iduty=0;
            }
         }
    }
  5. Avatar de rokag3
    • |
    • permalink
    La vérité c'est que je suis un gros fainéant et que j'essaye de me mettre un peu de pression mais un peu de retour ne serait pas désagréble