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
Temps-x
Avatar de l’utilisateur
Expert
Expert
Messages : 1372
Enregistré en : juillet 2016
Localisation : Terre

#421 Message par Temps-x » mer. 29 mai 2019 00:49

Bonjour JJE, F6FCO, et tout le forum,

De toute façon, seul le résultat compte, et tu nous là bien prouvé. :bravo:

==> A+
:roll: Les requins, c'est comme le langage ASM, c'est le sommet de la chaîne alimentaire. :wink:

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

#422 Message par F6FCO » mer. 29 mai 2019 20:25

Bonsoir,
Et il y aura une suite :wink:
N'ayant toujours pas d'atelier je me suis lâché sur la 3D, le proto actuel en médium ayant un peu souffert des essais, j'ai fais l'étude du prochain pour la V.2 du soft 4L1C3.
Plus sérieux que le premier celui-ci, tout en alu usiné, s'il rue dans les brancards lors de la mise au point rien ne bougera :furieux: . J'avais envie de sortir un peu des sentiers battus en innovant, un peu la synthèse entre un portique fixe et un portique mobile.
L'électronique sera placée dans un coffret externe.
Ne pouvant pas faire de copeaux pour l'instant çà reste une étude sujette à quelques changements:

CL41R3 a.jpg


CL41R3 b.jpg


CL41R3 c.jpg


CL41R3 d.jpg
Vous n’avez pas les permissions nécessaires pour voir les fichiers joints à ce message.
Une porte nand prend 2 bits en entrée... cochonne va !!! :langue:

Soft de commande CNC en asm
JJE
Passioné
Passioné
Messages : 357
Âge : 79
Enregistré en : novembre 2017
Localisation : Picardie

#423 Message par JJE » jeu. 30 mai 2019 09:27

Attention, une idée peut en cacher une autre chez F6FCO :-D
Plus je suis ses posts, plus j'ai l'impression qu'il manque une corde à mon arc, c'est plus grave qu'à mon archet :cry: .
Cordialement

JJE

C'est pas parcequ'on n'a rien à dire qu'il faut fermer sa G....e

Soft de commande CNC en asm
JJE
Passioné
Passioné
Messages : 357
Âge : 79
Enregistré en : novembre 2017
Localisation : Picardie

#424 Message par JJE » ven. 31 mai 2019 06:22

bonjour à tous,
Je travaille toujours sur le soft de F6FCO dont le projet m'intéresse fort.
dans mon post #407
JJE a écrit :Source du message 3*8 soit 24 pour la boucle

j'aurais dû écrire
JJE a écrit :Source du message 3*7 soit 21 pour la boucle

puisqu'on commence la boucle par un decfsz
l'erreur se rapproche du négligeable (29 au lieu de 25, mais en mettant 6, c'est encore mieux (26/25) et en mettant 5 et deux nop avant le return, c'est pile poil. :-D
Avec mes excuses d'avoir écrit une bêtise. :furieux:
Cordialement

JJE

C'est pas parcequ'on n'a rien à dire qu'il faut fermer sa G....e

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

#425 Message par F6FCO » ven. 31 mai 2019 13:45

Ne t'inquiète pas, je crois que personne ne l'avait relevée. Tu es trop pointu pour nous :wink: .

Mais comme tu t’intéresse de près au programme voici la version définitive, deux parties car le forum n'accepte pas plus de 60 000 caractères par post et le programme est trop long.

Première partie:

Code : Tout sélectionner

;----------------------------------------------------------------------------------------------
;                            
4L1C3 Soft de commande CNC pour gravure de PCB
;                                by Jean-Claude Buisson F6FCO
;                        
;                             
Dernière modification le 24 février 2019  
;
;----------------------------------------------------------------------------------------------

    
Errorlevel-302                         Supprime le message "Ensure that bank bits are correct" 

    
list        p=18f4525                processeur utilisé 
    
#include    <p18f4525.inc>            ; Définitions des constantes

;---------------------------------------------------------------------------------------------
 
CONFIG    OSC XT                        Oscillateur ext 4MHz 
 
;CONFIG    OSC HSPLL                        Oscillateur interne 32Mhz 
 CONFIG    IESO 
OFF                        Oscillateur secondaire refusé (ON/OFF)
 
CONFIG PWRT ON                        Délai au démarrage (ON/OFF)
 
CONFIG BOREN OFF                        Reset si chute de tension (ON/OFF)
 
CONFIG BORV 0                        Tension de reset en 1/10ème Volts 
 CONFIG WDT 
OFF                        Mise hors service du watchdog (ON/OFF)
 
CONFIG PBADEN OFF                    PORTB<4:0les broches sont configurées comme E/S numériques lors de la réinitialisation
 CONFIG LPT1OSC 
OFF                    Timer1 configuré pour un fonctionnement plus puissant
 CONFIG MCLRE 
ON                        Mclr 
 CONFIG STVREN 
ON                        Reset sur débordement de pile (ON/OFF)
 
CONFIG LVP OFF                        Programmation basse tension autorisée (ON/OFF)
 
CONFIG XINST OFF                        L'extension du jeu d'instructions et le mode d'adressage indexé sont désactivés(mode hérité)
 CONFIG DEBUG = ON                        ; Debugger hors service
 CONFIG CP0 = OFF                        ; Code protection sur block 0 (ON/OFF)
 CONFIG CP1 = OFF                        ; Code protection sur block 1 (ON/OFF)
 CONFIG CP2 = OFF                        ; Code protection sur block 2 (ON/OFF)
 CONFIG CPB = OFF                        ; Code protection sur bootblock  (ON/OFF)
 CONFIG CPD = OFF                        ; Code protection sur eeprom (ON/OFF)
 CONFIG WRT0 = OFF                        ; Protection écriture block 0 (ON/OFF)
 CONFIG WRT1 = OFF                        ; Protection écriture block 1 (ON/OFF)
 CONFIG WRT2 = OFF                        ; Protection écriture block 2 (ON/OFF)
 CONFIG WRTB = OFF                        ; Protection écriture bootblock (ON/OFF)
 CONFIG WRTC = OFF                        ; Protection écriture configurations (ON/OFF)
 CONFIG WRTD = OFF                        ; Protection écriture zone eeprom (ON/OFF)
 CONFIG EBTR0 = OFF                        ; Protection lecture de table block 0 (ON/OFF)
 CONFIG EBTR1 = OFF                        ; Protection lecture de table block 1 (ON/OFF)
 CONFIG EBTR2 = OFF                        ; Protection lecture de table block 2 (ON/OFF)
 CONFIG EBTRB = OFF                        ; Protection lecture de table bootblock (ON/OFF)
            
;-------------------------------------- assignations ------------------------------------------

#define    btn_jog_Xmoins    PORTA,0    ; 1
#define    btn_jog_Xplus    PORTA,1    ; 1
#define    btn_jog_Ymoins    PORTA,2    ; 1
#define    btn_jog_Yplus    PORTA,3    ; 1
#define    btn_jog_Zmoins    PORTA,4    ; 1
#define    btn_jog_Zplus    PORTA,5    ; 1

#define capteur_pomZ    PORTB,0    ; 1
#define capteur_pomX    PORTB,1    ; 1
#define capteur_pomY    PORTB,2    ; 1
#define led_pomZ        PORTB,3    ; 0
#define led_pomY        PORTB,4    ; 0
#define cts                PORTB,5    ; 0
#define nc0                PORTB,6 ; x
#define nc1                PORTB,7 ; x

#define    led_popY        PORTC,0 ; 0
#define    led_popZ        PORTC,1 ; 0
#define    btn_run            PORTC,2    ; 1
#define    btn_popX        PORTC,3    ; 1
#define drv_stepY        PORTC,4    ; 0            pulse Y
#define drv_dirY        PORTC,5 ; 0            direction Y
#define Tx                PORTC,6    ; 1
#define Rx                PORTC,7    ; 1 

#define btn_popY        PORTD,0    ; 1
#define btn_popZ        PORTD,1    ; 1
#define drv_stepX        PORTD,2    ; 0            pulse X
#define drv_dirX        PORTD,3    ; 0            direction X
#define drv_stepZ        PORTD,4 ; 0            pulse Z
#define drv_dirZ        PORTD,5 ; 0            direction Z
#define    led_pomX        PORTD,6 ; 0
#define btn_pom            PORTD,7    ; 1
#define    btn_ctrl        PORTE,0 ; 1
#define    btn_fn            PORTE,1 ; 1
#define    led_popX        PORTE,2 ; 0

; ----------------------------------- Constantes ----------------------------------------------

#define limite_maxiX        d'
108'                    ; maxi à droite
#define limite_miniX        0                        ; mini à gauche (POM X)
#define offset_pomX            d'
12'                    ; offset après contact POM X (d'12' maxi)

