Bienvenue aux nouveaux arrivants sur FantasPic !

- Pensez à lire les règles durant votre visite, il n'y en a pas beaucoup, mais encore faut-il les respecter .
- N’hésitez pas à faire des remarques et/ou suggestions sur le Forum, dans le but de l'améliorer et de rendre vos prochaines visites plus agréables.
- Vous pouvez regarder votre "panneau de l'utilisateur" afin de configurer vos préférences.
- Un passage par "l'utilisation du forum" est recommandé pour connaître les fonctionnalités du forum.

--- L’équipe FantasPic ---
Forum général sur l'Assembleur !

Modérateur : mazertoc

Soft de commande CNC en asm
F6FCO
Avatar de l’utilisateur
Confirmé
Confirmé
Messages : 844
Âge : 65
Enregistré en : décembre 2017
Localisation : Furtif je suis.
Contact :

#301 Message par F6FCO » sam. 22 déc. 2018 19:16

Bonsoir tous,
Petit post pour donner des nouvelles du projet. Je travaille toujours sur les déplacements de chariots sur des pentes, j'ai développé un algorithme perso mais il manque encore de précision, je travaille dessus pour l'améliorer. Il utilise la routine de division que j'ai présentée juste au dessus (en passant la routine était fausse, je l'ai débuggée et simplifiée depuis), sur certaines valeurs de pentes le reste de la division est trop important et induit au final une trop grosse imprécision sur la pente. Il a aussi fallu faire un test pour détourner les divisions par zéro (en cas de droites verticales et horizontales, les deplacements X ou Y =0), dans ce cas-là l'astuce est de charger directement la valeur du dividende dans le quotient comme pour une division par 1.

J'ai louché sur l'algo de Bresenham mais il ne me convient pas pour deux raisons:
- destiné à l'affichage et l'allumage de pixels, ici on raisonne en pas moteurs.
- ce n'est pas moi qui l'ai développé et çà me gâcherait mon plaisir :sifflotte:

Reste la piste de l'équation de droite y=ax+b, je vais tenter quelque chose de ce coté là aussi. Le gcode nous donne le point de départ et celui d'arrivée:
- point de départ, ligne précédente du gcode (x_old, y_old), on la garde en memoire.
- point d'arrivée, ligne en cours du gcode (x, y)
on peut incrémenter x et calculer y pour chaque incrément, mais il faut connaître la constante 'a' que le gcode ne nous donne pas. L'équation deltaY/deltaX nous la donne, à partir de là on peut calculer chaque point de la pente et amener les chariots au bon endroit.

Reste la piste de l'équation de droite y=ax+b, je vais tenter quelque chose de ce coté là aussi. Le gcode nous donne le point de départ et celui d'arrivée:
- point de départ, ligne précédente du gcode (x_old, y_old), on la garde en memoire.
- point d'arrivée, ligne en cours du gcode (x, y)
on peut incrémenter x et calculer y pour chaque incrément, mais il faut connaître la constante 'a' que le gcode ne nous donne pas. Petits rappels de l'école qui est bien loin maintenant...

La pente 'a' est donnée par dy/dx
La constante 'b' est donnée par b=y-(a.x1)
avec tout çà on peut maintenant tout calculer.

exemple de gcode choisi au hasard:

Code : Tout sélectionner


X0070 Y0008 Z0000 
; points de départ de la pente, X et Y sauvegardés en -old
X0080 Y0030 Z0000 
; points d arrivée de la pente, dernière ligne reçue

A noter que les virgules ne sont pas un problème, on multiplie tout par 10 et on reste en entiers.

1/ calcul des deltas
dX=X-Xold, 80-70=10
dY=Y-Yold, 30-8=22

2/calcul de la pente 'a'
dy/dx=22/10=2.2

3/calcul de la constante 'b'
b=Y-a.X
b=30-(2.2.80)=-146

l'équation de la droite devient y=2.2X-146

pour X=70, Y=2,2x70-146=8 (ce qui se vérifie avec le gcode de début)
pour X=71, Y=2,2x71-146=10,2 (l'axe X avance de 1, l'axe Y avance de 2,2)
pour X=72, Y=2,2x72-146 = 12,4 (l'axe X avance de 1, l'axe Y avance de 2,2)
etc.
pour X=80 Y=2,2x80-146=30 (ce qui se vérifie avec le gcode final)
Reste à coder la routine qui fera tout çà.

