Mot-clé - arduino

Fil des billets - Fil des commentaires

Samedi, avril 13 2013

Premiers pas avec le pcDuino

Si vous êtes un peu au courant de tout ce qui se passe dans le monde du DIY, vous avez peut-être entendu parler du pcDuino, concurrent direct du RaspberryPi. Certes, il n'a pas bénéficié du même effet d'annonce, mais pourtant il le mérite au moins autant. En effet, c'est une incroyable petite bestiole qui pousse le concept de mini-ordinateur hackable à souhait bien plus loin encore que le RasPi...

Jeudi, février 28 2013

[DIY + arduino] Alimentation d’atelier DIY – partie 2

Bonjour tout le monde !

Aujourd’hui j’ai le plaisir de publier la seconde partie de mon projet d’alimentation d’atelier DIY.
Pour ceux qui n’auraient pas suivi la première partie est disponible ici :
http://skyduino.wordpress.com/2012/09/04/bricolage-partie-1-alimentation-datelier-diy-a-partir/

Certains points ont évolué depuis la rédaction de cette première partie, en particulier concernant le schéma du montage que j’ai du entièrement revoir.
Trêve de bavardages, voici venu l’heure du DIY :)

Le matériel :

P1060038

Pour la réalisation de la carte mère j’ai utilisé :
1x carte arduino pro mini
1x écran LCD compatible HD44780
3x capteurs de courant ACS712
2x protoboards 3x7cm
3x prises banane (rouge)
3x prises banane (noir)
3x leds rouge 5mm
2x leds verte 5mm
1x buzzer
1x résistance de 100 ohms
3x résistance de 10K
5x résistances de 330 ohms
1x condensateur de 100µF
1x potentiomètre de 47K
1x capteur LM35 (optionnel)
+ des connecteurs tulipes mâles et femelles
+ des fils de câblages

Remarque : sur la photo vous pouvez voir un écran "POWERTIP PC1602-H", j’ai du changer d’écran après coup suite à un problème technique (j’en parlerai plus tard).

Le câblage :

Le montage est constitué de plusieurs parties qui une fois assemblées forment le montage final.

Les capteurs de tension :

diy_alim_voltage

Une des fonctionnalités de base d’une alimentation c’est de fournir un retour sur la tension réel en sortie.

Pour ceux faire j’ai utilisé 3 ponts diviseurs de tension, abaissant les 3 tensions de sortie de l’alimentation à un maximum de 5V pouvant être mesuré par la suite par l’arduino.
Les sorties +3v3 et +5v de l’alimentation sont mesurées au travers d’un pont diviseurs 1/2 pouvant donc accepter 10v maximum en entrée (j’ai vu large "au cas où").
La sortie +12v est mesuré au travers d’un pont diviseur 1/4 pouvant donc accepter 20v en entrée.

Les capteurs de courant :

diy_alim_current

Une autre fonctionnalité bien pratique pour une alimentation c’est de fournir une mesure du courant consommé sur chaque sortie.
Dans mon cas j’ai utilisé trois capteurs de courant intégrés du fabricant Alegro facilement disponible en breakout sur ebay ou dealExtreme : le ACS712.
Comme je ne sait pas encore très bien dans quelle fourchette de courant je vais me situer j’ai choisi de taper haut, j’ai donc pris une version x30A avec un maximum mesurable de 30A.
(autant dire qu’avec 30A j’ai de la marge)

Datasheet du ACS712-30A : http://www.allegromicro.com/~/Media/Files/Datasheets/ACS712-Datasheet.ashx

Les signaux de contrôle de l’alimentation :

diy_alim_signals

Pour pouvoir fonctionner correctement mon système à besoin de deux signaux reliés à l’alimentation d’ordinateur qui me sert de source de tension.

Un PSU d’ordinateur (= une alimentation à haut rendement) ce contrôle via deux signaux :
- PSU_ON (entrant, actif à l’état bas)
- POWER_OK (sortant, actif à l’état haut)
Ce sont tout les deux des signaux TTL, si PSU_ON est mis à GND l’alimentation démarre, de même quand POWER_OK passe à 5v cela signifie que la tension de sortie est stabilisé.

Vous remarquerez que j’ai mis la led du signal PSU_ON à l’envers (actuellement elle s’allume quand l’alimentation est arrêté).
Une fois le montage fini et testé je ferai une petite modification afin qu’elle s’allume quand PSU_ON = 0v, mais pour le moment je garde la configuration du schéma.

