Cahier des charges du banc-test:

Low-cost.
Motorisation en NEMA17.
Fonctionnement en 1/16 de pas.
Doit pouvoir fonctionner sous 12vcc.
Drivers low-cost chinois a base de TB6600.
Petit prix oblige le materiau sera du medium.
Noix usinees dans du POMC pour limiter le backlash.
Pour les tests la broche sera remplacee par un stylo.
Encombrement format A4 pour ne pas g�ner sur le bureau.
L'electronique sera incluse dans le ch�ssis toujours par souci d'encombrement.
Vis-meres en tige filetee M6/100. 1mm par tour, pas ideal pour simplifier les calculs
Choix d'un seul guidage MGN12 par axe, pas besoin d'une grande rigidite pour ecrire sur une feuille.
Pas d'ecran pour simplifier dans un premier temps, tout devra fonctionner par poussoirs et visu a leds.

Et bien sur, toujours le debut en 3D pour savoir ou on va, comme d'habitude je commence par definir les trois axes et j'adapte ensuite un b�ti pour les supporter.

Axe X

Axe Y

Axe Z

Ensemble des 3 axes. Les guidages sont en MGN12, j'ai fais le radinasse: un seul par axe, la machine n'ayant qu'a deplacer un stylo pas besoin de plus. Pour optimiser la compacite les moteurs X et Y sont montes a l'interieur du b�ti, la transmission par courroies et poulies GT2 rapport 1/1 resoud le probleme d'alignement moteurs/axes. Seul le moteur Z est monte sur coupleur souple.

Le cahier des charges imposant de ne pas occuper une surface plus grande qu'une feuille A4 sur le bureau j'ai fais le choix de positionner l'electronique sous la machine. Ce sont de petits drivers chinois equipes de TB6600 que j'ai deja montes sur CH4RL0TT3. et qui fonctionnent tres bien.

Ch�ssis en medium 10 et 13mm. C'est bizarre mais elle me rappelle quelqu'un, un mec caracteriel toujours en noir et un casque, qui parle avec la gorge et qui n'arr�te pas de souffler. Ca me reviendra.
Elle a l'air un peu feroce comme ca mais il ne faut pas s'y fier, ce sera une brave fille.

La grosse T1T1N3. mise a contribution pour la decoupe des differents panneaux.

Toujours low-cost les vis d'entra�nement sont en M6x100, le pas de 1 sera bien pratique lors de la programmation des deplacements d'axes, les tiges sont montees sur de petits roulements a billes 13x5x4. J'ai remplace les ecrous M6 initialement prevus par des noix usinees dans des chutes de POMC pour limiter le backslash.

Realite conforme au virtuel.

Les moteurs X et Y sont montes a l'interieur du ch�ssis pour un gain de place.

Encombrement A4 sur le bureau.

Bon, maintenant on peut passer a ce qui nous interesse.

L'�me d'4L1C3. Schema et implantation du PCB PIC18F4525.

NOTA: J'ai depuis refondu le schema et l'implantation par rapport a la carte finie premiere version ci-dessous car les barettes etant tres serrees il etait peu pratique d'avoir acces aux pins avec le chevelu une fois tout c�ble.

Tiens, un PIC18F4525duino...
j'ai double les barettes pour pouvoir connecter un analyseur logique en // sur les signaux. Le PCB comporte deux regulateurs de tension, un petit pour l'alim du PIC et un 1A pour distribuer le +5vcc aux peripheriques.

La platine POM (Prises Origines Machine).
Au demarrage de la machine les axes peuvent �tre positionne n'importe ou dans le domaine usinable, cette operation permet de ramener chaque axe en debut de course. Les origines sont mises a zero, la machine connaissant ses limites maxi (constantes definies dans le programme), elle connait par consequent son volume usinable et il n'y aura pas de risque que les chariots aillent taper dans le ch�ssis en bout de course. C'est la premiere operation qu'on fait au demarrage de la machine.

La platine POP (Prises Origines Piece).
La piece a usiner peut-�tre bridee par l'operateur n'importe-ou dans le volume usinable, il faut donc indiquer a la machine sa position exacte en venant tangenter sur les trois axes et ainsi faire les origines piece.