#define limite_maxiY        d'
120'                    ; maxi devant
#define limite_miniY        0                        ; mini au fond derrière (POM Y)
#define    offset_pomY            d'
20'                    ; offset après contact POM Y (d'30' maxi)


#define limite_maxiZ        d'
30'                      ; tout en haut (POM Z)
#define limite_miniZ        d'
0'                    ; tout en bas
#define    offset_pomZ            d'
1'                    ; offset après contact POM Z (d'10' maxi)

;#define    pas_moteur            200                        ; 1/1 pas
;#define    pas_moteur            400                        ; 1/2 pas
#define    pas_moteur            800                        ; 1/4 pas
;#define    pas_moteur            1600                    ; 1/8 pas

;------------------------------ déclaration des variables -------------------------------------

                 CBLOCK    H'
08'
                     ptr                                ; sert à la raz des variables en init
                    axeX:1                            ; ascii '
Z'
                    coordX:7                        ; coordonnée stockée sur 32 bits
                    espace1                            ; espace
                    axeY                            ; ascii '
Y'
                    coordY:7                        ; coordonnée stockée sur 32 bits
                    espace2                            ; espace
                    axeZ                            ; ascii '
Z'
                    coordZ:7                        ; coordonnée stockée sur 32 bits
                    ptr_train_RCIF                    ; compteur nb octets reçus dans un train
                    coordZ_old:3
                    coordX_old:3
                    coordY_old:3
                    dividende16:2                        ; utilisé par division 16bits
                    diviseur16:2                        ; utilisé par division 16bits
                    quotient16:2                        ; utilisé par division 16bits
                    reste16:2                            ; utilisé par division 16bits
                    
                    dividende48:6
                    diviseur48:6
                    
                    multiplicande32:4                    ; mult 16_16
                    multiplicateur32:4                    ; mult 16_16
                    resultat32:4                        ; mult 16_16
                    result:6                            ; Mult32x16
                    tampon                                ; mult 16_16
                    deltaX:3
                    deltaY:3
                    deltaZ:3
                    translatZ
                    translatX                        ; distance parcourue en X
                    translatY
                     valeur1:3                         ; utilisée par les opérations arithmetiques
                    valeur2:3                        ; utilisée par les opérations arithmetiques
                    valeur3:3                        ; valeur tampon pour les les opérations arithmetiques
                    flagX
                    flagY
                    report16                        ; si carry en dépassement
                    tangente16:2
                    val_popZ
                    val_popX                        ; valeur de la course pop par rapport à l'
origine X
                    val_popY
                    nbmm                            
sert à calculer la distance parcourue sur un nb pulse calculé
                    tampon0
:3                        sert de variable locale
                    tampon1
:3                        sert de variable locale
                    tampon2                            
sert de variable locale
                    tampon3                            
sert de variable locale
                    tamponA                            
sert de variable locale
                    tamponB                            
sert de variable locale
                    flag_fin_gcode
                    Tampon_REC                        
tampon réception
                    Reg_1
                    Reg_2
                    Reg_3
                    Reg_4
                    W_TEMP
                    STATUS_TEMP
                    BSR_TEMP
                    
; --------------                partie musique
                    note
                    duree_note
                    silence
                    led1
                    led2
                    led3
                    led4
                    led5
                    dir
                    axe
                    
                    
                 ENDC
                 
                 CBLOCK H
'100' 
                
ENDC

; ---------------------------------------- macros --------------------------------------------
    
qrt            macro                            Etat hautdemande au PC d'arreter l'émission 
                bsf        cts
            endm
            
qrv            macro                            
Etat basdemande au PC de relancer l'émission
                bcf        cts            
            endm

plongée_Z macro
            bcf        drv_dirZ
            nop
            endm            
remontée_Z macro
            bsf        drv_dirZ
            nop
            endm
            
marche_av_X macro
            bsf        drv_dirX
            nop
            endm            
marche_ar_X macro
            bcf        drv_dirX
            nop
            endm

marche_av_Y macro
            bsf        drv_dirY
            nop
            endm            
marche_ar_Y macro
            bcf        drv_dirY
            nop
            endm

led_popZ_ON macro
            bsf        led_popZ
            endm
led_popZ_OFF macro
            bcf        led_popZ
            endm
            
led_popX_ON macro
            bsf        led_popX
            endm
led_popX_OFF macro
            bcf        led_popX
            endm

led_popY_ON macro
            bsf        led_popY
            endm
led_popY_OFF macro

            bcf        led_popY
            endm

led_pomZ_ON macro
            bsf        led_pomZ
            endm
led_pomZ_OFF macro    
            bcf        led_pomZ
            endm
        
led_pomX_ON macro
            bsf        led_pomX
            endm
led_pomX_OFF macro
            bcf        led_pomX
            endm

led_pomY_ON macro
            bsf        led_pomY
            endm
led_pomY_OFF macro
            bcf        led_pomY
            endm


;--------------------------------- adresse de depart après reset -----------------------------²
            ORG     H'
0'



            bra        init      

;--------------------------------------- interruptions ---------------------------------------

            ORG        H'
08'
interrupt   btfss    PIR1,RCIF                ; registre plein ? si oui on saute à réception
            bra        int1                    ; sinon on sort de l'
interrupt                   
reception        
            nop
            movff    RCREG
,POSTINC0            lecture de RCREG  et mise en mem       
            incf    ptr_train_RCIF            
on a reçu qq chose donc on incrémente le compteur de trains
            btfss    RCSTA
,OERR                test d'une erreur d'overrun
            
goto    int1
            
traitement de l'erreur d'overrun
            bcf        RCSTA
,CREN                on efface le bit OERR
            bsf        RCSTA
,CREN                on relance la réception
int1        
traitement des autres interruptions
            retfie
            
; ------------------------------------- datas --------------------------------------------------------
table précalculée sur 24bits utilisée dans les routines de conversion ascii/hexaplacée volontairement en début de programme pour avoir une adresse fixe 
et ne pas avoir les points d'entrée altérés par les modifs ultérieures du code
;ascii_poids6    db    0x00,0x00,0x00  ,0x0F,0x42,0x40  ,0x1E,0x84,0x80  ,0x2c,0xc6,0xc0  ,0x3d,0x09,0x00  ,0x4c,0x4b,0x40  ,0x5b,0x8d,0x80  ,0x6a,0xcf,0xc0  ,0x7a,0x12,0x00  ,0x89,0x54,0x40    ; multiplication chiffre.0xA.0xA.0xA.0xA.0xA.0xA        
ascii_poids5    db    0x00,0x00,0x00  ,0x01,0x86,0xA0  ,0x03,0x0d,0x40  ,0x04,0x93,0xe0  ,0x06,0x1a,0x80  ,0x07,0xa1,0x20  ,0x09,0x27,0xc0  ,0x0a,0xae,0x60  ,0x0c,0x35,0x00  ,0x0d,0xbb,0xa0    ; multiplication chiffre.0xA.0xA.0xA.0xA.0xA         
ascii_poids4    db    0x00,0x00,0x00  ,0x00,0x27,0x10  ,0x00,0x4e,0x20  ,0x00,0x75,0x30  ,0x00,0x9c,0x40  ,0x00,0xc3,0x50  ,0x00,0xea,0x60  ,0x01,0x11,0x70  ,0x01,0x38,0x80  ,0x01,0x5f,0x90    ; multiplication chiffre.0xA.0xA.0xA.0xA         
ascii_poids3    db    0x00,0x00,0x00  ,0x00,0x03,0xe8  ,0x00,0x07,0xd0  ,0x00,0x0b,0xb8  ,0x00,0x0f,0xa0  ,0x00,0x13,0x88  ,0x00,0x17,0x70  ,0x00,0x1b,0x58  ,0x00,0x1f,0x40  ,0x00,0x23,0x28    ; multiplication chiffre.0xA.0xA.0xA         
ascii_poids2    db    0x00,0x00,0x00  ,0x00,0x00,0x64  ,0x00,0x00,0xc8  ,0x00,0x01,0x2c  ,0x00,0x01,0x90  ,0x00,0x01,0xf4  ,0x00,0x02,0x58  ,0x00,0x02,0xbc  ,0x00,0x03,0x20  ,0x00,0x03,0x84    ; multiplication chiffre.0xA.0xA
ascii_poids1    db    0x00,0x00,0x00  ,0x00,0x00,0x0a  ,0x00,0x00,0x14  ,0x00,0x00,0x1e  ,0x00,0x00,0x28  ,0x00,0x00,0x32  ,0x00,0x00,0x3c  ,0x00,0x00,0x46  ,0x00,0x00,0x50  ,0x00,0x00,0x5a    ; multiplication chiffre.0xA     

