Orientation d'une grue par rapport a une ligne donnée

mateus · le 5 décembre 2012

Bonjour,

J'aimerais de l'aide pour ma fin de programmation.

Mon sujet est la création d'une grue.

Mon objectif est de pouvoir orienter ma grue par rapport a une ligne donnée (ex: s'aligner par rapport a un bâtiment existant)

voici mon programme:

(defun c:Grue()

 (command "-calque" "n" "Grue" "co" "10" "Grue" "ch" "Grue" "")
 
 ;Saisie des paramètres
 ;Pt0 : Point de départ du rail
 ;Long: Longueur du rail
 ;Ang0: Angle d'orientation du rail /Ox
 ;R : Rayon d'emprise de la grue
 ;Pt1 Point de fin du rail
 ;pt2 point d'un batiment
 ;ang2: Angle d'orientation du bâtiment
 
 (setvar "cmdecho" 0)
 (vl-load-com)
 (setq Choix (getstring "\nChoisissez un type de grue (fixe ou rails):"))

;Grue fixe
 	(if(or (= Choix "Fixe") (= Choix "F"))
  (progn
  (setq Pt0 (getpoint "\nPoint de base de la grue:"))
  (setq Ray (getdist "\nDonner la rayon de la grue:"))
      	  (command "point" Pt0)
 	  (command "cercle" Pt0 Ray)
 )
 
  ;Cas d'une grue sur rails
 	(if(or (= Choix "Rails") (= Choix "R"))
 (progn
   (setq Pt0 (getpoint "\nPoint de départ du rail:"))
   (setq Long (getdist "\nLongueur du rail:"))

   	(setq Choix (getstring "\nChoisir l'orientation de la grue (seul ou selon un bâtiment):"))

   ;orientation seul
   (if(or (= Choix "Seul") (= Choix "S"))
     (progn
   (setq Ang0 (getangle Pt0 "\nAngle d'orientation du rail /Ox:"))
   (setq R (getdist "\nRayon d'emprise de la grue:"))
   (setq Pt1 (polar pt0 ang0 long))
   (setq Pt2 (polar pt0 (+ Ang0 (* 1.5 pi)) R))
   (setq Pt3 (polar Pt1 (+ Ang0 (* 1.5 pi)) R))
   (setq Pt4 (polar Pt1 (+ Ang0 (* 0.5 pi)) R))
   (setq Pt5 (polar Pt0 (+ Ang0 (* 0.5 pi)) R))
   (setq Pt6 (polar Pt0 (+ Ang0 pi) R))
   (setq Pt7 (polar Pt1 (+ Ang0) R))
   (command "ligne" pt0 pt1 "")
   (command "ligne" pt2 pt3 "")
   (command "ligne" pt4 pt5 "")
   (command "arc" pt2 pt6 pt5 "")
   (command "arc" pt4 pt7 pt3 "")
   
   )))

   ;orientation suivant un bâtiment
   (if= (Choix"B"))
   	   (progn
     
   	(setq L1 (entsel "selectionner une ligne:"))
   	(vl-load-com)
   	(setq NomEntité (car LI))
   	(setq liste (entget NomEntité))
   	(setq p1 (cdr (assoc 10 liste)))
   	(setq p2 (cdr (assoc 11 liste)))
   	(setq ang2 (angle p1 et p2)))
   
   (setq R (getdist "\nRayon d'emprise de la grue:"))
   (setq Pt1 (polar pt0 ang0 long))
   (setq Pt2 (polar pt0 (+ Ang2 (* 1.5 pi)) R))
   (setq Pt3 (polar Pt1 (+ Ang2 (* 1.5 pi)) R))
   (setq Pt4 (polar Pt1 (+ Ang2 (* 0.5 pi)) R))
   (setq Pt5 (polar Pt0 (+ Ang2 (* 0.5 pi)) R))
   (setq Pt6 (polar Pt0 (+ Ang2 pi) R))
   (setq Pt7 (polar Pt1 (+ Ang2) R))
   (command "ligne" pt0 pt1 "")
   (command "ligne" pt2 pt3 "")
   (command "ligne" pt4 pt5 "")
   (command "arc" pt2 pt6 pt5 "")
   (command "arc" pt4 pt7 pt3 "")
   
   ))))
  
 ))

A la fin de mon programme une erreur s'affiche comme quoi j'ai trop d’argument. après avoir rechercher longuement je me retrouve bloqué et je demande l'aide de quelqu'un!

Merci d'avance!

Modifié le 5 décembre 2012 par (gile)
ajout de bbcodes

