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
paulfjujo
Avatar de l’utilisateur
Expert
Expert
Messages : 1084
Âge : 68
Enregistré en : juillet 2015
Localisation : 01800
Contact :

#211 Message par paulfjujo » ven. 12 oct. 2018 14:56

bonjour à tous,


Temps-x a écrit : humour!! : :eek: JMarc mets du pluriel sur les Datas :lol:



:sifflotte: il n'a pas tord


Le terme « data » signifie en anglais « données ».
Du latin data (« choses données (au pluriel) »)

meme mon fils m'a remonté les bretelles quand je met un directory \datas
mais comme un bon français n'ayant pas fait de latin, je continue à mettre aussi un S
On est Gaulois ! pas Romain.

Soft de commande CNC en asm
satinas
Passioné
Passioné
Messages : 314
Enregistré en : novembre 2015

#212 Message par satinas » ven. 12 oct. 2018 15:11

Bonjour
L'adressage indirect sur le 18F :

si octet en RAM (et pas ailleurs), placer son adresse 12 bits dans FSRH et FSR0L, ou dans FSR0 avec l'instruction lfsr.
Pour lire/écrire cet octet, utiliser les registres INDF0 ou POSTINC0 ou POSTDEC0 (voir aussi PREINC0, PLUSW0)
Même principe pour FSR1 ou FSR2.

Si octet en FLASH (et pas ailleurs), placer son adresse 21 bits dans TBLPTRU et TBLPTRH et TBLPTRL.
Pour lire cet octet, utiliser l'instruction TBLRD* (ou TBLRD*+, TBLRD*-, ...) qui le copie vers le registre TABLAT.
Pour écrire cet octet, écrire d'abord la nouvelle valeur dans le registre TABLAT, puis utiliser l'instruction TBLWT* (ou TBLWT*+, TBLWT*-, ...) qui copie TABLAT vers la flash.
Voir le code de JMarc

Ne pas oublier le "retfie 1" si tu utilises la sauvegarde auto des registres.

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

#213 Message par F6FCO » ven. 12 oct. 2018 17:12

Ben voilà une explication qu'elle est claire :-) .Je comprends mieux maintenant, j'y perdais mon latin et j'ai mis un 's' à data .
Du coup j'ai appris plein de trucs mystérieux pour moi:
- les dt par Temps-X
- FSR que j'avais déjà utilisé correctement par coup de pot.
- Tablat que j'ai utilisé dans ma routine de conversion ascii/hexa sur 32bits après l'intervention de JMarc.
Un grand merci à Satinas, Temps-X et JMarc, que deviendrais-je sans vous.

A force on va bien finir par faire quelque chose du jeune F6FCO.
Une porte nand prend 2 bits en entrée... cochonne va !!!

Soft de commande CNC en asm
JMarc
Confirmé
Confirmé
Messages : 517
Enregistré en : août 2016
Localisation : Dans le Sud...

#214 Message par JMarc » ven. 12 oct. 2018 20:35

Bonjour à tous


paulfjujo a écrit :bonjour à tous,


Temps-x a écrit : humour!! : :eek: JMarc mets du pluriel sur les Datas :lol:



:sifflotte: il n'a pas tord


Le terme « data » signifie en anglais « données ».
Du latin data (« choses données (au pluriel) »)

meme mon fils m'a remonté les bretelles quand je met un directory \datas
mais comme un bon français n'ayant pas fait de latin, je continue à mettre aussi un S
On est Gaulois ! pas Romain.



Heu...moi j’y suis pour rien :sifflotte: , c’est le fichier de F6FCO

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

#215 Message par Temps-x » ven. 12 oct. 2018 21:21

Bonsoir JMarc, F6FCO, satinas, paulfjujo, et tous le forum,

Ce que je veux dire, c'est dans l'assembleur il existe une directive DATA, sans S
______________________________________________________________________________________________________

data :

data "texte","texte",..

Utilisé pour une écriture dans la mémoire programme

______________________________________________________________________________________________________

Est l'utilisé comme étiquette en rajoutant un S, c'est un risque d'erreur.


JMarc a écrit :Source du message Heu...moi j’y suis pour rien :sifflotte: , c’est le fichier de F6FCO


humour!! JMarc fallait pas copier F6FCO, comme tu peux te rends de compte ci-dessous.

