Le projet 4L1C3, micro-cnc format A4

Hello tous,
Les H sont plus longs que les C. Comme la machine est très petite j'ai choisi des courts.

Re ! et merci pour ta réponse ! mais j'ai oublié une question !
Te souviens-tu des entraxes des fixations des guides

D'habitude ils mettent des plans et des cotes, mais là..non !

Merci à toi,

Hervé

Tu es épatant !
J'adore, encore du DIY à 98%

J'aimerai bien m'en faire une juste pour les CI, pour ne pas monopoliser la chintok, c'est encourageant de voir ça

Allez, je sais que tu es capable de nous faire une petite vidéo

Si je comprends bien, tu crées également un soft de commande embarqué, pourquoi ? Pour ne pas avoir de PC dédié ?

A+
Stéphane

Voici Hervé, tu trouveras tout ce que tu cherches sur cette page: https://fr.aliexpress.com/item/Mini-MGN12-12mm-miniature-linear-rail-slide-1pcs-12mm-L300mm-rail-2pcs-MGN12H-C-carriage-for/1504086544.html

Pas pratique pour la vidéo Stéphane, car la machine n'est commandée pour l'instant par aucun soft de commande (LinuxCNC, Mach3, etc.), pour la faire bouger et les premiers tests j'ai utilisé mon générateur BF en lui envoyant des signaux carrés pour simuler les pulses normalement envoyés par le PC. Et comme les courses ne sont pas longues il faut que je gère d'une main la tension appliquée sur l'entrée C/CW pour changer de sens au bon moment.
Mais une fois que le soft sera en état de faire bouger les axes je ferai une vidéo.

Oui cette machine est juste un petit banc-test pour tester mes routines, c'est juste pour le plaisir de me créer mon propre soft de commande CNC, comme je suis en plein déménagement et que je n'ai plus de machines en état de fonctionner pour un laps de temps indéterminé (le temps de terminer la rénovation de la future maison, puis aménager un nouvel atelier et ré-installer mes machines), je vais me consacrer à la programmation, truc qu'on peut faire sur un coin de bureau

RE !

Merci ! j'en avait vu, mais je ne savais pas si les MGN12 des " chinois "
étaient standards on dirai que oui !! 25mm pour les " 12 " !

Merci !!

Hervé

Je ne sais pas de quelle dimension tu parles mais si c'est de la largeur W des rails c'est du 12mm.

Hervé-34 a écrit:

Re ! et merci  pour ta réponse ! mais j'ai oublié une question !
Te souviens-tu des entraxes des fixations des guides

D'habitude ils mettent des plans et des cotes, mais là..non !

Merci à toi,

Hervé

Non ! je sais que des MGN 12 font 12mm mais ce sont les entraxes
qui m'intéressait !! donc 25mm c'est bon !

Hervé

Oups, j'avais mal lu plus haut.

Stéphane à demandé une vidéo
La tige filetée du Y est un peu voilée (récup), je vais la changer pour gagner en fluidité.

Excellent !

Perso, je ne vois pas d'à-coups sur le Z, en tous cas elle promet la petite !

Vraiment du beau boulot !

Stéphane

Bonjour,
La machine est finie, je vais pouvoir maintenant m'attaquer à la programmation pure, en premier lieu gérer la transmission du gcode par liaison UART du PC vers 4L1C3. Un PIC n'ayant pas une grande mémoire et ne pouvant pas par conséquent stocker un programme gcode j'ai choisi la solution d'envoyer les infos au fur et à mesure, un paquet sera composé d'une ligne de 15 octets contenant les infos X,Y et Z.
Une ligne, déplacement X,Y,Z
Une autre ligne, déplacement X,Y,Z
etc. etc. juqu'à la fin du gcode.