;----------------------------------- Initialisations -------------------------------------------------
init
                ;movlw    b'
01000000'                ; oscillateur interne 8Mhzx4=32Mhz
                ;movwf    OSCTUNE                    
                movlw    b'
11000000'                ; INTCON (activation des int GIE/GIEH=1, PEIE/GIEL=1)
                movwf    INTCON
                movlw    b'
10000000'                ; RCON (priorités int activées IPEN=1,)
                movwf    RCON
                movlw    b'
00100000'                ; IPR1 (Rx en haute priorité RCIP=1)
                movwf    IPR1
                movlw    b'
00100000'                ; PIE1 (int RX activée RCIE=1)
                movwf    PIE1
                movlw    b'
00100100'                ; TXSTA (Emission USART activée TXEN=1, et mode asynchrone haute vitesse BRGH=1)
                movwf    TXSTA
                movlw    b'
10010000'                ; RCSTA (Utilisation du port série activée SPEN=1, Réception USART activée CREN=1)
                movwf    RCSTA
                movlw    d'
25'                    ; 9600bauds avec sync=O, brgh=1, brg16=0, xtal=4Mhz
                movwf    SPBRG
                bcf        BAUDCON,BRG16            ; réglé à 8bits        
                movlw     B'
00000111'                 
                movwf    TRISB
                movlw     B'
11001100'                
                movwf    TRISC
                movlw     B'
10000011'                  
                movwf    TRISD
                movlw     B'
10000011'                 
                movwf    TRISE
                clrf    PORTB
                clrf    PORTC
                clrf    PORTD
                clrf    PORTE
                ; -----------------   initialisation du PORT A
                clrf    PORTA
                clrf    LATA
                movlw    0xf
                movwf    ADCON1
                movwf    0x07
                movwf    CMCON            
                movlw     0xff                 
                movwf    TRISA

                qrt
            
                ; ---------------- RAZ de la zone variables de axeX à 0x7e
init2            lfsr    FSR0,axeX
                movlw    0x76
                movwf    ptr
raz_var            clrf    POSTINC0
                decf    ptr
                bnz        raz_var
                lfsr    FSR0,axeX                ; on repointe sur la première variable axeX    
                
                movlw    limite_maxiZ        
                movwf    translatZ                ; initialisation axe Z à zéro
                ; prêt pour réception
                
                bcf        led_pomX
                bcf        led_pomY
                bcf        led_pomZ
                ;bra     main
                ;bra     Test_nb_trains
                

;############################################################################################################################
;#                                                                                                                            #
;#                                        Programme principal, appel des procédures                                            #
;#                                                                                                                            #
;############################################################################################################################

main      
            
            marche_av_X                        ; on est en POM donc on force l'
axe en avant
            qrt                                
on coupe la réception UART le temps des initialisations

initialisations_machine    
            
scrutation des claviers    
            
text btn_fonction
            btfss    btn_ctrl
            bra        fn2    
            btfss    btn_fn
            bra        fn1
            
_________________________ POM générales (Prises Origines Machine)
            
btfss    btn_pom                            
            call    POM
            
_________________________ gestion des JOG
            btfss    btn_jog_Xmoins                    
            call    xmoins    
            
jog X plus
            btfss    btn_jog_Xplus                                        
            call    xplus
            
jog Y moins
            btfss    btn_jog_Ymoins                    
            call    ymoins    
            
jog Y plus
            btfss    btn_jog_Yplus                                        
            call    yplus
            
jog Z moins


            btfss    btn_jog_Zmoins                
            call    zmoins    
            
jog Z plus
            btfss    btn_jog_Zplus                                        

            call    zplus
            
_________________________ gestioon des POP
            
pop X
            btfss    btn_popX                                        
            call    popX
            
pop Y
            btfss    btn_popY                                        
            call    popY
            
pop Z
            btfss    btn_popZ                                        

            call    popZ
            
_________________________ RUN   validation de l'interruption rec UART et exécution du gcode
            btfss    btn_run                                        
            bra        run
            ; _________________________ on reboucle tant qu'
un bouton n'a pas été pressé
            bra        initialisations_machine
            
            
fn1            nop    ; (btn fonction)
            ;
            btfss    btn_jog_Zmoins
            call    _4L1C3
            ;
            btfss    btn_jog_Zplus
            ;call    pomz
            call    zik_partisan
            ;
            btfss    btn_jog_Xmoins
            call    pomx
            ;
            btfss    btn_jog_Ymoins
            call    pomy
            ;
            btfss    btn_popX
            call    monteZ_1centième
            ;    
            btfss    btn_popY
            call    monteZ_5centièmes
            ;
            btfss    btn_popZ
            call    monteZ_1dixième
            ;
            ;btfss    btn_run    
            ;call     PartisanCW
            ;
            bra        initialisations_machine    

fn2            nop ; (btn ctrl)
            ;
            btfss    btn_jog_Zmoins
            ;call    F6FCO
            call    RiretteCW
            ;
            btfss    btn_jog_Zplus
            call    zik_rirette
            call     tempo_1s
            call    zik_rirette
            ;
            btfss    btn_popX
            call    descendZ_1centième
            ;
            btfss    btn_popY
            call    descendZ_5centièmes
            ;
            btfss    btn_popZ
            call    descendZ_1dixième
            ;
            btfss    btn_run    
            call     RiretteCW
            ;
            bra        initialisations_machine        

            
; --------------------------------------------------- démarrage de l'
usinage  -----------------------------------------------
            
run            avant de lancer le gcode on s'assure que les axes sont bien à leurs origines POP, si non on les ramène à la bonne valeur
            ;call    positionnement_origines_pop
fin_init_machine
            call    tempo
            qrv                                ; POM et POP effectuées on active la réception UART 
            nop
            nop
            nop
            nop
            nop
            nop
            bra        Test_nb_trains

            ; Cette partie ne sert qu'
au débuggage en forçant des valeurs gcode en dur.
            ;
X
            movlw    0x30        

            
movwf    coordX+0
            movlw    0x30        

            
movwf    coordX+1
            movlw    0x30        

            
movwf    coordX+2
            movlw    0x31        

            
movwf    coordX+3
            movlw    0x4e
; ------------ point
            movwf    coordX
+4
            movlw    0x36        

            
movwf    coordX+5
            movlw    0x35        

            
movwf    coordX+6
            
;X_old
            movlw    0x0    

            
movwf    coordX_old+2
            movlw    0xc        

            
movwf    coordX_old+1
            movlw    0xc1        
CC1=3265
            movwf    coordX_old
            
; -----------------------
            ;
Y
            movlw    0x30        

            
movwf    coordY+0
            movlw    0x30        

            
movwf    coordY+1
            movlw    0x30        

            
movwf    coordY+2
            movlw    0x31        

            
movwf    coordY+3
            movlw    0x4e
; ------------ point
            movwf    coordY
+4
            movlw    0x32        

            
movwf    coordY+5
            movlw    0x37        

            
movwf    coordY+6
            
;Y
            movlw    0x0        

            
movwf    coordY_old+2
            movlw    0xc        

            
movwf    coordY_old+1
            movlw    0x9b        
C9b=3227
            movwf    coordY_old
            
; -----------------------        
            ; 
Z
            movlw    0x30        

            
movwf    coordZ+0
            movlw    0x30        

            
movwf    coordZ+1
            movlw    0x32        

            
movwf    coordZ+2
            movlw    0x32        

            
movwf    coordZ+3
            movlw    0x4e
; ------------ point
            movwf    coordZ
+4
            movlw    0x31        

            
movwf    coordZ+5
            movlw    0x35        

            
movwf    coordZ+6
                    
            
Z_old
            movlw    0x00        

            
movwf    coordZ_old+2
            movlw    0x00        

            
movwf    coordZ_old+1
            movlw    0x54        

            
movwf    coordZ_old
            bra        go
            
; ------------------------------------------- Réception des données et gestion des trains -----------------------------------
            
Test_nb_trains    
             
;movlw    d'17'                             compter 17 octets pour un train en 32bits (X0000)
             
movlw    d'26'                             compter 26 octets pour un train avec deux décimales (X0000.00)
            
subwf    ptr_train_RCIF,w
            btfss    STATUS
,Z
            bra        Test_nb_trains
go            qrt                                        
stop émission
            call    test_fin_gcode                    
test si fin du gcode
            movlw    1
            subwf    flag_fin_gcode
            btfsc    STATUS
,Z
            bra        fin_programme
            clrf    flag_fin_gcode
            
;                                    
            ; ------------------- 
On place ici les appels aux sous-routines de gestion de la machine
            
;                              
            
