Communauté
Salut,
Si tu n'as pas eu de réponses plus tôt, c'est probablement que ceux qui son à même de te répondre n'en ont pas eu encore le temps.
Je ne sais pas quelle formation tu suis, mais je me pose de sérieuses questions sur ces formateurs qui proposent projets aussi ambitieux (liason avec Excel) sans, visiblement au vu de ton code, donner les bases à mon sens indispensables pour apprendre AutoLISP.
Je te recommande de consulter Introduction à AutoLISP.
Il semble que tu n'utilises pas l'éditeur Visual LISP (VLIDE) qui t'aurait facilement aidé à trouver quelques erreurs :
- appariement des parenthèse (un (progn est placé derrière une ligne de commentaire)
- entlest au lieu de entsel (avec la coloration syntaxique -fonction LISP en bleu- l'erreur apparaît immédiatement)
ni la possibilité d'évaluer une expression directement dans la console :
si tu double-clique devant la prenthèse ouvrante de (getvar "SCU"), tu verras que ça retorune nil parce qu'il n'y a pas de variable système "SCU".
ni les fonctions de débogage qui permettent d'exécuter le code pas à pas pour trouver les erreurs. Le problème n'est pas de faire des erreurs mais de savoir les localiser et les corriger. C'est comme ça qu'on apprend.
Sans entrer dans les détails de ton code,
- déclare les variables localement plutôt que de leur affecter la valeur 0 (ou affecte leur plutôt nil)
- OSMDE fonctionne avec une somme de code binaires, pour avoir les accrochages NODal et PROche il faut faire :
(setvar "OSMODE" (+ 8 512)) mais en général, on préfère désactiver tous les accrochages pour être sur qu'ils n'interfèrent pas avec les coordonnées passées dans le code.
- pour rendre ton code plus lisible, choisis des noms de variables plus explicites et qui correspondent au type de la valeur affectée (pt pour les pints c'est bien, mais (setq pt5 (entget name)) par exemple,affecte une liste DXF à une variable pt5...
- utiliser (while T ...) est la meilleure façon d'entrer dans une boucle sans fin (la condition est, par nature, toujours vraie)
Pour le SCU, il faudrait enregistrer le SCU courant pour pouvoir le restaurer ultérieurement , regarde les options de la commande SCU. Mais je pense qu'il est préférable de calculer la rotation d'après la ligne sélectionnée (regarde la fonction angle) et de l'affecter au bloc au lieu de modifier le SCU.
Pour les attributs regarde aussi ATTREQ.
En résumé, sers toi de l'éditeur Visual LISP, sers toi de l'aide AutoCAD pour les variables et les commandes, sers toi de l'aide aux développeurs et/ou de Introduction à AutoLISP pour les fonctions LISP.
Evalue ton code par fractions (ou mieux, fractionne le en plusieurs sous-routines) pour corriger chaque erreur au fur et à mesure.
Hello
Je ne suis pas du tout developpeur mais je SOUTIENS Gilles sur cette remarque PERTINENTE !
>>>
Je ne sais pas quelle formation tu suis, mais je me pose de sérieuses questions sur ces formateurs qui proposent projets aussi ambitieux (liason avec Excel) sans, visiblement au vu de ton code, donner les bases à mon sens indispensables pour apprendre AutoLISP.
<<<
Patrice ( Supporting Troops ) - Autodesk Expert Elite
If you are happy with my answer please mark "Accept as Solution" and if very happy please give me a Kudos (Felicitations) - Thanks
If you are happy with my answer please mark "Accept as Solution" and if very happy please give me a Kudos (Felicitations) - Thanks
Patrice BRAUD
Salut,
Encore une fois, avant de passer à une étape suivante comme la mise à jour des attributs, finis ce que tu as commencé.
Tant que la partie insertion des blocs ne fonctionne pas correctement, concentre toi là dessus.
>> Mais là j'ai un autre problème, je n'arrive pas à sélectionner tout les blocs qui sont dans la boucle, ça ne sélectionne que le dernier...
Normal, à chaque passage dans la boucle, tu remplaces la valeur affectée à la variable ent7 par le nom d'entité du dernier bloc créé (entlast). Donc quand tu sors de la boucle, ent7 ne contient que le dernier bloc créé. Si tu veux conserver tous les noms d'entités des blocs créés il faut les socker dans une liste en ajoutant le nouveau bloc créé à chaque passage.
>> Dans ma boucle j'ai un autre problème au lieu de partir de la dernière valeur de mon attribut il part de la valeur de l'attribut du premier bloc cré dans ma boucle
Normal, à chaque passage tu affectes à valatt2 le résultat de la somme de pt9 et valatt qui doit être la valeur saisie pour le premier bloc et qui reste constante.
Pour la condition dans ta boucle, regarde les fonctions getkword et initget qui sont exactement adaptées à ce que tu veux faire.
Attention, si l'utilisateur ne répond pas de la manière attendue aux invites getpoint ou getdist (en faisant Enter par exemple) l'exécution va se poursuivre avec des valeur nil pour pt8 ou pt9, ce qui provoquera une erreur.
Il vaudrait mieux essayer d'implémenter : tant que l'utilisateur répond "Oui" ET qu'il spécifie un point ET qu'il spécifie une distance, on calcule la nouvelle valeur, on insère le bloc et on l'ajoute à la liste des blocs insérés.
Salut,
Il semble que tu ne lises pas bien ou que tu ne tiennes pas compte des conseils que je te donnes. Il n'est pas question d'obéir bêtement à ce que je dis mais d'essayer de le prendre en compte.
Si tu utilisais l'éditeur Visual LISP, avec les quelques explications données dans "Introduction à AutoLISP", tu verrais que ton code génère une erreur à l'expression (<> pt8 0) du style : "; erreur: no function definition: <>" ce qui veut dire que "<>" n'est pas une fonction LISP (à moins que l'aies définie par ailleurs). L'éditeur te l'aurait d'ailleurs tout de suite signalé en ne colorisant pas ce symbole en bleu (comme toutes les fonctions LISP prédéfinies).
En LISP le symbole pour la fonction "différent de" est : /=
D'autre part, je t'avais dit qu'une variable à laquelle aucune valeur n'est affectée n'est pas égale à 0 (qui est un nombre entier) mais égale à nil.
Il est précisé, au chapitre 12 "Expression conditionnelles" de l'Introduction à AutoLISP, qu'en LISP toute valeur qui n'est pas nil est considérée comme "vrai".
Il est donc d'usage d'utiliser l'expression d'assignation de la variable comme condition en testant si une valeur a bien été assignée
Par exemple :
(while (setq pt (getpoint "\nSpécifiez un point: ")) (command "_.circle" pt 10.0) )
Tant que l'utilisateur spécifie un point, un cercle de centre du point spécifié et de rayon 10 est dessiné. Dès que l'utilisateur fait Entrée, Espace, clic droit ou Echap, on sort de la boucle.
Avec plusieurs expressions de test on utilise (and ...) comme tu l'as fait:
(while
(and
(setq pt (getpoint "\nSpécifiez un point: "))
(setq rad (getdist pt "\nSpécifiez le rayon: "))
)
(command "_.circle" "_non" pt rad)
)
Dès que l'utilisateur fait Entrée au lieu de spécifier le centre ou le rayon, la boucle s'arr
Mais avec quelques subtilités avec initget et getkword.
- initget retourne toujours nil. Il faut donc grouper initget et getkword dans une même expression avec progn qui retourne le résultat de l'évaluation de la dernière expression (ici getkword).
- avec getkword, pour utiliser une valeur par défaut (<Oui>), il faut prendre en compte le fait que l'utilisateur fera entrée pour valider cette valeur.
Que retourne getkword quand on répond par Entrée ?
Dans la console de l'éditeur Visual LISP, tu copies l'expression suivante pour la tester :
(progn (initget "Oui Non") (getkword "\nVoulez-vous continuer sur cette rangée ? [Oui/Non] <Oui> :") )
Tu fais Entrée pour lancer l'évaluation et tu réponds à l'invite dans AutoCAD, de retour dans l'éditeur, tu as la valeur retorunée par l'expression. Tu fais Tabulation pour rappeler l'expression et tu essayes d'autres réponses. Au vu des différents résultats suvant qu'on réponde "Oui" "Non" ou Entrée, tu vas pouvoir construire l'expression conditionnelle pour qu'elle retourne nil uniquement si l'utilisateur fait "Non".
On va se concentrer sur la boucle, on pourra corriger/optimiser le reste après.
Un peu d'algorithmie :
tant que l'utilisateur veut continuer (condition1) ET qu'il spécifie un point (condition2) ET qu'il qu'il spécifie une longueur (condition3),
on ajoute la longueur spécifiée au cumul des longueurs (action1),
on insère le bloc au point spécifié (action2),
on ajoute le bloc à la liste des blocs insérés (action3).
on va aussi avoir besoin de quelques variables pour stocker des valeurs (et on leur donne des noms plus explicite) :
le point d'insertion spécifié : insPt
la longueur spécifiée : long
le cumul des longueurs : cumul
la liste des blocs insérés : blocs
cumul devrait avoir la distance de départ spécifiée avant la boucle et blocs contenir le premier bloc inséré, les autres variables devraient être vides avant l'entrée dans la boucle, c'est à dire nil (et pas 0, encore une fois, ce n'est pas du tout la même chose !).
On va maintenant essayer de traduire cet algorithme en code LISP.
Le code devrait avoir ce squelette :
(while
(and
condition1
condition2
condition3
)
action1
action2
action 3
)
Un peu de logique :
La fonction and évalue une après l'autre les expressions qui lui sont passées en argument et retorune nil dès qu'unes de ces expressions retourne nil ou T si aucunes des expression ne retourne nil. Autrement dit on sort de la boucle dès qu'une des 3 conditions retourne nil.
condition1 : en utilisant intget et getkword avec une valeur par défaut égale à "Oui", on a vu que getkword retournait soit "Oui" ou nil si l'utilisateur veut continuer soit "Non" s'il veut s'arrêter.
Pour rester dans la boucle, il faut que condition1 soit vraie, il faut que getkword retourne "Oui" ou nil, autrement dit, il suffit qu'il retourne une valeur différente de "Non".
condition1 peut donc s'écrire :
(progn (initget "Oui Non") (/= (getkword "\nVoulez-vous continuer sur cette rangée ? [Oui/Non] <Oui> :") "Non") )
condition2 et condition3 : ces deux conditions seront considérées comme vraies si elle ne retournent pas nil. Les fonctions getpoint et getdist retournent nil si l'utilisateur fait entrée, Espace ou clic droit. La fonction setq retourne la valeur attribuée à la variable donc la valeur retournée par getpoint ou getdist qui peut être soit un point ou un nombre réel soit nil. On peut donc utiliser les expressions d'affectation des variables insPt et long comme expressions conditionnelles.
condition2 peut s'écrire :
(setq insPt (getpoint "\nSélectionner le point suivant :"))
condition3 peut s'écrire :
(setq long (getdist "\nDistance :"))
action1 : il s'agit d'ajouter au premier passage dans la boucle la valeur spécifiée (long) à la valeur déja stockée dans cumul avant l'entée dans la boucle, puis, au passage suivant d'ajouter la nouvelle valeur spécifiée (toujours long) à la somme des valeurs précédentes. Il suffit donc, à chaque passage, de redéfinir la variable cumul en remplaçant sa valeur par la somme de celle-ci et de celle de long.
acction2 peut s'écrire :
(setq cumul (+ cumul long))
action2 : on insère le bloc.
(command "_insert" "blocaltimel" pt8 1 1 0 (rtos cumul 2 2) "")
action3 : à chaque passage on stocke le block nouvellement inséré en l'ajoutant à la listes de ceux précédemment insérés en redéfinissant la variable blocs.
action3 peut s'acrire :
(setq blocs (cons (entlast) blocs))
Voilà, tu peux maintenant remplir le squelette de code de la boucle et le tester. Et si tu as bien compris ce qu'on a fait là, tu devrais pouvoir améliorer le reste du code.
Tu répètes n fois exactement la même chose :
(setq bloc1 (car blocs))
bloc1 sera toujours le premier bloc de la liste.
(setq pt10 (list (car pt8) (cadr insPt)))
pt10 aura toujour la même valeur puisque ni pt8 ni inspt ne changent dans la boucle.
(setq cumul2 (+ cumul dis))
cumul2 aura toujours la même valeur égale à la somme de cumul et dis qui elles non plus ne sont pas modifiées dans la boucle.
Résultat : tu insères n fois le même bloc à la même position avec la même valeur d'attribut...
Utiliser foreach au lieu de repeat te ferait au moins changer de bloc à chaque passage.
Et pour pt10 et cumul2 si tu ne veux pas qu'ils soient identiques à chaque passage, il faut qu'à chaque passage il y ait quelque chose change (pt8 et/ou insPt, cumul et/ou dist).
Si j'ai bien compris, blocs est une liste (type LIST en LISP)
Or, la commande _COPY fonctionne avec une entité (type ENAME) ou un jeu de sélection (type PICKSET).
Pour pouvoir passer la liste à la commande _COPY il faut,
- soit la transformer en jeu de sélection : créer un jeu de sélection vide avec ssadd et ajouter chacun des termes de blocs au jeu de sélection, toujours avec ssadd (regarde dans l'aide la fonction ssadd).
- soit, plus simplement à mon avis, parcourir la liste avec foreach et copier les blocs un par un.
Le message d'erreur dit bien que le type d'entité passé à ssadd est incorrect.
lentityp signifie que l'argument aurait dû être une entité (ENAME)
Or on voit bien que l'argument que tu as passé est une liste de ENAMEs.
Il faudrait donc parcourir la liste avec foreach pour ajouter chaque entité au jeu de sélection.
C'est pour ça que je disais qu'il était plus simple de parcourir la liste et de copier les blocs un par un.
Le premier argument de foreach est une variable qui prend tour à tour la valeur de chaque élément de la liste.
Le second argument de foreach est la liste à énumérer
Les arguments suivants la ou les expressions à évaluer.
C'est bien d'essayer des trucs, mais lire l'aide pour les fonctions, c'est indispensable...
(foreach bloc blocs (command "_copy" bloc "" ptbase pt8 "")
)
Quant à la mise à jour (automatique) des attributs, on n'en est pas encore là...
Vous n'avez pas trouvé ce que vous recherchiez ? Posez une question à la communauté ou partagez vos connaissances.
Publier dans les forums