F6FCO a écrit :Source du message A force on va bien finir par faire quelque chose du jeune F6FCO.


humour!! F6FCO nous fait toujours des choses incroyable



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

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

#216 Message par F6FCO » mer. 17 oct. 2018 19:35

Hello,
Des nouvelles du projet 4L1C3. J'avais atteint les 1032 lignes d'assembleur et j'ai eu un bug bizarre et indécelable: une boucle imbriquée qui fonctionne bien en fichier externe ne voulait plus marcher dés que je dépassais les 40 itérations, elle fonctionnait bien en pas à pas mais partait en boucle sans fin en fonctionnement normal, le truc qui énerve bien. En plus elle m'effaçait des variables qui n'avaient rien à voir avec elle. Bref, j'y suis resté une semaine dessus et au final çà a fini par me gonfler. J'ai fais une RAZ et j'ai recommencé le projet 4L1C3_new en ne gardant que le fichier de base et les interruptions UART.
Une bonne chose, ce soir par exemple j'ai recodé la routine de conversion ASCII sur 4 octets en hexa 2 octets en 1h et proprement alors que j'avais mis deux jours à la mettre au point en bidouillant.
Maintenant que je sais exactement ou je vais, je vais refaire tout le travail au propre.
Voilà voilà...
Une porte nand prend 2 bits en entrée... cochonne va !!!

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

#217 Message par Temps-x » mer. 17 oct. 2018 20:04

Bonsoir F6FCO, et tout le forum,

F6FCO a écrit :Source du message J'avais atteint les 1032 lignes d'assembleur et j'ai eu un bug bizarre et indécelable


Dans ce cas, il ne faut plus utiliser un Bra qui est codé en 16 bits, mais un GOTO qui est codé en 32 bits pour le Pic18F.

C'est bien de recommencer quand ça par de tous les cotés, c'est le meilleur moyen d'apprendre. :wink:

J'espère que tes travaux de rénovation avance, bonne continuation.

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

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

#218 Message par F6FCO » jeu. 18 oct. 2018 12:22

C'est peut-être la cause de mes déboires, bien que tous mes bra avaient une portée restreinte, surtout utilisés dans des boucles d'une dizaine de lignes au sein de leur procédures, ces procédures plus ou moins éloignées du main étant appelées par des call.
Mais çà me plait de tout refaire au propre, comme tous les protos çà commençait à devenir un peu foutoir.

La réno avance mais pas assez vite à mon gout, je me met le compte avec la truelle la journée et je me délasse sur MPlab le soir :-)
Une porte nand prend 2 bits en entrée... cochonne va !!!

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

#219 Message par F6FCO » mar. 23 oct. 2018 22:19

Finalement ce n'était pas un bug venant de moi mais MPlab qui s'était complètement altéré, il me faisait et disait n'importe quoi. J'ai désinstallé et réinstallé (W7 aussi) et maintenant tout roule comme çà le devrait :wink: .
Voici ou j'en suis, une bonne partie du boulot est faite à ce stade:

J'ai créé un petit fichier gcode de test:

Capturegcode.PNG


Pour l'instant je ne traite que l'axe X donc on oublie les gcodes Y et Z. Pour ses déplacements la machine se réfère toujours à la position zéro et les déplacements sont en mm.
Au premier train X=1, donc on fait faire 800pas au moteur (moteurs 200pas par tour, réglé en 1/4pas donc 800pas/tr, 1 tour=1mm)
Au deuxième train de données X vaut 3, mais comme on a déjà fait 1mm il n'y a que 2mm à parcourir en avançant, donc 800x2=1600pas.
Au troisième train de données X vaut 100, comme on a déjà fait 3mm il reste 97mm à parcourir en avançant, donc 800x97=77600pas
Au quatrième train X vaut39, donc il faut reculer de 61mm (100-39), donc 61x800= 48800 pas en reculant
Au cinquième train X vaut 18, on continue à reculer de 39-18=21mm, donc 16800pas.
Au sixième train le programme reconnait le M de fin du gcode et stoppe.

L'analyseur logique confirme ces valeurs, on y voit les trains sur la pin UART, les ordres CTS qui séparent les trains et les pulses générés sur la pin drv_stepX entre chaque train:

Capturekingst.PNG


Code : Tout sélectionner