call    conversion_decimal_entierX
            call    conversion_decimal_entierY
            call    conversion_decimal_entierZ
            call    conversion_ascii_hexaZ            
convertit les
            call     conversion_ascii_hexaX            
données ascii des 
            call    conversion_ascii_hexaY            
3 axes en hexadécimal
            call    calcul_deltaZ
            call    deplaceZ
            call    calcul_deltaX
            call    calcul_deltaY
            call    calcul_tangente                    
            call     construction_droite
            call    sauvegarde_coordZ_old
            call     sauvegarde_coordX_old
            call    sauvegarde_coordY_old
            call    tempo                            
sert juste à mieux visionner les séquences sur l'analyseur logique
            ;
            ; -------------------
            ;
            clrf    ptr_train_RCIF    
            lfsr    FSR0,axeX                        ; on repointe sur la première variable axeX    
            qrv                                        ; pret pour réception
            bra     Test_nb_trains
            
test_fin_gcode
            movlw    0x4D                            ; test du '
M' de la fin du gcode (M00000000)
            subwf    axeX,w    
            btfss    STATUS,Z    
            return
            movlw    1
            movwf    flag_fin_gcode
            return
            
fin_programme
            call    pomz
clignotte    call    clignotte_3ledPOP
            call    clignotte_3ledPOM
            btfss    btn_run                                        
            bra        init2
            bra        clignotte
            
            
            
            
;############################################################################################################################
;#                                                                                                                            #
;#                                                                                                                            #
;#                                                    GESTION AXE Z                                                            #
;#                                                                                                                            #
;#                                                                                                                            #
;############################################################################################################################

; ------------------------------------------- Conversion ASCII/hexa Z ---------------------------------------------------------
conversion_ascii_hexaZ
; on commence par transformer chaque poids en décimal en soustrayant 0x30
            movlw    0x30
            subwf    coordZ
            subwf    coordZ+1
            subwf    coordZ+2
            subwf    coordZ+3
            subwf    coordZ+4
            subwf    coordZ+5

; ensuite au lieu de multiplier chaque poids par son multiplicateur approprié on va chercher la valeur finale
; dans la table précalculée
            
            ; le poids0 est à ce stade à la valeur 0
            
            ; le poids5
            movlw    High ascii_poids5   
            movwf    TBLPTRH             ; adresse poid fort de la memoire a lire 
            movlw    Low ascii_poids5
            movwf    TBLPTRL             ; adresse poid faible a lire
            movf    coordZ+5,w
            mullw    3
            movf    PRODL,w
            addwf   TBLPTRL             
            tblrd*+                        ; on lit le poids fort et on le place dans valeur1+2
            movff    TABLAT,valeur2+2        
            tblrd*+                        ; on lit le poids fort et on le place dans valeur1+1
            movff    TABLAT,valeur2+1        
            tblrd*                        ; on lit le poids faible et on le place dans valeur1
            movff    TABLAT,valeur2
                        
            ; le poids4
            movlw    High ascii_poids4   
            movwf    TBLPTRH             ; adresse poid fort de la memoire a lire 
            movlw    Low ascii_poids4
            movwf    TBLPTRL             ; adresse poid faible a lire
            movf    coordZ+4,w
            mullw    3
            movf    PRODL,w
            addwf   TBLPTRL             
            tblrd*+                        ; on lit le poids fort et on le place dans valeur1+2
            movff    TABLAT,valeur1+2        
            tblrd*+                        ; on lit le poids fort et on le place dans valeur1+1
            movff    TABLAT,valeur1+1        
            tblrd*                        ; on lit le poids faible et on le place dans valeur1
            movff    TABLAT,valeur1
            call    addition24
            ; résultat dans valeur2+0,+1,+2
            
            ; le poids3
            movlw    High ascii_poids3   
            movwf    TBLPTRH             ; adresse poid fort de la memoire a lire 
            movlw    Low ascii_poids3
            movwf    TBLPTRL             ; adresse poid faible a lire
            movf    coordZ+3,w
            mullw    3
            movf    PRODL,w
            addwf   TBLPTRL             
            tblrd*+                        ; on lit le poids fort et on le place dans valeur1+2
            movff    TABLAT,valeur1+2        
            tblrd*+                        ; on lit le poids fort et on le place dans valeur1+1
            movff    TABLAT,valeur1+1        
            tblrd*                        ; on lit le poids faible et on le place dans valeur1
            movff    TABLAT,valeur1
            call    addition24
            ; résultat dans valeur2+0,+1,+2
            
            ; le poids2
            movlw    High ascii_poids2   
            movwf    TBLPTRH             ; adresse poid fort de la memoire a lire 
            movlw    Low ascii_poids2
            movwf    TBLPTRL             ; adresse poid faible a lire
            movf    coordZ+2,w
            mullw    3
            movf    PRODL,w
            addwf   TBLPTRL             
            tblrd*+                        ; on lit le poids fort et on le place dans valeur1+2
            movff    TABLAT,valeur1+2        
            tblrd*+                        ; on lit le poids fort et on le place dans valeur1+1
            movff    TABLAT,valeur1+1        
            tblrd*                        ; on lit le poids faible et on le place dans valeur1
            movff    TABLAT,valeur1
            call    addition24
            ; résultat dans valeur2+0,+1,+2
            
            ; le poids1
            movlw    High ascii_poids1   
            movwf    TBLPTRH             ; adresse poid fort de la memoire a lire 
            movlw    Low ascii_poids1
            movwf    TBLPTRL             ; adresse poid faible a lire
            movf    coordZ+1,w
            mullw    3
            movf    PRODL,w
            addwf   TBLPTRL             
            tblrd*+                        ; on lit le poids fort et on le place dans valeur1+2
            movff    TABLAT,valeur1+2        
            tblrd*+                        ; on lit le poids fort et on le place dans valeur1+1
            movff    TABLAT,valeur1+1        
            tblrd*                        ; on lit le poids faible et on le place dans valeur1
            movff    TABLAT,valeur1
            call    addition24
            ; résultat dans valeur2+0,+1,+2

            ; et enfin on additionne le poids 0 (0 à 9, forcément codé sur 1 octet) à tout çà pour obtenir le résultat final
            ; c'
est à dire (poids0*A*A*A*A*A*A) + (poids1*A*A*A*A*A) + (poids2*A*A*A*A) + (poids3*A*A*A) + (poids4*A*A) + (poids5*A) + poids6
            
on avait une valeur ascii de distance codée sur 7 octetson se retrouve avec une valeur hexa codée 
            
sur 3 octets utilisable dans le programme
            movff    coordZ
,valeur1
            clrf    valeur1
+1
            clrf    valeur1
+2
            call    addition24    
            
on obtient une valeur 24bits qu'on stocke dans coordX+6, coordX5 et coordX+4    
            movff    valeur2,coordZ
            movff    valeur2+1,coordZ+1
            movff    valeur2+2,coordZ+2
            nop
            clrf    coordZ+3
            clrf    coordZ+4
            clrf    coordZ+5
            clrf    coordZ+6
            nop
            return
            
; -----------------------------------------conversion décimal -> entier Z --------------------------------------
conversion_decimal_entierZ
            movff    coordZ+5,tampon        
            movff    coordZ,coordZ+5            
            movff    coordZ+1,coordZ+4
            movff    tampon,coordZ+1            
            movff    coordZ+6,coordZ                
            movff    coordZ+2,tampon            
            movff    coordZ+3,coordZ+2            
            movff    tampon,coordZ+3    
            clrf    coordZ+6
            return
            
; -----------------------------------------Sauvegarde coordonnées CoordZ dans Z old -----------------------------
sauvegarde_coordZ_old                
            movff    coordZ+0,coordZ_old+0
            movff    coordZ+1,coordZ_old+1
            movff    coordZ+2,coordZ_old+2
            return

; ----------------------------------------------- Calcul delta Z -------------------------------------------------
calcul_deltaZ
            ; comparaison octet HSB
            movf    coordZ_old+2,w
            subwf    coordZ+2,w
            bz        cz0                ; les deux nombres sont égaux, on passe à la comparaison de l'
octer MSB
            btfss    STATUS
,C        on saute si C=1    
            bra        coordZ_old_fort 
on branche si  Z=0 et C=0            
            bra        coordZ_fort        
on branche si Z=0 et C=1
            
comparaion octet MSB
cz0            movf    coordZ_old
+1,w
            subwf    coordZ
+1,w
            bz        cz1
            btfss    STATUS
,C        on saute si C=1
            bra        coordZ_old_fort    
on branche si  Z=0 et C=0
            bra        coordZ_fort        
on branche si Z=0 et C=1
            
comparaion octet LSB            
cz1            movf    coordZ_old
,w
            subwf    coordZ
