ReplicatorG est un logiciel de contrôle sur le PC qui permet de :

• Ouvrir et visualiser des fichiers 3D au format .STL
• Générer le GCode en utilisant le moteur SkeinForge
• Se connecter et envoyer des ordres à la carte de commande de la RepRap.

ReplicatorG est un logiciel assez populaire et beaucoup utilisé dans le monde de l'imprimante 3D libre car il dispose de beaucoup d'options et est compatible avec beaucoup de modèles d'imprimante.

Cette article ne couvrira que l'installation du logiciel, je ferais une présentation détaillée plus tard.

• Aller sur le site http://replicat.org/download pour récupérer le logiciel correspondant à votre OS, en l’occurrence "Linux".
• Décompresser l'archive :

  tar xvzf replicatorg-0029_r2-linux.tgz

• Installer le JRE Java pour la visualisation 3D (ne fonctionne pas pour l'instant avec la version libre openjdk) :

  sudo aptitude install sun-java6-jre

  Puis sélectionner la version de java à utiliser en choisissant la ligne contenant sun :

  sudo update-alternatives --config java

• Ensuite il faut copier le driver librxtxSerial de votre système en lieu et place du driver embarqué dans le dossier de Replicatorg (dans mon cas, mon système est 64 bits) :

  cp /usr/lib/jni/librxtxSerial.so replicatorg-0029_r2/lib-x86_64/

  Si vous ne faites pas cette étape, il se peut que vous vous retrouviez avec ce type de crash :

  *** buffer overflow detected ***: java terminated
  ======= Backtrace: =========
  /lib/x86_64-linux-gnu/libc.so.6(__fortify_fail+0x37)[0x7f4fa22001d7]
  /lib/x86_64-linux-gnu/libc.so.6(+0xfd0f0)[0x7f4fa21ff0f0]
  /lib/x86_64-linux-gnu/libc.so.6(+0xfc569)[0x7f4fa21fe569]
  /lib/x86_64-linux-gnu/libc.so.6(_IO_default_xsputn+0xd8)[0x7f4fa2176b98]
  /lib/x86_64-linux-gnu/libc.so.6(_IO_vfprintf+0x1abd)[0x7f4fa214931d]
  /lib/x86_64-linux-gnu/libc.so.6(__vsprintf_chk+0x94)[0x7f4fa21fe604]
  /lib/x86_64-linux-gnu/libc.so.6(__sprintf_chk+0x7a)[0x7f4fa21fe54a]
  /home/robert/3dprint/replicatorg-0025/lib-x86_64/librxtxSerial.so(fhs_lock+0x16f)[0x7f4f873e0a9f]
  /home/robert/3dprint/replicatorg-0025/lib-x86_64/librxtxSerial.so(Java_gnu_io_RXTXCommDriver_testRead+0x65)[0x7f4f873e0b25]

• S'assurer qu'on appartient au groupe "dialout" avec la commande id.
  Sinon, taper en root (en remplaçant nomUtilisateur par le votre) :

  usermod -a -G dialout nomUtilisateur

• Lancer le logiciel :

  cd replicatorg-0029_r2
  ./replicatorg &

  (au premier démarrage, les fichiers de préférences vont être créés)

Et voilà !

J'espère avec ce court article avoir pu vous aider à résoudre certains problèmes d'installation, comme j'en ai eu !

___

Partager cet article :

• Tweet

Après le préambule sur l'explication du rôle du firmware, et comme promis, voici un exemple concret du paramétrage du Firmware Sprinter pour la RAMPS 1.2.

Personnellement, j'ai passé beaucoup de temps à me renseigner, essayer, configurer tout un tas de versions existantes : Teacup, Tonokips, Sprinter,... Il y a beaucoup d'exemples, voire trop, et on est vite perdu dans la jungle des exemples trouvés, et qui semblent ne pas fonctionner sur sa machine.

Il faut alors s'armer de patience et de persévérance, car il faut faire l'effort de comprendre à quoi servent les paramètres à régler, et comment adapter un fimware pour qu'il fonctionne avec sa configuration.

Personellement, j'ai arrêté mon choix sur le Firmware Sprinter, développé principalement par Kliment et caru, et qui est un fork du Firmware Tonokips. Il est sous license GNU GPL v3, ce qui veut dire qu'on a le droit de mettre les mains dedans, et de faire partager nos modifications, ce que je vais m'empresser de faire !

Remplissez votre tasse de café ou votre verre de bière, cet article va être long ! Tout ce qui va suivre est adapté en fonction de ma carte de commande (la RAMPS v1.2) et de mon modèle de RepRap (Prusa), mais en fouillant un peu, il peut se généraliser à d'autres cartes. Voici précisément la liste des composants dont je dispose, et qu'il faut paramétrer dans le firmware :

• Modèle Prusa
• Moteurs pas à pas 200 pas / tour NEMA 17
• Extruder modèle Wade avec moteur pas à pas 200 pas / tour
• Thermistance d'extruder 100kOhm
• Thermistance du lit chauffant 100kOhm
• Electronique RAMPS version 1.2 avec driver POLOLU

Téléchargement du Firmware

Pré-requis

La carte RAMPS est basé sur la plateforme Arduino, il faut donc récupérer l'IDE Arduino pour compiler et flasher facilement la carte.

Télécharger le code source avec git

La méthode la plus simple est de récupérer le code sur le dépot GitHub de Sprinter. Pour cela, il faut ouvrir un terminal, aller dans le dossier où son ranger les sketchs Arduino, puis taper :

$ git clone https://github.com/kliment/Sprinter.git

Git va alors télécharger automatiquement le code source du Firmware. A l'avenir, il sera simple de mettre à jour votre code en local avec les modifications du dépot officiel en utilisant git, mais ce n'est plus le propos de cette article.

Télécharger le code source, pour les allergiques à la ligne de commande

Allez sur le dépot GitHub : https://github.com/kliment/Sprinter, puis cliquez sur l'icône "ZIP" pour télécharger un zip contenant le code source, puis décompressez le dossier dans votre dossier contenant vous sketchs Arduino.

Paramétrage du firmware

Ouvrez le Sketch Sprinter avec l'IDE Arduino, ce qui va ouvrir un tas d'onglets avec tous les fichiers sources. N'ayez pas peur, nous n'aurons besoin de modifier qu'un seul fichier : Configuration.h.

C'est dans ce fichier que nous réglerons tous les coefficients, gains, vitesses, accélérations et caractéristiques des composants de la carte électronique et de la machine. Ouvrez le fichier Configuration.h, et voyons ce qu'il y a à paramétrer :

Le type de carte électronique

Chaque type de carte possède des entrées/sorties différentes et spécifiques, qui sont renseignées dans le fichier pins.h. Reportez-vous au commentaire du fichier pour trouver celui qui correspond à votre carte. Pour la RAMPS 1.2, il s'agit du numéro 3.

// MEGA/RAMPS up to 1.2 = 3,
// RAMPS 1.3 = 33
// Gen6 = 5,
// Sanguinololu up to 1.1 = 6
// Sanguinololu 1.2 and above = 62
// Teensylu (at90usb) = 8
// Gen 3 Plus = 21
// gen 3 Monolithic Electronics = 22
// Gen3 PLUS for TechZone Gen3 Remix Motherboard = 23
#define MOTHERBOARD 3

Le type des thermistances

Ensuite, il faut renseigner le type de thermistance utilisée pour l'extruder et le lit chauffant. La thermistance permet de mesurer la température. En effet, sa caractéristique est d'avoir une résistance variable en fonction de la température.

Pour les curieux, les tables de conversion sont visibles dans le fichier thermistortables.h. Pour ma part, j'ai deux fois la même résistance de 100k.

// 1 is 100k thermistor
// 2 is 200k thermistor
// 3 is mendel-parts thermistor
// 4 is 10k thermistor
// 5 is ParCan supplied 104GT-2 100K
// 6 is EPCOS 100k
// 7 is 100k Honeywell thermistor 135-104LAG-J01
#define THERMISTORHEATER 1
#define THERMISTORBED 1

Calibration des axes

La calibration des axes permet de relier le nombre de pas moteur au déplacement de l'axe. Ayant le modèle Prusa, j'ai gardé les valeurs par défaut fournies dans l'exemple. Pour faire le calcul, il faut connaître :

• Le nombre de pas par tour du moteur Npas ( = 200 pour le NEMA 17)
• La résolution de controle du moteur Res (en fonction du paramétrage du driver de moteur pas à pas)  (=1/16 pour les axes X,Y et E, et 1/4 pour l'axe Z)
• Le nombre de dents de la poulie, Ndents (=8 pour les axes X et Y)
• La résolution de la courroie Rc, qui correspond au nombre de mm par dent (=5mm pour une courroie standard T5 de reprap).

Le paramètre de calibration vaut : step_per_unit = Npas / (Res * Ndent * Rc) = 200 / (1/16* 8*5) = 80 pas par mm pour l'axe X par exemple.

Le type de calcul est équivalent pour les axes Y et Z (et les valeurs par défaut conviennent).

Là où ça se corse, c'est sur le calcul du paramètre pour l'extrudeur "E". Il faut savoir combien il faut de pas moteur pour faire avancer le fil en entrée de 1 mm. Attention cependant, en fonction de la version du moteur de génération de trajectoire, Skeinforge (j'ai prévu de faire un article là dessus, parce que si je commence à en parler maintenant, je ne finirai jamais cet article), sur les anciennes versions ( <= 39) il fallait indiquer combien de pas moteur il fallait pour avoir en sortie de l'extruder un certain volume de matière.

Le plus simple est de se baser sur une version >= 40 de Skeinforge, et de régler le premier type de paramètre, qui est pus facile à calculer.

En fonction de votre extruder, du moteur, du ratio de l'engrenage, le ratio "step_per_unit" de l'extruder varie beaucoup d'un repraper à l'autre. En ce qui me concerne, j'arrive à ce ratio :

//// Calibration variables
// X, Y, Z, E steps per unit - Metric Prusa Mendel with Wade extruder:
float axis_steps_per_unit[] = {80, 80, 3200/1.25,700};

 Paramétrage des fins de course

En fonction du type de fin de course, il faut indiquer si le capteur retourne un signal haut ou bas. Si vous avez des fins de course avec une fourche optique, laisser les valeurs par défaut à FALSE, sinon avec des fins de course mécaniques (et en fonction du câblage), il faut inverser le signal, et donc indiquer TRUE. Si malgré ce réglage les axes ne bougent que sur la course de la butée, c'est qu'il faut inverser les constantes.

//// Endstop Settings
#define ENDSTOPPULLUPS // Comment this out (using // at the start of the line) to disable the endstop pullup resistors
// The pullups are needed if you directly connect a mechanical endswitch between the signal and ground pins.
//If your axes are only moving in one direction, make sure the endstops are connected properly.
//If your axes move in one direction ONLY when the endstops are triggered, set [XYZ]_ENDSTOP_INVERT to true here:
const bool X_ENDSTOP_INVERT = false;
const bool Y_ENDSTOP_INVERT = false;
const bool Z_ENDSTOP_INVERT = false;

 Vitesse de communication

Il faut paramétrer la vitesse de communication en bauds, et la retenir pour l'indiquer plus tard au logiciel sur le PC pour qu'il puisse communiquer correctement avec la carte. Je vous conseille de laisser la valeur par défaut.

// This determines the communication speed of the printer
#define BAUDRATE 115200

Utilisation d'une carte SD

Si vous avez un lecteur de carte SD sur votre électronique, et que vous souhaiter booter dessus au démarrage de l'imprimante, les lignes suivantes sont faites pour ça. Sinon, laissez-les commentées.

// Comment out (using // at the start of the line) to disable SD support:
//#define SDSUPPORT
// Uncomment to make Sprinter run init.g from SD on boot
//#define SDINITFILE

Paramétrage des axes

Je vais passer quelques lignes dont vous n'aurez a priori pas à toucher pour une utilisation normale (inversion / désactivation des axes).

Paramétrage des fins de course

En fonction du placement de vos fins de course, il faut spécifier au firmware si les fins de course correspondent au minimum de l'axe (-1) ou au maximum (+1). Ainsi, lors de l'initialisation des axes (Homing), le zéro sera fait en fonction du min ou du max de la course de l'axe.

//// ENDSTOP SETTINGS:
// Sets direction of endstops when homing; 1=MAX, -1=MIN
#define X_HOME_DIR -1
#define Y_HOME_DIR -1
#define Z_HOME_DIR -1

On peut également définir et activer des butées logicielles sur les axes, ce qui permet de les arrêter avant d'arriver en butée physique, et de forcer voire d'endommager l'axe. Pour celà, il suffit de mesurer la capacité physique d'évolution de chaque axe à partir de la butée d'initialisation.

const bool min_software_endstops = false; //If true, axis won't move to coordinates less than zero.
const bool max_software_endstops = true; //If true, axis won't move to coordinates greater than the defined lengths below.
const int X_MAX_LENGTH = 200;
const int Y_MAX_LENGTH = 200;
const int Z_MAX_LENGTH = 100;

Paramétrage des vitesses et accélérations

Vous pouvez ensuite définir respectivement les vitesses de déplacement maximales des axes en mm/min (feedrate), les vitesses de déplacement lors de la phase d'initialisation (rester sur des vitesses lentes pour initialiser les axes avec précision). Les autres paramètres sont à laisser aux valeurs par défaut.

//// MOVEMENT SETTINGS
const int NUM_AXIS = 4; // The axis order in all axis related arrays is X, Y, Z, E
float max_feedrate[] = {200000, 200000, 240, 500000};
float homing_feedrate[] = {1500,1500,120};
bool axis_relative_modes[] = {false, false, false, false};

Pour la suite, le paramétrage des accélérations est à laisser aux valeurs par défaut, sauf si vous vous y connaissez suffisamment pour paufiner les réglages de votre imprimante.

Réglage de la commande de chauffage

Tous les paramètres suivants concernent le réglage de la partie chauffante, et peuvent être délicats à régler, je vous conseille de laisser les valeurs pas défaut. Cependant, il peut être intéressant de limiter la valeur maximale de température, ce qui peut être utile pour ne pas endommager l'imprimante.

#define MAXTEMP 220

Compilation et téléchargement du firmware

Maintenant tous ces paramètres renseignés, compilez puis téléchargez le programme sur la carte de commande (cliquez pour l'aide Arduino). Vous pouvez maintenant essayer de connecter l'imprimante au logiciel de commande sur le PC (par exemple Replicatorg), et essayer de faire bouger les axes un à un ou de commander la température avec l'interface de controle du logiciel.

Je vous conseille fortement de garder la main sur l'interrupteur d'alimentation tant que vous n'êtes pas sûrs que les vitesses, fon de course et autre ne sont pas réglés correctement.

***

Pour la suite, je vous présenterai le logiciel Replicatorg, que j'utilise, ainsi que le logiciel Skeinforge. D'ici là, si vous avez des difficultés, vous pouvez m'en faire part dans les commentaires .

___

Partager cet article :

• Tweet

• Pilotage des moteurs pas à pas
• Gestion des butées physiques et logicielles
• Asservissement en température de l'extruder et du lit chauffant
• Pilotage du ventilateur de refroidissement

Attention, il ne faut pas confondre ce logiciel avec celui qui est installé sur le PC et qui sert à convertir un object 3D en commandes pour l'imprimante 3D.

Le Firmware ne connaît pas l'objet à imprimer, il ne fait que exécuter les ordres transmis par l'ordinateur de commande : se déplacer, chauffer l'extruder à 190°C, extruder, ...

Cependant, l'ordinateur ne connaît pas du tout les caractéristiques du matériel. Si le PC demandeà l'axe X d'avancer de 10mm, concrètement, il va envoyer cette commande à la carte :

G0 X10

Je ne veux pas rentrer maintenant dans les détails du langage de commande utilisé (le GCode), c'est juste pour montrer un exemple.

Le PC demande donc à l'axe X d'avancer de 10mm, mais il ne dit pas directement combien le moteur pas à pas doit faire de crans, avec quelle accélération, si il faut s'arrêter quand on arrive en butée,... Tout ce paramétrage se fait dans le Firmware de la carte. On commence donc a comprendre qu'il y a potentiellement énormément de paramètres à régler... et c'est le cas !

Fort heureusement, pour un modèle standard de RepRap, par exemple le modèle Prusa avec le "Wade's Extruder", ces paramètres sont connus et il n'y a plus qu'à copier/coller (enfin en théorie). De même, un firmware peut convenir à plusieurs cartes électroniques, mais les principales sont déjà intégrées dans le code de ces firmwares.

Je m'arrête là pour cet article, qui a pour vocation d'être un préambule à un prochain article sur la présentation et au paramétrage du firmware que j'utilise pour ma carte RAMPS v1.2, et qui arrive très bientôt (je sais que certains de mes lecteurs l'attendent avec impatience ) !

___

Partager cet article :

• Tweet

Dans cet article, nous allons voir rapidement comment transformer une alimentation de PC de type ATX pour avoir une alimentation utilisable facilement.

ATTENTION : Cette manipulation peut être dangereuse car nous allons ouvrir un appareil 220V, avec des condensateurs qui sont potentiellement encore chargés. Faites bien attention !

Première étape : choisir l'alimentation

En fonction de la puissance dont vous avez besoin, vous pourrez récupérer une vielle alimentation, ou acheter une alimentation Premier Prix. Pour une RepRap, il faut avoir idéalement 15A sous 12V, ce que peut délivrer une alimentation 300W. L'alimentation doit être compatible ATX pour pouvoir ensuite piloter l’allumage et l'extinction.

Deuxième étape :

Sur la grande prise, repérer le fil VERT (PS_ON) et coupez-le, ainsi qu'un fil de masse NOIR (COM) à proximité.

Troisième étape :

Ouvrir l'alimentation, et tirer les câbles que vous venez de couper. Pour vérification, sur mon alimentation le fil vert est bien noté PS_ON sur la carte :

On peut alors connecter les deux fils précédemment coupés sur un interrupteur :

Dernière étape :

Intégrez l'interrupteur dans le boîtier, et c'est fini !

___

Partager cet article :

• Tweet

Le modèle de l'électronique que j'ai choisi Arduino + RAMPS 1.2 en est un parmis tant d'autres, je vous conseille d'aller sur le Wiki RepRap pour avoir plus d'informations sur les autres modèles possibles. Une vidéo vaut mieux qu'un long discours pour présenter la carte :

 
D'une manière générale voici les fonctionnalités que vous retrouverez sur la carte de commande d'une imprimante 3D :

• Contrôle des moteurs pas à pas pour les axes
• Contrôle de l'extrudeur (moteur pas à pas ou CC en fonction du modèle)
• Commande des résistances de chauffage de l'extruder et du lit chauffant
• Acquisition des températures de l'extruder et du lit chauffant
• Acquisition des informations de fin de course (mécanique ou fourche optique)
• Pilotage d'un ventilateur pour le refroidissement au niveau de l'extruder

Ci dessous, la photos de la carte RAMPS version 1.2 en pièces détachées achetée sur le site GRRF.de. Je vous invite également à consulter leur wiki qui explique très bien comment assembler la carte étape par étape avec beaucoup de photos (c'est en allemand, mais Google le traduit bien si vous le souhaitez). 

Depuis, la boutique de GRRF.de propose la version RAMPS 1.4 qui ajoute la possibilité d'ajouter un second extruder, et d'ajouter une carte SD pour pouvoir imprimer sans l'ordinateur.

___

Partager cet article :

• Tweet

Dans le cas d'une RepRap, il est beaucoup plus difficile de trouver des réglages qui correspondent parfaitement à ce que l'on souhaite, du fait de la diversité des composants. Mais au final, on a la satisfaction de comprendre comment ça marche, et quand ce n'est pas le cas de comprendre pourquoi ça ne fonctionne pas .

Je reviendrai dans de prochains articles sur la description de ma configuration (mécanique, électronique, et logicielle), et surtout j'expliquerai tout ce qui m'a fait perdre du temps, en espérant que cela puisse servir à d'autres !

Une des premières impressions, un cube d'étalonnage.

___

Partager cet article :

• Tweet

Récemment, je suis tombé sur un bug lié à cette puce Mega8U2, qui visiblement ne se produit que sur les systèmes GNU/Linux. Les symptômes sont les suivants :

• Le périphérique /dev/ttyACM0 ne répond plus,
• L'IDE Arduino freeze pendant plusieurs secondes,
• Il faut parfois plus de 4-5 fois pour réussir à programmer l'Arduino

En parcourant les forums, je suis tombé sur ce topic, en anglais, où la solution à ce problème est donné par stimmer. Je vais donc traduire en français la marche à suivre pour la résolution, en espérant que cela puisse servir à d'autres !

ATTENTION ! Je vous encourage à bien vous renseigner sur la procédure, car elle peut être risquée pour un néophyte.

1. Préparation de la carte : sur l'Arduino Uno, il faut souder une résitance de 100 kΩ aux bornes des pastilles entourées en rouge sur la photo suivante (au dos de la carte) :
   
   
   
2. Installer le paquet dfu-programmer qui va permettre de reprogrammer la puce :

   # aptitude install dfu-programmer

3. Télécharger le binaire correspondant à votre carte (Uno ou Mega) sur le site suivant : https://github.com/arduino/Arduino/tree/new-extension/hardware/arduino/firmwares/arduino-usbserial (clic sur le fichier, puis clic droit sur le bouton "Raw" et Enregistrer Sous)
   Arduino-usbserial-uno.hex pour l'Arduino Uno
   Arduino-usbserial-mega.hex pour l'Arduino Mega
4. Brancher l'Arduino au PC avec le câble USB.
5. Faire contact entre les deux pins entourées en rouge sur la photo suivante :
   

   Cette opération permet de faire un reset de la puce Mega8U2. L'Arduino ne doit alors plus apparaître dans /dev/ :

   # ls /dev/ttyACM*

   Ne doit rien afficher.

6. Ensuite, il n'y a plus qu'à flasher la puce avec les commandes suivantes (à faire en root) :

   # dfu-programmer at90usb82 erase
   # dfu-programmer at90usb82 flash --debug 1 Arduino-usbserial-uno.hex
   Validating...
   4058 bytes used (99.07%)
   # dfu-programmer at90usb82 reset

7. Il n'y a alors plus qu'à débrancher puis rebrancher l'Arduino, et tous les bugs cités en introduction seront normalement résolus !

[Sources]
http://www.arduino.cc/cgi-bin/yabb2/YaBB.pl?num=1286088093/30
http://arduino.cc/en/Hacking/DFUProgramming8U2

___

Partager cet article :

• Tweet

Actuellement, les paquets arduino et arduino-core, qui sont les paquets officiels, sont en version 18 sur Wheezy, ce qui est une version assez ancienne qui ne supporte pas la dernière version de l'Arduino Uno.

Ne voulant pas passer ma machine en testing, ni jouer avec les dépendances pour installer à la main la version 22 (qui est la dernière version à ce jour) des paquets précédents, je me suis donc fait un chroot contenant la version unstable nommée "Sid". Pour ça, un petit coup de debootstrap :

# debootstrap --arch amd64 --variant=minbase sid /chemin/vers/chroot http://ftp.fr.debian.org/debian/

Ensuite, j'ai un petit script (launchChroot.sh) pour monter correctement les volumes nécessaires au chroot, lancer le chroot et tout démonter correctement à la fin :

#!/bin/bash
chemin=/chemin/vers/dossier/installation/du/chroot
mount --bind /dev $chemin/dev
mount --bind /proc $chemin/proc
mount --bind /sys $chemin/sys
cp {,$chemin}/etc/resolv.conf
chroot $chemin;
#fin on demonte
umount "$chemin"/{dev,proc,sys}

Ensuite, un petit coup de

# chmod 755 launchChroot.sh

puis, pour lancer le tout :

# ./launchChroot.sh

On est maintenant dans le système chrooté fraîchement installé. Nous allons donc pouvoir installer les dernières version des paquets arduino (qui a pour dépendance arduino-core) :

# apt-get install arduino

Pour éviter de faire trop de bêtises, on se créer un compte utilisateur :

# adduser nomUtilisateur

On ajoute l'utilisateur au groupe dialout pour qu'il puisse accéder au port série (sinon le sous menu Tools > Serial Port sera désactivé quand on lancera l'IDE arduino)

# usermod -a -G dialout nomUtilisateur
# su  nomUtilisateur
# arduino &

Tadam !

Ensuite petite vérification, sélectionner le Serial Port dans le menu Tools. Si vous avez un Arduino Uno par exemple, le périphérique /dev/ttyACM0 doit apparaître. Si ce n'est pas le cas, plusieurs raisons :

• L'utilisateur n'est pas dans le groupe dialout
• Vous n'avez pas bindé /dev dans le chroot (voir script du lancement de chroot ci-dessus)
• Vérifiez la version des paquets arduino et librxtx-java :

  # dpkg -s arduino |grep Version

  (doit être  >= 22)

  # dpkg -s librxtx-java |grep Version

  (doit être >= 2.2pre2-3)

• Ou encore, comme j'ai eu, vous êtes victime d'un bug concernant les drivers USB3. Je n'ai pas trop eu le temps de creuser, ce bug a l'air d'être connu mais je ne saurait dire si ça vient du hard, du noyau ou de la distro. Dans ce cas, il suffit dans brancher la carte sur un port USB2, et ça fonctionnera.

Bon amusement !

___

Partager cet article :

• Tweet

Pour ce premier article de la série, je vais parler de l'architecture mécanique de la RepRap.

L'imprimante est articulée autour de trois axes X, Y et Z qui permet de positionner la tête d'impression (en anglais "Extruder") en trois dimensions relativement à l'objet à imprimer. Le mouvement du plateau support est unidirectionnel selon l'axe Y, et la tête est mue selon les axes X et Z. Lors de la dépose d'une couche de plastique, seuls les axes X et Y bougent de manière synchronisée. Une fois la couche terminée, la tête de lecture est déplacée légèrement selon l'axe Z, puis une nouvelle couche peut être déposée.

Les mouvements selon les axes X et Y sont réalisés avec un moteur par axe, tandis qu'il faut 2 moteurs de part et d'autre de l'imprimante pour actionner l'axe Z.

Les moteurs sont des moteurs pas à pas, ce qui permet de les piloter facilement en position (nous y reviendrons plus tard). Les moteurs X et Y sont reliés à des courroies pour faire bouger la navette et le plateau. Les moteurs pour l'axe Z sont reliés directement aux vis permettant de monter et descendre la navette. Il existe aussi des versions avec un seul moteur pour l'axe Z, avec une courroie pour relier les deux vis permettant de faire monter la navette avec l'Extruder, mais le problème est que ces deux vis doivent être parfaitement synchronisées pour que l'axe X soit bien horizontal.

Le châssis de l'imprimante est composé de deux parties. Des tiges filetées et des barreaux (en gris sur l'image ci-dessus), et des pièces d'assemblage en plastique (en vert). Ce sont ces pièces qui peuvent être imprimées par l'imprimante pour en recréer d'autres, ce qui vaut à la RepRap sa qualification d'auto-réplicatrice !

Dans un prochain article, je vais me focaliser sur la tête d'impression.

___

Partager cet article :

• Tweet

• Le site URLOpener.com permet de saisir et d'ouvrir une liste d'URL
• Le site OpenUpper.com permet de saisir et de sauvegarder des listes d'URL pour les ouvrir plus tard (par exemple pour partager des listes, ça peut être utile).

C'est tout !

___

Partager cet article :

• Tweet

Oui je suis faible, j'ai craqué pour une RepRap... ( enfin !! )

Je ne vais pas expliquer ce qu'est une RepRap ici, mes lecteurs sont suffisamment geeks pour savoir ce que c'est .

Ça va faire plus de deux ans que j'ai pris connaissance du projet RepRap, mais à l'époque je n'avais pas de sous j'étais étudiant, et le modèle Mendel "de base" comportait beaucoup de pièces, qui étaient rares donc chères.  Depuis, les choses on beaucoup évolué. Tout un tas de nouveaux modèles sont sortis, qui à chaque fois permettait d'améliorer les performances de la machine, tout en diminuant le nombre de pièces nécessaires et donc le coût total. Le modèle Mendel Prusa a le vent en poupe ces derniers temps, et est maintenant considéré comme la nouvelle référence RepRap. A titre de comparaison, la RepRap Mendel originale nécessite 50 roulements à bille, contre 3 seulement pour la RepRap Prusa.

Vouloir avoir une RepRap, beaucoup de gens en rêvent. Concrétiser son rêve, c'est beaucoup plus compliqué, parce que :

• C'est quand même une petite somme d'argent à investir (cf plus bas),
• Il faut beaucoup de temps pour se renseigner sur les différents modèles et choisir le sien,
• Il faut faire la liste des pièces nécessaires, fouiller sur internet, les forums, les blogs,...
• Il faut trouver où acheter les pièces. Et c'est là que ça se corse : les vendeurs sur internet se font rares, et les pièces à vendre sur eBay partent rapidement. Il faut donc être trèèèèès patient pour trouver les bonnes pièces au meilleur prix sans se faire arnaquer,
• Il faut avoir du temps pour fabriquer la RepRap. Et oui c'est quand même plus marrant de tout faire soit même que d'acheter un kit déjà monté (et surtout beaucoup moins cher !!),
• Il faut avoir du temps pour modéliser les pièces et les imprimer. Il faut compter 10 à 20 cm³ par heure de débit de plastique (enfin quand on en est rendu à cette étape, on est content)

Personnellement, ça fait quelques semaines que je me renseigne activement sur la RepRap, et j'ai jeté mon dévolu sur le modèle Prusa, qui est suffisamment connu et diffusé pour qu'on trouve de la documentation à son sujet. Cette étape est vraiment primordiale pour bien savoir dans quoi on se lance, connaître les pièces à obtenir, les différents organes de la machine, etc.

Vient ensuite la chasse aux meilleurs prix et aux disponibilités sur internet. Le site officiel RepRap.org contient beaucoup de liens vers des sites marchand qui fournissent des kits plus ou moins complest, mais souvent à des prix prohibitifs. La solution pour moi a donc été de chercher dans les recoins d'eBay des pièces détachées, pour petit à petit cocher toutes les lignes de la liste des composants requis. En faisant cela, je suis arrivé à un coût nettement inférieur aux revendeurs de kits complets (de l'ordre de -40%, avec les frais de ports).

Voici le détail du coût de ma RepRap:

• Kit de pièces imprimés "Prusa" métrique : 78€
• Éléments mécaniques (tiges, vis, écrous,...) : 60€
• Base chauffante : 33€
• 5 Moteurs pas à pas : 100€
• Electronique complète : 200€
• Tête chauffante : 50€
• TOTAL : 521€

En cherchant encore plus, j'aurais pu rogner encore quelques dizaines d'euros, mais je n'avais pas envie de faire 50 commandes non plus...

Bref, je suis maintenant dans la phase d'attente de réception de tout ce matériel, ce qui me laisse le temps de faire grandir ma liste d'objets à imprimer...

___

Partager cet article :

• Tweet

Entre temps, j'ai beaucoup été pris par le boulot, et par Atlantronic, mon équipe participant à la Coupe de France de robotique. Cette année, nous remettons le couvert pour une nouvelle participation, ma cinquième

Sinon j'ai beaucoup de projets personnels plus ou moins avancés (dont mon horloge binaire à qui j'ai fait un beau boîtier), donc potentiellement plein d'articles à écrire. Encore une fois, il faut que je trouve le temps de faire tout ça, mais je ne désespère pas !

___

Partager cet article :

• Tweet

• Celle du riche fainéant : faire remplacer le clavier par Apple (200 €)
• Celle du pauvre de l'étudiant curieux : acheter un clavier externe (20 €) et déconnecter l'interne.

Le problème de la seconde solution, c'est que ça ne résout pas le problème des frappes intempestives sur clavier interne. Une solution facile est de déconnecter physiquement le clavier de la carte mère, et pour cela j'ai fait confiance un très célèbre site iFixit, spécialiste des réparations de produits Apple. La manipulation est décrite dans l'étape 15 de l'article de ce lien.

Le gros soucis, c'est que le bouton de mise en marche est justement relié par ce connecteur ! Qu'à cela ne tienne, j'ai donc cherché des les recoins d'internet et je suis tombé sur ce forum ou quelqu'un décrit quels sont les pins à relier ensemble pour simuler un appui sur le bouton.

Pour pouvoir allumer le Macbook sans le clavier, il suffit dont de faire contact entre les pins 5 et 29 du connecteur du clavier. Pour éviter d'avoir à ouvrir le portable pour chaque mise en route, j'ai donc soudé deux petits câbles, maintenus par un bon coup de pisto-colle, que j'ai fait sortir par la grille de ventilation arrière, et le tour est joué !

Et démarrer son Macbook à la MacGyver, ça n'a pas de prix !

(J'ai pensé à protéger un peu les contacts pour ne pas que la machine ne démarre ou s'arrête toute seule...)

___

Partager cet article :

• Tweet

Diagramme du DS1631

Ci-dessous un exemple de cablage avec l'Arduino, sachant qu'on peut choisir une partie de l'adresse I²C avec les pins A0, A1, A2 ce qui peut s'avérer pratique pour gérer plusieurs capteurs en même temps.

Branchement du DS1631 avec l'Arduino

Et voici le code permettant de lire puis d'afficher la température sur à l'aide d'une liaison série sur mon Minitel.

/*
 * DS1631 Temperature sensor
 * www.peyregne.info
*/
 
#include <Wire.h>
 
// Adress pins of the DS1631 device
// 0 if pin connected to GND, 1 to VDD
 
#define DS1631_A0 0
#define DS1631_A1 0
#define DS1631_A2 0
 
#define DS1631_CFG_R1     1  // resolution 9 to 12 bits
#define DS1631_CFG_R0     1  // set to 12 bits (750ms conversion time)
#define DS1631_CFG_POL    0  // T_OUT polarity (1=active high, 0=active low)
#define DS1631_CFG_1SHOT  1  // Conversion mode (1=one shot mode, 0=continuous mode)
 
// Do not change the following definitions
 
#define DS1631_ADDR (0x48 | DS1631_A2<<2 | DS1631_A1<<1 | DS1631_A0)
 
#define DS1631_CFG (DS1631_CFG_R1 << 3 \
                    | DS1631_CFG_R0 << 2 \
                    | DS1631_CFG_POL << 1 \
                    | DS1631_CFG_1SHOT)
 
#define DS1631_DONE_MASK 0x80;
 
void setup()
{
  // Opening I2C interface as Master
  Wire.begin();
 
  // First, stop the conversion (if configured in continuous
  // conversion mode) to access the configuration register.
  Wire.beginTransmission(DS1631_ADDR);
  Wire.send(0x22); // Stop conversion
  Wire.endTransmission();  
 
  // Configuration of DS1631 (see Datasheet)
  Wire.beginTransmission(DS1631_ADDR);
  Wire.send(0xAC); // Access Configuration
  Wire.send(DS1631_CFG);
  Wire.endTransmission();
 
#if DS1631_CFG_1SHOT == 0
  // If continuous mode is set, start continuous conversion
  Wire.beginTransmission(DS1631_ADDR);
  Wire.send(0x51);
  Wire.endTransmission();
  delay(750); // delay to be sure that the first value is correct
#endif
 
  UCSR0C = B00100100; // passage en mode 7bits + bit de parité
  Serial.begin(1200);
  Serial.print(12,BYTE);
}
 
 
void loop()
{
  float t = 0.0;
  t = readTempOne(DS1631_CFG_1SHOT);
  Serial.print(12,BYTE);
  Serial.print(10,BYTE);
  Serial.print(13,BYTE);
  Serial.print("Temperature : ");
  Serial.print(t,4);
  Serial.print(" degres");
 
  delay(10000); // wait 10 seconds 
}
 
float readTempOne(boolean oneShotMode)
{
  float temp = 0.0;
 
  if (oneShotMode)
  {
    // Temperature conversion request
    Wire.beginTransmission(DS1631_ADDR);
    Wire.send(0x51);
    Wire.endTransmission();
 
    delay(750); // delay for 12 bits precision
 
    // Now we wait the end of the conversion
    boolean tempAvailable = false;
    while (!tempAvailable)
    {
      // See if the conversion is finished
      // in the configuration byte
      Wire.beginTransmission(DS1631_ADDR);
      Wire.send(0xAC);
      Wire.endTransmission();
      Wire.requestFrom(DS1631_ADDR,1);
      Wire.available();
      tempAvailable = Wire.receive() & DS1631_DONE_MASK;
      delay(10);
    }
  }
 
  // read result
  Wire.beginTransmission(DS1631_ADDR);
  Wire.send(0xAA); // read last conversion
  Wire.endTransmission();
  Wire.requestFrom(DS1631_ADDR,2);
  Wire.available();
  int tempMS = (int) Wire.receive();
  Wire.available();
  int tempLS = (int) Wire.receive();
 
  tempLS >>= 4; // last 4 bits are always 0
 
  if (tempMS & 0x80) // if the signed bit = 1
    tempMS -= 256;
 
  // Float conversion
  temp = (float) (tempMS + tempLS*0.0625);
 
  return temp;
}

Le programme en action

___

Partager cet article :

• Tweet

En fait, quand on lance un terminal, on accède au shell d'accès, qui n'est pas personnalisé. Pour faire simple, le .bashrc, .profile, etc. ne sont pas chargés. On va alors forcer le chargement de ces fichiers à l'ouverture d'un terminal.

Au lancement d'un shell, le fichier .bash_profile qui est situé à la racine du dossier personnel est lu (s'il existe). Il suffit donc dans ce fichier de dire qu'on souhaite charger le .bashrc avec la commande source (ou ".").

Voici à quoi doit ressemble le .bash_profile pour résoudre la problème (créer le fichier à la racine de votre répertoire personnel si ce n'est déjà fait) :

#!/bin/bash
clear
source ~/.profile
source ~/.bashrc

Maintenant, à chaque lancement du terminal, votre .bahrc et autres fichiers seront correctement pris en compte.

___

Partager cet article :

• Tweet