api e アセンブリ

[Sbabba]

salve a tutti.

per la tesi sto lavorando su un assemblaggio automatico di una serie di componenti standard in configurazioni differenti.
ho scritto un programma in c# che permette la selezione di questi componenti e comanda due cad, solid works e solid edge, per l'assemblaggio dei modelli di tali componenti secondo la configurazione scelta.

per quanto riguarda solid works non ho avuto alcun problema. ho inserito due piani tra loro ortogonali ed un asse sull'estremità di ciascun pezzo, in modo da accoppiarli tra loro tramite due comandi di complanarità ed uno di coassialità; questa procedura di accoppiamento viene iterata per ciascuna coppia di componenti fino a creare l'assembly finale, in quanto i piani e gli assi hanno sempre lo stesso nome e sw seleziona piani ed assi con una sintassi del tipo "nome_piano@nome_parte@nome_assembly".

per la precisione i comandi utilizzati sono:

selectbyid2() per la selezione dei piani ed assi con cui eseguire l'accoppiamento;
addmate3() per l'aggiunta dell'accoppiamento planare ed assiale.

ora sto cercando di fare la stessa cosa con solid edge, però ho delle difficoltà.

innanzitutto ho trovato i comandi axialrelation3d() e planarrelation3d() per eseguire gli accoppiamenti, ma ho parecchi dubbi su come possa fare. l'sdk della st4 dice (qui) che è possibile usare il comando planarrelation3d() per rendere parallele due facce di due parti differenti: anziché due facce, sarebbe possibile usare due piani da me creati, nominati in un ben preciso modo, in modo da applicare lo stesso comando iterativamente per i vari componenti?

per quanto riguarda la coassialità mi sembra di capire che non sia possibile, perchè il comando axialrelation3d() rende colineari due assi di due parti cilindriche, ma nel mio caso non ho solamente parti cilindriche; d'altronde se non permette, a differenza di sw, di inserire assi a piacere. potrei facilmente risolvere il problema usando un terzo piano e una terza complanarità, però volevo accertarmi di questa cosa.

purtroppo online si trovano pochissime informazioni per quanto riguarda l'uso dell'api di solid edge con gli assembly, e l'sdk di se è estremamente scarno se paragonato a quello di sw, quindi brancolo un po' nel buio.

ringrazio in anticipo chiunque possa darmi anche solo il più piccolo aiuto!!e sull'estremit

 

[Be_on_edge]

salve a tutti.

per la tesi sto lavorando su un assemblaggio automatico di una serie di componenti standard in configurazioni differenti.
ho scritto un programma in c# che permette la selezione di questi componenti e comanda due cad, solid works e solid edge, per l'assemblaggio dei modelli di tali componenti secondo la configurazione scelta.

per quanto riguarda solid works non ho avuto alcun problema. ho inserito due piani tra loro ortogonali ed un asse sull'estremità di ciascun pezzo, in modo da accoppiarli tra loro tramite due comandi di complanarità ed uno di coassialità; questa procedura di accoppiamento viene iterata per ciascuna coppia di componenti fino a creare l'assembly finale, in quanto i piani e gli assi hanno sempre lo stesso nome e sw seleziona piani ed assi con una sintassi del tipo "nome_piano@nome_parte@nome_assembly".

per la precisione i comandi utilizzati sono:

selectbyid2() per la selezione dei piani ed assi con cui eseguire l'accoppiamento;
addmate3() per l'aggiunta dell'accoppiamento planare ed assiale.

ora sto cercando di fare la stessa cosa con solid edge, però ho delle difficoltà.

innanzitutto ho trovato i comandi axialrelation3d() e planarrelation3d() per eseguire gli accoppiamenti, ma ho parecchi dubbi su come possa fare. l'sdk della st4 dice (qui) che è possibile usare il comando planarrelation3d() per rendere parallele due facce di due parti differenti: anziché due facce, sarebbe possibile usare due piani da me creati, nominati in un ben preciso modo, in modo da applicare lo stesso comando iterativamente per i vari componenti?

per quanto riguarda la coassialità mi sembra di capire che non sia possibile, perchè il comando axialrelation3d() rende colineari due assi di due parti cilindriche, ma nel mio caso non ho solamente parti cilindriche; d'altronde se non permette, a differenza di sw, di inserire assi a piacere. potrei facilmente risolvere il problema usando un terzo piano e una terza complanarità, però volevo accertarmi di questa cosa.