L’écran LCD :

diy_alim_lcd

Pour l’affichage j’ai pris un écran LCD 16×2 compatible HD44780, du classique disponible dans n’importe quelle boutique d’électronique.

J’ai cependant fait les frais d’une petite erreur d’inattention lors de ma commande !
J’avais commandé à l’origine un écran de la marque POWERTIP de référence : "PC1602-H".
Grosse boulette !

Le suffixe "-H" dans la référence signifie qu’il s’agit d’un écran pour une utilisation assujetti à de fortes températures (plein soleil, fours, …).
En dessous de 60° l’écran est totalement vierge, au dessus, miracle il est parfaitement lisible …
Pour pouvoir l’utiliser dans des applications "classique" (à 20-25°) il faut envoyer une tension négative dans la broche VO (contraste).
Dans mon cas cela n’était absolument pas envisageable …
J’ai donc du changer d’écran, au final j’ai pris un écran lcd 16×2 qui traînait dans un tiroir.

Les leds de statut :

diy_alim_leds

Mon alimentation DIY a une petite fonctionnalité bonus : chaque sortie est géré indépendamment.
Ainsi j’ai prévu 3 leds rouges qui s’allumeront pour prévenir d’une surcharge imminente sur une sortie.
Cela me permettra de savoir quelle sortie pose problème si l’alimentation se coupe par sécurité.

Le bouton start / stop / restart :

diy_alim_button

Pour l’allumage / arrêt / redémarrage de l’alimentation j’ai prévu un unique bouton.
Ainsi pour démarrer l’alimentation il suffira de presser le bouton, de même pour l’éteindre.
Et dans le cas où l’alimentation se couperait par sécurité il suffirait de presser ce même bouton pour redémarrer l’alimentation.

Afin d’éviter tout problème côté arduino j’ai inclus un anti-rebond matériel au niveau du bouton.
L’anti-rebond se résume à un condensateur de 100µF en parallèle de l’interrupteur, soit un anti-rebond de ~100ms (T = RxC, R = 10000, C = 10E-6 soit T = 0.1).

Le buzzer :

diy_alim_buzzer

Une bonne alimentation (surtout DIY !) se doit d’avoir un buzzer :)
C’est pourquoi j’ai prévu dans mon montage un buzzer avec une résistance de limitation de courant de 100 ohms.

Ce buzzer aura pour but d’alerter d’une coupure de l’alimentation, d’une surcharge ou de la stabilisation des tensions de sortie.
Ce sera aussi une bonne occasion d’inclure un "easter eggs" dans le code arduino :)

Le capteur de température :

diy_alim_temp

Après avoir fini mon montage je me suis rendu compte qu’il me restait une entrée analogique de libre …
Cela aurait été dommage de la laisser tel quelle, c’est pourquoi j’ai ajouté un capteur de température analogique LM35 au montage.
Celui ci permettra de surveiller la température des capteurs de courant qui risque de chauffer avec de fortes charges sur les sorties.

Montage sans câbles :

Voici quelques photos prisent durant le montage avant la mise en place des différents câbles.

La "carte mère", vue côté buzzer :

P1060041

(le potentiomètre sur la gauche est celui de l’écran lcd)

La "carte mère", vue côté capteurs de courant :

P1060043

Les différents morceaux constituant la "carte mère" :

P1060044

La base de la "carte mère" :

P1060046

Le support déporté pour l’écran lcd et les leds :

P1060049

(il s’agit de la première version, avant que je découvre le problème de l’écran lcd)

Petite parenthèse concernant l’écran lcd :

P1060051

Comme je vous le disait l’écran d’origine posait problème de part son alimentation négative pour le contraste.
Dans la première version de mon montage l’écran venait s’enficher dans un connecteur dédié comme vous pouvez le voir sur la photo.

C’était propre, mais bon … tant pis.
Refaire une commande pour prendre le même écran en version standard m’aurait coûté trop chère (surtout en frais de port), j’ai donc sacrifié mon montage "propre" au profit d’un montage fonctionnel.

Montage fini avec les câbles :

P1060080

Ça fait tout de suite beaucoup moins propre je vous l’accorde.

P1060083