Que faut-il de plus pour être heureux ? un projet passionnant, de l'assembleur et des chocolats de Noël :langue:
Une porte nand prend 2 bits en entrée... la cochonne !!! 8-)

Soft de commande CNC en asm
venom
Avatar de l’utilisateur
Confirmé
Confirmé
Messages : 622
Âge : 33
Enregistré en : avril 2016
Localisation : Klyntar
Contact :

#302 Message par venom » dim. 23 déc. 2018 20:41

Bravo F6FCO,
Je vois que sa travail dur. :eek: :bravo:

J'ai eu mal a la tête juste en lisant ton post. :?
Bon courage pour la suite.






@++
En fait tout est une question de BIT ? :-D

Soft de commande CNC en asm
F6FCO
Avatar de l’utilisateur
Confirmé
Confirmé
Messages : 844
Âge : 65
Enregistré en : décembre 2017
Localisation : Furtif je suis.
Contact :

#303 Message par F6FCO » sam. 29 déc. 2018 20:20

Hello,
Oui çà cogite, çà cogite :-)
Une porte nand prend 2 bits en entrée... la cochonne !!! 8-)

Soft de commande CNC en asm
Temps-x
Avatar de l’utilisateur
Expert
Expert
Messages : 1253
Enregistré en : juillet 2016
Localisation : Terre

#304 Message par Temps-x » dim. 30 déc. 2018 17:00

Bonsoir F6FCO, venom, et tout le forum,

Bon je viens de regarder tes calculs, j'ai pas tout compris, mais je me demande si il serait pas plus simple de convertir le Gcode
en pixel par l'intermédiaire du PC(via un petit programme) :sifflotte: puis l'envoyer sur le Pic.

Le Pixel serait en plus haute définition pour un pas moteur de X et Y

==> A+
Quand la souris nargue le chat, c'est que son trou n'est pas loin.

Soft de commande CNC en asm
paulfjujo
Avatar de l’utilisateur
Expert
Expert
Messages : 1338
Âge : 68
Enregistré en : juillet 2015
Localisation : 01800
Contact :

#305 Message par paulfjujo » dim. 30 déc. 2018 20:05

bonsoir,

bonsoir à tous,

[QUOTE=F6FC0]
J'ai louché sur l'algo de Bresenham mais il ne me convient pas pour deux raisons:
- destiné à l'affichage et l'allumage de pixels, ici on raisonne en pas moteurs.
- ce n'est pas moi qui l'ai développé et çà me gâcherait mon plaisir
[/QUOTE]

Qu'on utilise des algorythmes déja établis et éprouvés est une bonne chose,
pouquoi réinventer la roue ?
même si c'est frustrant .. il reste quand meme le travail à faire pour l'appliquer correctement !

Si on voit les resultats assez encourageant obtenus sur des formes graphiques en PIXEL, je rejoins un peu l'avis
de TEMPS-X , le tout est de definir la valeur du "simili pixel" ,
representant le pas minimum possible de deplacement dans les 2 axes.

La vitesse de deplacement peut etre aussi un facteur agravant
d'autant si on a pas de codeur en info de retour position..
Aides toi, le ciel ou Fantastpic t'aideras

Soft de commande CNC en asm
F6FCO
Avatar de l’utilisateur
Confirmé
Confirmé
Messages : 844
Âge : 65
Enregistré en : décembre 2017
Localisation : Furtif je suis.
Contact :

#306 Message par F6FCO » mar. 1 janv. 2019 20:18

Bonsoir tous,
et bonne année 2019

Cela semble plus simple pour vous qui connaissez un langage pour coder sur le PC mais pas pour moi, il faudrait que je commence par apprendre le basic :wink:
En ce qui concerne l'équation de la droite Y=ax+b c'est des reste de l'école, autant que çà serve à quelque chose, et puis je peux travailler soit au 1/10e ou 1/100e:
1mm (800pas)
1/10e mm (80pas)
1/100emm (8pas)

Le seul point qui m’embêtait un peu c'était le calcul de la pente 'a' qui nécessite l(utilisation d'une division, celle que j'ai développée fonctionne bien mais est extrêmement lente, mais j'ai trouvé celle de Peter G. Harrison sur le net qui est bien plus rapide et que je vais utiliser dans ma routine.
Une porte nand prend 2 bits en entrée... la cochonne !!! 8-)