purtroppo online si trovano pochissime informazioni per quanto riguarda l'uso dell'api di solid edge con gli assembly, e l'sdk di se è estremamente scarno se paragonato a quello di sw, quindi brancolo un po' nel buio.

ringrazio in anticipo chiunque possa darmi anche solo il più piccolo aiuto!!e sull'estremit

gli assi in solid edge si possono creare, il comando è nascosto e da tirare fuori. ti consiglio di utilizzare invece i sistemi di coordinate che al tempo stesso contengono sia gli assi che i piani.

poi puoi inserire la relazione che fa coincidere due sistemi di coordinate, e con una sola relazione posizioni la parte.

puoi comunque seguire la strada da te intrapresa, invece delle facce dovrai dargli i piani.

cerca i comandi "addplanar" e "addaxial", la documentazione per la programmazione di solid edge è molto ben scritta ho il dubbio che tu stia guardando nel posto sbagliato.

ciao

 

[vespa_83]

il consiglio dell'uso del sistema di coordinate mi sembra molto buono. in alternativa, per l'asse, proporrei uno schizzo con una linea.
per selezionare un elemento, il metodo più semplice (secondo le mie capacità) è utilizzare l'indice, anche se per qualche oggetto funziona anche il nome:
selezione per nome: famigliadioggetti("nomea")
selezione del primo: famigliadioggetti(0)
selezione dell'ultimo: famigliadioggetti( famigliadioggetti.count()-1 )

i piani di riferimento penso siano sempre i primi, puoi stabilire se il primo o ultimo schizzo contiene i tuoi assi.
per la programmazione con solid edge ti suggerisco i seguenti link, se già non li conosci:
sespy: http://solidedgespy.codeplex.com/
di http://www.jasonnewell.net/

 

[Sbabba]

grazie per le risposte!

scusate il ritardo con cui rispondo, ho avuto l'ultimo esame prima della laurea e mi ha preso parecchio! ora posso concentrarmi a pieno sulla tesi

l'idea del sistema di coordinate mi sembra ottima! sto provando ad utilizzarla, ma incontro delle difficoltà.

ho preso come base questa guida, riscrivendo poi i comandi per c#.

ora, io ho aperto due file assembly di cui devo far combaciare i sistemi di coordinate, sono "seassy1" e "seassy2", e ne ho acquisito il sistema di coordinate con questi comandi:

seassy1cos = seassy1.coordinatesystems.item(2);
seassy2cos = seassy2.coordinatesystems.item(2);

item(2) perchè il primo è quello di default, il secondo è quello che ho creato io.

la guida dice poi di usare il comando "getorientation()" per ottenere i "dettagli del sistema di coordinate".

seassy1cos.getorientation(axo, ayo, azo, axr, ayr, azr);