Vous remarquerez que les broches A6 et A7 (disponibles uniquement dans la version CMS de l’ATmega328p) sont derrière le bouton reset, de même que A4 / A5 sont situés juste à coté du régulateur.
J’ai du jouer du cutter pour couper une piste reliée sur A5, cette version chinoise de l’arduino pro mini intégrant des résistances de pull-up pour l’I2C qui venaient fausser mes mesures analogiques.

P1060085

P1060087

(la colle chaude c’est la vie !)

P1060089

Astuce : les capteurs de courants que j’ai utilisé avaient déjà des borniers de base.
J’ai donc juste mis un câble pour "piquer" la tension au niveau du capteur de courant et l’injecter dans les ponts diviseurs mesurant la tension des sorties.

P1060092

Voici un exemple très parlant de l’expression : "cacher la merde sous le tapis" :)

P1060094

Annexe, le capteur de température :

P1060126

Comme je l’ai déjà dit j’ai ajouté un capteur de température LM35 au circuit.
Celui ci sera monté à terme sur une petite lame de métal qui recouvrira les trois capteurs de courant (avec de la patte thermique pour faire la liaison).
Cela permettra de dissiper la chaleur émise par les capteurs tout en la mesurant.

Premier essai du hardware :

Histoire de tester sommairement mon montage j’ai réalisé un petit code de test :

#include <LiquidCrystal.h>

/* Pin mapping */
static const byte LED_PIN[3] = {
  11, 12, 13
};
static const byte VOLTAGE_SENSOR_PIN[3] = {
  A0, A1, A2
};
static const byte CURRENT_SENSOR_PIN[3] = {
  A3, A6, A7
};
static const byte BUTTON_PIN = 2;
static const byte POWER_OK_PIN = 3;
static const byte PSU_ON_PIN = 4;
static const byte BUZZER_PIN = A4;
static const byte TEMP_PIN = A5;

/* LCD mapping */
LiquidCrystal lcd(10, 9, 8, 7, 6, 5);

/* PSU state */
static byte PSU_state;

void setup() {

  /* Setup pins */
  for(byte i = 0; i < 3; ++i) {
    pinMode(LED_PIN[i], OUTPUT);
    pinMode(VOLTAGE_SENSOR_PIN[i], INPUT);
    pinMode(CURRENT_SENSOR_PIN[i], INPUT);
  }
  pinMode(BUTTON_PIN, INPUT);
  pinMode(POWER_OK_PIN, INPUT);
  pinMode(PSU_ON_PIN, OUTPUT);
  pinMode(BUZZER_PIN, OUTPUT);

  /* PSU_ON and button signals interrupt setup */
  attachInterrupt(0, buttonPressCallback, FALLING);
  attachInterrupt(1, powerOkCallback, CHANGE);

  /* Serial setup */
  Serial.begin(115200);

  /* LCD setup */
  lcd.begin(16, 2);

  /* Get current PSU state */
  PSU_state = digitalRead(POWER_OK_PIN);

  /* Test code */
  lcd.print("Hello World !");
  digitalWrite(LED_PIN[0], HIGH);
  digitalWrite(LED_PIN[1], HIGH);
  digitalWrite(LED_PIN[2], HIGH);
  tone(BUZZER_PIN, 440, 500);
}

void loop() {

  /* Test code */
  for(byte i = 0; i < 3; ++i) {
    Serial.print(i);
    Serial.print(": ");
    Serial.print(analogRead(VOLTAGE_SENSOR_PIN[i]));
    Serial.print(" , ");
    Serial.println(analogRead(CURRENT_SENSOR_PIN[i]));
  }

  static byte s = LOW;
  digitalWrite(PSU_ON_PIN, (s = !s));
  
  delay(500);
}

void buttonPressCallback() {

  /* Test code */
  tone(BUZZER_PIN, 440, 500);
}

void powerOkCallback() {

}

Il est vraiment basique mais il m’as permis de tester grossièrement chaque partie du montage et de concevoir un squelette de code pour la suite.

Test de la carte arduino :

P1060096

Test des leds :

P1060101

Test de l’écran lcd :

P1060102

Test des capteurs de courant :

P1060107

La suite ?

Il me reste encore à réaliser un boitier pour le montage, de même qu’une jolie façade (sérigraphié ça serait top).
Ensuite il me faudra faire le code est finir le câblage des prises banane et des sorties de l’alimentation.
J’ai encore du boulot pour un petit moment :)

Bon bidouillage et bon WE à tous ;)