Soft de commande CNC en asm
Temps-x
Avatar de l’utilisateur
Expert
Expert
Messages : 1253
Enregistré en : juillet 2016
Localisation : Terre

#307 Message par Temps-x » mer. 2 janv. 2019 01:08

Bonsoir paulfjujo, F6FCO, venom, et tout le forum,

==> ==> ==> ==> ==> ==> ==> ==> ==> ==> ==> ==> ==> ==> ==> ==> Bonne année 2019

F6FCO a écrit :Source du message Cela semble plus simple pour vous qui connaissez un langage pour coder sur le PC mais pas pour moi, il faudrait que je commence par apprendre le basic :wink:


Tu n'est pas obligé de le faire en basic, tu peux le faire en ASM ..... :sifflotte:

Je vais pouvoir revenir vers ce projet de CNC, car j'ai presque fini mon appareille que j'ai commencé il y a 1 an

Ne pas oublier ce que c'est un pixel

dpi-1.jpg


Plus la résolution est élevée, plus les points sont nombreux.

Les écrans d'ordinateurs sont habituellement utilisés en 72 ou 75 dpi.
C'est aussi dans cette résolution que sont les images sur Internet (dans votre navigateur).

A l'impression c'est assez laid, mais à l'écran c'est suffisant.

Les faxs sont généralement en 200 dpi.

Les imprimantes grand public font entre 360 dpi (qualité normale) et 1400 dpi.

Cela permet d'obtenir une qualité tout à fait honorable pour des travaux courants (courrier, rapports...).

Les scanners grand public font généralement 300, 600 ou 1200 dpi.

Les photocomposeuses et le matériel d'impression professionnel fonctionne bien souvent à 4800 dpi ou plus.

C'est indispensable pour avoir des impressions de très bonne qualité, tels que les magazines ou les livres.

Une image a donc 3 caractéristiques:

- sa taille en points (ou pixels)
- ses dimensions réelles (en centimètres ou pouces)
- sa résolution.

Ces 3 informations sont liées.

Si vous en connaissez 2, vous pouvez toujours calculer la troisième.

Le calcul est très simple:

==> ==> Points par pouce = Nombre de points / Nombre de pouces

Sans oublier qu'un pouce = 2,54 centimètres.

Exemples

J'ai une page A4 (21x29,7 cm) que je scanne en 360 dpi.
Quelle sera la taille de l'image en pixels ?

360*(21/2,54) = 2976 pixels
360*(29,7/2,54) = 4209 pixels

La page A4 en 360 dpi donnera donc une image de 2976 par 4209 pixels.

Ce n''est pas la connaissance d'un langage qui est primordial, mais c'est savoir l'utiliser avec ce qu'on peu découvrit ou imaginé.

A+
Vous n’avez pas les permissions nécessaires pour voir les fichiers joints à ce message.
Modifié en dernier par Temps-x le mer. 2 janv. 2019 19:37, modifié 2 fois.
Quand la souris nargue le chat, c'est que son trou n'est pas loin.

Soft de commande CNC en asm
paulfjujo
Avatar de l’utilisateur
Expert
Expert
Messages : 1338
Âge : 68
Enregistré en : juillet 2015
Localisation : 01800
Contact :

#308 Message par paulfjujo » mer. 2 janv. 2019 15:14

Bonjour à tous et meilleurs voeux

La santé ,avant tout.

F6FCO a écrit :...
1/100emm (8pas)
...


plutot sympa cette relation ..
vu que pour diviser par 8 il suffit de faire d= Nb_Pas>>3 ou le contraire *8 Nb_Pas=d<<3
SHR ou SHL

est-ce cela sous entend que la resolution maximum serait +-1 pas => +-1.25µm ?
:sifflotte: .. qui pourrait etre donc notre "simili Pixel"
Aides toi, le ciel ou Fantastpic t'aideras

Soft de commande CNC en asm
F6FCO
Avatar de l’utilisateur
Confirmé
Confirmé
Messages : 844
Âge : 65
Enregistré en : décembre 2017
Localisation : Furtif je suis.
Contact :

#309 Message par F6FCO » jeu. 3 janv. 2019 19:50

C'est çà 1,25 micron, pour çà il suffit de faire bouger le moteur de 1 pas :-)