La platine JOG, deplacements manuel des axes.
(pour aller faire les POP par exemple ou pourquoi, pas faire de l'usinage manuel).

Les platines installees sur le ch�ssis.

Mise en place des capteurs d'origines machine.
Systeme par relais ILS fixe sur le ch�ssis et commande par un aimant solidaire du chariot, masse commutee envoyee au PIC.

Capteur origine X.
Vue de l'ILS fixe sur le ch�ssis.

Capteur origine X.
Vue de l'aimant fixe sur le chariot.

Capteur origine Y, l'aimant est fixe sur la table mobile.

Capteur origine Z.

C�blage de l'electronique de commande.

---oO(#)Oo---

........( Heureux evenement )........

C'est officiel, j'ai la grande joie de vous annoncer la naissance de la petite 4L1C3, 3.2kg et des boutons bleus. Le papa est tres fier.

bon c'est pas tout ca, je lui ai mis un PIC 18F4525 en guise de cerveau mais maintenant il s'agit de le lui remplir...

Apres moults tests et grognements j'ai fini par trouver les bons parametres de courant et frequences de pulses. Les trois axes sont fonctionnels, fluides et pseudo-silencieux.
Et m�me assez rapides pour des vis au pas de M6, je m'attendais a pire.

Pour determiner les frequences de fonctionnement ideales j'ai fais les premiers essais avec un generateur de signaux TTL, directement applique aux entrees STEP des drivers. A priori les frequences de pulses valides sont comprises dans une fourchette allant de 1 a 20Khz suivant le reglage de micro-pas.
- en 1/2pas 2,4Khz
- en 1/4pas 4,6Khz
- en 1/8epas 9Khz
- en 1/16pas 18Khz

Pour une utilisation plus confortable je me suis apercu que je manquerai de poussoirs, j'ai donc rajoute une plaque avec deux boutons de fonctions qui, associes aux autres ajoutera des fonctionnalites supplementaires (retour aux POP, avances rapides, etc.). Ces deux poussoirs sont c�bles sur les deux pins libres Re0 et Re1.
Je suis en ce moment en plein demenagement et toutes mes machines sont demontees, j'ai donc du graver la plaque a la Mac Gyver, au cutter sur un bord de table. Pas tres joli mais fonctionnel, je referai ca mieux quand je serai de nouveau installe. On va dire que c'est du provisoire definitif.

Algorithme de fonctionnement d'4L1C3, tout simple, on fait d'abord les prises d'origines machine (POM) et piece (POP, on lance le programme (RUN). A partir de la le gcode est transmi au PIC qui le decoupe en trains de donnees X, Y et Z.
On active l'uart, on recoit un train de donnees, on bloque l'uart le temps de deplacer les axes selon les donnees recues et on recommence cette sequence jusqu'a la fin du programme gcode.:

........( Labels et assignation des pins )........

L'assignation des pins, reste pour l'instant 5 pins de libres pour d'eventuelles futures modifs ou ameliorations. Les trois capteurs d'origine machine sont assignes a RB0, RB1 et RB3 au cas ou je devrais les placer sous interruptions

Quelques legendes:
capteur_pomX = capteur Prise Origine Machine sur l'axe X
capteur_pomY = capteur Prise Origine Machine sur l'axe Y
capteur_pomZ = capteur Prise Origine Machine sur l'axe Z
btn_run = poussoir demarrage usinage
btn_pom = poussoir prise origine machine
btn_popX = poussoir Prise Origine Piece
btn_jogXmoins = poussoir deplacement X en negatif
btn_popX = poussoir prise d'origine piece sur l'axe X
led_popX = Led visu prise origine piece sur l'axe X
led_pomX = led visu prise origine machine sur l'axe X
drv_dirX = info direction sur le driver X
drv_stepX = info de pas sur le driver X

........( Format gcode )........

Un exemple du gcode simplifie que j'utiliserai pour le developpement, genere par Cambam. Au debut pas de trucs compliques, codes G et autres, je garde juste le M30 pour signifier la fin du programme. Au depart je vais faire simple, juste des deplacements X, Y et Z, je verrai quand tout fonctionnera pour apporter des ameliorations si besoin.

Voila ce qu'on va faire, tout ce qui suit n'en est que le developpement:
Recevoir par l'UART des trains de donnees contenant les valeurs de deplacement et deplacer les trois axes entre chaque train. Ceci jusqu'a la fin du gcode. C'est tout, pas plus.
Maintenant il s'agit de developper.

Il va me falloir programmer un interpreteur gcode mais d'abord il faut reflechir au format des donnees, j'ai envie de tout stocker en 64bits, pas que j'ai besoin d'autant pour cette petite machine mais ce programme pourrait peut-�tre servir de base pour d'autres futurs projets, autant voir grand tout de suite. Ca ne m'emp�chera pas d'effectuer les calculs dans un autre format approprie a mes petites courses, histoire de gagner du temps de calcul bien qu'en assembleur et les microcontr�leurs actuels ca ne pose pas de reel probleme.

Qu'est-ce qu'on a a faire ?
Cambam (le soft dont je me sers pour generer mes gcodes) donne des valeurs en mm, le PIC fonctionne en pulses pour faire fonctionner les moteurs, il va donc falloir transformer ces mm en nombre de pulses, dependant du choix de micro-pas.
L'UART envoie des donnees ASCII, il faudra donc les convertir en valeurs decimales
Cambam genere au debut du gcode un ordre Z isole et redondant. A l'heure actuelle je n'ai toujours pas reussi a modifier le post-processeur pour l'annuler donc je le ferai sauter manuellement.

........( Transmission gcode PC vers PIC )........

Tout cela est deja suffisamment complique alors pour les debuts et les premieres mises au point j'ai simplifie les performances, la machine ne tracera que des droites horizontales, verticales et a 45�, suffisant dans un premier temps pour faire de la gravure de PCB a l'anglaise, des ameliorations pourront toujours �tre implementees une fois le projet viable.
Un choix important a faire au depart: l'importation du gcode. Deux options, soit par transmission PC/CNC par liaison serie en temps reel comme sur la plupart des CNC, soit le fonctionnement en autarcie de la machine sur SDcard genre imprimante3D. Ayant eu quelques soucis de fiabilite avec les cartes SD lors du projet G4ST0N. j'ai opte cette fois pour la liaison serie. En plus c'est une technique que je n'ai pas encore experimentee, ca va me permettre de decouvrir. Le developpement du projet se faisant en partie sur un vieux PC portable non equipe de prise serie DB9 la transmission se fera par USB/FTDI. Cote PC j'utiliserai le terminal TERATERM.

Le code ASM qui gere la liaison RS232 servira de tronc au programme, toutes les autres routines seront implementees en tant que sous-procedures appelees par le tronc.

........( Reception des lignes gcode sur le PIC )........

Un fichier gcode peut prendre enormement de place en mem suivant la complexite de la piece a usiner, souvent trop volumineux pour un PIC. Pour remedier a ce probleme je vais envoyer le fichier par morceaux, il restera stocke sur le PC qui enverra des trains d'octets au PIC. Celui-ci n'aura qu'a recevoir le nombre d'octets composant une ligne Z,X et Y du fichier gcode, il ordonnera au PC de cesser la transmission le temps de bouger les trois axes suivant les valeurs recues, une fois ce travail termine il ordonnera au PC d'envoyer la ligne suivante, etc. etc. Le challenge est d'arriver a retirer les infos de deplacement dans une ligne gcode codee de cette maniere:
"'Z' ascii, valeur Z sur 32bits, 'espace' ascii, 'X' ascii, valeur X sur 32 bits, 'espace' ascii, 'Y' ascii, valeur Y sur 32 bits".

Au depart pour gagner une pin j'ai voulu faire les interruptions du flux de facon logicielle (XON/XOFF), ca ne fonctionnait pas et ca me faisait parfois disparaitre mon port COM4. En visu avec l'analyseur logique il s'averait que les ordres partaient bien vers le PC mais n'interrompaient pas la liaison UART, je met ca sur le compte de mon W7 qui est vieux et commence a �tre corrompu. Plut�t que tout reinstaller je suis passe en interruption de flux hardware avec CTS, et la tout fonctionne correctement. Un petit bemol quand m�me, il passe encore deux octets apres envoi du CTS, il a fallu gerer ca dans le gcode en rajoutant deux octets non significatifs en fin de chaque ligne.
Pour resumer la reception cote PIC se fait sous interruption, lorsque RCIF passe a 1 on recupere l'octet recu et on le stocke sur le PIC dans la variable prevue a cet effet, un train d'impulsions comporte les donnees X,Y et Z. Plus besoin d'emission cote PIC, le contr�le du flux se faisant en hard par la pin CTS du module FTDI.

La premiere chose a faire, separer les infos ligne par ligne. Pour m'y retrouver j'ai cree un fichier gcode test avec des valeurs reconnaissables qui se suivent stockees sur 32bits.

Les macros qui assurent la separation des lignes en activant ou bloquant l'uart.

Le resultat vu par l'analyseur logique, on voit bien les trames isolees par les impulsions CTS. C'est dans ces espaces qu'oeuvreront les sous-programmes de gestion des trois axes de la machine.

Loupe sur une trame.
Elles font toutes 30 octets de long mais le CTS laissant passer 2 octets apres son envoi (visible sur l'ecran de l'analyseur), j'ai du initialiser le compteur de reception a 28.

A l'issue de chaque train XYZ les valeurs recues sont stockees dans leurs variables respectives, il n'y aura plus qu'a venir les recuperer pour calculer le deplacement de chaque axe.
Nota: on peut voir sur la capture de l'analyseur des trains 64bits, alors que le gcode est en 32bits, normal ils ne sont pas actualises, je suis en pleine phase de recherches et bricolages
et je ne fais pas une nouvelle capture d'ecran a chaque modif.

........( Conversion ASCII -> numerique )........

Les valeurs recues par la liaison UART sont sous format ASCII.
Chiffre 0 = valeur ascii 0x30 (48 decimal)
Chiffre 1 = valeur ascii 0x31 (49 decimal)
etc.
etc.
Chiffre 9 = valeur ascii 0x39 (57 decimal)
Il suffit de retrancher 0x30 aux valeurs contenues dans les variables pour obtenir leur valeur numerique. (Nota: pour plus de clarte je ne traite ici que l'axe X)

Variables brutes de reception avant conversion.

Apres conversion.

Mais tout cela ne suffit pas et c'est un peu plus complique qu'il n'y parait. Une telle conversion aussi simple ne fonctionne que sur les premiers chiffres (0 a 9), ensuite a partir de 10 on est code sur deux octets, cad 10= 0x01 0x00 (0x31 0x30 en ascii), chaque chiffre etant code sur 8 bits. Si on prend comme exemple la valeur maximale ASCII sur 32bits qui est 9999, ca donne 0x39 0x39 0x39 0X39. Pour avoir la valeur hexa il faut faire:
9*0xa*0xa*0xa (4eme rang: 0x2328) + 9*0xa*0xa (3eme rang: 0x0384) + 9*0xa (2eme rang: 0x5a) + 9*0x0 (1er rang: 9) = 0x270f.
Verification d'9999'= 0x270f, valeur hexa codee sur deux octets et maintenant utilisable dans le programme.

Voici la routine qui execute la conversion par table pre-calculee.

Petite aparte... j'avais suggere au depart que le stockage des donnees se ferait en 64bits et ceux qui ont suivi ont du remarquer que j'ai tout fait jusque-la en 32bits, , le plus grand nombre ASCII pouvant �tre stocke sur 32bits (4 octets) est 9999, ce qui donne apres conversion 9999 decimal, evidemment, donc 9999mm ce qui est amplement suffisant pour une CNC. Si on examine la memoire ce nombre est stocke sous la forme 0x39 0x39 0x39 0x39 (0x39 etant la valeur hexadecimale du chiffre 9 ascii).
Pour avoir une valeur plus grande que 9999 il faut augmenter le format.

........( Generation des impulsions pour la commande des moteurs )........

On pose comme base que la machine fonctionnera en 1/4pas, donc 800pas par tour. Le pas des vis-meres fait 1mm (M6x100, choisi en consequence), unite ronde bien pratique dont on n'aura pas a tenir compte dans les calculs. Pour obtenir le nombre de pulses par axe en 1/4pas il faut donc multiplier chaque valeur par 800.

Bien que la famille des PIC18F possede des instructions de multiplication, il est lourd en assembleur de multiplier un grand nombre occupant plusieurs octets par un autre nombre superieur a 255. Je vais tourner la difficulte en faisant en quelque sorte une multiplication hardware, c'est a dire decomposer le nombre stocke sur les 8 octets d'une coordonnee et multiplier chaque terme par une routine qui produira 800 impulsions et un multiple de 10 suivant son poids.
Tricheur va !

Exemple: la valeur 537 est stockee dans les trois premiers octets de coordX. Il faudrait faire une routine pour multiplier 537x800, stocker sur plusieurs octets le resultat qui sera certainement abomifreux, il faudra ensuite coder une routine pour en tirer le nombre de pulses adequat. Lourd a programmer. Il existe certainement des algorithmes pour faire ce genre de chose mais n'etant pas du metier je n'en connais aucun. Je trouve plus elegant de programmer: nb2=5, nb1=3, nb0=7 , puis (nb2x10x10x4x200)+(nb1x10x4x200)+(nb0x4x200) pour arriver au m�me resultat (429600). Niveau programmation il suffit de faire des boucles imbriquees, ca donne une boucle effectuant 200 pulses inclue dans une boucle de 4 iterations et suivant le poids contenue elle-m�me dans une ou plusieurs boucles de 10 iterations. Aucun resultat a stocker, juste des creneaux en sortie, exactement ce qu'on veut.

La routine produisant 800 pulses sur l'axe X.

L'analyseur logique confirme le resultat:

La routine semi-complete, j'ai traite seulement les 4 bits de poids faible (ce qui m'autorise des courses maxi de 9000mm).

J'ai evidemment fait les tests sur plusieurs valeurs. Pour verification j'ai force dans les variables coordX la valeur de la course maxi de la table d'4L1C3 qui fait 150mm, on obtient bien 120000 pulses (150x800), la translation complete devrait se faire en environ 26 secondes et on a bien les 4,6Khz definis aux essais.

Test: series de 120000 pulses separees par des tempos de 0,5 secondes.

Les trois axes en fonction (virtuellement pour l'instant car les drivers ne sont pas encore branches, il reste a gerer les directions). On distingue bien les sequences de pulses XYZ successifs entre les trains de donnees UART, tous des multiples de 800 selon le gcode incremental special cree pour les tests: le premier fait 800 pulses (X00000001) et le dernier 120000 pulses (Z00000015).

Autre petite aparte: certains pourraient se dire "Oui mais comment fait-on quand on ne possede pas de supers appareils de mesure de la mort qui tue pour voir ce qui est invisible ?". Simple, il existe actuellement des analyseurs logiques 16 canaux a relier sur un port USB vendus pour quelques euros chez les chinois.

A ce niveau on a tout ce qu'il faut pour executer un programme gcode:
- on a converti les donnees ascii en valeur hexa
- on a calcule et genere des impulsions a envoyer aux drivers pour commander les moteurs pas a pas
- on a calcule la vraie valeur a parcourir d'apres le point a atteindre et le chemin deja parcouru par l'axe.
Mais ca ne suffit pas pour avoir une machine operationnelle, il faut faire auparavant quelques operations d'initialisation.

........( Initialisations de la machine )........

Au demarrage de la machine la reception UART est coupee et on effectue une lecture des poussoirs en attendant une decision de l'operateur (il manque ici la lecture du poussoir Run qui sera implemente plus tard).

........( Les POM )........

Mais se servir de la machine a ce stade comporte des risques et inconvenients, les axes peuvent �tre positionnes n'importe-ou au demarrage de la machine, rien n'est carre et on pourrait tres bien aller taper les chariots dans le b�ti et detruire la machine. Pour cela les machines cnc sont equipees de deux fonctions: les POM (Prises Origines Machines) et POP (Prises Origines Pieces). Ces origines se font sur chaque axe.
Il faut effectuer en premier lieu les POM. Sur ordre de l'operateur la machine deplace ses chariots pour venir les positionner au point zero de chaque axe. Ces points zero sont materialises par des capteurs (ici des ILS), une fois ce point zero atteint sur chaque axe la machine connait son volume usinable, ses distances de translation maximum etant determinees par des constantes inclues dans le programme et reglees precisemment par des essais prealables. A partir de la la machine connait ses limites min et max en translation et ne peut plus aller taper dans le b�ti.
Une variable nommee 'translat' a pour t�che de tenir le compte des mm parcouru par les axes dans les deux sens.

........( Les JOG )........

Il faut pouvoir deplacer les axes manuellement, pour par exemple effectuer les Prises d'origine des pieces, soit pour usiner a la main, on n'a pas toujours envie de passer du temps a creer un gcode pour effectuer une t�che simple tel un surfacage. Des poussoirs sont prevus pour cette fonction, deux par axes pour pouvoir se deplacer dans les deux sens.
Donc pouvoir deplacer les axes tout en tenant compte des limites de la machine, toujours pour rester dans le cadre de son domaine usinable.

........( Les POP )........

Conna�tre son domaine usinable c'est bien mais l'operateur peut decider de brider la piece a usiner n'importe-ou sur la surface de la table, il faut aussi conna�tre la hauteur de la piece pour effectuer les prises de passe. Donc determiner les positions X, Y et Z de l'emplacement de la piece. C'est un acte d'operateur en venant tangenter sur la piece en executant des Jog et validant les positions.

........( gestion des pentes )........

Pour l'instant la machine ne sait tracer que des lignes verticales et horizontales. Si on lui demande de tracer une pente de X20,Y30 a X80,Y50 elle va commencer par se deplacer de x20 a X80 horizontalement et seulement ensuite elle de deplacera verticalement de Y30 a Y50, elle dessinera un angle. Evidemment ce n'est pas ce qu'on veut mais au depart ne sachant pas ou j'allais j'ai choisi de faire simple, il s'agit maintenant de lui apprendre a tracer des pentes.

On connait la position XY de depart et la position XY d'arrivee, L'idee qui vient de suite est d'utiliser l'equation de droite y=ax+b avec a=deltaY/deltaX et b=y-(ax). L'ennui c'est que suivant la pente on peut se retrouver avec un b negatif. D'un autre cote on se fiche de b car le deplacement a l'ordonnee est deja fait, le chariot se trouvant deja positionne. Donc on dit que b=0 et on se retrouve avec un calcul de tangente y=tan().x
tan()=deltaY/deltaX pour calculer la pente, ensuite il ne reste plus qu'a incrementer X et on calculer Y pour chaque valeur de X --> Y(X) --> Y=X.tan(), on incremente les pas moteurs pour chaque position.
Seulement voila, pour simplifier on a decide de rester en entiers des le debut du projet et on se retrouve maintenant avec des nombres a virgule pas pratiques, on va donc transformer tout ca en entier en multipliant par un grand nombre. Ca tombe bien il faut 800 pas pour une revolution de moteur et parcourir 1mm (pour rappel on a choisi sciemment une vis au pas de 1). On va donc multiplier la valeur de tangente par 800, tan()=(deltaY/deltaX).800, on obtient un grand nombre et du coup les chiffres derriere la virgule ne sont plus significatifs. Pour garder l'equilibre on commandera 1/800e de revolution a chaque appel de la routine, c'est a dire 1mm/800=0,00125 (1,25micron) parcouru par un pas moteur.

Je recapitule: on connait la position XY de depart, la position XY d'arrivee, on calcule deltaX: Xnew-Xold et deltaY: Ynew-Yold, ce qui nous permet de calculer la tangente. Si Xold (idem pour Yold) est superieur a Xnew en cas de retour en arriere, il resultera un nombre negatif, donc on inverse les donnees et on fait dans ce cas Xold-Xnew (ce qui nous donne le bon deltaX positif), on prend soin d'inverser le sens de deplacement du chariot et on retombe sur nos pattes. On multiplie cette tangente par 800 pour obtenir un grand nombre. Ensuite on incremente X en recalculant Y a chaque pas. On deplace les chariots X et Y et on trace la pente.
Ca roule.

; ----------------------------------------------- Calcul delta X --------------------------------------------------------------- ; soustractions entre nouvelles coordonnees et anciennes coordonnees ; pour obtenir la vraie distance a parcourir calcul_deltaX ; Avant de soustraire il faut determiner quel est le terme le plus fort entre coord et coord_old ; pour effectuer la soustraction sans avoir de nombre negatif et aussi pour savoir dans quel sens mouvoir l'axe ; La conversion ayant ete faite on n'a a s'occuper que des deux octets poids2 et poids3 movf coordX_old+2,w ; on teste le poids faible subwf coordX+2,w ; on soustrait coordX_old a coordX bn coordX_old_fort ; si coordX_old>coordX on saute a coordX_old_fort bnz coordX_fort movf coordX_old+3,w ; ensuite on teste le poids fort subwf coordX+3,w bn coordX_old_fort bnz coordX_fort ; si coordX_old>=coordX on saute a coordX_old_fort coordX_fort marche_av_X ; on avance 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 marche_ar_X ; on recule movff coordX_old+2,valeur1 movff coordX_old+3,valeur1+1 movff coordX+2,valeur2 movff coordX+3,valeur2+1 call soustraction16 stock_resultX ; Resultat sur 16bits dans valeur2 et valeur2+1 ; et on stocke le resultat dans deltaX movff valeur1,deltaX+1 movff valeur1+1,deltaX fin_soustractX return

La routine ci-dessous detecte si elle doit tracer une verticale, horizontale ou une pente:

Je ne m'interesserais pas jusqu'ici a la gestion des cercles et des arcs, le postpro de Cambam integre une fonction pour les transformer en un ensemble de segments ce qui me simplifie bien le travail.

ELLE BOUGE !!!! elle etait la, pauvre petite chose inerte sur la table, j'ai dirige les lasers metafulgurants asymetriques sur elle, abaisse un levier contre le mur, des eclairs partout, odeur d'ozone, pompe le courant dans tout le quartier, black-out total mais je m'en tape.
et... et... et PAF! elle s'est mise a dessiner.

Tout d'abord je voudrai remercier un ami pour tous ses conseils sur la marche a suivre. Dr Frank Stein si tu me lis... je sais enfin ce que tu as eprouve.

4L1C3 en langage digital ca s'ecrit comme ca:

La gestion des arcs et cercles a ete un peu plus pointue a mener parce que j'ai du resoudre pas mal de petits bugs autant mecaniques que logiciels, mais voila, c'est chose faite.

Quand 4L1C3 fait de l'art abstrait...

Le programme est a present fonctionnel, on passe maintenant a la phase d'optimisation. Jusqu'a present on fonctionnait en entiers, le gcode arrivait sur 4 chiffres codes en 32bits et n'affichait que des mm entiers, impossible de travailler avec precision avec de telles donnees mais c'etait plus pratique pour la mise au point du programme. J'ai modifie le postpro de Cambam pour qu'il me livre a present du gcode code sur 4 chiffres avec deux decimales apres la virgule. On est precis maintenant au 1/100e de mm, largement suffisant pour graver des circuits imprimes.
J'ai aussi passe les drivers en 1/16e de pas pour augmenter la precision des deplacements et avoir ainsi une plus grande marge de programmation.

Cela remet en cause tous les calculs, ainsi que les dimensionnements des variables. Pour la phase de tests et verifications je me suis aide d'une feuille de calcul creee sur le tableur d'Open-Office, elle m'evite de longs et laborieux calculs manuels avec toutes les sources d'erreurs que ca implique. Je rentre mes donnees gcode dans la feuille, je les ecris parallelement en dur dans le gcode que je donne en p�ture a 4L1C3 et les resultats doivent coincider.
Cette feuille de calcul est decrite ci-dessous. Les donnees a saisir manuellement sont dans les cases blanches, les resultats dans les cases rouges. La partie tout a gauche m'a servi pour definir les datas precalcules pour la conversion ASCII/decimal. Les trois autres blocs simulent tous les calculs du programme en partant de la valeur de la donnee gcode jusqu'a la valeur de la tangente utilisee pour le calcul des pentes. L'exemple ci-dessous simule les donnees gcode X1234.56, Y7890.12 et Z3456.78 (en decimal). Les anciennes coordonnees necessaires pour le calcul des delta X, Y et Z sont rentrees en hexadecimal a la main (on part du principe qu'elles ont deja ete calculees et traitees au tour d'avant), dans cet exemple 0x12122 pour le X et 0x73839 pour le Y. Les deltas resultant sont deltaX=0x0C11E et deltaY=0x04D1DB. Comme on l'a vu plus haut le deltaY est ensuite multiplie par 800 ce qui nous donne 0xF0FCC60 pour arriver a la valeur de tangente: 0x13F7.
Il n'y a plus qu'a envoyer le gcode au PIC, placer des points d'arrets dans le programme et scruter les registres apres chaque operation pour verifier les calculs.

La machine est trop petite pour y installer un tableau de bord de BOEING, neanmoins on peut acceder a toutes les fonctions de base par des associations de boutons.

Le programme est a present abouti et fonctionnel, il peut y avoir de petites differences entre le code definitif et les exemples cites plus haut, les modifications ayant ete nombreuses depuis mais l'idee generale est respectee. Des que j'aurai termine mon nouvel atelier je m'emploierai a construire une cnc graveuse de PCB digne de ce nom pour remplacer le prototype actuel en medium et elle servira a devellopper la version V.2 du soft 4L1C3.

Code definitif et complet d'4L1C3:

La video d'4L1C3 dans ses oeuvres:

Sarah Connors en saute de joie.