Classé dans:arduino, Corrigé, programmation, projet Tagged: diy, hack, madeinfr

Dimanche, février 24 2013

Pédale égaliseur graphique à base d’arduino et de MSGEQ7

Le projet d'aujourd'hui consiste, comme le titre de l'article l'indique, en la réalisation d'une pédale égaliseur graphique à base d'Arduino. Dans ce qui va suivre, je vais vous expliquer comment utiliser le MSGEQ7 (un égaliseur 7 bandes), afficher le résultat sur un écran LCD et, cerise sur le gâteau, comment faire votre propre shield Arduino maison.

Vendredi, février 15 2013

[DIY] Dock micro USB OTG

Bonjour tout le monde !

Pour notre projet tutoré à l’IUT nous avions besoin d’un dock micro usb OTG (je ne rentre pas dans les détails du projet en lui même ce serait trop long à expliquer).
On trouve plein de câble micro usb OTG dans le commerce, souvent en import direct de chine, le tout pour moins de 10$ voir moins.

Un câble "du commerce" c’est bien mais le problème c’est que ça prend de la place, qu’il soit coudé à 90° ou non !
Pour notre projet nous avions plutôt besoin d’un dock "low profil" avec un connecteur micro usb câblé en OTG qu’un simple câble coudé.
Après des heures de recherche sur ebay, dealExtreme & co le constat est sans appel, ça n’existe pas en "tout fait" …

Du coup, ni une ni deux, une commande de connecteur chez farnell, un petit typon sous Ares et voila ce que cela donne en image ;)

Le connecteur :

P1060128

J’ai choisi d’utiliser des connecteurs micro usb traversant miniature SANS "bouclier" de métal autour du connecteur afin d’éviter que le dock ne soit trop dur à brancher / débrancher.
Pour ceux qui veulent la référence ce sont des ZX20-B-5S disponibles chez farnell pour un prix dérisoire.

P1060133

Aussi par miniature, j’entends "vraiment" miniature, le bout de pince que vous pouvez apercevoir sur la photo fait en réalité 2mm, ça vous donne une idée de la taille globale du connecteur.

Mon "environnement de travail" :

P1060136

Bon j’avoue c’est pas très "pro" comme environnement de travail ;)

1er étape : le pré-câblage du connecteur :

P1060137

Comme les broches du connecteur ne font qu’un millimètre de long je ne pouvais pas les souder directement sur un morceau de pcb.
L’astuce des câbles OTG "du commerce" utilisant ce genre de connecteur est d’insérer un pcb très fin entre les deux rangées de broches et de souder le connecteur directement dessus.

Le problème c’est qu’ils nous faillaient un dock, soit un connecteur perpendiculaire au câble.
J’ai résolu le problème en soudant des fils de cuivre émaillés très fin à chaque broche du connecteur, fils qui seront soudés par la suite sur le pcb.

P1060140

Gros plan sur les soudures, ça m’a pris une bonne demi-heure pour tout souder et vérifier que les soudures étaient bonnes.

2iéme étape : le pcb :

P1060147

Ce que vous voyez là c’est ma cuisine … on a vu mieux comme atelier gravure …

Le typon a été réalisé sous Ares, puis transféré sur la plaque de cuivre au moyen d’une imprimante laser et de la célèbre méthode du "transfert de toner".
Pour la gravure en elle même je suis resté sur la solution "classique" du perchlorure de fer.

P1060148

Le pcb âpres 8 minutes de gravure à ~38°C, à ce stade il est prêt à être rincé.

P1060152

Le pcb rincé avec le toner encore présent sur les pistes de cuivre.

3iéme étape : l’assemblage :

P1060153

Vous remarquerez le magnifique effet miroir … c’est pas grave pour ce typon mais la prochaine fois je ferais plus attention.

P1060145

Petite particularité de mon câble USB OTG, celui ci est destiné à être "pluggé" dans une carte arduino !
Les cartes arduino possédant un connecteur USB-B mâle (ou femelle je me rappelle jamais …) j’ai donc massacré deux câbles usb-a / usb-b pour faire mon câblage.

P1060156

Voila ce que ça donne une fois le câble (la partie usb-b) soudé sur le pcb, avec en plus un petit strap pour tenir le câble solidement en place.

Les câbles OTG, trucs et astuces :

Quand j’ai voulu tester mon câble OTG pour la première fois rien ne c’est passé … rien de chez rien, quedal, niét, nada !

