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 ---
- 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 ---
Modérateur : mazertoc
Soft de commande CNC en asm
Soft de commande CNC en asm
- F6FCO
Expert- Messages : 1413
- Âge : 70
- Enregistré en : décembre 2017
- Localisation : Furtif je suis.
- Contact :
Bonsoir,
Et il y aura une suite
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 . 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:
Et il y aura une suite
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 . 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:
Vous n’avez pas les permissions nécessaires pour voir les fichiers joints à ce message.
Soft de commande CNC en asm
Soft de commande CNC en asm
bonjour à tous,
Je travaille toujours sur le soft de F6FCO dont le projet m'intéresse fort.
dans mon post #407
j'aurais dû écrire
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.
Avec mes excuses d'avoir écrit une bêtise.
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.
Avec mes excuses d'avoir écrit une bêtise.
Soft de commande CNC en asm
- F6FCO
Expert- Messages : 1413
- Âge : 70
- Enregistré en : décembre 2017
- Localisation : Furtif je suis.
- Contact :
Ne t'inquiète pas, je crois que personne ne l'avait relevée. Tu es trop pointu pour nous .
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:
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: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_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 haut, demande au PC d'arreter l'émission
bsf cts
endm
qrv macro ; Etat bas, demande 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/hexa, placé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 octets, on 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 valeur2, valeur2+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-0, tant 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 maxi) dans 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 octets, on 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,3µ
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 égaux, on 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éro, donc 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 faite, petit 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 à 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 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+6, coordX5 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 maxi) dans 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 égaux, on 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 faite, petit 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
Soft de commande CNC en asm
- F6FCO
Expert- Messages : 1413
- Âge : 70
- Enregistré en : décembre 2017
- Localisation : Furtif je suis.
- Contact :
Deuxième partie, il suffit de les concaténer dans MPLab:
[code=php][/code]
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.
[code=php][/code]
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.
Vous n’avez pas les permissions nécessaires pour voir les fichiers joints à ce message.
Soft de commande CNC en asm
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.
A+
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.
A+
Soft de commande CNC en asm
Chapeau pour le code 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.
@++
@++
Soft de commande CNC en asm
- F6FCO
Expert- Messages : 1413
- Âge : 70
- Enregistré en : décembre 2017
- Localisation : Furtif je suis.
- Contact :
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
@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 .
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:
Vous n’avez pas les permissions nécessaires pour voir les fichiers joints à ce message.
Soft de commande CNC en asm
Bonjour F6FCO, JJE, et tout le forum,
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
Bonne continuation
A+
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
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
Bonne continuation
A+
Retourner vers « Langage ASM »
Qui est en ligne
Utilisateurs parcourant ce forum : Aucun utilisateur enregistré et 71 invités