Je pense que ce sera le plus compliqué à faire, ensuite les déplacements d'axes suivant les valeurs reçues devraient être plus simples à gérer.
Un truc m'interpelle un peu quand même, c'est au niveau des accélérations et décélérations, j'ai observé avec le générateur de signaux que la marge de fréquence disponible n'est pas si grande que çà, au-deça et en-deça d'une certaine valeur çà commence à grogner. La plage disponible n'est pas très grande (je dirais entre 3 et 4Khz) et çà pourrait me limiter dans la programmation des phases d'accélérations.
Toujours est-il qu'avec le générateur de signaux j'appliquais une fréquence (donc vitesse) constante et que çà fonctionnait très bien comme çà, surement du à la légèreté des chariots et du petit pas des vis.
Mais ce ne sont pour l'instant que des considérations, je verrai çà plus précisément aux essais.

Hello tout le monde,
En réfléchissant aux fonctions nécessaires au bon fonctionnement de la machine je me suis rendu compte que j'avais été un peu radin sur le bon nombre de poussoirs. POM, POP, JOG et RUN ne suffisent pas. Malheureusement il ne me reste plus beaucoup de pins disponibles sur le PIC (40 pins pourtant), et je voudrais bien en garder quelques unes pour un éventuel futur affichage bien que çà n'ait pas été prévu dans le cahier des charges au départ.
J'ai donc réquisitionné 2 pins parmi les rares disponibles pour ajouter deux poussoirs de fonctions, genre la touche "Function" d'une calculette ou de Windows. J'ai donc deux nouveaux poussoirs "CTRL" et "Fn" qui associés aux poussoirs déjà utilisés me permettront de rajouter des fonctionnalités sympas à la machine (déplacements rapides, retour aux POP, etc.). Comme il n'y a pour l'instant pas d'affichage de prévu et que tout sera géré par poussoir et leds il faut réfléchir d'une autre façon que celle qu'on connait avec LinuxCNC ou MACH3 pour son utilisation.

Je n'ai pour l'instant plus de machines, alors j'ai du graver le PCB avec un cutter sur un coin de table. Pas très beau mais fonctionnel, je referai mieux quand je serai de nouveau équipé

Hello tout le monde,

Je suis actuellement sans internet (et c'est bien   , je peux me consacrer à la programmation au lieu de perdre du temps à surfer inutilement   ), je profite d'une visite à la famille pour me connecter et venir vous dire bonjour.
Je travaille toujours sur le projet et j'ai attaqué la programmation du soft de commande, mais comme ce n'est pas l'endroit pour poster des routines et causer d'assembleur, pour ceux qui seraient intéressés par la chose je tiens à jour cette page dédiée à 4L1C3:
http://f6fco.pagesperso-orange.fr/4L1C3.htm

Je viens de terminer la gestion du flux UART, la séparation des données en trains XYZ et le stockage des valeurs dans les bonnes variables.
Je vais m'attaquer maintenant aux routines de génération des pulses pour chaque axe. L'avancement des travaux sera mis à jour sur la page web.

je prend mon ticket mais c'est un peu du masochisme...
La jalousie m'étouffe.

Nota: aurais-tu un flux RSS sur ton site?

Bonjour tous,
Désolé pour le retard de ma réponse Ced21 mais comme déjà dit je n'ai plus de connection internet, je ne peux venir que rarement à l'occasion d'une connection chez qqun d'autre.
Non, Orange ne propose pas de flux RSS, désolé. Mais je mets ma page à jour à mesure de l'avancée du projet et l'upload dés que j'en ai l'occasion.
Elle a déjà pas mal grossieb depuis mon dernier message.
@plus dés que je peux.

Salut JC,

Bon courage et reviens vite

A+

Stéphane

Hello!

Pour un écran tu peux pas mettre un I2C ou un one-wire (plus lent peut-être..) ?

Bonne continuation !

Bonjour tous,
Je me connecte quand je peux   .
Pour l'écran I2C ou on-wire je verrai quand elle sera fonctionnelle (si elle l'est un jour), mais il me faudra apprendre à les gérer en assembleur.

