Table traçante

De Wiki LOGre
Aller à : navigation, rechercher


Table traçante

Présentation

Hérité d'un projet personnel qui avait pour but de me permettre de tracer les différents panneaux de tissus qui composent les différentes ailes de kitesurf et de parapente que je réalise, il s'agit d'une table traçante de grande dimension capable de tracer de façon précise à l'aide d'un feutre et à l'avenir à une série d'outils interchangeables (Feutre POSCA, bombe de peinture, aérographe, pointe de pyrogravure, laser, ...). Cette table me fait gagner un temps énorme pour la réalisation de tout mes projets "tissus" et évite d'imprimer des m² de patrons qui seront de toute façon jetés (à recycler).

Vidéo tracé

Différents prototypes de tables que j'ai réalisé:

Exemple de réalisation faite à l'aide de cette table :

Exemple multi-outils : feutre et Posca :

à L'origine cette table était piloté par une carte de type chinoise à l'aide d'un PC dédié et d'un logiciel de mon cru qui permet de piloter les différentes phases de déplacement des différentes glissières. la table a été décliné dans différentes versions utilisant la même électronique et le même logiciel, le meilleur exemple est une table de découpe laser réalisé par mon ami Germain utilisée pour la réalisation de voiles de kitesurf dans un projet de traversé trans-atlantique :

Mécanique

La table

à l'origine, composée de panneaux d'aggloméré, elle faisait 2m de haut par 3.5m de long et occupait le mur d'un couloir de mon appartement:

Au LOGAL la table sera faite en Placo BA13. Les plaques de plâtre qui composent la table sont accroché à des rails réglés pour obtenir la meilleur planéité possible.

Le portique

Le portique est la partie mobile en X (longueur de la table) et qui soutien la glissière Y (largeur de la table). Il roule sur un rail en aluminium qui fait la longueur de la table, entrainé par un moteur Pas à Pas qui engraine une crémaillère (courroie crantée collée sur le rail):

La glissière

La glissière est la partie mobile en Y qui soutient la tête d'impression, elle est mise en mouvement à l'aide d'un moteur Pas à Pas qui engraine une courroie crantée.

Il sera sans doute nécessaire de mettre un contre-poids pour les têtes les plus lourdes.

La tête d'impression

C'est la partie interchangeable qui va servir d'outil.

Electronique

Un PC et une carte de contrôle de moteurs Pas à Pas était installé sur la table d'origine.

Par la suite je souhaite utiliser une carte de pilotage type Smoothieboard pour dédier le pilotage et la rendre compatible avec tout les logiciels de pilotage actuels de type Repetier Host... Cela permettra aussi de la rendre compatible tout OS.

Les moteurs sont des NEMA23 de forte puissance, pour pallier aux relativement faibles puissances des drivers présent sur la smoothie, j'utilise un carte équipé de drivers plus puissants placé dessous celle-ci.

Logiciel

FDS est le logiciel de base de la machine, c'est un interpréteur de fichier DXF(R12) qui converti le fichier vectoriel en GCODE et est aussi capable de piloter la carte de moteur pas à pas.

Ce logiciel est voué à disparaître, remplacé par une simple moulinette qui transformera un fichier vectoriel (DXF, SVG, ...) en fichier GCODE diréctement interprétable par la carte Smoothieboard.

Convertisseur Dxf(R12) -> Gcode

une petite moulinette qui permet de convertir un fichier Dxf (R12) en Gcode en fonction du diamètre du stylo.

/**
 ******************************************************************************
 *
 * @brief      A simple dxf R12 to Gcode converter
 *
 * @file       dxf2gcode.c
 * @author     BARTHELEMY Roman Copyright (C) 2012-2013.
 * @brief      
 * @see        The GNU Public License (GPL) Version 3
 *
 *****************************************************************************/
/*
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
 * for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; if not, write to the Free Software Foundation, Inc.,
 * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 */
 
#include <signal.h>
 
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <fcntl.h>
#include <string.h>
#include <time.h>
 
#ifdef TARGET_OS_MAC
#elif defined __linux__
#include <sys/ioctl.h>
#include <linux/types.h>
#include <linux/rtc.h>
#elif defined _WIN32 || defined _WIN64
#endif
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/time.h>
 
 
#if defined _WIN32
#include <windows.h>
#endif
 
 
//! Private methods
void sig_handler(int signum);
 
char TXTBuffer[1024];
char OUTBuffer[1024];
 
//! Private variables
int fd;                // The spidev device
FILE *file_gcode;         // The gcode file
FILE *file_dxf;         // The dxf file
 
