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…

Trêve de bla-bla, voyons un peu à quoi ressemble l’engin:

featured-image

Au programme:

  • CPU: Cortex A8 cadencé à 1GHz
  • GPU: OpenGL ES2.0, OpenVG 1.1 Mali 400 core
  • 1Go de RAM
  • Ports: HDMI, Ethernet, 3 ports USB
  • Slot micro-SD (pour le stockage)

Déjà là, on sent bien que le Raspberry Pi a du souci à se faire! CPU beaucoup plus puissant, 1Go de RAM contre 256/512Mo…Mais attendez, ce n’est que le début!

La carte embarque une mémoire flash NAND de 2Go. Ca semble con comme ça, mais l’intérêt est avant tout d’y loger le système d’exploitation. Et oui, là où le Raspi charge l’OS en RAM à partir d’une carte SD, le pdDuino utilise une mémoire flash. Et là, croyez-moi, ça dépote. A titre d’info, le pcDuino effectue un reboot complet en 45 secondes. D’ailleurs, parlons-en de l’OS…

Le pcDuino est livré avec Ubuntu 12.10, mais il est possible d’y installer un Android Ice Cream Sandwich. Oui, vous avez bien lu. Ubuntu et Android. Je vous laisse imaginer la suite!

Bon, on est pas mal là quand même! Et si je vous dit que ce n’est pas fini? Si je vous dis en plus que le pcDuino est compatible avec la plupart des shields Arduino?

Elle est pas belle la vie?

Le pcDuino dispose en effet des quatres séries de pins d’un Arduino standard: les analog, les PWM, les TX/RX…et ça, c’est vraiment cool.

Maintenant, passons au travaux pratiques!

Première prise en main

Pour lancer la bestiole, rien de plus simple: clavier, souris, écran sur le HDMI, Ethernet, alimentation. Quelques secondes plus tard, tadaaaaa:

2013-04-05-180149_1280x720_scrot

Petit test de Chrome:

2013-04-05-180809_1280x720_scrot

Bon, visiblement ça fonctionne! Maintenant, il s’agit de configurer tout ce petit monde!

Configurer le clavier

Parce que le QWERTY ça va 5 minutes:

sudo dpkg-reconfigure keyboard-configuration

Si nécessaire, rebootez:

sudo reboot

Configurer SSH

Oui, ça peut aider, non? Cette partie est un basée sur cet article.

Tout d’abord, on se créé un utilisateur qu’on ajoute de suite au groupe admin, histoire d’avoir les droits qui vont bien et de pouvoir faire du sudo avec ce compte:

sudo su
adduser deabdird
puis:
adduser deadbird admin
Ensuite, récupérez votre adresse IP:
ifconfig
Installez le package SSH:
apt-get install ssh
Puis nano, un éditeur de texte en ligne de commande:
apt-get install nano
Le but est d’éditer un peu la conf de SSH pour le sécuriser un tout petit peu plus. Modifiez la ligne suivante:
PermitRootLogin yes
en
PermitRootLogin no
et ajoutez celle-ci:
AllowUsers deadbird

Ces changements permettent de n’autoriser que l’user que vous avez créé à se logger en SSH. Maintenant, rebootez et testez avec une autre machine.

Changer la résolution

Si comme moi vous brancher votre pcDuino sur un écran d’ordi avec un adapteur HDMI vers VGA, vous devriez avoir une résolution moisie. Mon but: avoir du 1280*1024. Changer la résolution d’affichage n’est pas une partie de plaisir, mais voici la manip, tirée du site the greathouses:

Tout d’abord, installez git, libusb et pkg-config:

sudo apt-get install git libusb-1.0.0-dev pkg-config

Ensuite, nous allons récupérer et compiler les sources de sunxi-tools, un programme permettant d’éditer le fichier evb.bin, où se trouve la configuration de l’affichage.

git clone https://github.com/linux-sunxi/sunxi-tools

cd sunxi-tools

make

Maintenant, il va nous falloir accéder à evb.bin, qui est stocké dans la partition de boot, plus précisément dans la mémoire flash de la carte:

sudo mount /dev/nanda /boot

Maintenant, vous avez accès à evb.bin:

ls /boot

Avant de modifier le fichier, faites-en une copie:

sudo cp /boot/evb.bin /boot/evb.bin.bak

Ensuite, décompilez le fichier evb.bin et faites-en un fichier:

./bin2fex /boot/evb.bin >evb.conf

Ouvrez-le avec nano.

Attention à ce que vous touchez dans ce fichier, il y a là de quoi cramer votre pcDuino!

A ce propos, di vous voulez vraiment mettre les mains dans le cambouis, allez donc voir le FEX Guide ici, vous y trouverez de quoi charcuter l’evb.bin. Mais encore une fois, attention…

Cherchez une section nommée “disp_init” (utilisez Ctrl+W pour chercher avec nano). Elle devrait ressembler à ceci:

[disp_init]
disp_init_enable = 1
disp_mode = 0
screen0_output_type = 3
screen0_output_mode = 5
screen1_output_type = 3
screen1_output_mode = 9
fb0_framebuffer_num = 2
fb0_format = 10
fb0_pixel_sequence = 0
fb0_scaler_mode_enable = 1
fb1_framebuffer_num = 2
fb1_format = 10
fb1_pixel_sequence = 0
fb1_scaler_mode_enable = 0

Modifiez la valeur de la variable “screen0_output_mode”:

HDMI Mode Resolution
0 480i
1 576i
2 480p
3 576p
4 720p50
5 720p60 (default)
6 1080i50
7 1080i60
8 1080p24
9 1080p50
10 1080p60
11 PAL
12 PAL_SVIDEO
14 NTSC
15 NTSC_SVIDEO
17 PAL_M
18 PAL_M_SVIDEO
19 PAL_NC
21 PAL_NC_SVIDEO
23 1080p24-3D
24 720p50-3D
25 720p60-3D
26 1360×768-60
27 1280×1024-60

Une fois les modifs enregistrées, transformez le fichier en un nouvel evb.bin:

sudo ./fex2bin evb.conf /boot/evb.bin

puis démontez la partition:

umount /boot

et redémarrez:

sudo reboot

Et là…croisez les doigts. Si ca ne fonctionne pas, recommencez la manip inverse ou restaurez l’evb.bin que vouz avez sauvegardé. Essayez d’autres résolutions jusqu’à tomber sur quelque chose de bien.

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.

Etape 1: le MSGEQ7.

Je rentre direct dans le vif du sujet, je vais vous montrer comment fonctionne ce merveilleux petit circuit. Tout d’abord, où le trouver. Si vous résidez en France, je vous conseille hobbyelectro de l’ami Furrtek. Rapide et pas cher. Sinon, le MSGEQ7 est aussi dispo chez Sparkfun (trois fois plus cher, mais bon…).

Une fois que vous avez votre puce en main, il suffit de chercher la datasheet pour trouver le pinout:Screen Shot 2013-02-24 at 6.06.08 PM

mais aussi et surtout le schéma de câblage:

Screen Shot 2013-02-24 at 6.07.40 PMBon, ça fait peur comme ça, mais en cherchant un peu sur le net j’ai trouvé une version plus facile à comprendre:

schem1-450x600

J’ai utilisé ce schéma que j’ai câblé sur une breadboard, et ça donne ça:

IMG_2585

Les plus tâtillons d’entre vous aurons remarqué que j’ai utilisé 3 condos de 100pf en série pour faire un condo de 33pf, de même que deux résistances de 100kohms pour faire une de 200. J’ai beau avoir des milliers de résistances, j’en ai pas une seule de 200kohms…

Maintenant, la partie logicielle…

Etape 2: le code

Nous avons 3 pins à utiliser:

  • STROBE, connectée à la pin Digital 2 sur l’arduino,
  • RESET, connectée à la pin Digital 3,
  • OUT, connectée à la pin Analog 0.

Vous pouvez utiliser les pins que vous voulez, le MSGEQ7 n’utilise pas d’interrupt, pas d’I2C, pas de SPI, rien de spécial. Chaque patte a une utilisation particulière, comme l’explique le chronogramme de la datasheet:

Screen Shot 2013-02-24 at 9.28.00 PM

Là vous vous dites: “ohlàlà, mais qu’est-ce qu’il nous gonfle avec tous ces détails?”…le MSGEQ7 est une puce relativement simple à comprendre, autant se pencher un peu sur la théorie!