ELLE A BOUGE

Bravo,une belle étape de franchie !
Maintenant une longue partie, la mise au point ?

Ben je sais pas trop, n'ayant plus d'atelier pour bricoler je comptais que ce serait mon petit projet pour occuper mes soirées d'hiver, et cet après-midi j'ai codé les routines de JOG des trois axes et une bonne partie des POM. Si çà continue à ce rythme je vais vite être au chômage.

Voilà ou j'en suis:
UART ok
Séparation des trains de données ok
Conversion ascii/hexa ok
Calculs de déplacement ok
Génération des séries de pulses en fonction des données envoyées par l'uart dans chaque train ok
Tests des 3 axes ok
Déplacement manuels fonctionnels
Prises d'Origine Machine presque finies

En fait ce que tu es en train de dire c'est qu'il te manque qu'un stylo à lui mettre dans le bec c'est ça?

Pas encore mais dans pas longtemps, il reste des petits trucs à faire quand même et comme je ne suis pas un bon informaticien et que je n'ai pas assez commenté mon programme je suis parfois un peu paumé en me relisant    ( à ce stade j'en suis à 1165 lignes d'assembleur).

Ah oui quand même ! Fait mettre deux écran 16/9eme verticaux l'un sur l'autre pour lire ça

Mais c'est vrai qu'en assembleur ça part vite!!!

Et même tu serais juste

Je viens de finir de coder et les essais des POM, çà y est la machine fait ses origines, connait maintenant son volume usinable et ne peut plus aller taper dans le bâti en cas de fausse manoeuvre.

Reste à m'attaquer aux POP mais je m'accorde un temps de reflexion avant de taper sur le clavier car la chose n'est pas aussi simple qu'il n'y parait.

Voici un aperçu du programme actuel:

Code:


;----------------------------------------------------------------------------------------------
; 4L1C3 - F6FC0
; 24 octobre 2018  
; réception trains et stockage valeur en mem ok
; axes X, Y et Z fonctionnels en virtuel
; 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 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_btn_fn PORTE,1 ; 1
#define led_popX PORTE,2 ; 0

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

;limite_maxiX equ d'125'
;limite_miniX equ 0
;limite_maxiY equ d'120'
;limite_miniY equ 0
;limite_maxiZ equ d'30'   ; tout en haut
;limite_miniZ equ d'0' ; tout en bas

#define limite_maxiX d'125'
#define limite_miniX 0
#define limite_maxiY d'120'
#define limite_miniY 0
#define limite_maxiZ d'30'   ; tout en haut
#define limite_miniZ d'0' ; tout en bas

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

 CBLOCK    H'08'
 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
 translatX ; distance parcourue en X
 translatY
 translatZ
 nbmm ; sert à calculer la distance parcourue sur un nb pulse calculé
 tampon0 ; ces tampons servent aux calculs du nombre de pulses
 tampon1
 tampon2
 tampon3
 tampon4
 tampon5
 tampon6
 tampon7
 tamponA
 tamponB
 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
 
 CBLOCK H'100'
 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'
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
 movlw b'01000000' ; oscillateur interne 8Mhzx4=32Mhz
 movlw 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
 
 ; ---------------- 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
 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

 ; -------------------- 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  
 bcf RCSTA,CREN ; on stoppe la réception UART, on ne la validera qu'une fois les inits machine effectuées

initialisations_machine
 ; POM (Prise Origine Machine)
 btfss btn_pom
 call POM
 ; jog X moins
 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 plus
 btfss btn_jog_Zplus
 call zplus
 ; jog Z moins
 btfss btn_jog_Zmoins
 call zmoins

 bra initialisations_machine
 
 
POM ;------- on commence par la pom X
 
 bcf drv_dirX ; on passe en marche arrière, le capteur d'origine étant situé à gauche du X