;----------------------------------------------------------------------------------------------
;
                                4L1C3 - F6FC0
; 23 octobre 2018  réception trains et stockage valeur en mem ok
; faire un reset du code, une déco/reco de teraterm avant de lancer chaque processus.
;----------------------------------------------------------------------------------------------

    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    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:0> les 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_Yplus    PORTA,1    ; 1
#define    btn_jog_Ymoins    PORTA,2    ; 1
#define    btn_jog_Xplus    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_btn_fn        PORTE,1 ; 1
#define    led_popX        PORTE,2 ; 0

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

                 CBLOCK    H'
0'
                 ENDC
                 
                 CBLOCK H'
80
                    tampon0                            ; ces tampons servent aux calculs du nombre de pulses
                    tampon1
                    tampon2
                    tampon3
                    tampon4
                    tampon5
                    tampon6
                    tampon7
                    tamponA
                    tamponB
                    axeX:1                            ; ascii '
Z'
                    coordX:4                        ; coordonnée stockée sur 32 bits
                    espace1                            ; espace
                    axeY                            ; ascii '
Y'
                    coordY:4                        ; coordonnée stockée sur 324 bits
                    espace2                            ; espace
                    axeZ                            ; ascii '
Z'
                    coordZ:4                        ; coordonnée stockée sur 32 bits
                    retour_ligne1                    ; retour chariot
                    retour_ligne2
                    retour_ligne3

                    ptr_train_RCIF                    ; compteur nb octets reçus dans un train
                    coordX_old:4
                    coordY_old:4
                    coordZ_old:4
                    coordX_travail:4
                    coordY_travail:4
                    coordZ_travail:4
                     valeur1:2                         ; utilisée par la soustract
                    valeur2:2                        ; utilisée par la soustract
                    valeur3:2                        ; valeur tampon pour les additions multiples
                    ptr_variable                    ; utilisé pour calculer l'
adr mem ou stocker les valeurs du train
                    flag_fin_gcode
                    tampon
                    Tampon_REC                        
; tampon réception
                    Reg_1
                    Reg_2
                    Reg_3
                    W_TEMP
                    STATUS_TEMP
                    BSR_TEMP
                ENDC


; ---------------------------------------- macros --------------------------------------------
    
qrt            macro                            
; demande au PC d'arreter l'émission 
                bsf        cts
            endm
            
qrv            macro                            
; demande au PC de relancer l'émission
                bcf        cts            
            endm
        
        
;--------------------------------- adresse de depart après reset -----------------------------
                ORG     H'
0'
                bra        init      

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

            ;ORG        H'
08'
            ;btfss    PIR1,RCIF            ; registre plein ? si oui on saute à réception
            ;bra        int1                ; sinon on sort de l'
interrupt
                    
;reception    
            
;movff    RCREG,axeX+ptr_train_RCIF    ; 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
            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 --------------------------------------------------------
ascii_poids4    db    0x00,0x00,0x03,0xe8,0x07,0xd0,0x0b,0xb8,0x0f,0xa0,0x13,0x88,0x17,0x70,0x1b,0x58,0x1f,0x40,0x23,0x28             
ascii_poids5    db    0x00,0x00,0x00,0x64,0x00,0xc8,0x01,0x2c,0x01,0x90,0x01,0xf4,0x02,0x58,0x02,0xbc,0x03,0x20,0x03,0x84
ascii_poids6    db    0x00,0x00,0x00,0x0a,0x00,0x14,0x00,0x1e,0x00,0x28,0x00,0x32,0x00,0x3c,0x00,0x46,0x00,0x50,0x00,0x5a          
         
;----------------------------------- Initialisations -------------------------------------------------
init
                bcf        ADCON0,ADON                ; convertisseur a/n dévalidé
                movlw    0xFF
                movwf    ADCON1,PCFG3            ; on passe tout en digital
                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'
11111111'                 
                movwf    TRISA
                movlw     B'
00000111'                 
                movwf    TRISB
                movlw     B'
11001100'                
                movwf    TRISC
                movlw     B'
10000011'                 
                movwf    TRISD
                movlw     B'
10000011'                 
                movwf    TRISE
                clrf    PORTA
                clrf    PORTB
                clrf    PORTC
                clrf    PORTD
                clrf    PORTE
            
            ; ---------------- RAZ du bloc de variables de axeX à flag_fin_gcode
                lfsr    FSR0,axeX
                movlw    d'