-Olivier- · le 5 décembre 2012

Bonjour Mogo,

Tu as une parenthèse fermante de trop à la ligne

(setq ang2 (angle p1 et p2)))

J'ai regardé le programme en diagonale, mais je pense que tu devrais aussi regarder du côté de la fonction cond pour simplifier.

Enfin, les 2 lignes (vl-load-com) ne servent à rien à moins que ton programme soit incomplet (tu n'utilise pas les fonctions vla-...

Olivier

EDIT : tu as d'autres problèmes de parenthèses dans tes fonctions if. Bon courage !

(gile) · le 5 décembre 2012

Salut,

S'il te plait, pour que le code soit plus lisible, utilise les bbcodes :

[code] ici le code [/code]

donne :

 ici  le code

Accessible via l'icône :

Sinon en regardant vite fiat, ton erreur vient probablement de la ligne :

(if= (Choix"B"))

Regarde aussi du côté des fonction getkword et initget pour les choix d'options

alala · le 5 décembre 2012

Je note quelques erreurs :

Le LI à remplacer par L1 dans:

(setq NomEntité (car LI))

Le "et" est en trop dans :

(setq ang2 (angle p1 et p2)))

L'expression suivante qui ne fonctionnera pas :

(if= (Choix"B")

Et qui peu être remplacer par :

(if= (or (= Choix "batiment") (= Choix "B"))

Les commandes "arc" ont un "" en trop en bout de ligne!

Et quelques erreurs de parenthéses mal placées.

Pour les parenthèse je te conseille fortement l'utilisation d'un logiciel de traitement de texte qui gére la coloration syntaxique.

Personnellement j'utilise Notepad++.

Je te conseille également de remplacer les getstring par des getkword qui renvoient toujours le bon "mot" ou nil.

(gile) · le 5 décembre 2012

Pour les parenthèse je te conseille fortement l'utilisation d'un logiciel de traitement de texte qui gére la coloration syntaxique.
Personnellement j'utilise Notepad++.

Moi je conseillerai plutôt l'éditeur Visual LISP qui n'est pas seulement un éditeur de code mais Environnement de Développement Intégré avec des fonction d'évaluation et de débogage.

J'utilise aussi Notepad++, mais pas pour écrire ou déboguer du code.

bonuscad · le 5 décembre 2012

Mise à part les erreurs de syntaxes qui empêchent l'achèvement du code, je souligne aussi la préférence du (cond au (if et de l'utilisation de (getkword) au lieu de (getstring), en pensant à armer les bits avec (initget)

Tu y gagnera en clarté du code

NB: pense aussi à déclarer tes variables en locale.

En correction succincte (ne connaissant ton intention finale) voici ce que cela pourrait donné

(defun c:Grue ( / oldlayer Choix Pt0 Ray Long Ang0 R Pt1 Pt2 Pt3 Pt4 Pt5 Pt6 Pt7 L1 NomEntite liste p1 p2 ang2)
 (setvar "cmdecho" 0)
 (setq oldlayer (getvar "CLAYER"))
 (command "_.-Layer" "_new" "Grue" "_color" "10" "Grue" "_set" "Grue" "")

;Saisie des paramètres
;Pt0 : Point de départ du rail
;Long: Longueur du rail
;Ang0: Angle d'orientation du rail /Ox
;R : Rayon d'emprise de la grue
;Pt1 Point de fin du rail
;pt2 point d'un batiment
;ang2: Angle d'orientation du bâtiment

 (initget 1 "Fixe Rails")
 (setq Choix (getkword "\nChoisissez un type de grue [Fixe/Rails]:"))

;Grue fixe
 (cond
   ((eq Choix "Fixe")
     (initget 1)
     (setq Pt0 (getpoint "\nPoint de base de la grue: "))
     (initget 3)
     (setq Ray (getdist Pt0 "\nDonner la rayon de la grue: "))
     (command "_.point" "_none" Pt0)
     (command "_.circle" "_none" Pt0 Ray)
   )

;Cas d'une grue sur rails
   ((eq Choix "Rails")
     (initget 1)
     (setq Pt0 (getpoint "\nPoint de départ du rail: "))
     (initget 3)
     (setq Long (getdist Pt0 "\nLongueur du rail: "))
   )
 )
 (initget 1 "Seul Batiment")
 (setq Choix (getkword "\nChoisir l'orientation de la grue [seul/Batiment]: "))

;orientation seul
 (cond
   ((eq Choix "Seul")
     (initget 1)
     (setq Ang0 (getangle Pt0 "\nAngle d'orientation du rail /Ox: "))
     (initget 3)
     (setq R (getdist Pt0 "\nRayon d'emprise de la grue: "))
     (setq
       Pt1 (polar pt0 ang0 R)
       Pt2 (polar pt0 (+ Ang0 (* 1.5 pi)) R)
       Pt3 (polar Pt1 (+ Ang0 (* 1.5 pi)) R)
       Pt4 (polar Pt1 (+ Ang0 (* 0.5 pi)) R)
       Pt5 (polar Pt0 (+ Ang0 (* 0.5 pi)) R)
       Pt6 (polar Pt0 (+ Ang0 pi) R)
       Pt7 (polar Pt1 (+ Ang0) R)
     )
     (command "_.line" "_none" pt0 "_none" pt1 "")
     (command "_.line" "_none" pt2 "_none" pt3 "")
     (command "_.line" "_none" pt4 "_none" pt5 "")
     (command "_.arc" "_none" pt2 "_none" pt6 "_none" pt5)
     (command "_.arc" "_none" pt4 "_none" pt7 "_none" pt3)
   )

;orientation suivant un bâtiment
   ((eq Choix "Batiment")
     (while (null (setq L1 (entsel "\nSélectionner une ligne:"))))
     (setq
       NomEntite (car L1)
       liste (entget NomEntite)
     )
     (cond
       ((eq (cdr (assoc 0 liste)) "LINE")
         (setq
           p1 (cdr (assoc 10 liste))
           p2 (cdr (assoc 11 liste))
           ang2 (angle p1 p2)
         )
         (initget 3)
         (setq R (getdist Pt0 "\nRayon d'emprise de la grue:"))
         (setq
           Pt1 (polar pt0 ang2 R)
           Pt2 (polar pt0 (+ Ang2 (* 1.5 pi)) R)
           Pt3 (polar Pt1 (+ Ang2 (* 1.5 pi)) R)
           Pt4 (polar Pt1 (+ Ang2 (* 0.5 pi)) R)
           Pt5 (polar Pt0 (+ Ang2 (* 0.5 pi)) R)
           Pt6 (polar Pt0 (+ Ang2 pi) R)
           Pt7 (polar Pt1 (+ Ang2) R)
         )
         (command "_.line" "_none" pt0 "_none" pt1 "")
         (command "_.line" "_none" pt2 "_none" pt3 "")
         (command "_.line" "_none" pt4 "_none" pt5 "")
         (command "_.arc" "_none" pt2 "_none" pt6 "_none" pt5)
         (command "_.arc" "_none" pt4 "_none" pt7 "_none" pt3)
       )
       (T
         (princ "\nCe n'est pas une ligne!")
       )
     )
   )
 )
 (setvar "CLAYER" oldlayer)
 (setvar "cmdecho" 1)
 (prin1)
)

Tu remarquera qu'avec (getkword) et la bonne syntaxe dans le message, tu auras directement tes options accessible dans un menu contextuel par un click droit de souris, pas besoin de taper les options. ;)

alala · le 5 décembre 2012

Moi je conseillerai plutôt l'éditeur Visual LISP qui n'est pas seulement un éditeur de code mais Environnement de Développement Intégré avec des fonction d'évaluation et de débogage.
J'utilise aussi Notepad++, mais pas pour écrire ou déboguer du code.

Effectivement je vien d'y regarder (ce que je n'avais pas fait jusqu'ici, me servant de cet éditeur que comme passerelle vers l'aide!).

Et c'est bien plus efficace pour debuguer!

mateus · le 5 décembre 2012

bonjour bonuscad

j'ai une érreur d'entre dans le programme que vous avez mit en place

mateus · le 5 décembre 2012

Ah sa marche j'ai oublié une paranthése

Merci bonuscad

mateus · le 15 décembre 2012

Bonjour

j'ai probléme dans mon lisp

quand je fais tourner mon programme c'est à dire au moment je prend l'option grue fixe tout se passer bien, mais à la fin de ma procédure, le programme donne suite à l'option grue sur rails

es-ce que quelqu'un peut m'aider?

voici le lisp:

(defun c:Grue ( / oldlayer Choix Pt0 Ray Long Ang0 R Pt1 Pt2 Pt3 Pt4 Pt5 Pt6 Pt7 L1 NomEntite liste p1 p2 ang2)

(command "-calque" "n" "Grue" "co" "10" "Grue" "ch" "Grue" "")

;Saisie des paramètres

;Pt0 : Point de départ du rail

;Long: Longueur du rail

;Ang0: Angle d'orientation du rail /Ox

;R : Rayon d'emprise de la grue

;Pt1 Point de fin du rail

;pt2 point d'un batiment

;ang2: Angle d'orientation du bâtiment

(vl-load-com)

(initget 1 "Fixe Rails")

(setq Choix (getkword "\nChoisissez un type de grue [Fixe/Rails]:"))

;Grue fixe

(cond

((eq Choix "Fixe")

(initget 1)

(setq Pt0 (getpoint "\nPoint de base de la grue: "))

(initget 3)

(setq Ray (getdist Pt0 "\nDonner la rayon de la grue: "))

(command "point" Pt0)

(command "cercle" Pt0 Ray)

)

;Cas d'une grue sur rails

((eq Choix "Rails")

(initget 1)

(setq Pt0 (getpoint "\nPoint de départ du rail: "))

(initget 3)

(setq Long (getdist Pt0 "\nLongueur du rail: "))

)

(initget 1 "Seul Batiment")

(setq Choix (getkword "\nChoisir l'orientation de la grue [seul/Batiment]: "))

;orientation seul

(cond

((eq Choix "Seul")

(initget 1)

(setq Ang0 (getangle Pt0 "\nAngle d'orientation du rail /Ox: "))

(initget 3)

(setq R (getdist Pt0 "\nRayon d'emprise de la grue: "))

(setq

Pt1 (polar pt0 ang0 R)

Pt2 (polar pt0 (+ Ang0 (* 1.5 pi)) R)

Pt3 (polar Pt1 (+ Ang0 (* 1.5 pi)) R)

Pt4 (polar Pt1 (+ Ang0 (* 0.5 pi)) R)

Pt5 (polar Pt0 (+ Ang0 (* 0.5 pi)) R)

Pt6 (polar Pt0 (+ Ang0 pi) R)

Pt7 (polar Pt1 (+ Ang0) R)

)

(command "polylign" pt0 pt1 "")

(command "polylign" pt2 pt3 "")

(command "polylign" pt4 pt5 "")

(command "arc" pt2 pt6 pt5 "")

(command "arc" pt4 pt7 pt3 "")

)

;orientation suivant un bâtiment

((eq Choix "Batiment")

(while (null (setq L1 (entsel "\nSélectionner une ligne:"))))

(setq

NomEntite (car L1)

liste (entget NomEntite)

)

(cond

((eq (cdr (assoc 0 liste)) "LINE")

(setq

p1 (cdr (assoc 10 liste))

p2 (cdr (assoc 11 liste))

ang2 (angle p1 p2)

)

(initget 3)

(setq R (getdist Pt0 "\nRayon d'emprise de la grue:"))

(setq

Pt1 (polar pt0 ang2 R)

Pt2 (polar pt0 (+ Ang2 (* 1.5 pi)) R)

Pt3 (polar Pt1 (+ Ang2 (* 1.5 pi)) R)

Pt4 (polar Pt1 (+ Ang2 (* 0.5 pi)) R)

Pt5 (polar Pt0 (+ Ang2 (* 0.5 pi)) R)

Pt6 (polar Pt0 (+ Ang2 pi) R)

Pt7 (polar Pt1 (+ Ang2) R)

)

(command "polylign" pt0 pt1 "")

(command "polylign" pt2 pt3 "")

(command "polylign" pt4 pt5 "")

(command "arc" pt2 pt6 pt5)

(command "arc" pt4 pt7 pt3)

(command "inserer" "bloc_grue" Pt2 1 1 0 "");insertion de bloc

)

(T

(princ "\nCe n'est pas une ligne!")

)

(command "scu" "general")

(command "-calque" "ch" 0 "")

)

(gile) · le 15 décembre 2012

S'il te plait, pour que le code soit plus lisible, utilise les bbcodes :

[code] ici le code [/code]

donne :

 ici  le code

Accessible via l'icône :

mateus · le 16 décembre 2012

Grue

mateus · le 16 décembre 2012

bbb

mateus · le 16 décembre 2012

[/bbbbbbbbbbb]

mateus · le 16 décembre 2012

[Grue]

mateus · le 16 décembre 2012

excus moi mais je connais pas cette facon de mettre mon code

mateus · le 16 décembre 2012

(defun c:Grue ( / oldlayer Choix Pt0 Ray Long Ang0 R Pt1 Pt2 Pt3 Pt4 Pt5 Pt6 Pt7 L1 NomEntite liste p1 p2 ang2)


;Saisie des paramètres
;Pt0 : Point de départ du rail
;Long: Longueur du rail
;Ang0: Angle d'orientation du rail /Ox
;R : Rayon d'emprise de la grue
;Pt1 Point de fin du rail
;pt2 point d'un batiment
;ang2: Angle d'orientation du bâtiment
 (command "-calque" "n" "Grue" "co" "10" "Grue" "ch" "Grue" "")
 (vl-load-com)
 (initget 1 "Fixe Rails")
 (setq Choix (getkword "\nChoisissez un type de grue [Fixe/Rails]:"))

;Grue fixe
 (cond
   ((eq Choix "Fixe")
     (initget 1)
     (setq Pt0 (getpoint "\nPoint de base de la grue: "))
     (initget 3)
     (setq Ray (getdist Pt0 "\nDonner la rayon de la grue: "))
     
   )

;Cas d'une grue sur rails
 
   ((eq Choix "Rails")
     (initget 1)
     (setq Pt0 (getpoint "\nPoint de départ du rail: "))
     (initget 3)
     (setq Long (getdist Pt0 "\nLongueur du rail: "))
   )
 )
 (initget 1 "Seul Batiment")
 (setq Choix (getkword "\nChoisir l'orientation de la grue [seul/Batiment]: "))

;orientation seul
 (cond
   ((eq Choix "Seul")
     (initget 1)
     (setq Ang0 (getangle Pt0 "\nAngle d'orientation du rail /Ox: "))
     (initget 3)
     (setq R (getdist Pt0 "\nRayon d'emprise de la grue: "))
     (setq
       Pt1 (polar pt0 ang0 R)
       Pt2 (polar pt0 (+ Ang0 (* 1.5 pi)) R)
       Pt3 (polar Pt1 (+ Ang0 (* 1.5 pi)) R)
       Pt4 (polar Pt1 (+ Ang0 (* 0.5 pi)) R)
       Pt5 (polar Pt0 (+ Ang0 (* 0.5 pi)) R)
       Pt6 (polar Pt0 (+ Ang0 pi) R)
       Pt7 (polar Pt1 (+ Ang0) R)
     )
     (command "polylign" pt0 pt1 "")
     (command "polylign" pt2 pt3 "")
     (command "polylign" pt4 pt5 "")
     (command "arc" pt2 pt6 pt5)
     (command "arc" pt4 pt7 pt3)
     (command "inserer" "bloc_grue" pt0 1 1 0 "");insertion de bloc
   )

;orientation suivant un bâtiment
   ((eq Choix "Batiment")
     (while (null (setq L1 (entsel "\nSélectionner une ligne:"))))
     (setq
       NomEntite (car L1)
       liste (entget NomEntite)
     )
     (cond
       ((eq (cdr (assoc 0 liste)) "LINE")
         (setq
           p1 (cdr (assoc 10 liste))
           p2 (cdr (assoc 11 liste))
           ang2 (angle p1 p2)
         )
         (initget 3)
         (setq R (getdist Pt0 "\nRayon d'emprise de la grue:"))
         (setq
           Pt1 (polar pt0 ang2 R)
           Pt2 (polar pt0 (+ Ang2 (* 1.5 pi)) R)
           Pt3 (polar Pt1 (+ Ang2 (* 1.5 pi)) R)
           Pt4 (polar Pt1 (+ Ang2 (* 0.5 pi)) R)
           Pt5 (polar Pt0 (+ Ang2 (* 0.5 pi)) R)
           Pt6 (polar Pt0 (+ Ang2 pi) R)
           Pt7 (polar Pt1 (+ Ang2) R)
         )
         (command "polylign"  pt0 pt1 "")
         (command "polylign"  pt2 pt3 "")
         (command "polylign"  pt4 pt5 "")
         (command "arc"  pt2 pt6 pt5)
         (command "arc"  pt4 pt7 pt3)
  (command "inserer" "bloc_grue" pt0 1 1 0 "");insertion de bloc
       )
       
     )
   )
 )
  (command "scu" "general")
  (command "-calque" "ch" 0 "")
)

Connexion

Orientation d'une grue par rapport a une ligne donnée

Messages recommandés

mateus

-Olivier-

(gile)

alala

(gile)

bonuscad

alala

mateus

mateus

mateus

(gile)

mateus

mateus

mateus

mateus

mateus

mateus

Créer un compte ou se connecter pour commenter

Créer un compte

Se connecter

Forums

Naviguer

Activité

Information importante