pomx call Xpulse_base
 btfsc capteur_pomX
 bra pomx
 ; POM faite, petit jog jusqu'à la limite mini
 call tempo_pom ; juste pour marquer l'arret entre la pom et la mise en place
 movlw d'18' ; jog jusqu'à la limite mini X
 movwf tampon0
pomxa call X800pulses
 decf tampon0
 bnz pomxa
 bsf led_pomX
 clrf translatX ; initialisation axe X à zéro
 call tempo_pom
 
 ; on continue par la pom Y
 bcf drv_dirY ; on passe en marche arrière, le capteur d'origine étant situé à gauche du X
pomy call Ypulse_base
 btfsc capteur_pomY
 bra pomy
 ; on jog à la limite
 call tempo_pom
 movlw d'30'
 movwf tampon0
pomya call Y800pulses
 decf tampon0
 bnz pomya
 bsf led_pomY
 clrf translatY ; initialisation axe Y à zéro
 call tempo_pom
 
 ; et on finit par la pom Z
 bsf drv_dirZ
pomz call Zpulse_base
 btfsc capteur_pomZ
 bra pomz
 ; on jog à la limite
 call tempo_pom
 movlw d'10'
 movwf tampon0
pomza call Z800pulses
 decf tampon0
 bnz pomza
 bsf led_pomZ
 movlw limite_maxiZ
 movwf translatZ ; initialisation axe Z à zéro
 return

; JOG ------------- déplacements manuels

; ------------- JOG X
xmoins ; 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
 bcf drv_dirX ; jog en arrière
 clrf tampon3
 movf translatX,w
 subwf tampon3,w
 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 X800pulses
 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
 bsf drv_dirX ; 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 X800pulses
 incf translatX
 return


; ------------- JOG Y
ymoins bcf drv_dirY ; jog en arrière
 clrf tampon3
 movf translatY,w
 subwf tampon3,w
 bn moinsy
 return
moinsy btfsc btn_jog_Ymoins
 return
 call Y800pulses
 decf translatY
 return

yplus movlw limite_maxiY
 subwf translatY,w
 bn plusy
 bnz plusy
 return
plusy bsf drv_dirY ; jog en avant
 btfsc btn_jog_Yplus
 return
 call Y800pulses
 incf translatY
 return

; ------------- JOG Z
zplus bsf drv_dirZ ; jog en remontant
 movlw limite_maxiZ
 subwf translatZ,w
 bn plusz ; si limite_maxiZ > translatZ on continue à jogger
 return
plusz btfsc btn_jog_Zplus
 return
 call Z800pulses
 incf translatZ
 return

zmoins bcf drv_dirZ ; jog en plongeant (prise de passe)
 clrf tampon3
 movf translatZ,w
 subwf tampon3,w
 bn moinsz
 return
moinsz btfsc btn_jog_Zmoins
 return
 call Z800pulses
 decf translatZ
 return


 
 
; ----------------------- Réception données et usinage
 
 
run bcf RCSTA,CREN ; POM et POP effectuées on active la réception UART
 
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
 clrf flag_fin_gcode
 ;
 ;
 ; ------------------- On place ici les appels aux sous-routines de gestion de la machine
 ;                                  
 nop
 call conversion_ascii_hexaX ; convertit les données ascii des 3 axes en hexadécimal
 call conversion_ascii_hexaY
 call conversion_ascii_hexaZ
 call soustractX ; on va soustraire nouvelles coordonnées - anciennes coordonnées
 call soustractY
 call soustractZ
 call géné_pulsesX ; génère les pulses
 call géné_pulsesY
 call géné_pulsesZ
 call sauvegarde_coordX_old
 call sauvegarde_coordY_old
 call sauvegarde_coordZ_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 Test_nb_trains
 
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
 
; ---------------------------------------- conversion ASCII --> hexa
 
conversion_ascii_hexaX
; 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
 