63'
                movwf    tampon
raz_var            clrf    POSTINC0
                decf    tampon
                btfss    STATUS,Z
                bra        raz_var    

                clrf    tampon0
                clrf    tampon1
                clrf    tampon2
                clrf    tampon3
                clrf    flag_fin_gcode            ; drapeau gcode, si égal à 1 le gcode est terminé
                clrf    ptr_train_RCIF    
                lfsr    FSR0,axeX                ; on repointe sur la première variable axeX    
                
                qrv                                ; prêt pour réception
                bcf        led_pomY
                bra     main

            ; -------------------- Cette partie ne sert qu'
à la mise au point, on force des valeurs pour test
                movlw    0x31
                movwf    coordX
+0
                movlw    0x33
                movwf    coordX
+1
                movlw    0x35
                movwf    coordX
+2
                movlw    0x37
                movwf    coordX
+3

            
; -------------------- Cette partie ne sert qu'à la mise au point, on force des valeurs pour test
                clrf    coordX_old
                clrf    coordX_old+1
                movlw    0x05
                movwf    coordX_old+2
                movlw    0x4a
                movwf    coordX_old+3

                
; -------------------------------------- Programme principal --------------------------------------
main  
            ;nop
            ;movlw    b'
00000000'                ; PIE1 (int RX désactivée RCIE=0)
            ;call    conversion_ascii_hexa
            ;call    soustractX
            ;call    géné_pulsesX
            ;call    sauvegarde_coordX_old    
            ;nop
            ;movlw    b'
00100000'                ; PIE1 (int RX activée RCIE=1)
            ;bra        main


Test_nb_trains

            movlw    d'
17'                 ; compter 17 octets pour un train en 32bits
            subwf    ptr_train_RCIF,w
            btfss    STATUS,Z
            bra        main        
            qrt                            ; stop émission
            call    test_fin_gcode                ; test si fin du gcode
            movlw    1
            subwf    flag_fin_gcode
            btfsc    STATUS,Z
            bra        init

            ;
            ;                                    
            ; ------------------- On place ici les appels aux sous-routines de gestion de la machine
            ;                                   
            nop
            call     conversion_ascii_hexa        ; convertit les données ascii des 3 axes en hexadécimal
            call    soustractX                    ; on va soustraire nouvelles coordonnées - anciennes coordonnées
            call    géné_pulsesX                ; génère les pulses sur axe X
            call     sauvegarde_coordX_old
            call    tempo                        ; sert juste à mieux visionner les séquences sur l'
analyseur logique
            
;nop
            
;
            ; -------------------
            ;
            ;
            nop
            nop
            clrf    ptr_train_RCIF    
            lfsr    FSR0
,axeX                    ; on repointe sur la première variable axeX    
            qrv                                    
; pret pour réception
            bra main
            
test_fin_gcode
            movlw    0x4D                        
; test du 'M' de la fin du gcode (M00000030)
            subwf    axeX,w    
            btfss    STATUS
,Z    
            return
            bsf        led_pomY        
            movlw    1
            movwf    flag_fin_gcode
            return

        

        
;---------------------------------------------- soustractions entre nouvelles données et anciennes données
;                                                pour obtenir la vraie distance à parcourir
soustractX
; Avant de soustraire il faut déterminer quel est le terme le plus fort entre coord et coord_old
; pour effectuer la soustraction sans avoir de nombre négatif et pour savoir dans quel sens mouvoir l'axe
; La conversion ayant été faite on n'
a à s'occuper que des deux octets poids2 et poids3
            movf    coordX_old+2,w
            subwf    coordX+2,w
            bn        coordX_old_fort
            bnz        coordX_fort
    
            movf    coordX_old+3,w
            subwf    coordX+3,w
            bn        coordX_old_fort
            bnz        coordX_fort
            bra        fin_soustractX
    
coordX_fort
            bsf        drv_dirX
            movff    coordX+2,valeur1
            movff    coordX+3,valeur1+1
            movff    coordX_old+2,valeur2
            movff    coordX_old+3,valeur2+1
            call    soustraction16
            bra        stock_resultX        

coordX_old_fort
            bcf        drv_dirX    
            movff    coordX_old+2,valeur1
            movff    coordX_old+3,valeur1+1
            movff    coordX+2,valeur2
            movff    coordX+3,valeur2+1
            call    soustraction16