P1060157

J’avais pourtant fait le test avec une clef usb (formaté en FAT) et l’application "usb otg helper" pour android, censée fonctionner parfaitement … mais sans succès.

L’astuce est vraiment conne, mais une fois qu’on la connait tout marche tout de suite beaucoup mieux !

difference_circuit_271738111300

Vous voyez la broche "sense" (aussi appelait "ID") ?
Si elle est flottante c’est un câble normal, si elle est reliée à GND c’est un câble OTG.

La différence est mince mais le résultat totalement différent !

P1060159

On voit clairement les deux fils GND et ID reliés ensemble sur cette photo.

Et bien sûr une fois les deux broches reliées tout marche parfaitement :

P1060162

Pour les curieux ceci est ma clef usb "d’installation linux", avec mon wallpaper, mon script d’installation apt-get, un log u-boot (qui sort de je ne sais où) et une image openWRT que je garde de côté pour mon eeepc.

À noter aussi que le galaxy S3 n’est pas à moi mais à l’IUT … je n’ai pas le budget pour m’acheter un téléphone à +450€ (j’ai un HTC HD2 flashé sous android 4.1 ça me suffit largement :) ).

Fabrication du dock :

P1060164

Histoire de faire un truc "solide" j’ai collé le connecteur avec de la résine epoxy (tube avec deux composants à mélanger).
Mes essais avec de la colle cyanoacrylate n’ont pas été concluant, c’était trop cassant.

P1060167

Vous remarquerez le fait que le strap qui maintient le câble usb est volontairement fondu sur la gaine du câble pour éviter que celui ci ne bouge dans le futur.

4iéme étape : soudure des fils :

Tous d’abord les fils ont été coupés à la bonne longueur :

P1060168

Puis avec une bonne "lampe loupe" et un fer à souder bien chaud ça donne ça :

P1060170

Remarque : oui j’ai complétement raté le centrage de mon perçage sur la 1er plaque …
Remarque 2 : les fils sont émaillés donc aucun risque de court-circuit ;)

Fignolages :

La colle chaude c’est la vie ! Je le répéterai jamais assez : bénis soit l’inventeur de la colle chaude !

P1060172

P1060175

Résultat final :

P1060176

(le deuxième câble est identique au premier ;) )

Je peux vous garantir que vous trouverez jamais un connecteur micro USB OTG aussi DIY que celui là :)
Le cout total s’élève à 3.5€ (pcb et colle exclut) par dock, soit pas grand chose au final.

Bon bidouillage et bon WE à tous ;)


Classé dans:arduino, programmation, projet Tagged: diy, madeinfr

Dimanche, novembre 11 2012

WebPlug: la domotique en utilisant un arduino

Bonjour à tous. Aujourd'hui, je vais vous montrer un des trucs les plus cools que l'on puisse faire avec un arduino: contrôler des appareils. Quand je dis "appareils", je parle de vos lampes, de votre grille-pain...

Mercredi, octobre 10 2012

La carte électronique de Bleuette : Shield Bleuette

Pour ceux qui aurait raté les épisodes précédents, Bleuette est un robot hexapode (3 paires de pattes) entièrement libre (logiciel, plan, etc...) réalisable avec une imprimante 3D ou dans une moindre mesure et de la patience en découpant les pièces dans du Plexiglas. Concernant la carte fille, je viens d'arriver au bout de son routage et je vais... Lire La carte électronique de Bleuette : Shield Bleuette

Samedi, avril 7 2012

[Arduino] BrossoGlisseur, le robot qui se déplace sur des brosses

Bonjour tout le monde !

Aujourd’hui je vous ai préparé un article qui, je l’espère, va en faire sourire plus d’un ;)
Un bon article avec de gros morceaux de « What the f*ck ! » dedans, et oui c’est samedi !

J’ai le plaisir de vous présenter : le brossoGlisseur !

Ceci est une révolution !

Bon concrètement qu’est ce que le brossoGlisseur ?
C’est un robot contrôlable à distance, jusque là rien de bien nouveau, mais qui utilise des balayettes comme moyen de propulsion.

Vous êtes sûrement en train de vous demander s’il s’agit d’un concept révolutionnaire ou d’un truc complètement dingue.
Ne cherchez pas c’est de la haute technologie moderne, même Apple n’aurait jamais imaginé un truc pareil :)

