[Realisation] 4L1C3, soft de pilotage CNC en asm

[F6FCO]

Bonjour les gens,
Perso pour mes CNC j'utilise LinuxCNC et en suis très content, je ne ferai jamais aussi bien et performant mais juste pour le fun j'ai envie de me pencher sur un système d'exploitation (simplifié) pour CNC. Maintenant que j'ai mis le nez dedans avec ma rampe d'accélération, je suis parti à cogiter sur la rampe de décélération. Quand ce sera fait (plus quelques petits détails à régler) çà donnera une commande d'axe valide et ce serait idiot de ne pas pousser plus loin.
Alors j'ouvre ce sujet pour en discuter ici. Et coder un décodeur Gcode doit être bien passionnant.
Peut-être ce projet n'aboutira-t'il pas mais çà me fera toujours progresser en asm. J'avais déjà fait un soft pour CNC sur ma première en médium, programmé sur arduino, çà fonctionnait bien mais c'était lourd d'emploi car il fallait intégrer le gcode au programme et de ce fait j'étais très limité en mémoire, c'est ce qui m'a fait migrer sur LinuxCNC.

[F6FCO]

Bonsoir les gens,
J'ai codé cet a/m la routine de décélération. Pour l'essai je lui ai attribué une décélération sur 30 pulses. Codé sur 8bits on pourrait monter jusqu'à 255 pulses, pour l'instant je n'ai pas assez d'infos précises sur ce genre de détail, les essais en charge seront peut-être parlants.

Deceleration.JPG

Code : Tout sélectionner



;**********************************************************************
;                                                                     
;    NOM:        rampe de décélération pour moteur PAP                                        
;    Date:       19/04/2018                                           
;    Auteur:     F6FCO  JC Buisson                                       
;     xtal:       4Mhz                                                 
;    
;    Commande de moteur PAP en PFM
;   
;
;                                                                     
;**********************************************************************
    
    Errorlevel-302
    
    List p=16F88    
    #include <p16F88.inc>

    __CONFIG    _CONFIG1, _CP_OFF & _CCP1_RB0 & _DEBUG_OFF & _WRT_PROTECT_OFF & _CPD_OFF & _LVP_OFF & _BODEN_OFF & _MCLR_ON & _PWRTE_OFF & _WDT_OFF & _XT_OSC
    __CONFIG    _CONFIG2, _IESO_OFF & _FCMEN_OFF
      
OPTIONVAL    EQU    H'0008'            

; --------------------------------------------------------------------------------------------
#define clock PORTB,0              ; clock
#define dir PORTB,1              ; direction

BANK0    macro
        bcf    STATUS,RP0            ; passer banque0
        endm

BANK1    macro
        bsf    STATUS,RP0            ; passer banque1
        endm

pulse_haut macro
    bsf        clock
    call     tempo_base
    endm
    
pulse_bas macro
    bcf        clock
    call     tempo_base
    endm


;*********************************************************************

    CBLOCK 0x020                   
        decel                    ; temps morts entre deux pulses_haut en fin de rampe
        decelmax                ; nb maxi de temps morts
        nb_pulses                ; variable tampon
        tampon:2                ; variable tampon
        valeur1:2                 ; pour la soustraction 16 bits
        valeur2:2                ; pour la soustraction 16 bits
        Reg_1
        Reg_2
        Reg_3
    ENDC                                                                                  

;**********************************************************************

    org     0x0000                 ; Adresse de départ après reset
init;
    BANK1                        ; bank1
    clrf    ANSEL                ; broches du CAN en I/O
    movlw    OPTIONVAL            ; charger masque
    movwf    OPTION_REG            ; initialiser registre option
    clrf    TRISB                ; PORTB en sortie 
    BANK0                        ; bank0
    

;*********************************************************************
;                      Routine de décélération                       *
;*********************************************************************

main
  
init_variables
    ; ------------------- ; initialisation du nb temps morts par alternance au départ rampe 
    movlw    d'30'
    movwf    decelmax                
    clrf    nb_pulses
    clrf    decel
    incf    decel,f