Ce que nous dit ce chronogramme:

  1. la puce crache les valeurs de chaque fréquence (il y en a 7 différentes, d’où le “7″ de “MSGEQ7″) sur OUT.
  2. pour cela, il faut effectuer un reset de la puce avant chaque lecture. pour cela, il faut passer la patte RESET à haut puis à bas.
  3. ensuite, il faut passer la pin STROBE à bas
  4. attendre 36 microsecondes, que la puce crache la valeur sur OUT
  5. passer STROBE à haut.
  6. recommencer à l’étape 3

En termes d’arduino, voici ce que cela donne:

const int ANALOG = 0;
const int STROBE = 4;
const int RESET = 5;
int outputValues[7];

void setup(void) {
  //setup MSGEQ7
  pinMode(ANALOG, INPUT);
  pinMode(STROBE, OUTPUT);
  pinMode(RESET, OUTPUT);

  analogReference(DEFAULT);

  digitalWrite(RESET, LOW);
  digitalWrite(STROBE, HIGH);

}

void loop(void) {
  //reset chip
  digitalWrite(RESET, HIGH);
  digitalWrite(RESET, LOW);

  for (int i = 0; i < 7; i++) {
    digitalWrite(STROBE, LOW);
    delayMicroseconds(30);
    outputValues[i] = analogRead(ANALOG);
    digitalWrite(STROBE, HIGH);
  }
}

Ok, c’est bien tout ça, mais comme savoir si ça fonctionne? Simple: ajoutez un Serial.begin(9600) dans le setup et quelques Serial.print dans le loop pour afficher les valeurs sur le serial monitor et hop, c’est gagné! Et là vous vous rendrez certainement compte que le MSGEQ7 est une véritable perle: donnez lui du son et il fera le reste! Je l’ai utilisé avec une basse possédant un gros niveau de sortie et avec la carte son de mon iMac, il réagit aussi bien avec l’un qu’avec l’autre. Bon maintenant, il s’agirait peut-être d’afficher les valeurs autrement, non?

Etape 3: l’écran LCD

Les écrans LCD pour arduino, c’est pas ce qu’il y a de plus difficile à trouver. On en trouve une tétrachiée chez Sparkfun par exemple…mais si on veut quelque chose de sympa et pas cher, il faut creuser un peu plus. En ce qui me concerne, eBay m’a encore une fois sauvé la vie.

Petit aparté.

Je tiens à remercier du fond du coeur nos amis les chinois sans qui ce qui va suivre aurait couté un bras, un oeil et un rein. Merci à tous les chinois qui vendent des trucs complètement dingues sur eBay à des prix ahurissants, le tout avec frais de ports offerts. Je vous aime les mecs, sincèrement.

Voilà, tout ça pour dire que j’ai déniché sur eBay cette petite perle:

IMG_2618

Les specs: 128*64 pixels bleus, rétro éclairé, le tout pour 7€, alors qu’un modèle équivalent peut valoir jusqu’à 30$ chez adafruit ou sparkfun.  Mais le top, c’est qu’il est utilisable en mode parallèle et en série! Là tout de suite, c’est beaucoup plus intéressant! En parallèle on a facilement besoin de 15 pins, et donc d’un arduino Mega…En mode série, 8 pins suffisent!

Le câblage est le suivant pour un arduino uno ou équivalent:

  • pin 10 (SS) vers RS
  • pin 11 (MOSI) vers R/W
  • pin 12 (MISO) vers E
  • +5V vers VDD et BLA (BLA c’est l’anode du rétro éclairage)
  • GND vers VSS, PSB (PSB à 0 = mode série) et BLK (cathode du rétro éclairage).

Simple, non? Ben non, parce que la partie logicielle se corse un peu. Pour afficher quoi que ce soit sur ce LCD, vous aurez besoin d’une librairie, dispo ici: http://code.google.com/p/u8glib/ . Autre astuce: pour cet écran, le constructeur à utiliser est “U8GLIB_ST7920_128X64 u8g(12, 11, 10, U8G_PIN_NONE);”. Pour le reste, à savoir comment dessiner sur l’écran, regardez la doc de la librairie. En attendant, voici le code de l’égaliseur:

#include "U8glib.h"

U8GLIB_ST7920_128X64 u8g(12, 11, 10, U8G_PIN_NONE);

const int ANALOG = 0;
const int STROBE = 4;
const int RESET = 5;
const int outputValues[7];

void drawMediumBars(void) {
  for (int i = 0; i < 7; i++) {
    u8g.drawBox(5+18*i, 64-(outputValues[i]/16), 10, outputValues[i]/16);
  }
}

void setup(void) {
  //setup MSGEQ7
  pinMode(ANALOG, INPUT);
  pinMode(STROBE, OUTPUT);
  pinMode(RESET, OUTPUT);
  analogReference(DEFAULT);
  digitalWrite(RESET, LOW);
  digitalWrite(STROBE, HIGH);
}

void loop(void) {
  u8g.firstPage();  
  do {
    //reset chip
    digitalWrite(RESET, HIGH);
    digitalWrite(RESET, LOW);

    for (int i = 0; i < 7; i++) {
      digitalWrite(STROBE, LOW);
      delayMicroseconds(30); // to allow the output to settle
      outputValues[i] = analogRead(ANALOG);
      digitalWrite(STROBE, HIGH);
    }

    //draw values
    drawMediumBars();
  } while(u8g.nextPage());
}

Avec ça, vous devriez afficher de jolies barres sur l’écran, quelque chose de ce style:

IMG_2597

Sympa, non? Mais bon, un seul design, ca craint, si seulement on pouvait en changer à la volée…

Etape 4: les boutons et les interruptions

Tout d’abord, kesséssé une interruption? C’est tout simplement un bout de code qui est lié à une évènement matériel: le passage d’une pin de l’état haut à l’état bas par exemple. Quand l’évènement se déclenche, le code est exécuté. Le but de ce qui va suivre est de modifier la routine qui dessine les barres grâce à une interruption.

Voici le code avec les modifications:

#include "U8glib.h"

U8GLIB_ST7920_128X64 u8g(12, 11, 10, U8G_PIN_NONE);

const int ANALOG = 0;
const int STROBE = 4;
const int RESET = 5;
int outputValues[7];

const int BT1 = 0;
const int DEBOUNCE_DELAY = 200;

uint8_t mode = 0;
uint8_t nModes = 3;

void drawJointFatBars(void) {
  for (int i = 0; i < 7; i++) {
    u8g.drawBox(1+18*i, 64-(outputValues[i]/16), 18, outputValues[i]/16);
  }
}

void drawMediumBars(void) {
  for (int i = 0; i < 7; i++) {
    u8g.drawBox(5+18*i, 64-(outputValues[i]/16), 10, outputValues[i]/16);
  }
}

void drawTopLine(void) {
  for (int i = 0; i < 6; i++) {
    u8g.drawLine(10+18*i, 64-(outputValues[i]/16), 10+18*(i+1), 64-(outputValues[i+1]/16));
  }
}

void setup(void) {
  //setup MSGEQ7
  pinMode(ANALOG, INPUT);
  pinMode(STROBE, OUTPUT);
  pinMode(RESET, OUTPUT);
  analogReference(DEFAULT);
  digitalWrite(RESET, LOW);
  digitalWrite(STROBE, HIGH);

  //change mode button
  attachInterrupt(BT1, button1, FALLING);
}

void loop(void) {
  u8g.firstPage();  
  do {
    //reset chip
    digitalWrite(RESET, HIGH);
    digitalWrite(RESET, LOW);

    for (int i = 0; i < 7; i++) {
      digitalWrite(STROBE, LOW);
      delayMicroseconds(30); // to allow the output to settle
      outputValues[i] = analogRead(ANALOG);
      digitalWrite(STROBE, HIGH);
    }

    //draw values
    if (mode == 0) drawJointFatBars();
    else if (mode == 1) drawMediumBars();
    else if (mode == 2) drawTopLine();

  } while(u8g.nextPage());
}

void button1() {
  static unsigned long last_interrupt_time = 0;
  unsigned long interrupt_time = millis();
  // If interrupts come faster than 200ms, assume it's a bounce and ignore
  if (interrupt_time - last_interrupt_time > DEBOUNCE_DELAY) {
    last_interrupt_time = interrupt_time;

    //interrupt code
    if (mode == (nModes-1)) mode = 0;
    else mode++;

  }
}