Le hardware est très simple :
- 2 balayettes (0.90€ pièces),
- 2 moteur à courant continu,
- une carte interface de puissance,
- une carte arduino,
- un module 433MHz.

Le principe :
En gros les moteurs font faire vibrer le bout des balayettes, ce qui a pour effet de générer une légère impulsion vers l’avant lorsque le poids accroché à l’axe du moteur descend puis remonte.
En faisant cela à une vitesse relativement élevée et en gérant indépendamment le moteur droite et le moteur gauche il est possible d’avancer ou de tourner.

Au niveau de l’interface de puissance j’ai ré-utilisé mon circuit à base de mosfet que j’avais réalisé pour un projet précédant.
Le schéma est disponible ici.

Les moteurs en eux même sont fixés avec de la colle chaude en mode « grosse brute ».
Tant qu’ils sont centrés tout va bien, après qu’il soit fixé avec des vis ou de la colle chaude … c’est juste une question de durabilité.

Pour contrôler tout ce petit monde j’utilise une seconde carte arduino avec un duo émetteur / récepteur 433MHz et la librairie VirtualWire.
Le contrôle des moteurs se fait avec l’axe X et Y du joystick.

Voici le code arduino pour les deux cartes :

Télécommande :

#include <VirtualWire.h>

#define MAX_SPEED 127 // Vitesse maximum (0 ~ 255)
#define MIDDLE_LIMIT 50 // Marge par rapport au centre du joystick

uint8_t buf[2];
int cal, balance, speed;
float bal1, bal2;

void setup() {
  pinMode(5, OUTPUT);
  pinMode(7, OUTPUT);
  digitalWrite(5, HIGH);
  digitalWrite(7, LOW); // Astuce pour utiliser le joystick sans câblage

  pinMode(A0, OUTPUT);
  pinMode(A4, OUTPUT);
  digitalWrite(A0, LOW);
  digitalWrite(A4, HIGH); // Astuce pour utiliser le module 433MHz sans câblage

  cal = analogRead(A2);

  vw_set_tx_pin(6);
  vw_setup(2000);
}

void loop() {
  balance = analogRead(A2);
  speed = analogRead(A3);

  balance -= cal;
  bal1 = (balance < -MIDDLE_LIMIT) ? -balance / cal : 1;
  bal2 = (balance > MIDDLE_LIMIT) ? balance / cal : 1;

  speed = map(speed, 0, 1023, MAX_SPEED, 0);

  buf[0] = speed * bal1;
  buf[1] = speed * bal2;

  vw_send(buf, 2);
  vw_wait_tx();
  delay(100);
}

Robot :

#include <VirtualWire.h>

uint8_t buf[VW_MAX_MESSAGE_LEN];
uint8_t buflen = VW_MAX_MESSAGE_LEN;

void setup() {
  pinMode(5, OUTPUT);
  pinMode(6, OUTPUT);
  digitalWrite(5, LOW);
  digitalWrite(6, HIGH); // Astuce pour utiliser le module 433MHz sans câblage

  vw_set_rx_pin(7);
  vw_setup(2000);
  vw_rx_start();
}

void loop() {
  if (vw_wait_rx_max(200))
    if (vw_get_message(buf, &buflen)) {
      analogWrite(3, buf[0]);
      analogWrite(11, buf[1]);
    }
}

Au niveau de l’alimentation je voulais utiliser une batterie de modélisme, mais j’ai malencontreusement perdu mon chargeur.
Du coup je n’ai pas pu l’utiliser.

A la place j’utilise mon alimentation d’atelier avec un fils de 5m de long, c’est pas du tout pratique, mais bon on fait avec ce qu’on a.

Et comme promis voici une vidéo de démonstration du robot en action.
Pour une fois j’ai fait cette vidéo en mode relâche. Il doit y avoir une bonne dizaine de « et m*rde … », c’est du grand n’importe quoi.
Je vous ai gardé que le meilleur :)

Héhé maintenant vous ne regarderez plus les balayettes de la même manière :)
Qui sait, si ça se trouve les voitures de demain seront propulsés par ce système … ou pas ^^

Enjoy :)


Classé dans:arduino, programmation, projet Tagged: arduino, madeinfr, robot, wtf

Mercredi, mars 7 2012

Assemblage de l'Ultimaker

5 semaines après la commande, un transporteur m’amène un lourd carton (10kg) venu des Pays Bas : ça y est, j’ai reçu mon UltiMaker.