int ReadLine(FILE *file)
{
	int NbChar=0;
	int Pos=0;
	char c;
	memset(TXTBuffer,0,sizeof(TXTBuffer));
	if(feof(file))
	{
		return -1;
	}
	else
	{
		while(c!='\n')
		{
			c=getc(file);
			//fread(c, 1, sizeof(char), file);
			//fprintf(stdout, "%x",c);
			TXTBuffer[Pos]=c;
			Pos++;
			if( feof(file))
			{
				break;
			}
		}
		TXTBuffer[Pos]='\0';
		NbChar=Pos;
	}
	return NbChar;
}
 
int main(int argc, char **argv)
{
	float x,y,z;
	float diameter;
	float sqrt2=1.41421356237f;
	boolean InPolyline=0;
	boolean PolStart=0;
	boolean InVertex=0;
	char c;
	const char	*name;
	char name_output[256];
	while ((c = getopt(argc, argv, "d")) != EOF) {
		switch (c) {
		case 'd':
			diameter = atof(optarg);
			if (diameter < 0)
				goto usage;
			continue;
		case '?':
usage:
			fprintf(stderr,
				"usage: %s [-d N] file.dxf(R12)",
				argv[0]);
			return 1;
		}
	}
 
	// Install the signal handler
	signal(SIGINT, sig_handler);
 
	if ((optind + 1) != argc)
	{
		name = argv[optind];
		file_dxf = fopen(name, "rb");
		sprintf(name_output,"%s.gcode",name);
		fprintf(stdout, "%s\n",name_output);
	}
 
	fprintf(stdout, "Fertito Dxf 2 Gcode\n");
 
	file_gcode = NULL;
	file_gcode = fopen(name_output, "w");
 
	if(1)
	{
 
		unsigned char c[256];
		//file_dxf = fopen(name, "rb");
		ReadLine(file_dxf);
		while(ReadLine(file_dxf)!=-1)
		{
 
			if(sscanf(TXTBuffer, "POLYLINE%s",(char*)&c))
			{
				if(!InPolyline)
				{
					InPolyline=1;
					PolStart=1;
					//sprintf(OUTBuffer,"POLYLINE\n  5\n%x\n  8\n0\n 66\n     1\n 10\n0.0\n 20\n0.0\n 30\n0.0\n  0\n\0",PosDxfHexPoly);
					//fwrite(OUTBuffer, 1, strlen(OUTBuffer), file_gcode);
				}
			}
 
			else if(sscanf(TXTBuffer, "VERTEX%s",(char*)&c))
			{
				InVertex=1;
			}
 
			else if(sscanf(TXTBuffer, " 10%s",(char*)&c))
			{
				if(InVertex)
				{
					ReadLine(file_dxf);
					sscanf(TXTBuffer, "%f",&x);
					ReadLine(file_dxf);
					sscanf(TXTBuffer, "  20%s",(char*)&c);
					ReadLine(file_dxf);
					sscanf(TXTBuffer, "%f",&y);
					ReadLine(file_dxf);
					sscanf(TXTBuffer, "  30%s",(char*)&c);
					ReadLine(file_dxf);
					sscanf(TXTBuffer, "%f",&z);
					y=y+sqrt2*(diameter/2);//add the dimension of the pen.
					if(PolStart)
					{
						sprintf(OUTBuffer,"G0 X%f Y%f Z%f F600.0 S0.0\n\0",x,y,z);
						PolStart=0;
					}
					else
					{
						sprintf(OUTBuffer,"G1 X%f Y%f Z%f F600.0 S1.0\n\0",x,y,z);
					}
					fwrite(OUTBuffer, 1, strlen(OUTBuffer), file_gcode);				
					InVertex=0;
				}
			}
 
			else if(sscanf(TXTBuffer, "SEQEND%s",(char*)&c))
			{
				InPolyline=0;
			}
		}
		InPolyline=0;
		exit(0);
	}
	return 0;
}
 
/**
 * Signal handler that closes out all the devices
 * @param signum the signal that was received
 */
void sig_handler(int signum) 
{
	switch(signum) {
#ifdef __linux__
		case SIGQUIT:
#endif
		case SIGINT:
			fprintf(stdout, "Shutting down.");
			if(file_gcode) {
				fclose(file_gcode);
				file_gcode = NULL;
			}
			close(fd);
			exit(0);
			break;
		default:
			break;
	}
}

Travaux au LOGAL

Voici un état des lieux de l'avancement du montage de la table au LOGAL :

11/12/14 Assemblage de la base des rails

28/12/14 Mise à plat des rails et première passe d'enduit

30/12/14 2ème couche d'enduit, présentation du portique

Ponçage, enduit, pose du premier rail et présentation du portique :

Prise de photos du support moteur Y (vertical) à refaire ainsi que la glissière et du porte outils.

13/01/15 câblage et début des finitions

La sous couche a été posée, la crémaillère est collée sur 3.5m et le système de renvoi de poulie pour empêcher les oscillations du bras est en place.

Les câbles sont en places et la machine est opérationnelle, manque encre 2m de rail et la couche de peinture magnétique.