loopD
    pulse_haut
    pulse_bas
    ;test de decel, pour le tester sans le déformer on le transfère et on travaille dans la variable tampon
    movf    decel,W
    movwf    tampon
    movf    decelmax,w
    subwf    tampon,f
    btfsc    STATUS,Z
    goto    findecel            ; si Z=1 on a fini la déceleration et de fait le trajet du chariot
    incf    decel,f                ; sinon on rentre dans la routine de deceleration pour ajouter des pulses bas entre deux pulses haut
    clrf    nb_pulses
loop_ecart_D
    pulse_bas
    incf    nb_pulses,f
    movf    nb_pulses,w
    subwf    decel,w
    btfss    STATUS,Z
    goto    loop_ecart_D
    goto    loopD
    
findecel
    call     tempo_fin_de_programme    ; juste pour séparer chaque éxécution du programme et pouvoir les différencier sur l'analyseur logique
    goto     main
    
    
tempo_base        ; temps de base d'un pulse (demi_alternance)
; 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,F
            goto        $-1
              return
            
tempo_fin_de_programme
; Délai 200 000 Cycles de la machine
; Durée du délai 200 millisecond
; Fréquence de l'oscillateur 4 MHZ
            movlw       .186
            movwf       Reg_1
            movlw       .4
            movwf       Reg_2
            movlw       .2
            movwf       Reg_3
            decfsz      Reg_1,F
            goto        $-1
            decfsz      Reg_2,F
            goto        $-3
            decfsz      Reg_3,F
            goto        $-5
            nop
            return
            
    END             




[F6FCO]

L'accélération et la décélération sont opérationnelles, reste le plus compliqué à faire, l'assemblage de l'accélération, du trajet à pleine vitesse et de la décélération, tout en veillant à ce que l'ensemble respecte scrupuleusement le nombre de pas total envoyé par le gcode.

[Temps-x]

Bonsoir F6FCO, et tout le forum

Source du message Perso pour mes CNC j'utilise LinuxCNC et en suis très content

je préfère écrit mon programme sur PC sans passer par un tas de logiciel, après coté pilotage des moteurs j'utiliserai les microcontrôleur Pic.

Coté PC il faut faire un programme qui gère les contours de figure, pour créer le Gcode, le reste n'est plus que de la lecture.

Personnellement je sais pas comment fonctionne un Gcode, car d'après le peu de documentation que j'ai pu avoir il y aurait plusieurs
système qui sont en évolutions permanent.

Pour faire fonctionner ma CNC, j'ai inventé mon propre protocole, mais j'aimerai le standardisé au protocole présent sur la plupart
des CNC.

F6FCO à écrit :

il fallait intégrer le gcode au programme et de ce fait j'étais très limité en mémoire

Oui tu as fait un lecteur de Gcode, mais pour créer un Gcode il te faut un programme sur ordinateur.

Ou as tu trouvés la documentation sur le standard du Gcode ?

A+

[ducran lapoigne]

bonsoir le forum,

pour débuter en cnc gcode etc ...

http://id-conception.fr/

onglet tutoriels

[F6FCO]

Bonsoir Temps-X, Antoine et les gens,
Le Gcode est un "langage" très simple à comprendre, mais écrire un vrai programme qui crée du gcode à partir d'un fichier STL ou DXF au niveau amateur relève de l'utopie, il doit savoir gérer les cercles, les tangentes, les arcs de cercles, approcher les tangentes au plus près tout en respectant les différents diamètres d'outils, les perçages, les trajets rapides, lents, et j'en passe. Çà c'est pour la partie simple, il doit aussi être capable de gérer mes vitesses d'avance de l'outil, plongée de l'outil dans la matière en spirale ou pas, la vitesse de rotation de la broche, de créer du gcode à partir d'une pièce complexe pour faire de l'usinage 3D. Bref, une vraie usine à gaz.

J'utilise Sketchup et Freecad pour la création de mes pièces et leur exportation en .STL, (certains travaillent en .DXF) et ensuite Cambam pour convertir le modèle STL en Gcode. Pour les pièces simples on peut s'affranchir des softs 3D et les dessiner directement dans Cambam.
Çà c'est pour le travail en amont, le soft de pilotage d'une CNC ne s'occupe pas de çà.