conversion_ascii_hexaY
 movlw 0x30
 subwf coordY
 subwf coordY+1
 subwf coordY+2
 subwf coordY+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 coordY,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 coordY+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 coordY+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 coordY+3,valeur1
 clrf valeur1+1
 call addition16
 ; on stocke dans coordY+3 et coordY+2
 movff valeur2,coordY+3
 movff valeur2+1,coordY+2
 nop
 return
 
conversion_ascii_hexaZ
 movlw 0x30
 subwf coordZ
 subwf coordZ+1
 subwf coordZ+2
 subwf coordZ+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 coordZ,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 coordZ+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 coordZ+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 coordZ+3,valeur1
 clrf valeur1+1
 call addition16
 ; on stocke dans coordZ+3 et coordZ+2
 movff valeur2,coordZ+3
 movff valeur2+1,coordZ+2
 nop
 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


soustractY
 movf coordY_old+2,w
 subwf coordY+2,w
 bn coordY_old_fort
 bnz coordY_fort
 movf coordY_old+3,w
 subwf coordY+3,w
 bn coordY_old_fort
 bnz coordY_fort
 bra fin_soustractY
coordY_fort
 bsf drv_dirY
 movff coordY+2,valeur1
 movff coordY+3,valeur1+1
 movff coordY_old+2,valeur2
 movff coordY_old+3,valeur2+1
 call soustraction16
 bra stock_resultY
coordY_old_fort
 bcf drv_dirY
 movff coordY_old+2,valeur1
 movff coordY_old+3,valeur1+1
 movff coordY+2,valeur2
 movff coordY+3,valeur2+1
 call soustraction16
stock_resultY
 movff valeur2,coordY_travail+2
 movff valeur2+1,coordY_travail+3
fin_soustractY
 return

soustractZ
 movf coordZ_old+2,w
 subwf coordZ+2,w
 bn coordZ_old_fort
 bnz coordZ_fort
 movf coordZ_old+3,w
 subwf coordZ+3,w
 bn coordZ_old_fort
 bnz coordZ_fort
 bra fin_soustractZ
coordZ_fort
 bsf drv_dirZ
 movff coordZ+2,valeur1
 movff coordZ+3,valeur1+1
 movff coordZ_old+2,valeur2
 movff coordZ_old+3,valeur2+1
 call soustraction16
 bra stock_resultZ
coordZ_old_fort
 bcf drv_dirZ
 movff coordZ_old+2,valeur1
 movff coordZ_old+3,valeur1+1
 movff coordZ+2,valeur2
 movff coordZ+3,valeur2+1
 call soustraction16
stock_resultZ
 movff valeur2,coordZ_travail+2
 movff valeur2+1,coordZ_travail+3
fin_soustractZ
 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
 incf nbmm ; pour calculer la distance parcourue en mm
 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
 
 
géné_pulsesY ; génère le nombre de pulses sur l'axe Y
 ; 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_pulseY
; On génère le nombre de pulses suivant la valeur contenue dans coordY_travail+2 par 0x100
 clrf tampon6
 bcf STATUS,Z
 movf coordY_travail+2,w
 movwf tampon6
yg6 bz yg66
 ;------------------------
 movlw 0x80
 movwf tampon5
yg5 bz yg55
 ;------------------------
 movlw 2
 movwf tampon4
yg4 bz yg44
 call Y800pulses
 decf tampon4
 bra yg4
yg44 nop
 ;------------------------
 decf tampon5
 bra yg5
yg55 nop
 ;------------------------
 decf tampon6
 bra yg6
yg66 nop
; ensuite on génère le nombre de pulses suivant la valeur contenue dans coordY+3
 clrf tampon6
 bcf STATUS,Z
 movf coordY_travail+3,w
 movwf tampon6
yi6 bz yi66
 call Y800pulses
 decf tampon6
 bra yi6
yi66 nop
 return