La fonction “attachInterupt” relie une fonction (ici button1) à  un évènement (FALLING = passage de l’état haut à l’état bas) sur une interruption donnée (ici l’interruption 0, laquelle correspond à la pin DIGITAL 2).

En ce qui concerne le corps de la fonction button1, j’utilise une variable pour mesurer le temps entre deux appels à la fonction. Pourquoi? Parce que les boutons poussoirs ne sont pas parfaits et peuvent déclencher deux fois l’interruption lors d’un seul appui, faute à la mécanique. En ce qui me concerne, le délai minimum entre deux appuis est de 200ms.

Pour câbler l’interruption, voici le schéma:

IMG_2619

Simple, non?

Au final, vous devez obtenir ceci:

IMG_2599

Etape 5: transformer un prototype en shield

Quelle satisfaction de transformer un projet qui fonctionne en un produit fini! Et là, on a un montage qui ne demande qu’à être transformé en shield arduino. Pour les shields vierges, allez donc faire un tour chez l’ami semageek.

Un seul conseil: placez vos composants, soudez une fois que vous êtes sûrs. Voici à quoi ressemble le mien:

IMG_2603

IMG_2607

IMG_2606

Etape 6: la mise en boîte.

Pour mettre ma pédale en boite, je voulais un boîtier petit, super costaud, transparent. J’ai donc utilisé une otterbox que j’avais chopé dans un PX sur une base militaire US. Ces boîtiers sont géniaux. Vous en trouverez chez adafruit.

Pour la découpe en rectangle dans le boitier, voici ma méthode pour faire un rectangle bien propre. C’est aussi valable pour du métal ou du bois:

  • faites le tracé de votre découpe.
  • réalisez une découpe grossière. tous les moyens sont bons: dremel, scie à métaux…le tout c’est de ne pas trop s’approcher du contour final.
  • finissez les bords à la lime fine et plate.

De cette façon vous pourrez faires des découpes très propres et très droites à travers à peu près n’importe quel matériau:

IMG_2621

Par exemple, mon boitier:

IMG_2613

IMG_2612

Pour attacher l’arduino au fond du boîtier, j’ai utilisé un pistolet à colle:

IMG_2620

Une bande de velcro plus tard, et hop:

IMG_2617

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…

Voici de quoi vous aurez besoin:

  • Tout d’abord, un Arduino. N’importe quel modèle conviendra. J’utilise un vieux Mega 1280 parce qu’il a beaucoup d’I/O, mais même le petit Mini Pro de chez sparkfun ferait l’affaire.

  • Ensuite, il nous faut un Shield Ethernet. J’utilise l’officiel, mais là encore il existe de nombreux modèles qui feraient l’affaire.
  • Des cartes à relais. J’ai trouvé des cartes opto-isolées à 4 relais chez YourDuino . Ils vendent des trucs dingues à de super prix, je vous les recommande fortement. 8 dollars pour une carte à 4 relais, c’est une super affaire. Ils vendent aussi des cartes à 1 et 8 relais.
  • Il vous faudra aussi quelques câbles.

Il nous faudra quelques autres trucs pour terminer le projet, mais en attendant c’est déjà pas mal.

Etape 1: le module ethernet.

La première chose à faire c’est de faire fonctionner le module ethernet. Assemblez les deux et branchez-les:

Ensuite, uploadez l’exemple “WebServer” de l’IDE arduino. Ensuite, utilisez votre navigateur pour aller à l’adresse IP spécifiée au tout début du code (et qui devrait être 192.168.1.177):

Cool, l’arduino répond! On peut passer à l’étape suivante!

Etape 2: contrôler les I/O sur commande

Maintenant, nous avons besoin de contrôler les entrées/sorties digitales en utilisant des URL. J’ai trouvé un tuto super sympa à ce propos sur le site de bildr. Le but est d’allumer et d’éteindre des LEDs, je l’ai donc un peu modifié pour qu’il corresponde à mes besoins:

//ARDUINO 1.0+ ONLY
//ARDUINO 1.0+ ONLY