,w
            bz        coordZ_fort
            btfss    STATUS
,C        on saute si C=1
            bra        coordZ_old_fort
            
coordZ_fort    
            remontée_Z
            movff    coordZ
,valeur1
            movff    coordZ
+1,valeur1+1
            movff    coordZ
+2,valeur1+2
            movff    coordZ_old
,valeur2
            movff    coordZ_old
+1,valeur2+1
            movff    coordZ_old
+2,valeur2+2
            call    soustraction24
            bra        stock_resultZ        
coordZ_old_fort
            plongée_Z
            movff    coordZ_old
,valeur1
            movff    coordZ_old
+1,valeur1+1
            movff    coordZ_old
+2,valeur1+2
            movff    coordZ
,valeur2
            movff    coordZ
+1,valeur2+1
            movff    coordZ
+2,valeur2+2
            call    soustraction24
stock_resultZ
            
Résultat sur 24bits dans valeur2valeur2+1 et valeur2+2
            
et on stocke le résultat dans deltaZ
            movff    valeur1
,deltaZ
            movff    valeur1
+1,deltaZ+1
            movff    valeur1
+2,deltaZ+2
fin_soustractZ
            
return


; ---------------------------------------------- 
Déplacements Z -------------------------------------------------------
deplaceZ    génère le nombre de pulses sur l'axe Z
            ; avant de générer les pulses on vérifie que le gcode n'
est pas terminé en scrutant le flag_fin_gcode
            movf    flag_fin_gcode
,w
            sublw    1
            btfsc    STATUS
,Z
              
return
            
movf    deltaZ,deltaZ
            bnz        suitez
            
return
            
suitez        movff    deltaZ,tampon0
            movff    deltaZ
+1,tampon0+1
boucleZ        
on avance de 1mm en Z
            call    Zpulses32
            movff    tampon0
,valeur1
            movff    tampon0
+1,valeur1+1
            movlw    1
            movwf    valeur2
            clrf    valeur2
+1
            call    soustraction16
            movff    valeur1
,tampon0
            movff    valeur1
+1,tampon0+1
            movf    tampon0
+1,tampon0+1
            bnz        boucleZ        
            movf    tampon0
,tampon0
            bnz        boucleZ
            
return

; ---------------------------------------------- 
Déplacements Z manuel fin ------------------------------------------------
descendZ_1centième
            plongée_Z    
            call    Zpulses32
            call    tempo_10s
            
return

descendZ_5centièmes
            plongée_Z    
            call    Zpulses64
            call    tempo_10s
            
return
            
descendZ_1dixième
            plongée_Z    
            call    Zpulses320
            call    tempo_10s
            
return

monteZ_1centième
            remontée_Z    
            call    Zpulses32
            call    tempo_10s
            
return

monteZ_5centièmes
            remontée_Z    
            call    Zpulses64
            call    tempo_10s
            
return
            
monteZ_1dixième
            remontée_Z    
            call    Zpulses320
            call    tempo_10s
            
return

; ---------------------------------------------- 
Génération des pulses Z 1/16e de pas-------------------------------------------------------
Zpulses3200    1mm en 1/16pas (1/3200=mm)
            
movlw    d'40'
            
movwf    tamponA
Z3200        movlw    d
'80'
            
movwf    tamponB
Zm3200        call    Zpulse_base
            decf    tamponB
            bz        Zfin3200
            bra        Zm3200
Zfin3200    decf    tamponA
            bnz        Z3200
            
return

; --------------------------------
Zpulses320    1/10e mm en 1/16pas (1/3200=mm)
            
movlw    d'2'
            
movwf    tamponA
Z320        movlw    d
'160'
            
movwf    tamponB
Zm320        call    Zpulse_base
            decf    tamponB
            bz        Zfin320
            bra        Zm320
Zfin320        decf    tamponA
            bnz        Z320
            
return

; --------------------------------
Zpulses64    ;  5/100e mm en 1/16 pas
            movlw    d
'64'
            
movwf    tamponB
Zm64        call    Zpulse_base
            decf    tamponB
            bz        Zfin64
            bra        Zm64
Zfin64        
return


; --------------------------------
Zpulses32    1/100e mm en 1/16 pas    
            movlw    d
'32'
            
movwf    tamponB
Zm32        call    Zpulse_base
            decf    tamponB
            bz        Zfin32
            bra        Zm32
Zfin32        
return


; --------------------------------
Zpulse_base    ;  pas de base     
            bsf        drv_stepZ
            call     tempoH_18khz
            bcf        drv_stepZ
            call     tempoL_18khz
            
return
            
; ------------------------------------------------- 
JOG Z ------------------------------------------------------------------
            ; 
ici on va vérifier si on est en limite mini
            
on décrémente translatX à chaque mm parcouru
            
on effectue la soustraction limite translatZ-0tant que translatz est supérieur à zéro on jog
            
sinon c'est qu'on est arrivé au mini et on sort
zmoins        plongée_Z                        
descente
            clrf    tampon3
            movf    translatZ
,w                                
            subwf    tampon3
,w                        
            bn        moinsz                    
si négatif on peut aller jogger
            
return                            ; sinon on sort
moinsz        btfsc    btn_jog_Zmoins    
            
return
            
call    Zpulses3200
            decf    translatZ
            
return
                                    
zplus        ici on va vérifier si on est en limite maxi
            