Y800pulses ; 800 pulses en 1/4pas
 incf nbmm ; pour calculer la distance parcourue en mm
 movlw d'4'
 movwf tamponA
Y200 movlw d'200'
 movwf tamponB
Ym200 call Ypulse_base
 decf tamponB
 bz Yfin200
 bra Ym200
Yfin200 decf tamponA
 bnz Y200
 return

Ypulse_base
 nop
 bsf drv_stepY
 call tempo_4.6khz
 bcf drv_stepY
 call tempo_4.6khz
fin_pulseY
 return


géné_pulsesZ ; génère le nombre de pulses sur l'axe Y
 ; 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_pulseZ
; On génère le nombre de pulses suivant la valeur contenue dans coordZ_travail+2 par 0x100
 clrf tampon6
 bcf STATUS,Z
 movf coordZ_travail+2,w
 movwf tampon6
zg6 bz zg66
 ;------------------------
 movlw 0x80
 movwf tampon5
zg5 bz zg55
 ;------------------------
 movlw 2
 movwf tampon4
zg4 bz zg44
 call Z800pulses
 decf tampon4
 bra zg4
zg44 nop
 ;------------------------
 decf tampon5
 bra zg5
zg55 nop
 ;------------------------
 decf tampon6
 bra zg6
zg66 nop
; ensuite on génère le nombre de pulses suivant la valeur contenue dans coordZ+3
 clrf tampon6
 bcf STATUS,Z
 movf coordZ_travail+3,w
 movwf tampon6
zi6 bz zi66
 call Z800pulses
 decf tampon6
 bra zi6
zi66 nop
 return

Z800pulses ; 800 pulses en 1/4pas
 incf nbmm ; pour calculer la distance parcourue en mm
 movlw d'4'
 movwf tamponA
Z200 movlw d'200'
 movwf tamponB
Zm200 call Zpulse_base
 decf tamponB
 bz Zfin200
 bra Zm200
Zfin200 decf tamponA
 bnz Z200
 return

Zpulse_base
 nop
 bsf drv_stepZ
 call tempo_4.6khz
 bcf drv_stepZ
 call tempo_4.6khz
fin_pulseZ
 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
 
sauvegarde_coordY_old ; sauvegarde les coordY dans coordY_old
 movff coordY,coordY_old
 movff coordY+1,coordY_old+1
 movff coordY+2,coordY_old+2
 movff coordY+3,coordY_old+3
 return
 
sauvegarde_coordZ_old ; sauvegarde les coordZ dans coordZ_old
 movff coordZ,coordZ_old
 movff coordZ+1,coordZ_old+1
 movff coordZ+2,coordZ_old+2
 movff coordZ+3,coordZ_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

; ----------------------------------------- temporisation

tempo_pom
; Délai 1 000 000 Cycles de la machine
; Durée du délai 1000 millisecond
; Fréquence de l'oscillateur 4 MHZ

            movlw       .173
            movwf       Reg_1
            movlw       .19
            movwf       Reg_2
            movlw       .6
            movwf       Reg_3
            decfsz      Reg_1,F
            goto        $-1
            decfsz      Reg_2,F
            goto        $-3
            decfsz      Reg_3,F
            goto        $-5
            nop
            nop
            return

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

            movlw       .141
            movwf       Reg_1
            decfsz      Reg_1,F
            goto        $-1
            nop
            return

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

            movlw       .36
            movwf       Reg_1
            decfsz      Reg_1,F
            goto        $-1
            nop
            return

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

            movlw       .31
            movwf       Reg_1
            decfsz      Reg_1,F
            goto        $-1
            nop
            nop
            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
      





Aujourd'hui à 17h58, j'ai déclaré:
"Waoooooo ! Waoooooo! P....n de sa m..e !!!! le c.. de sa race !!!! çà marcheeeeeee !!".
Que des trucs que je dis rarement.