fatto, però già qua trovo un errore. visual studio mi fa notare che mancano due parametri al comando, che sarebbero "relativetoparent" e "zfirstrotation" ( http://dl2.plm.automation.siemens.c...edgepart~coordinatesystem~getorientation.html )
io però non capisco esattamente di che parametri si tratti, nel senso che visual studio nell'aiuto alla compilazione mi dice questo



e non so cosa sia "type.missing". inoltre secondo la pagina del comando get orientation sul sito siemens, ogni parametro dovrebbe essere opzionale, e per questo la guida, penso, non li riporti tutti, però sembra che non siano affatto opzionali in realtà :d

ho provato a sorvolare ed andare oltre, per concludere qualcosa, per cui ho seguito ancora la guida che a questo punto vuole estrarre i piani che definiscono il sistema di coordinate. lo fa con il comando "coordinatesystem.plane()" che vuole a parametro la costante indicante il piano che si vuole estrarre, che ho trovato qua

assyxyplane = seassy1cos.plane(secoordsysxyplane);

il problema è che visual studio non è ancora contento, e mi dice "indexed property solideedgepart.coordinatesystem.plane has non-optional argument that must be provided". non capisco... il parametro da fornire è solo uno, la costante che indica il piano, e pure nell'auto compilazione vs me ne chiede uno solo... a cosa si riferisce con "parametro non opzionale" che non gli starei dando?

ogni volta che faccio un passo avanti ne faccio due indietro... è assurdo perchè sono certo che si tratta di una cosa molto semplice, però al momento mi sembra impossibile!!

vi ringrazio anticipatamente per qualsiasi aiuto sappiate darmi. grazie anche per il consiglio di solid edge spy, davvero utile!

 

[Be_on_edge]

nella guida di solid edge i parametri di getorientation li indica tutti come "variant" per cui non mi preoccuperei troppo ed inserirei due variabili di questo tipo.

ho appena provato in vb6 e il seguente codice funziona, purtroppo non programmo in c per cui non so aiutarti se non consigliandoti di chiedere sul forum dove hai trovato il codice di cui parli.

    dim objapp as solidedgeframework.application
    dim objasm as solidedgeassembly.assemblydocument
    
    dim piano as solidedgegeometry.face
    
    set objapp = getobject(, "solidedge.application")
    set objasm = objapp.activedocument
    
    set piano = objasm.coordinatesystems(2).plane(secoordsysxyplane)

 

[Sbabba]

grazie per la veloce risposta, ora provo! il fatto che sia in vb non è un problema, tanto c# è molto simile!

comunque ho scoperto il motivo del primo errore, quello sul getorientation(). vuole dei parametri di tipo "object" e vanno impostati in uscita, quindi la sintassi corretta è "getorientation(out axo, out ayo, out azo, out axr, out ayr, out azr);" con axo...azr dichiarati object, e non double come faceva quella guida (che, quindi, mi chiedo come potesse funzionare :d).

grazie ancora

 

[Sbabba]

dunque, ce l'ho fatta!!! insomma, quasi :d

allora dopo un po' di peripezie ho scritto questo codice, che riesce ad allineare perfettamente i sistemi di coordinate di due pezzi, però solo di quelli! mi spiego meglio.

io parto inserendo un numero variabile di componenti (minimo 5, massimo 8) in un assembly che creo al momento. questi componenti sono tutti assembly a parte un solo .par. la funzione di assemblaggio è unica e viene chiamata più volte in un ciclo in modo da unire tutti i componenti necessari. conosco l'ordine di inserimento dei componenti dell'assembly, che è lo stesso in cui andranno ordinati, per cui alla funzione passo una variabile "c" che indica la posizione nell'ordine, in modo che il codice unisca di volta in volta il componente c-esimo con il c-esimo + 1.

//mi collego all'assembly creato per la visualizzazione dell'assembly
            seassy = application.activedocument;

            //creo l'occurrence relativa ai due componenti
            seocc1 = seassy.occurrences.item(c);
            seocc2 = seassy.occurrences.item(c+1);

            //prendo il sistema di coordinate da me creato per ogni componente. solo per il primo assemblaggio sarà il numero (2)
            if (c == 1)
            {
                seocc1cos = seocc1.occurrencedocument.coordinatesystems.item(2);
            }
            else
            {
                seocc1cos = seocc1.occurrencedocument.coordinatesystems.item(3);
            }
            
            seocc2cos = seocc2.occurrencedocument.coordinatesystems.item(2);


            //acquisisco i dettagli del sistema di coordinate da me creato
            seocc1cos.getorientation(out a1xo, out a1yo, out a1zo, out a1xr, out a1yr, out a1zr);
            seocc2cos.getorientation(out a2xo, out a2yo, out a2zo, out a2xr, out a2yr, out a2zr);


            //acquisisco i piani che costituiscono il sistema di coordinate da me creato
            occ1xyplane = seocc1cos.plane[SolidEdgePart.CoordinateSystemFeatureConstants.seCoordSysXYPlane];
            occ1yzplane = seocc1cos.plane[SolidEdgePart.CoordinateSystemFeatureConstants.seCoordSysYZPlane];
            occ1zxplane = seocc1cos.plane[SolidEdgePart.CoordinateSystemFeatureConstants.seCoordSysZXPlane];
            
            occ2xyplane = seocc2cos.plane[SolidEdgePart.CoordinateSystemFeatureConstants.seCoordSysXYPlane];
            occ2yzplane = seocc2cos.plane[SolidEdgePart.CoordinateSystemFeatureConstants.seCoordSysYZPlane];
            occ2zxplane = seocc2cos.plane[SolidEdgePart.CoordinateSystemFeatureConstants.seCoordSysZXPlane];


            //cancello la relazione ground dei due componenti
            seocc1.relations3d.item(1).delete();
            seocc2.relations3d.item(1).delete();

            //acuisisco le relazioni del pezzo
            serels3d = seassy.relations3d;


            //creo un reference fra il pezzo e il piano ed aggiunge la relazione planare
            serefocc1 = seassy.createreference(seocc1, occ1xyplane);
            serefocc2 = seassy.createreference(seocc2, occ2xyplane);
            serels3d.addplanar(serefocc1, serefocc2, false, constrainingpoint, constrainingpoint);

            serefocc1 = seassy.createreference(seocc1, occ1yzplane);
            serefocc2 = seassy.createreference(seocc2, occ2yzplane);
            serels3d.addplanar(serefocc1, serefocc2, false, constrainingpoint, constrainingpoint);

            serefocc1 = seassy.createreference(seocc1, occ1zxplane);
            serefocc2 = seassy.createreference(seocc2, occ2zxplane);
            serels3d.addplanar(serefocc1, serefocc2, false, constrainingpoint, constrainingpoint);

nota: quando acquisisco il sistema di coordinate ho messo un if {} perchè tutti i componenti si assemblano verticalmente uno sopra l'altro, per cui di volta in volta prendo il sistema di coordinate di quello sotto e lo unisco a quello del pezzo che sta sopra. il primo componente, però, ha un solo sistema di coordinate da me creato, perchè essendo sempre il primo non avrà mai la necessità di essere collegato con 2 componenti, ma solo con uno che gli starà sopra. ecco il perchè dell'if{}.


ora il codice funziona perchè i primi due componenti vengono assemblati perfettamente, il problema si presenta al secondo ciclo. fa ancora la parte iniziale senza problemi, ma dà errore quando raggiunge il momento di creare la reference per poi fare l'accoppiamento. in particolare va in errore su:

serefocc1 = seassy.createreference(seocc1, occ1xyplane);

ho pensato che magari fosse perchè "serefocc1" non fosse inizializzato a "null", ma anche in quel modo dà errore. ho pensato che magari dovesse poter mantenere i vecchi riferimenti, per cui ho provato facendogli fare il secondo assemblaggio con una variabile diversa, del tipo "serefocc3", ma dà errore anche in quel modo.

chiaramente al secondo assemblaggio "seocc1" è un componente diverso da prima, in particolare è il secondo che ho assemblato in precedenza (quello che prima era "seocc2"), e occ1xyplane è il piano xy preso dal suo sistema di coordinate.


non capisco quale sia il problema, ed è sicuramente a livello di solid edge. evidentemente mi sfugge qualcosa sul modo in cui funzionano gli occurrence, i reference e il comando createreference(), però non capisco cosa possa essere.

qualcuno ha un'idea su cosa possa essere il problema? risolto questo avrei praticamente finito!!

vi ringrazio ancora per l'attenzione, siete gentilissimi :d

 

[Be_on_edge]

che tipo di errore ti viene fuori ?

da una letta veloce del tuo codice il primo componente non è vincolato a nulla e quindi in grado di muoversi.
sarebbe bene lasciargli la relazione di terra. questo è vero in tutte le situazioni, il componente principale va vincolato a terra.

ciao

 

[Sbabba]

grazie per la risposta.

allora mi sono accorto di un errore, nel senso che siccome tutto quel codice viene chiamato più volte di fatto è come se fosse in un ciclo, quindi ad ogni volta cercavo di eliminare le relazioni ground dei due pezzi che stava assemblando in quel momento, ma chiaramente uno dei due era già stato assemblato prima e quindi la relazione ground era già stato tolta in precedenza.

ho modificato il codice in modo da togliere i vincoli a tutti i pezzi tranne il primo solo la prima volta che viene chiamata la funzione.
ho anche inizializzato a "null" tutte le variabili in modo da eliminare possibili residue informazioni.

ora, dopo aver inizializzato a null, il programma assembla ancora il primo ed il secondo pezzo, poi quando la funzione si ripete per l'assemblaggio del secondo con il terzo si blocca sul secondo "createreference", quello con il piano yz. l'errore è questo



e' talmente generico che non riesco a capire dove sbagli, per questo dicevo che sicuramente mi sfugge qualcosa nel metodo di funzionamento del createreference(), il problema è che non capisco cosa... oltretutto il primo createreference() con il piano xy lo fa.

ora magari provo a fargli saltare quel componente e passare al successivo, magari è un problema del modello.

grazie e ciao!

 

[Sbabba]

edit: ho provato ad assemblare a mano i due pezzi usando i piani dei due sistemi di coordinate e non ho alcun problema a farlo, quindi i pezzi non credo abbiano dei problemi. sempre più incomprensibile :d


questo è il codice attuale, rispetto a prima ho solo modificato l'eliminazione del vincolo di terra sui componenti.

//mi collego all'assembly creato per la visualizzazione della protesi
            seassy = application.activedocument;

            //creo l'occurrence relativa ai due componenti. c inizialmente vale 1 e viene incrementata ad ogni chiamata di questa funzione
            seocc1 = seassy.occurrences.item(c);
            seocc2 = seassy.occurrences.item(c+1);

            //prendo il sistema di coordinate da me creato per ogni componente. solo per il primo assemblaggio sarà il numero (2)
            if (c == 1)
            {
                //cancello la relazione ground di tutti i componenti tranne il primo, che deve restare fisso
                int countocc = seassy.occurrences.count;
                int a = 2;
                
                while (a <= countocc)
                {
                    seassy.occurrences.item(a).relations3d.item(1).delete();
                    a++;
                }
                seocc1cos = seocc1.occurrencedocument.coordinatesystems.item(2);
            }
            else
            {
                seocc1cos = seocc1.occurrencedocument.coordinatesystems.item(3);
            }
            
            seocc2cos = seocc2.occurrencedocument.coordinatesystems.item(2);

            //acquisisco i dettagli del sistema di coordinate da me creato
            seocc1cos.getorientation(out a1xo, out a1yo, out a1zo, out a1xr, out a1yr, out a1zr);
            seocc2cos.getorientation(out a2xo, out a2yo, out a2zo, out a2xr, out a2yr, out a2zr);

            //acquisisco i piani che costituiscono il sistema di coordinate da me creato
            occ1xyplane = seocc1cos.plane[SolidEdgePart.CoordinateSystemFeatureConstants.seCoordSysXYPlane];
            occ1yzplane = seocc1cos.plane[SolidEdgePart.CoordinateSystemFeatureConstants.seCoordSysYZPlane];
            occ1zxplane = seocc1cos.plane[SolidEdgePart.CoordinateSystemFeatureConstants.seCoordSysZXPlane];
            
            occ2xyplane = seocc2cos.plane[SolidEdgePart.CoordinateSystemFeatureConstants.seCoordSysXYPlane];
            occ2yzplane = seocc2cos.plane[SolidEdgePart.CoordinateSystemFeatureConstants.seCoordSysYZPlane];
            occ2zxplane = seocc2cos.plane[SolidEdgePart.CoordinateSystemFeatureConstants.seCoordSysZXPlane];


            //acuisisco le relazioni del pezzo
            serels3d = seassy.relations3d;

            //creo un reference fra il pezzo e il piano ed aggiunge la relazione planare
            serefocc1 = seassy.createreference(seocc1, occ1xyplane);
            serefocc2 = seassy.createreference(seocc2, occ2xyplane);
            serels3d.addplanar(serefocc1, serefocc2, false, constrainingpoint, constrainingpoint);

            serefocc1 = seassy.createreference(seocc1, occ1yzplane);
            serefocc2 = seassy.createreference(seocc2, occ2yzplane);
            serels3d.addplanar(serefocc1, serefocc2, false, constrainingpoint, constrainingpoint);

            serefocc1 = seassy.createreference(seocc1, occ1zxplane);
            serefocc2 = seassy.createreference(seocc2, occ2zxplane);
            serels3d.addplanar(serefocc1, serefocc2, false, constrainingpoint, constrainingpoint);

 

[Sbabba]

ho provato anche cambiando i pezzi, si inchioda sempre sulla creazione del reference fra il pezzo ed il suo piano yz, indipendentemente dal sistema di coordinate o dal pezzo che prendo.

quando lo fa per il primo dei pezzi funziona, con qualsiasi altro crasha, eppure con il piano xy non dà problemi ed i sistemi di coordinate sono stati costruiti allo stesso modo. non capisco...

 

[Be_on_edge]

in vb6 questo è come lo farei io, e funziona.

ciao

private sub assembla()
    
    dim objapp as solidedgeframework.application
    dim objasm as solidedgeassembly.assemblydocument
    
    dim objocc1 as solidedgeassembly.occurrence
    dim objocc2 as solidedgeassembly.occurrence
    
    dim objocc1cs as solidedgepart.coordinatesystem
    dim objocc2cs as solidedgepart.coordinatesystem
    
    dim objocc1xyplane as solidedgegeometry.face
    dim objocc1yzplane as solidedgegeometry.face
    dim objocc1zxplane as solidedgegeometry.face
    dim objocc2xyplane as solidedgegeometry.face
    dim objocc2yzplane as solidedgegeometry.face
    dim objocc2zxplane as solidedgegeometry.face
    
    dim xyzpoints1(1 to 6) as double
    dim xyzpoints2(1 to 6) as double
    
    dim objocc1ref as solidedgeframework.reference
    dim objocc2ref as solidedgeframework.reference
    
    set objapp = getobject(, "solidedge.application")
    set objasm = objapp.activedocument
    
    for each occurrence in objasm.occurrences
        
        if occurrence.index <> objasm.occurrences.count then
        
            set objocc1 = occurrence
            set objocc2 = objasm.occurrences.item(objocc1.index + 1)
            
            for i = objocc2.relations3d.count to 1 step -1
                objocc2.relations3d(i).delete
            next i
            
            set objocc1cs = objocc1.occurrencedocument.coordinatesystems(2)
            set objocc2cs = objocc2.occurrencedocument.coordinatesystems(3)
            
            call objocc1cs.getorientation(xyzpoints1(1), xyzpoints1(2), xyzpoints1(3), xyzpoints1(4), xyzpoints1(5), xyzpoints1(6))
            call objocc2cs.getorientation(xyzpoints2(1), xyzpoints2(2), xyzpoints2(3), xyzpoints2(4), xyzpoints2(5), xyzpoints2(6))
            
            set objocc1xyplane = objocc1cs.plane(secoordsysxyplane)
            set objocc1yzplane = objocc1cs.plane(secoordsysyzplane)
            set objocc1zxplane = objocc1cs.plane(secoordsyszxplane)
            
            set objocc2xyplane = objocc2cs.plane(secoordsysxyplane)
            set objocc2yzplane = objocc2cs.plane(secoordsysyzplane)
            set objocc2zxplane = objocc2cs.plane(secoordsyszxplane)
            
            set objocc1ref = objasm.createreference(objocc1, objocc1xyplane)
            set objocc2ref = objasm.createreference(objocc2, objocc2xyplane)
            
            call objasm.relations3d.addplanar(objocc1ref, objocc2ref, false, xyzpoints1, xyzpoints2)
            
            set objocc1ref = objasm.createreference(objocc1, objocc1yzplane)
            set objocc2ref = objasm.createreference(objocc2, objocc2yzplane)
            
            call objasm.relations3d.addplanar(objocc1ref, objocc2ref, false, xyzpoints1, xyzpoints2)
            
            set objocc1ref = objasm.createreference(objocc1, objocc1zxplane)
            set objocc2ref = objasm.createreference(objocc2, objocc2zxplane)
            
            call objasm.relations3d.addplanar(objocc1ref, objocc2ref, false, xyzpoints1, xyzpoints2)
            
        end if
        
    next occurrence
    
end sub

 

[Sbabba]

ciao!

il tuo codice è praticamente come il mio, infatti anche il mio funziona con il primo assemblaggio.

sul secondo assemblaggio esegue l'addplanar sulla prima coppia di piani (qualsiasi essa sia: xy, yz, zx), poi quando creo di nuovo i reference per chiamare per la seconda volta l'addplanar crasha sempre sulla creazione del reference. e crasha indipendentemente da quale piano usi!!

cioè se faccio prima l'xy e poi l'yz:

  set objocc1ref = objasm.createreference(objocc1, objocc1xyplane)
            set objocc2ref = objasm.createreference(objocc2, objocc2xyplane)
            
            call objasm.relations3d.addplanar(objocc1ref, objocc2ref, false, xyzpoints1, xyzpoints2)
            
            set objocc1ref = objasm.createreference(objocc1, objocc1yzplane)
            set objocc2ref = objasm.createreference(objocc2, objocc2yzplane)
            
            call objasm.relations3d.addplanar(objocc1ref, objocc2ref, false, xyzpoints1, xyzpoints2)

fa l'xy ma crasha sull'yz, cioè su "set objocc1ref = objasm.createreference(objocc1, objocc1yzplane)"

mentre se scambio l'ordine facendo prima l'yz e poi l'xy:

  set objocc1ref = objasm.createreference(objocc1, objocc1yzplane)
            set objocc2ref = objasm.createreference(objocc2, objocc2yzplane)
            
            call objasm.relations3d.addplanar(objocc1ref, objocc2ref, false, xyzpoints1, xyzpoints2)
            
            set objocc1ref = objasm.createreference(objocc1, objocc1xyplane)
            set objocc2ref = objasm.createreference(objocc2, objocc2xyplane)
            
            call objasm.relations3d.addplanar(objocc1ref, objocc2ref, false, xyzpoints1, xyzpoints2)

fa l'yz ma crasha sull'xy, "set objocc1ref = objasm.createreference(objocc1, objocc1xyplane)"

praticamente crasha sempre sul secondo reference, mentre il primo riesce sempre a crearlo, indipendentemente da quali piani io usi! ho provato pure con zx, stesso discorso.

non capisco che senso abbia... come mai sempre sul secondo?

 

[Be_on_edge]

nel tuo codice scrivi:

serels3d.addplanar(serefocc1, serefocc2, false, constrainingpoint, constrainingpoint)

in pratica utilizzi lo stesso punto (constrainingpoint) per l'orientamento e non credo che possa funzionare.
il due punti devono essere relativi alla due facce che gli dai come parametro.

nel mio codice infatti utilizzo xyzpoints1 e xyzpoints2

verifica

 

[Sbabba]

ok ora lo sistemo, ma lui non crasha su addplanar ma su createreference, per cui non credo sia questo il motivo.

 

[Be_on_edge]

ok ora lo sistemo, ma lui non crasha su addplanar ma su createreference, per cui non credo sia questo il motivo.

dando dei riferimenti sbagliati credo vengano create relazioni apparentemente valide che creano problemi poi a quelle successive.
hai verificato sul cad le relazioni create in che stato sono ?

ciao

 

[Sbabba]

grazie, hoo fatto come mi hai detto ma purtroppo trovo sempre lo stesso errore.

le relazioni dove le vedo? da spy non riesco a trovare la voce "reference".

scusa se ne approfitto, ma posso provare a passarti i 3 componenti che sto assemblando? magari tu vedi l'errore dove io sto sbattendo la testa da 3 giorni...

il problema è quando crea il secondo reference fra il terzo sistema di coordinate del pezzo 2 (sc_join_upper) e il pezzo 2.

grazie mille, sei gentilissimo.

 

[Be_on_edge]

grazie, hoo fatto come mi hai detto ma purtroppo trovo sempre lo stesso errore.

le relazioni dove le vedo? da spy non riesco a trovare la voce "reference".

scusa se ne approfitto, ma posso provare a passarti i 3 componenti che sto assemblando? magari tu vedi l'errore dove io sto sbattendo la testa da 3 giorni...

il problema è quando crea il secondo reference fra il terzo sistema di coordinate del pezzo 2 (sc_join_upper) e il pezzo 2.

grazie mille, sei gentilissimo.

intendo guardare le relazioni tra i pezzi dentro al cad non in programmazione.
comunque le relazioni le trovi dentro occurencedocument.relations3d

domani ci guardo adesso non ho vb

ciao

p.s.: che versione di solid edge utilizzi e con quale mp ? magari è un baco che è stato poi risolto e ti basta un aggiornamento.

 

[Sbabba]

la versione è la st5, l'mp non lo so perchè la mia è la versione accademica, però so che è la 105.00.00.102

ci ho pensato pure io, sto scaricando la st6 e dopo la provo!