on soustrait d'30' (limit maxià translatZ 
            
si négatif on continue le jog
            
on sort si la soustraction est égale à zéro 
            remontée_Z                        
montée
            movlw    limite_maxiZ            
on charge d'130' (limite maxidans W                            
            subwf    translatZ
,w                qu'on soustrait à translatZ                    
            bn        plusz                    ; si négatif on va jogger
            bnz        plusz                    ; et on sort si la soustraction est égale à zéro, donc qu'
on est arrivé en limite maxi    
            
return                    
plusz        btfsc    btn_jog_Zplus    
            
return
            
call    Zpulses3200
            incf    translatZ
            
return
                        
; ------------------------------------------------- 
POM Z ------------------------------------------------------------------
pomz        remontée_Z                        on passe en marche arrière (montée), le capteur d'origine étant situé en haut du Z
            call    Zpulse_base    
            btfsc    capteur_pomZ
            bra        pomz
            ; POM faite, petit jog jusqu'
à la limite maxi qui a été définie par essais
            call    tempo                    
juste pour marquer l'arret entre la pom et la mise en place
            ;movlw    d'
14'
            movlw    offset_pomZ
            movwf    tampon0
pomza        call    Zpulses3200
            decf    tampon0
            bnz        pomza
            bsf        led_pomZ
            movlw    limite_maxiZ
            movwf    translatZ                ; initialisation axe Z à limit maxi
            plongée_Z                        ; descente
            return
            
; ------------------------------------------------- POP Z ------------------------------------------------------------------
popZ        nop
            movff    translatZ,val_popZ
            bsf        led_popZ
            return

            
;############################################################################################################################
;#                                                                                                                            #
;#                                                                                                                            #
;#                                                    GESTION AXE X                                                            #
;#                                                                                                                            #
;#                                                                                                                            #
;############################################################################################################################


; ------------------------------------------- Conversion ASCII/hexa X ---------------------------------------------------------
conversion_ascii_hexaX
; on commence par transformer chaque poids en décimal en soustrayant 0x30
            movlw    0x30
            subwf    coordX
            subwf    coordX+1
            subwf    coordX+2
            subwf    coordX+3
            subwf    coordX+4
            subwf    coordX+5

; ensuite au lieu de multiplier chaque poids par son multiplicateur approprié on va chercher la valeur finale
; dans la table précalculée
            
            ; le poids0 est à ce stade à la valeur 0
            
            ; le poids5
            movlw    High ascii_poids5  
            movwf    TBLPTRH             ; adresse poid fort de la memoire a lire 
            movlw    Low ascii_poids5
            movwf    TBLPTRL             ; adresse poid faible a lire
            movf    coordX+5,w
            mullw    3
            movf    PRODL,w
            addwf   TBLPTRL             
            tblrd*+                        ; on lit le poids fort et on le place dans valeur1+2
            movff    TABLAT,valeur2+2        
            tblrd*+                        ; on lit le poids fort et on le place dans valeur1+1
            movff    TABLAT,valeur2+1        
            tblrd*                        ; on lit le poids faible et on le place dans valeur1
            movff    TABLAT,valeur2
                        
            ; le poids4
            movlw    High ascii_poids4   
            movwf    TBLPTRH             ; adresse poid fort de la memoire a lire 
            movlw    Low ascii_poids4
            movwf    TBLPTRL             ; adresse poid faible a lire
            movf    coordX+4,w
            mullw    3
            movf    PRODL,w
            addwf   TBLPTRL             
            tblrd*+                        ; on lit le poids fort et on le place dans valeur1+2
            movff    TABLAT,valeur1+2        
            tblrd*+                        ; on lit le poids fort et on le place dans valeur1+1
            movff    TABLAT,valeur1+1        
            tblrd*                        ; on lit le poids faible et on le place dans valeur1
            movff    TABLAT,valeur1
            call    addition24
            ; résultat dans valeur2+0,+1,+2
            
            ; le poids3
            movlw    High ascii_poids3   
            movwf    TBLPTRH             ; adresse poid fort de la memoire a lire 
            movlw    Low ascii_poids3
            movwf    TBLPTRL             ; adresse poid faible a lire
            movf    coordX+3,w
            mullw    3
            movf    PRODL,w
            addwf   TBLPTRL             
            tblrd*+                        ; on lit le poids fort et on le place dans valeur1+2
            movff    TABLAT,valeur1+2        
            tblrd*+                        ; on lit le poids fort et on le place dans valeur1+1
            movff    TABLAT,valeur1+1        
            tblrd*                        ; on lit le poids faible et on le place dans valeur1
            movff    TABLAT,valeur1
            call    addition24
            ; résultat dans valeur2+0,+1,+2
            
            ; le poids2
            movlw    High ascii_poids2   
            movwf    TBLPTRH             ; adresse poid fort de la memoire a lire 
            movlw    Low ascii_poids2
            movwf    TBLPTRL             ; adresse poid faible a lire
            movf    coordX+2,w
            mullw    3
            movf    PRODL,w
            addwf   TBLPTRL             
            tblrd*+                        ; on lit le poids fort et on le place dans valeur1+2
            movff    TABLAT,valeur1+2        
            tblrd*+                        ; on lit le poids fort et on le place dans valeur1+1
            movff    TABLAT,valeur1+1        
            tblrd*                        ; on lit le poids faible et on le place dans valeur1
            movff    TABLAT,valeur1
            call    addition24
            ; résultat dans valeur2+0,+1,+2
            
            ; le poids1
            movlw    High ascii_poids1   
            movwf    TBLPTRH             ; adresse poid fort de la memoire a lire 
            movlw    Low ascii_poids1
            movwf    TBLPTRL             ; adresse poid faible a lire
            movf    coordX+1,w
            mullw    3
            movf    PRODL,w
            addwf   TBLPTRL             
            tblrd*+                        ; on lit le poids fort et on le place dans valeur1+2
            movff    TABLAT,valeur1+2        
            tblrd*+                        ; on lit le poids fort et on le place dans valeur1+1
            movff    TABLAT,valeur1+1        
            tblrd*                        ; on lit le poids faible et on le place dans valeur1
            movff    TABLAT,valeur1
            call    addition24
            ; résultat dans valeur2+0,+1,+2

            ; et enfin on additionne le poids 0 (0 à 9, forcément codé sur 1 octet) à tout çà pour obtenir le résultat final
            ; c'
est à dire (poids0*A*A*A*A*A*A) + (poids1*A*A*A*A*A) + (poids2*A*A*A*A) + (poids3*A*A*A) + (poids4*A*A) + (poids5*A) + poids6
            
on avait une valeur ascii de distance codée sur 7 octetson se retrouve avec une valeur hexa codée 
            
sur 3 octets utilisable dans le programme
            movff    coordX
,valeur1
            clrf    valeur1
+1
            clrf    valeur1
+2
            call    addition24    
            
on obtient une valeur 24bits qu'on stocke dans coordX+6, coordX5 et coordX+4    
            movff    valeur2,coordX
            movff    valeur2+1,coordX+1
            movff    valeur2+2,coordX+2
            nop
            clrf    coordX+3
            clrf    coordX+4
            clrf    coordX+5
            clrf    coordX+6
            nop
            return
            
; -----------------------------------------conversion décimal -> entier X --------------------------------------
conversion_decimal_entierX
; on reçoit les données en inversé par l'
UART,
on réarrange les données en les inversant et en faisant sauter la virgule pour multiplier par 100
            movff    coordX
+5,tampon        
            movff    coordX
,coordX+5            
            movff    coordX
+1,coordX+4
            movff    tampon
,coordX+1            
            movff    coordX
+6,coordX                
            movff    coordX
+2,tampon            
            movff    coordX
+3,coordX+2            
            movff    tampon
,coordX+3    
            clrf    coordX
+6
            
return

; -----------------------------------------
Sauvegarde coordonnées CoordX dans X old -----------------------------
sauvegarde_coordX_old                
            movff    coordX
+0,coordX_old+0
            movff    coordX
+1,coordX_old+1
            movff    coordX
+2,coordX_old+2
            
return

; ---------------------------------------------- 
Génération des pulses X 1/16e de pas-----------------------------
Xpulses3200    1mm en 1/16pas (1/3200=mm)
            
movlw    d'40'
            
movwf    tamponA
X3200        movlw    d
'80'
            
movwf    tamponB
Xm3200        call    Xpulse_base
            decf    tamponB
            bz        Xfin3200
            bra        Xm3200
Xfin3200    decf    tamponA
            bnz        X3200
            
return

; --------------------------------
Xpulses1600    0,5mm en 1/16pas (1/3200=mm)
            
movlw    d'20'
            
movwf    tamponA
X1600        movlw    d
'80'
            
movwf    tamponB
Xm1600        call    Xpulse_base
            decf    tamponB
            bz        Xfin1600
            bra        Xm1600
Xfin1600    decf    tamponA
            bnz        X1600
            
return

; --------------------------------
Xpulses320    1/10e mm en 1/16pas (1/3200=mm)
            
movlw    d'2'
            
movwf    tamponA
X320        movlw    d
'160'
            
movwf    tamponB
Xm320        call    Xpulse_base
            decf    tamponB
            bz        Xfin320
            bra        Xm320
Xfin320        decf    tamponA
            bnz        X320
            
return

; --------------------------------
Xpulses64    ;  5/100e mm en 1/16 pas
            movlw    d
'64'
            
movwf    tamponB
Xm64        call    Xpulse_base
            decf    tamponB
            bz        Xfin64
            bra        Xm64
Xfin64        
return

; --------------------------------
Xpulses32    1/100e mm en 1/16 pas    
            movlw    d
'32'
            
movwf    tamponB
Xm32        call    Xpulse_base
            decf    tamponB
            bz        Xfin32
            bra        Xm32
Xfin32        
return


; --------------------------------
Xpulse_base    ;  pas de base     1/3200=0,00031mm 0,
            bsf        drv_stepX
            call     tempoH_18khz
            bcf        drv_stepX
            call     tempoL_18khz
            
return

; ----------------------------------------------- 
Calcul delta X -------------------------------------------------
calcul_deltaX
            
comparaison octet HSB
            movf    coordX_old
+2,w
            subwf    coordX
+2,w
            bz        cx0                
les deux nombres sont égauxon passe à la comparaison de l'octer MSB
            btfss    STATUS,C        ; on saute si C=1    
            bra        coordX_old_fort ; on branche si  Z=0 et C=0            
            bra        coordX_fort        ; on branche si Z=0 et C=1
            ; comparaion octet MSB
cx0            movf    coordX_old+1,w
            subwf    coordX+1,w
            bz        cx1
            btfss    STATUS,C        ; on saute si C=1
            bra        coordX_old_fort    ; on branche si  Z=0 et C=0
            bra        coordX_fort        ; on branche si Z=0 et C=1
            ; comparaion octet LSB            
cx1            movf    coordX_old,w
            subwf    coordX,w
            bz        coordX_fort
            btfss    STATUS,C        ; on saute si C=1
            bra        coordX_old_fort
            
            
coordX_fort    marche_av_X
            movff    coordX,valeur1
            movff    coordX+1,valeur1+1
            movff    coordX+2,valeur1+2
            movff    coordX_old,valeur2
            movff    coordX_old+1,valeur2+1
            movff    coordX_old+2,valeur2+2
            call    soustraction24
            bra        stock_resultX        
coordX_old_fort
            marche_ar_X
            movff    coordX_old,valeur1
            movff    coordX_old+1,valeur1+1
            movff    coordX_old+2,valeur1+2
            movff    coordX,valeur2
            movff    coordX+1,valeur2+1
            movff    coordX+2,valeur2+2
            call    soustraction24
stock_resultX
            ; Résultat sur 24bits dans valeur2, valeur2+1 et valeur2+2
            ; et on stocke le résultat dans deltaZ
            movff    valeur1+0,deltaX+0
            movff    valeur1+1,deltaX+1
            movff    valeur1+2,deltaX+2
fin_soustractX
            return

; ------------------------------------------------- JOG X ------------------------------------------------------------------
            ; ici on va vérifier si on est en limite mini
            ; on décrémente translatX à chaque mm parcouru
            ; on effectue la soustraction 0-translatX, tant que translatX est supérieur à zéro on jog
            ; sinon c'
est qu'on est arrivé à zéro et on sort
xmoins        marche_ar_X                ; on passe en marche arrière, le capteur d'
origine étant situé à gauche du X
            clrf    tampon3
            movf    translatX
,w                                
            subwf    tampon3
,w        on vérifie si translatX est à zéro                
            bn        moinsx            
si négatif on peut aller jogger
            
return                    ; sinon on sort
            
c'est négatif donc on jog                
moinsx        btfsc    btn_jog_Xmoins    
            return
            call    Xpulses3200
            decf    translatX
            return
                                    
xplus        ; ici on va vérifier si on est en limite maxi
            ; on soustrait d'
130' (limit maxi) à translatX 
            ; si négatif on continue le jog
            ; on sort si la soustraction est égale à zéro 
            marche_av_X                ; jog en avant
            movlw    limite_maxiX    ; on charge d'
130' (limite maxi) dans W                            
            subwf    translatX,w        ; qu'
on soustrait à translatX                    
            bn        plusx            
si négatif on va jogger
            bnz        plusx            
et on sort si la soustraction est égale à zérodonc qu'on est arrivé en limite maxi    
            return                    
plusx        btfsc    btn_jog_Xplus    
            return
            call    Xpulses3200
            incf    translatX
            return

; ------------------------------------------------- POM X ------------------------------------------------------------------
pomx        marche_ar_X                                ; on passe en marche arrière, le capteur d'
origine étant situé à gauche du X
            call    Xpulse_base    
            btfsc    capteur_pomX
            bra        pomx
            
POM faitepetit jog jusqu'à la limite mini qui a été définie par essais
            call    tempo                            ; juste pour marquer l'
arret entre la pom et la mise en place
            movlw    offset_pomX
            movwf    tampon0
pomxa        call    Xpulses3200
            decf    tampon0
            bnz        pomxa
            bsf        led_pomX        
            clrf    translatX                        
initialisation axe X à zéro
            marche_av_X                                
on vient de faire la POM donc on force la translation en avant
            
;bsf        drv_dirX
            
return

; ------------------------------------------------- 
POP X ------------------------------------------------------------------
popX        nop
            movff    translatX
,val_popX
            bsf        led_popX
            
return
            

;
############################################################################################################################
;#                                                                                                                            #
;#                                                                                                                            #
;#                                                    GESTION AXE Y                                                            #
;#                                                                                                                            #
;#                                                                                                                            #
;############################################################################################################################


; ------------------------------------------- Conversion ASCII/hexa Y ---------------------------------------------------------        
conversion_ascii_hexaY
on commence par transformer chaque poids en décimal en soustrayant 0x30
            movlw    0x30
            subwf    coordY
            subwf    coordY
+1
            subwf    coordY
+2
            subwf    coordY
+3
            subwf    coordY
+4
            subwf    coordY
+5

ensuite au lieu de multiplier chaque poids par son multiplicateur approprié on va chercher la valeur finale
dans la table précalculée
            
            
le poids0 est à ce stade à la valeur 0
            
            
le poids5
            movlw    High ascii_poids5   
            movwf    TBLPTRH             
adresse poid fort de la memoire a lire 
            movlw    Low ascii_poids5
            movwf    TBLPTRL             
adresse poid faible a lire
            movf    coordY
+5,w
            mullw    3
            movf    PRODL
,w
            addwf   TBLPTRL             
            tblrd
*+                        ; on lit le poids fort et on le place dans valeur1+2
            movff    TABLAT
,valeur2+2        
            tblrd
*+                        ; on lit le poids fort et on le place dans valeur1+1
            movff    TABLAT
,valeur2+1        
            tblrd
*                        ; on lit le poids faible et on le place dans valeur1
            movff    TABLAT
,valeur2
                        
            
le poids4
            movlw    High ascii_poids4   
            movwf    TBLPTRH             
adresse poid fort de la memoire a lire 
            movlw    Low ascii_poids4
            movwf    TBLPTRL             
adresse poid faible a lire
            movf    coordY
+4,w
            mullw    3
            movf    PRODL
,w
            addwf   TBLPTRL             
            tblrd
*+                        ; on lit le poids fort et on le place dans valeur1+2
            movff    TABLAT
,valeur1+2        
            tblrd
*+                        ; on lit le poids fort et on le place dans valeur1+1
            movff    TABLAT
,valeur1+1        
            tblrd
*                        ; on lit le poids faible et on le place dans valeur1
            movff    TABLAT
,valeur1
            call    addition24
            
résultat dans valeur2+0,+1,+2
            
            
le poids3
            movlw    High ascii_poids3   
            movwf    TBLPTRH             
adresse poid fort de la memoire a lire 
            movlw    Low ascii_poids3
            movwf    TBLPTRL             
adresse poid faible a lire
            movf    coordY
+3,w
            mullw    3
            movf    PRODL
,w
            addwf   TBLPTRL             
            tblrd
*+                        ; on lit le poids fort et on le place dans valeur1+2
            movff    TABLAT
,valeur1+2        
            tblrd
*+                        ; on lit le poids fort et on le place dans valeur1+1
            movff    TABLAT
,valeur1+1        
            tblrd
*                        ; on lit le poids faible et on le place dans valeur1
            movff    TABLAT
,valeur1
            call    addition24
            
résultat dans valeur2+0,+1,+2
            
            
le poids2
            movlw    High ascii_poids2   
            movwf    TBLPTRH             
adresse poid fort de la memoire a lire 
            movlw    Low ascii_poids2
            movwf    TBLPTRL             
adresse poid faible a lire
            movf    coordY
+2,w
            mullw    3
            movf    PRODL
,w
            addwf   TBLPTRL             
            tblrd
*+                        ; on lit le poids fort et on le place dans valeur1+2
            movff    TABLAT
,valeur1+2        
            tblrd
*+                        ; on lit le poids fort et on le place dans valeur1+1
            movff    TABLAT
,valeur1+1        
            tblrd
*                        ; on lit le poids faible et on le place dans valeur1
            movff    TABLAT
,valeur1
            call    addition24
            
résultat dans valeur2+0,+1,+2
            
            
le poids1
            movlw    High ascii_poids1   
            movwf    TBLPTRH             
adresse poid fort de la memoire a lire 
            movlw    Low ascii_poids1
            movwf    TBLPTRL             
adresse poid faible a lire
            movf    coordY
+1,w
            mullw    3
            movf    PRODL
,w
            addwf   TBLPTRL             
            tblrd
*+                        ; on lit le poids fort et on le place dans valeur1+2
            movff    TABLAT
,valeur1+2        
            tblrd
*+                        ; on lit le poids fort et on le place dans valeur1+1
            movff    TABLAT
,valeur1+1        
            tblrd
*                        ; on lit le poids faible et on le place dans valeur1
            movff    TABLAT
,valeur1
            call    addition24
            
résultat dans valeur2+0,+1,+2

            
et enfin on additionne le poids 0 (0 à 9forcément codé sur 1 octetà tout çà pour obtenir le résultat final
            ; 
c'est à dire (poids0*A*A*A*A*A*A) + (poids1*A*A*A*A*A) + (poids2*A*A*A*A) + (poids3*A*A*A) + (poids4*A*A) + (poids5*A) + poids6
            ; on avait une valeur ascii de distance codée sur 7 octets, on se retrouve avec une valeur hexa codée 
            ; sur 3 octets utilisable dans le programme
            movff    coordY,valeur1
            clrf    valeur1+1
            clrf    valeur1+2
            call    addition24    
            ; on obtient une valeur 24bits qu'
on stocke dans coordX+6coordX5 et coordX+4    
            movff    valeur2
,coordY
            movff    valeur2
+1,coordY+1
            movff    valeur2
+2,coordY+2
            nop
            clrf    coordY
+3
            clrf    coordY
+4
            clrf    coordY
+5
            clrf    coordY
+6
            nop
            
return
        
; -----------------------------------------
conversion décimal -> entier Y --------------------------------------
conversion_decimal_entierY
            movff    coordY
+5,tampon        
            movff    coordY
,coordY+5            
            movff    coordY
+1,coordY+4
            movff    tampon
,coordY+1            
            movff    coordY
+6,coordY                
            movff    coordY
+2,tampon            
            movff    coordY
+3,coordY+2            
            movff    tampon
,coordY+3    
            clrf    coordY
+6
            
return

; -----------------------------------------
Sauvegarde coordonnées CoordY dans Y old -----------------------------
sauvegarde_coordY_old                
            movff    coordY
+0,coordY_old+0
            movff    coordY
+1,coordY_old+1
            movff    coordY
+2,coordY_old+2
            
return

; ---------------------------------------------- 
Génération des pulses Y 1/16e de pas ----------------------------
Ypulses3200    1mm en 1/16pas (1/3200=mm)
            
movlw    d'40'
            
movwf    tamponA
Y3200        movlw    d
'80'
            
movwf    tamponB
Ym3200        call    Ypulse_base
            decf    tamponB
            bz        Yfin3200
            bra        Ym3200
Yfin3200    decf    tamponA
            bnz        Y3200
            
return

; --------------------------------
Ypulses320    1/10e mm en 1/16pas (1/3200=mm)
            
movlw    d'2'
            
movwf    tamponA
Y320        movlw    d
'160'
            
movwf    tamponB
Ym320        call    Ypulse_base
            decf    tamponB
            bz        Yfin320
            bra        Ym320
Yfin320        decf    tamponA
            bnz        Y320
            
return

; --------------------------------
Ypulses64    ;  5/100e mm en 1/16 pas
            movlw    d
'64'
            
movwf    tamponB
Ym64        call    Ypulse_base
            decf    tamponB
            bz        Yfin64
            bra        Ym64
Yfin64        
return


; --------------------------------
Ypulses32    1/100e mm en 1/16 pas    
            movlw    d
'32'
            
movwf    tamponB
Ym32        call    Ypulse_base
            decf    tamponB
            bz        Yfin32
            bra        Ym32
Yfin32        
return


; --------------------------------
Ypulse_base    ;  pas de base     
            bsf        drv_stepY
            call     tempoH_18khz
            bcf        drv_stepY
            call     tempoL_18khz
            
return

; ------------------------------------------------- 
JOG Y -------------------------------------------------------
ymoins        marche_ar_Y        jog en arrière
            clrf    tampon3
            movf    translatY
,w                                
            subwf    tampon3
,w                        
            bn        moinsy            
si négatif on peut aller jogger
            
return                    ; sinon on sort
moinsy        btfsc    btn_jog_Ymoins    
            
return
            
call    Ypulses3200
            decf    translatY
            
return
                                    
yplus        marche_av_Y        jog en avant
            movlw    limite_maxiY    
on charge d'130' (limite maxidans W                            
            subwf    translatY
,w        qu'on soustrait à translatX                    
            bn        plusy            ; si négatif on va jogger
            bnz        plusy            ; et on sort si la soustraction est égale à zéro, donc qu'
on est arrivé en limite maxi    
            
return                    
plusy        btfsc    btn_jog_Yplus    
            
return
            
call    Ypulses3200
            incf    translatY
            
return

; ----------------------------------------------- 
Calcul delta Y ------------------------------------------------
calcul_deltaY
            
comparaison octet HSB
            movf    coordY_old
+2,w
            subwf    coordY
+2,w
            bz        cy0                
les deux nombres sont égauxon passe à la comparaison de l'octer MSB
            btfss    STATUS,C        ; on saute si C=1    
            bra        coordY_old_fort ; on branche si  Z=0 et C=0            
            bra        coordY_fort        ; on branche si Z=0 et C=1
            ; comparaion octet MSB
cy0            movf    coordY_old+1,w
            subwf    coordY+1,w
            bz        cy1
            btfss    STATUS,C        ; on saute si C=1
            bra        coordY_old_fort    ; on branche si  Z=0 et C=0
            bra        coordY_fort        ; on branche si Z=0 et C=1
            ; comparaion octet LSB            
cy1            movf    coordY_old,w
            subwf    coordY,w
            bz        coordY_fort
            btfss    STATUS,C        ; on saute si C=1
            bra        coordY_old_fort
            
coordY_fort    marche_av_Y
            movff    coordY,valeur1
            movff    coordY+1,valeur1+1
            movff    coordY+2,valeur1+2
            movff    coordY_old,valeur2
            movff    coordY_old+1,valeur2+1
            movff    coordY_old+2,valeur2+2
            call    soustraction24
            bra        stock_resultY        
coordY_old_fort
            marche_ar_Y
            movff    coordY_old,valeur1
            movff    coordY_old+1,valeur1+1
            movff    coordY_old+2,valeur1+2
            movff    coordY,valeur2
            movff    coordY+1,valeur2+1
            movff    coordY+2,valeur2+2
            call    soustraction24
stock_resultY
            ; Résultat sur 24bits dans valeur2, valeur2+1 et valeur2+2
            ; et on stocke le résultat dans deltaZ
            movff    valeur1+0,deltaY+0
            movff    valeur1+1,deltaY+1
            movff    valeur1+2,deltaY+2
fin_soustractY
            return

; ------------------------------------------------- POM Y ---------------------------------------------------------
pomy        marche_ar_Y                                ; on passe en marche arrière, le capteur d'
origine étant situé à gauche du Y
            call    Ypulse_base    
            btfsc    capteur_pomY
            bra        pomy
            
POM faitepetit jog jusqu'à la limite mini qui a été définie par essais
            call    tempo                            ; juste pour marquer l'
arret entre la pom et la mise en place
            movlw    offset_pomY                            
pour aller se positionner au maxi après le capteur
            movwf    tampon0
pomya        call    Ypulses3200
            decf    tampon0
            bnz        pomya
            bsf        led_pomY
            clrf    translatY                        
initialisation axe Y à zéro
            marche_av_Y    
            
return
            
; ------------------------------------------------- 
POP Y ----------------------------------------------------------            
popY        nop
            movff    translatY
,val_popY
            bsf        led_popY
            
return
            
Une porte nand prend 2 bits en entrée... cochonne va !!! :langue:

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

#426 Message par F6FCO » ven. 31 mai 2019 14:26

Deuxième partie, il suffit de les concaténer dans MPLab:

[code=php][/code]

:furieux: Bon, le forum n'accepte pas la seconde partie du programme, je réessaierai plus tard.

PS: re-essayé plus tard et çà ne veut toujours pas, je met le programme entier en pièce jointe.

4L1C3 prog.txt
Vous n’avez pas les permissions nécessaires pour voir les fichiers joints à ce message.
Une porte nand prend 2 bits en entrée... cochonne va !!! :langue:

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

#427 Message par Temps-x » ven. 31 mai 2019 15:13

Bonjour F6FCO, JJE, et tout le forum,

J'ai lu une grande partie de ton code, et je savais pas que tu avais apprit à 4L1C3 à chanter.

Pour de l’assembleur tu n'as pas usiné sur la place, ben, si ça fonction bien c'est le principal. :wink:

==> A+
:roll: Les requins, c'est comme le langage ASM, c'est le sommet de la chaîne alimentaire. :wink:

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

#428 Message par venom » ven. 31 mai 2019 15:24

Chapeau pour le code :shock: Même si je n'y comprend rien a l'assembleur, je vois par la longueur et les vidéos d'4l1c3, qu'il y a eu du taf. :bravo:






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

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

#429 Message par F6FCO » dim. 2 juin 2019 15:21

Temps-x a écrit : je savais pas que tu avais apprit à 4L1C3 à chanter.

Alors c'est parce que tu n'as pas regardé la vidéo du post #394 jusqu'au bout :wink:

@Venom,
ben oui, pas mal de taf qui m'a bien occupé tout l'hiver, mais bon disons-le de suite: le fait de ne pas avoir d'atelier de bricolage pour l'instant m'a bien aidé à tenir le coup, je n'avais que ce projet pour m'occuper donc bien obligé de m'y tenir :-D .

Mais si le programme peut paraître rébarbatif de par sa longueur il se résume à un algoritme très simple et facile à comprendre:

al63.jpg
Vous n’avez pas les permissions nécessaires pour voir les fichiers joints à ce message.
Une porte nand prend 2 bits en entrée... cochonne va !!! :langue:

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

#430 Message par Temps-x » dim. 2 juin 2019 16:36

Bonjour F6FCO, JJE, et tout le forum,

F6FCO a écrit :Source du message Alors c'est parce que tu n'as pas regardé la vidéo du post #394 jusqu'au bout :wink:


Si j'ai regardé la vidéo jusqu'au bout, mais quand j'allume mon ordinateur, mes hauts parleurs ne sont pas en fonction.

Il faut que je le fasse manuellement, ce qui fait que la plupart du temps, je suis sans son, j'éteins toujours les périphériques qui ne servent à rien.

C'est en regardant le code que je m'en suis aperçu :wink:

Bonne continuation

==> A+
:roll: Les requins, c'est comme le langage ASM, c'est le sommet de la chaîne alimentaire. :wink:


Retourner vers « Langage ASM »

Qui est en ligne

Utilisateurs parcourant ce forum : Aucun utilisateur enregistré et 1 invité