Pour la partie CNC c'est "juste" (entre guillemets parce que c'est quand même quelque chose de très complexe) un lecteur de gcode et de commande des moteurs. Mais pas seulement, il doit aussi gérer les rampes, interrompre ces rampes, pouvoir lire tous les ordres de gcode, mais aussi gérer les limites et origines de la machine (limites matérialisées par des capteurs) en connaissant l'espace réel d'usinage suivant la machine, gérer la broche d'usinage, gérer l'arrosage, etc. etc.

Pour ma part ce que je me propose d'essayer de faire c'est un système très simplifié pour lire les ordres gcodes les plus simples et piloter trois axes. Evidemment pas pour piloter mes CNC au final, LinuxCNC fera toujours çà mieux que moi , c'est juste pour m'amuser, un prétexte sans prétentions pour faire de l'assembleur et progresser.

[Temps-x]

Bonsoir ducran lapoigne, F6FCO et le forum,

Je tiens à vous remercier pour toute cette documentation, en ce qui concert le logiciel de création Gcode j'en reparlerai avec vous.

Une fois que j'aurais fini le mien.

Bon aller comme ça fait partie de mon cahier des charges, et pour apprendre à coder un petit projet, alors je vais lui donner comme non.

Lecteur de Gcode à mémoire externe géré par écran

Bon, le langage pratiqué sera ASM, tout autre langage ne sera pas toléré, comme le C++

il faudra avoir 3 moteurs ou 4 moteurs pas à pas, pour effectuer les essais, ou une CNC

1) En premier lieu, Il faudra mettre les fichier Gcode sur un support de stockage( Micro carte, carte SD, USB, ou autre....)

2) Après avec microcontrôleur(hors connexion PC) on devra choisir avec un écran(LCD, ou autre, du moment qu'il y et un visuel)
un fichier qui a était mis sur votre support de stockage, et l’exécuté.

C'est à dire qu'il sera lu par notre microcontrôleur, les moteurs pas à pas son libre de choix( unipolaire, bipolaire, ....)

Tous le monde peux participer : Gérard (qui adore l'assembleur), F6FCO, ducran lapoigne, papeete, paulfjujo, satinas, Jérémy, cyril13110, adede5000, JJE, venom, jeanyves1976, Pikachu, JMarc, Bigonoff......

A+

[F6FCO]

Bonjour les gens,

Bonne idée de mettre les cerveaux et les routines en commun . On garde ce sujet comme terrain de jeu. Et en assembleur évidemment.

Je me demandais justement comment stocker le gcode, en datas dans le programme comme je l'ai déjà fait avec arduino ?, lourd d'emploi et limité en taille gcode, surtout sur un UNO. Sur carte SD ? j'ai déjà fait çà en arduino pour un robot et eu beaucoup de déboires, la lecture à bien fonctionné pendant quelques temps et est finalement devenue erratique. J'ai résolu le pbm en changeant le lecteur (chinois) jusqu'à ce que çà recommence. C'a ma couflé ! Le C Arduino ou le C++ sont dés langages très puissants mais on est tributaire de librairies plus ou moins opaques, on ne sait pas vraiment ce qui se passe derrière et quand un pbm aléatoire de ce genre survient on n'a plus la main et c'est difficile à gérer.

Je suis curieux de voir si çà fonctionne mieux en PIC.
Pour l'instant je vais continuer à travailler sur la commande de moteur, maintenant il faut assembler les deux rampes avec un trajet à pleine vitesse. Tout en sachant tout en sachant que le nombre de pas à parcourir peut-être inférieur à celui des deux rampes assemblées, pas simple du tout

[Gérard]

Hello tous,
Temps-X, il n'y a aucune chance que je participe, mon niveau en asm est du genre maternelle.

[Temps-x]

Bonjour,

Pour le stockage au choix (Micro carte, carte SD, USB, ou autre....)

Pour la visualisation au choix (écran Lcd, écran tactile, ou autre, du moment qu'il y et un visuel)

Je vous conseille de prendre un Pic qui à au moins 40 pattes

Gérard va se régaler avec toutes ces routines ASM.

A+