Légèrement en avance d’ailleurs car ils m’avaient annoncé 6 semaines de délai, je crois avoir été chanceux car je n’avais pas commandé de bobine de plastique supplémentaire et une semaine auparavant, un courriel de Ultimaker annonçait qu’il était en rupture de certain coloris de PLA et proposait, pour ceux en ayant commandé en plus, de remplir un formulaire, afin de choisir des couleurs de remplacement pour éviter d’attendre trop longtemps, du coup, j'ai dû être traiter légèrement en avance...

Carton ouvert, découverte du contenu :
20120303_104821.jpg

Tout est bien rangés, chaque sachet possède un autocollant avec sa référence et son nom, tout est dans du papier bulle...
Tout, hmmm, presque tout, jusqu’à ce que j’arrive au fond du carton, là, sont posés les plaques de bois (du bouleau, très solide et rigide) découpés au laser, ces dernières sont enfoncées toute au même niveau, conséquences d’un impact extérieur que je n’avais pas vu au premier abord sur le carton mais qui est bien visible... Les plaques étant emballées elles aussi dans du papier bulle mais directement en contact avec le carton trop petit, une chute, un envoi de livreur un peu brutal et paf le bouleau, comme vous le voyez sur les photos, c’est assez localisé, ça n’empêchera pas beaucoup le montage...

CIMG4864.JPG CIMG4865.JPG CIMG4867.JPG

La blessure la plus importante est celle-ci oû le choc à explosé le bois et bouché les trous permettant la fixation des planches entre elle...
CIMG4866.JPG

Je réquisitionne une grande table, étale le contenu du carton sur celle-ci et c’est parti...
CIMG4863.JPG

Aucun plan papier fourni, c’est pas plus mal, tout est disponible en ligne, en anglais, illustré de photos, ils indiquent 6 à 20h de travail...

Première étape, le caisson avec ces foutus passe cable qui m'ont fait tourné en bourrique...
CIMG4886.JPG

Tout se monte sans encombre jusqu’au drame :
CIMG4885.JPG

Il se sont trompés en me livrant une poulie avec le mauvais diamètre interne (les 2 de droites devraient être identiques avec un diamètre inférieur), arggg, la casse durant le transport, une poulie inutilisable, je me voyais mal attendre...
Par chance, j’avais une entretoise dont le diamère externe correspond au diamètre interne de la poulie, un petit usinage pour que son diamètre interne s’adapte à l’axe du moteur et voilà... ouf !!

CIMG4888.JPG CIMG4889.JPG CIMG4890.JPG

L’assemblage de la tête d’extrusion est plutôt délicat mais se fait sans trop de problème.

Le montage s’est poursuivi jusqu’à la plateforme de l’axe Z, il faut faire rentrer en force des roulements linéaires dans des planches de bois pour former un sandwich, les jeux sont plus que limite et j’ai dû m’y prendre à plusieurs fois afin d’avoir quelque chose d’à peu près correct, comprenez : quelque chose de droit.
Heureusement, ils ont prévus le coup et le jeu est rattrapable par un système de réglage à vis / ressort...

Enfin, vient le moment de relier électriquement tous les éléments, fin de course, moteur, élément de chauffe, puis l'allumage :
20120304_222945.jpg

Tout à fonctionné du premier coup sauf une erreur sur la carte qui indique la connection pour le capteur de fin de course droit alors que c’est le gauche, une inversion et tout roule...

Maintenant, le branchement à un ordinateur, est-ce plug and play ?
Oui, Ultimaker reconnu immédiatement (c’est une carte Arduino pour l’intelligence de la bête, j'avais déjà installer les pilote FTDI), j’ai pu envoyer des ordres pour piloter les moteur X, Y, Z, c’est très réactif et la vitesse impressionnante...

Au moment au j'écris ces lignes, je n'ai pas encore pu tester à fond l'animal donc, je n'aurai pas de retour à faire sur son utilisation, hormis le souci dans le transport (prévoir un carton plus grand) et l'erreur de poulie (la personne du contrôle ne devait pas être réveillée), le kit est de bonne qualité et je comprends mieux le prix, c'est vraiment bien étudié au niveau de l'assemblage, on retrouve des pièces en métal de très grande précision, la carte électronique est très bien réalisé, la partie puissance est totalement ventilé, bref, c'est du sérieux...

- page 1 de 3