#include <Ethernet.h>
#include <SPI.h>
boolean reading = false;

const int DLY = 100;
const int RLY1 = 30;
const int RLY2 = 31;
const int RLY3 = 32;
const int RLY4 = 33;

byte ip[] = { 192, 168, 0, 177 };   //Manual setup only
byte gateway[] = { 192, 168, 0, 1 }; //Manual setup only
byte subnet[] = { 255, 255, 255, 0 }; //Manual setup only

// if need to change the MAC address (Very Rare)
byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };

EthernetServer server = EthernetServer(80); //port 80

void setup(){
  Serial.begin(9600);

  pinMode(RLY1, OUTPUT);
  pinMode(RLY2, OUTPUT);
  pinMode(RLY3, OUTPUT);
  pinMode(RLY4, OUTPUT);

  Serial.println("Testing relays...");

  for (int i=RLY1; i<=RLY4; i++) {
    digitalWrite(i, LOW);
    delay(DLY);
    digitalWrite(i, HIGH);
    delay(DLY);
    digitalWrite(i, LOW);
    delay(DLY);
  }

  Ethernet.begin(mac);
  //Ethernet.begin(mac, ip, gateway, subnet); //for manual setup

  server.begin();
  Serial.println(Ethernet.localIP());
}

void loop() {
  checkForClient();
}

void checkForClient(){

  EthernetClient client = server.available();

  if (client) {

    // an http request ends with a blank line
    boolean currentLineIsBlank = true;
    boolean sentHeader = false;

    while (client.connected()) {
      if (client.available()) {

        if(!sentHeader){
          // send a standard http response header
          client.println("HTTP/1.1 200 OK");
          client.println("Content-Type: text/html");
          client.println();
          sentHeader = true;
        }

        char c = client.read();

        if(reading && c == ' ') reading = false;
        if(c == '?') reading = true; //found the ?, begin reading the info

        if(reading){
           switch (c) {
            case '1':
              Serial.println("RLY1 ON");
              triggerPin(RLY1, true, client);
              break;

            case '2':
              Serial.println("RLY2 ON");
              triggerPin(RLY2, true, client);
              break;

            case '3':
              Serial.println("RLY3 ON");
              triggerPin(RLY3, true, client);
              break;

            case '4':
              Serial.println("RLY4 ON");
              triggerPin(RLY4, true, client);
              break;

            case '5':
              Serial.println("RLY1 OFF");
              triggerPin(RLY1, false, client);
              break;

            case '6':
              Serial.println("RLY2 OFF");
              triggerPin(RLY2, false, client);
              break;

            case '7':
              Serial.println("RLY3 OFF");
              triggerPin(RLY3, false, client);
              break;

            case '8':
              Serial.println("RLY4 OFF");
              triggerPin(RLY4, false, client);
              break;
          }
        }

        if (c == '\n' && currentLineIsBlank)  break;

        if (c == '\n') {
          currentLineIsBlank = true;
        } else if (c != '\r') {
          currentLineIsBlank = false;
        }
      }
    }

    delay(1); // give the web browser time to receive the data
    client.stop(); // close the connection:
  }
}

void triggerPin(int pin, boolean on, EthernetClient client){
  if (on == false) {
    digitalWrite(pin, HIGH);

    client.print("Turning off relay ");
    client.println(pin);
    client.print("<br>");
  } else {
    digitalWrite(pin, LOW);

    client.print("Turning on relay ");
    client.println(pin);
    client.print("<br>");
  }
  delay(DLY);
}

Maintenant, branchez la carte à relais: (I/O 30 -> relais 1, 1/0 31 -> relais 2 et ainsi de suite):

Ulploadez le code et ouvrez le Serial Monitor. Vous devriez entendre les relais cliqueter. Voici une vidéo que j’ai faite avec un délai un peu plus court (CLY=10) et deux carte de quatre relais:

Click here to view the embedded video.

En voici une autre. Cette fois ci j’utilise mon iPhone pour accéder à distance aux relais. Pour y parvenir, il vous faudra paramétrer votre box pour rediriger le port voulu vers l’arduino.

Click here to view the embedded video.

Voici la première partie du projet terminée, maintenant il nous faut une boite pour y mettre notre projet.

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 2