stock_resultX
            movff    valeur2,coordX_travail+2
            movff    valeur2+1,coordX_travail+3

fin_soustractX
            return
    
; ---------------------------------------- conversion ASCII --> hexa
        
conversion_ascii_hexa
; pour ce projet de micro CNC on ne va travailler que sur les 4 octets de poids faible ce qui nous permet 
; une distance mini de 1000mm et maxi de 9999mm, ce qui est amplement suffisant.
; 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
; 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
            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,w
            mullw    2
            movf    PRODL,w
            addwf   TBLPTRL             
            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
            ; le poids1
            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+1,w
            mullw    2
            movf    PRODL,w
            addwf   TBLPTRL             
            tblrd*+                        ; on lit le poids fort et on le place dans valeur2+1
            movff    TABLAT,valeur2+1        
            tblrd*                        ; on lit le poids faible et on le place dans valeur2
            movff    TABLAT,valeur2
            ; on additionne les résultats de poids0 et poids1, résultat dans valeur2 et valeur2+1
            call    addition16
            ; le poids2
            movlw    High ascii_poids6   
            movwf    TBLPTRH             ; adresse poid fort de la memoire a lire 
            movlw    Low ascii_poids6
            movwf    TBLPTRL             ; adresse poid faible a lire
            movf    coordX+2,w
            mullw    2
            movf    PRODL,w
            addwf   TBLPTRL             
            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
            ; on additionne de nouveau les résultats
            call    addition16
            ; et enfin on additionne le poids 3 à tout çà pour obtenir le résultat final
            ; c'
est à dire (poids4*A*A*A)+(poids5*A*A)+(poids6*A)+poids7
            
; on avait une valeur ascii de distance codée sur 4 octets, on se retrouve avec une valeur hexa codée 
            
; sur 2 octets utilisable dans le programme
            movff    coordX
+3,valeur1
            clrf    valeur1
+1
            call    addition16    
            
; on stocke dans coordX+3 et coordX+2    
            movff    valeur2
,coordX+3
            movff    valeur2
+1,coordX+2
            nop
            return
        

    
; ------------------------------------------ Génération des pulses
géné_pulsesX                            
; génère le nombre de pulses sur l'axe X
            ; avant de générer les pulses on vérifie que le gcode n'
est pas terminé
            movf    flag_fin_gcode
,w
            sublw    1
            bz        fin_pulseX
; On génère le nombre de pulses suivant la valeur contenue dans coordX_travail+2 par 0x100
            clrf    tampon6
            bcf        STATUS
,Z
            movf    coordX_travail
+2,w
            movwf    tampon6        
xg6            bz        xg66
            
;------------------------
            movlw    0x80
            movwf    tampon5
xg5            bz        xg55
            
;------------------------
            movlw    2
            movwf    tampon4
xg4            bz        xg44
            call    X800pulses
            decf    tampon4
            bra        xg4
xg44        nop
            
;------------------------
            decf    tampon5
            bra        xg5
xg55        nop
            
;------------------------
            decf    tampon6
            bra        xg6
xg66        nop
; ensuite on génère le nombre de pulses suivant la valeur contenue dans coordX+3
            clrf    tampon6
            bcf        STATUS
,Z
            movf    coordX_travail
+3,w
            movwf    tampon6
xi6            bz        xi66
            call    X800pulses
            decf    tampon6
            bra        xi6
xi66        nop
            return

X800pulses                                
; 800 pulses en 1/4pas
            movlw    d
'4'
            movwf    tamponA
X200        movlw    d
'200'
            movwf    tamponB
Xm200        call    Xpulse_base
            decf    tamponB
            bz        Xfin200
            bra        Xm200
Xfin200        decf    tamponA
            bnz        X200
            return

Xpulse_base
            nop
            bsf        drv_stepX
            
;call     tempo_4.6khz
            bcf        drv_stepX
            
;call     tempo_4.6khz
fin_pulseX
            return
        
; --------------------------------- Sauvegardes _old
sauvegarde_coordX_old                
; sauvegarde les coordX dans coordX_old
            movff    coordX
,coordX_old
            movff    coordX
+1,coordX_old+1
            movff    coordX
+2,coordX_old+2
            movff    coordX
