rokag3

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

Noter ce billet

par

rokag3

, 10/09/2018 à 04h39 (950 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

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

Tags: cnc, hamamatsu, laser, nucleo-f401-re, quadrant photodiode, s5980, shadow, stm32

Catégories: Programmation , C++

Liste des billets

Commentaires

rokag3 - 10/09/2018 16h58
- |
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

rokag3 - 10/09/2018 19h59

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);


}

rokag3 - 11/09/2018 20h17
- |
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 ?

rokag3 - 13/09/2018 07h15

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;
        }
     }
}

rokag3 - 13/09/2018 18h33
- |
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

rokag3

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

Noter ce billet

Commentaires

+ Créer un blog

Catégories globales

Archives

<	Avril 2024
Di	Lu	Ma	Me	Je	Ve	Sa
24	25	26	27	28	29	30
31	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	1	2	3	4

<	Avril 2024
Di	Lu	Ma	Me	Je	Ve	Sa
24	25	26	27	28	29	30
31	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	1	2	3	4

<	Avril 2024
Di	Lu	Ma	Me	Je	Ve	Sa
24	25	26	27	28	29	30
31	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	1	2	3	4