Et bons voeux à tout le monde.
Une porte nand prend 2 bits en entrée... la cochonne !!! 8-)

Soft de commande CNC en asm
F6FCO
Avatar de l’utilisateur
Confirmé
Confirmé
Messages : 844
Âge : 65
Enregistré en : décembre 2017
Localisation : Furtif je suis.
Contact :

#310 Message par F6FCO » sam. 12 janv. 2019 21:58

Hello tous,
Ca y est !!!! elle dessine ses pentes :-D

Finalement j'ai laissé tomber l'équation Y=ax+b, pour certaines pentes je me retrouvais avec des calculs de b négatifs, pas compatible avec la volonté de rester en entiers en assembleur.
Je suis passé par le calcul de la tangente de l'angle formé par la pente. Comme une tangente est toujours un nombre à virgule il aurait fallu le multiplier par 1000 pour avoir quelque chose d'utilisable. Mais si je multiplie un terme par 1000 d'un coté il fallait diviser le résultat d'autant de l'autre, c'est à dire le nombre de pas à parcourir. Le problème c'est que le pas de base est 1/800eme de mm (1,25µm).
La solution était simple: multiplier la valeur de la tangente par 800 et commander le moteur Y par pas de 1/800e de mm.

Prenons l'exemple d'une pente partant de x0,y0 pour arriver à x54,y33.
1- Calcul des delta:
deltaX=X54-X0=54
deltaY=Y33-Y0=33

2- Calcul de la tangente améliorée:
tangente()=(deltaY/deltaX)*800
(33/54)*800=488 (valeur pour cet angle précis)

4- On fait bouger les moteurs:
On fait deltaX fois avancer le X de 1mm et le Y de tangente améliorée fois (donc 488) fois le pulse de base de 1,25µm.

Ce qui donne:
X=1 Y=X*488*0.00125=0 (on ne garde que la valeur entière)
X=2 Y=X*488*0.00125=1
X=3 Y=X*488*0.00125=1
X=4 Y=X*488*0.00125=2
X=5 Y=X*488*0.00125=3
etc.
etc.
X=49 Y=X*488*0.00125=29
X=50 Y=X*488*0.00125=30
X=52 Y=X*488*0.00125=31
X=53 Y=X*488*0.00125=32
X=54 Y=X*488*0.00125=32 (32,94 presque 33 mais on garde la valeur entière)

Ca dessine la pente :-)

La routine (deux boucles imbriquées):

Code : Tout sélectionner


construction_droite
            nop
            movff    deltaX
,tampon0        ; on charge deltaX dans le tampon de décrémentation
            movff    deltaX
+1,tampon0+1
boucleX
            
; on avance de 1mm en X
            call    X800pulses
            
; ---------------------- calcul de Y
            movff    tangente16
,tampon1
            movff    tangente16
+1,tampon1+1
boucleY        
            
; on avance de 1,25µm en Y
            call    Ypulse_base
            
; on décrémente tampon1
            movff    tampon1
,valeur1
            movff    tampon1
+1,valeur1+1
            clrf    valeur2
+1
            movlw    0x1
            movwf    valeur2
            nop
            call    soustraction16
            nop
            movff    valeur1
,tampon1
            movff    valeur1
+1,tampon1+1
            movf    tampon1
,tampon1
            nop
            bnz        boucleY
            
            
; ---------------------- 
            
; decrémentation de tampon0 (X)
            movff    tampon0,valeur1
            movff    tampon0
+1,valeur1+1
            clrf    valeur2
+1
            movlw    0x1
            movwf    valeur2
            nop
            call    soustraction16
            nop
            movff    valeur1
,tampon0
            movff    valeur1
+1,tampon0+1
            movf    tampon0
,tampon0
            nop
            bnz        boucleX
            return    


Y=x.tangente()
Et si on réfléchit un peu c'est l'équation y=ax+b avec b=0.

Il me reste quelques trucs à régler, par exemple dans le cas d'une verticale ou le deltaX est égal à zéro, donc division par zéro pas glop. Dans ce cas là je ferai une division par 1.
Modifié en dernier par F6FCO le sam. 12 janv. 2019 22:25, modifié 4 fois.
Une porte nand prend 2 bits en entrée... la cochonne !!! 8-)


Retourner vers « Langage ASM »

Qui est en ligne

Utilisateurs parcourant ce forum : Aucun utilisateur enregistré et 3 invités