+3,coordX_old+3
            return
    
; --------------------------------- routines annexes

;********************************************************************
;
                   Soustraction sur 16bits                            *
;
     Il faut préalablement déclarer des variables sur 16 bits         *
;
             valeur1:2 et valeur2:2                                    *
;
                                                                    *
;
 Placer le poids fort de la première valeur dans valeur1            *
;
 et le poids faible dans valeur1+1                                    *
;
 Placer le poids fort de la valeur à soustraire dans valeur2        *
;
 et le poids faible dans valeur2+1                                   *   
; Appeler la procédure soustraction16 et le résultat de             *
;
 valeur1-valeur2 sur 16bits sera dans les 2 octets de valeur2           *
;********************************************************************
   
soustraction16
    
; ------------------------------------- on traite valeur2
            movf    valeur2
,w        ; inversion du poids fort
            xorlw    0xff
            movwf    valeur2

            movf    valeur2
+1,w        ; complément à 2 du poids faible
            xorlw    0xff
            addlw    0x01
            movwf    valeur2
+1
    
            movf    STATUS
,w        ; on isole le carry
            andlw    0x01
            addwf    valeur2
,f        ; et on l'ajoute au poids fort
    
            ;----------------------------------- on additionne les deux poids faibles    
            movf    valeur1+1,w
            addwf    valeur2+1,f
    
            movf    STATUS,w        ; on isole le carry
            andlw    0x01
            addwf    valeur2,f        ; et on l'
ajoute au poids fort
    
            
;--------------------------------- on additionne maintenant les deux poids forts
            movf    valeur1
,w
            addwf    valeur2
,f
            
; s'il y a carry il sera perdu car on reste en 16bits
    
            return
    


;********************************************************************
;                   Addition sur 16bits      F6FCO                        *
;     Il faut préalablement déclarer des variables sur 16 bits         *
;             valeur1:2 et valeur2:2                                    *
;                                                                    *
; Placer le poids faible de la première valeur dans valeur1            *
; et le poids fort dans valeur1+1                                    *
; Placer le poids faible de la valeur à additionner dans valeur2    *
; et le poids fort dans valeur2+1                                   *   
; Appeler la procédure addition16 et le résultat de                     *
; valeur1+valeur2 sur 16bits sera dans les 2 octets de valeur2           *
;********************************************************************
addition16
                movf    valeur1,W
                addwf    valeur2,f
                ; on additionne le carry dans le poids fort
                movf    STATUS,W
                andlw    0x1
                addwf    valeur2+1,f
                movf    valeur1+1,W
                addwf    valeur2+1,f
                return    
    

; ----------------------------------------- temporisations

tempo_4.6khz
; Délai 4 Cycles de la machine
; Durée du délai 4 microsecond
; Fréquence de l'
oscillateur 4 MHZ

                movlw       .1
                movwf       Reg_1
                decfsz      Reg_1
                bra         
$-2
                return

;tempo_4.6khz
; Délai 100 Cycles de la machine
; Durée du délai 100 microsecond
; Fréquence de l'oscillateur 4 MHZ

                movlw       .33
                movwf       Reg_1
                decfsz      Reg_1
                bra         $-2
                return                
            
tempo
; Délai 10 000 Cycles de la machine
; Durée du délai 10 millisecond
; Fréquence de l'
oscillateur 4 MHZ
                movlw       .251
                movwf       Reg_1
                movlw       .13
                movwf       Reg_2
                decfsz      Reg_1
                bra         
$-2
                   decfsz      Reg_2
                bra         
$-6
                nop
                nop            
                return
            


          END
      




Il me reste à créer les routines traitant les axes Y et Z et je pourrai enfin brancher les moteurs pour faire les premiers mouvements en vrai. :wink:
Ensuite je m'attaquerai aux routines annexes telles que les POM, POP et JOG.
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 !!!

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

#220 Message par Temps-x » mer. 24 oct. 2018 01:36

Bonsoir,

Je suis sur que tu es impatient de faire tes premier essais, bravo pour le code, très bien fait.

humour!! elle va commencer à marcher, Ah les premier pas à pas, que du bonheur, bon après elle va surement faire ses dents. :wink:
Quand la souris nargue le chat, c'est que son trou n'est pas loin.


Retourner vers « Langage ASM »

Qui est en ligne

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