Introduction

J'ai retrouvé une vieille eeprom que j'avais récupérée en desossant un viel écran CRT. C'est une LC21B de ST Microelectronics, plus précisément une ST24LC21B.

Je me suis dit que ça serait chouette de travailler un peu à une étude de son fonctionnement avec un arduino, ça fait bien longtemps que je n'ai pas utilisé ce dernier.

La datasheet de cette EEPROM montre qu'elle ne fait que 1Kbits soit 1024bits et non 1024 octets. La capacité de l'EEPROM est donc de 128 octets ce qui est très faible (mais mieux que rien).

A l'origine, cette EEPROM servait à stocker les paramètres VESA des moniteurs (sans doute les données d'EDID). Elle est donc principalement faite pour être lue via le câblage VGA par la carte graphique. Mais, à la base, c'est une EEPROM alors on peut mettre ce qu'on veut dedans.

Mais ce qui est sans doute plus important c'est qu'elle est capable de fonctionner via le BUS I2C. Ce sera donc un bon moyen de voir comment lire et écrire des bits via ce mode de communication avec l'Arduino.

I2C

I2C est un standard de communication sur deux fils créé par Philips. Il est utilisable par l'Arduino via la bibliothèque Wire que nous allons utiliser.

Pour résumer, I2C utilise deux ports analogiques spécifiques de votre Arduino. Ces deux ports correspondent aux port SDA (Serial Data) et SCL (Serial clock). Chaque "périphérique" I2C dispose d'une adresse (un peu comme une adresse MAC) et répond quand un maître (l'Arduino dans notre cas) y fait appel.

Après, on peut lui envoyer des commandes qui auront une signification propre au périphérique (une EEPROM n'a rien à voir avec un capteur de température par exemple). I2C s'occupe juste des communications, pas de la manière dont fonctionne le périphérique.

Branchements et spécifications

Sur l'Arduino

J'ai un vieil Arduino (un duemilanove) mais je constate que le dernier Arduino correspondant à la gamme (le Uno rev3) n'a pas trop évolué au niveau des grandes lignes des spécifications. On retrouve les mêmes composants, la même quantité de RAM, de Flash, de ports, etc.

Ce qui nous intéresse, cans notre cas, ce sont les ports de l'Arduino que nous allons utiliser pour la communication I2C:

  • Analog 4: SDA
  • Analog 5: SCL

Sur l'EEPROM

Nous avons les connexions suivantes:

  • VCC (+5v): 8
  • GND/VSS : 4
  • SDA: 5
  • SCL: 6
  • VCLK: 7

En lisant la doc de l'EEPROM, on se rend compte que VCLK est un port qui permet d'autoriser ou non l'écriture dans l'EEPROM. S'il est haut (5V), alors l'écriture est autorisée. Sinon, même en envoyant des ordres d'écriture, l'EEPROM ne vera pas son contenu modifié.

Par ailleurs, nous avons besoin de connaître l'adresse unique I2C de l'EEPROM. En consultant la documentation, on se rend compte qu'elle vaut 1010000x. Le x de la fin varie suivant le mode écriture/lecture de l'EEPROM. Ainsi, si vous souhaitez lire son contenu, il faudra s'adresser à 10100001 soit 0x51. Si vous souhaitez écrire dans l'EEPROM, il faudra s'adresser à 10100000 soit 0X50.

Schéma

Au final, voici l'aspect du schéma électronique (que j'ai réalisé avec Kicad):

Un schéma entre Arduino et ST24LC21B

En plus du fait de relier les bons ports entre l'Arduino et l'EEPROM, on trouve quelques composants en plus: * Les deux résistances en 4.7kOhms sur SDA et SCL sont des résistances de pull-up. Elles servent à maintenir l'état haut du bus lorsqu'il n'y a pas de communication, le tout avec un courant assez faible. * La résistance de 4.7kOhms sur VCLK sert à limiter le courant entrant sur le port numérique en sortie de l'Arduino. D'après les spécifications de l'EEPROM, le courant max (Icc) doit être de 2mA lorsque Vcc vaut 5V. Si vous faites un branchement en direct, certes, il y aura du 5V en sortie mais il n'y aura rien pour limiter le courant. Vous risquez donc d'envoyer un flux de courant d'environ 40mA (le max d'une sortie numérique d'un ATMega) ce qui grillera votre EEPROM. Si on prend la moitié de la valeur de Icc, soit 1mA, la valeur de résistance sera de R = U/I soit 5/0.001 soit 5kOhms. Mettre une troisième résistance de 4.7KOhms rentre dans les tolérances (on est à 1.06mA). Pour ma part, j'utilise le port numérique 13, ça porte chance !

En plus du schéma "théorique", voilà le schéma sur une breadboard, ça peut toujours servir pour le débutant:

Une vue de connexion entre Arduino et ST24LC21B

Code

Passons maintenant à la partie logicielle. Dans mon cas, j'ai réalisé une espèce de programme interactif qui permet d'envoyer des commandes à l'Arduino via le port série (qui passe par l'USB). Cela me permet de réaliser des opérations à la demande sur l'EEPROM.

Je me suis arrêté quand j'ai obtenu un résultat significatif: - Savoir lire le contenu complet de l'EEPROM. - Savoir écrire un octet à une adresse spécifique de l'EEPROM. - Exploiter la fonction d'écriture massive de l'EEPROM.

Voici à quoi ça ressemble:

/*
  Use an old ST24LC21B EEPROM with I2C to read and store values.
  I2C address for EEPROM:
  * 1010.0001 for reading: 0x51
  * 1010.0000 for writing: 0x50

  (c) 2018 by Médéric Ribreux
  ***************************************************************************
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU General Public License as published by  *
  *   the Free Software Foundation; either version 3 of the License, or     *
  *   (at your option) any later version.                                   *
  *                                                                         *
  ***************************************************************************
*/
// on inclut la bibliothèque Wire qui fait très bien son travail avec I2C.
#include <Wire.h>

/* Quelques constantes globales */
#define writeID 0x50 // L'adresse I2C d'écriture.
#define readID 0x51  // L'adresse I2C de lecture.
#define romSize 128  // La taille de l'EEPROM en bytes.
#define writePin 13  // Le port qui contrôle le mode écriture.

/* Variables globales */
byte addr = 0;
unsigned char eeprom[romSize]; // un tableau qui capture le contenu de l'EEPROM.
String command; // Une chaîne de caractères pour gérer nos commandes.

// Affecte ou non la protection en écriture via le port dédié
void setWriteProtection(bool state) {
  if (state == false) {
    digitalWrite(writePin, HIGH);
  }
  else {
   digitalWrite(writePin, LOW);
  }
}

// Sélectionne une adresse d'octet dans l'EEPROM (Random Access).
byte selectAddr(byte address) {
  byte state = 0;
  Wire.beginTransmission(writeID);
  Wire.write(address);
  state = Wire.endTransmission();
  return(state);
}

// Dump de l'EEPROM
void dump() {
  byte block = 0;
  byte status = 0;
  byte offset = 0;

  status = selectAddr(0x0);
  if (status!=0) {
    Serial.println("Problème d'adressage");
  }
  else {
    for(block=0;block<=4;block++) {
      Wire.requestFrom(readID, 32, true);
      while(Wire.available()) {
        eeprom[offset] = Wire.read();
        offset = offset + 1;
      }
    }
  }
}

// Test d'écriture
void writeInMemory(byte offset, byte value) {
  byte state = 0;
  // on lève la protection en écriture
  digitalWrite(writePin, HIGH);
  delay(500);
  // On se place à l'offset
  Wire.beginTransmission(writeID);
  Wire.write(offset);
  Wire.write(value);
  state = Wire.endTransmission(true);
  if (state != 0) {
    Serial.print("Erreur d'écriture: ");
    Serial.println(state, DEC);
  }
  // on remet la protection en écriture
  delay(500);
  digitalWrite(writePin, LOW);
}

// Écriture massive
void zeroMemory() {
  byte state = 0;
  byte page = 0;
  unsigned char theZero[8] = {0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0};
  // on lève la protection en écriture
  digitalWrite(writePin, HIGH);
  delay(500);

  // On écrit séquentiellement
  for(page=0;page<=15;page++) {
    Wire.beginTransmission(writeID);
    Wire.write(page*8);
    Wire.write(theZero, 8);
    state = Wire.endTransmission(true);
    delay(100);
    if (state != 0) {
      Serial.print("Erreur d'écriture page: ");
      Serial.print(page);
      Serial.print(" :");
      Serial.println(state, DEC);
    }
  }
  // on remet la protection en écriture
  delay(500);
  digitalWrite(writePin, LOW);
}
// Configuration de l'Arduino
void setup() {
  pinMode(writePin, OUTPUT);
  setWriteProtection(true);
  Serial.begin(9600);
  Wire.begin(); // On lance le bus I2C
  Serial.println("\nI2C EEPROM Player");
  delay(5000);
}

// Fonction principale
void loop() {
  byte i = 0;
  //byte j = 0;

  // Un mode interactif
  if (Serial.available() > 0) {
    command = Serial.readStringUntil('\n');
    Serial.print("Your command:");
    Serial.println(command);
  }
  // On gère la signification du truc
  if (command.equals("dump")) {
    command = "";
    Serial.println("Dumping...");
    // On dumpe
    dump();
  }
  if (command.equals("print")) {
    Serial.println("Printing...");
    command = "";
    for(i=0;i<=127;i++) {
        Serial.print(eeprom[i], HEX);
        Serial.print("|");
    }
    Serial.println(" ");
  }
  if (command.equals("write")) {
    command = "";
    // on effectue une écriture de base
    Serial.println("Writing in EEPROM...");
    writeInMemory(0x9, 0xFE);
  }
  if (command.equals("flush")) {
    command = "";
    // on effectue une écriture de base
    Serial.println("Flushing data...");
    memset(eeprom,0,sizeof(eeprom));
  }
  if (command.equals("zero")) {
    command = "";
    // on effectue une écriture de base
    Serial.println("Zeroing memory...");
    zeroMemory();
  }
  delay(4000);
}

Compiler et mettre le code sur Arduino

En 2018, les bonnes recettes n'ont toujours pas changées: on a toujours besoin d'AVRdude et du paquet arduino-mk pour envoyer des choses vers l'Arduino.

Voici le Makefile que j'utilise:

# Makefile for lc21b
## Directories
ARDUINO_DIR   = /usr/share/arduino
ARDMK_DIR     = /usr/share/arduino
ARDUINO_LIBS  = Wire

## Arduino Board configuration
MCU          = atmega328p
F_CPU        = 16000000
ARDUINO_PORT = /dev/ttyUSB*

## Avrdude configuration
AVRDUDE_ARD_PROGRAMMER = arduino
AVRDUDE_ARD_BAUDRATE   = 57600

## Le nom de notre programme
TARGET        = lc21b

include /usr/share/arduino/Arduino.mk

Ensuite, un simple make suffit pour compiler le code. Pour l'upload, j'utilise make upload.

Utilisation

Ensuite, il faut voir ce que retourne l'Arduino par le port serial:

$ screen -L /dev/ttyUSB0

Vous pouvez ensuite taper vos commandes:

  • dump permet de capturer le contenu de l'EEPROM dans une variable.
  • print affiche la capture de l'EEPROM.
  • write écrit à l'adresse 0x9 la valeur FE (à vous de modifier cette valeur).
  • zero permet de mettre à zéro toute l'EEPROM.

Conclusions

Bon, j'ai bien aimé faire mumuse avec cette EEPROM. Ok, elle n'a pas beaucoup de stockage mais c'est parfait pour la lecture de données par l'Arduino qui n'a pas non plus beaucoup de mémoire. D'un point de vue didactique, c'est plutôt simple.

Bon, la bibliothèque Arduino fait vraiment bien son job: je n'ai jamais du lire les specs du protocole I2C ni faire d'opérations bas niveau pour exploiter le bus.

Bon, vous me direz que je suis bien avancé: je sais utiliser un circuit intégré qui n'est plus produit depuis au moins 10 ans. Mais sachez que le fonctionnement sera quasi-identique pour les derniers produits du moment. En effet, si je prends la M24C02, elle a pratiquement les mêmes spécifications et elles utilise les mêmes ports. Je peux substituer la ST24LCB1 de mon circuit par la M24C02 et tout marchera sans changer une virgule au code !

Ce qui est aussi dingue, c'est que cette EEPROM est assez ancienne. Je dirai qu'elle avait au moins 20 ans lors de la rédaction de cet article et les données dessus n'avaient pas bougé d'un poil de bit. Ce qui est encore plus dingue c'est que je l'ai déssoudée "à la main" pour la récupérer, avec tous les risques de surchauffe que ça comporte et qu'elle est parfaitement opérationnelle car j'arrive à tout lire et à tout écrire sans erreur.

En conclusion, je vous invite à désosser les circuits imprimés de vos rebus électroniques et à les conserver pour le futur. Ça peut toujours vous servir pour un circuit ou pour apprendre. Comme en plus vous n'aurez rien dépenser pour l'avoir, vous n'aurez pas trop de regrets lorsque, à la suite d'une mauvaise manipulation ou mauvais branchement, vous verrez un nuage de fumée en sortir !

PS: Ce composant est fait par ST Microelectronics, un vaillant fondeur de puces électroniques qui est français à l'origine. Cette multinationale embauche encore environ 10000 personnes en France. Souvent oubliée dans le monde de l'électronique qui présente souvent des acteurs américains, chinois ou japonais, ST est un acteur important de l'électronique qui emploie des vrais gens en France. Si vous avez de l'électronique à faire, je vous invite à utiliser les produits ST qui sont à la fois très bien faits, pas forcément chers à l'achat et qui profitent (un peu) à l'économie française !

Références

Posted sam. 26 mai 2018 17:29:25 Tags:

J'ai enfin réglé mon problème d'alimentation de mon SheevaPlug. Effectivement, ça faisait maintenant plus de deux ans que j'avais procédé en urgence à un changement un peu sommaire de l'alimentation en utilisant une solution que d'aucuns jugeraient "overkill"...

Après avoir pu regler les affaires courantes de ma todo-list, le sujet de réparer cette alimentation est revenu en haut de mes priorités. La solution de l'alimentation ATX a fait largement ses preuves: je n'ai eu aucun problème pendant plus de deux ans avec. Elle faisait juste un peu de bruit (le ventilateur qui refroidit les condensateurs et le bobinage des transformateurs) et était discrètement rangée dans un meuble dédié (non, ce n'est pas un rack ou toute sorte de chose qui s'y rapporte). Mais, il fallait bien trouver une solution plus élégante au problème.

J'ai donc acquis auprès de NewIt, une nouvelle alimentation dédiée, destinée à remplacer l'ancienne dans le même emplacement. Normalement, sur ce nouveau montage, les condensateurs qui posent problèmes ont été remplacés par des éléments capables de supporter plus facilement le voltage et la chaleur propagée. De plus, l'alimentation dispose d'une couche de plastique molle collée en dessous. C'est censé favoriser la dissipation thermique. Sur ce sujet d'ailleurs, la coque de protection qui était complètement isolante a été remplacée par une simple feuille de plastique épais qu'on plie pour l'adapter au logement de l'alimentation. Je pense que ça doit permettre de gagner quelques degrés car l'intérieur est moins confiné qu'avant.

Voici quelques photos pour voir à quoi ça ressemble:

Photo de la nouvelle alimentation NewIt pour Sheevaplug Photo de la nouvelle alimentation NewIt pour Sheevaplug

L'alimentation est livrée avec la pièce en plastique pour remplacer l'isolation thermique du circuit.

La doc de montage est disponible directement chez newIt.

Après un peu d'efforts de montage (le support de prise de courant est difficile à clipser correctement dans son logement), la machine redevient de dimension réduite. Elle tient à nouveau dans la main. En fonctionnement, elle ne fait plus de bruit du tout.

Photo du sheevaplug complètement fonctionnel avec sa nouvelle alimentation

Espérons que cette nouvelle alimentation fera preuve d'une plus grande longévité. Dans tous les cas, cet article me permettra de faire le point dans le temps, il reste une trace pour que je n'oublie pas cet évènement...

Rendez-vous, le plus tard possible sur ce sujet !

Posted lun. 01 sept. 2014 19:38:21

Une nouvelle alimentation pour Sheevaplug

Après quelques jours de vacances, quelle ne fût pas ma surprise de constater, depuis le bureau, que mon serveur n'était plus disponible... Ca arrive parfois, notamment, lorsque j'ai oublié de relancer certains services au cours de manipulations ou de mises à jour (personne n'est infaillible).

De retour dans la salle serveur (c'est le salon !), je me penche vers le Sheevaplug et découvre que les Leds du port ethernet sont fixes ! De plus impossible de pinguer le serveur, même depuis le réseau local. Ma tentative de connexion du port JTAG ne donne rien non plus... Ça commence à devenir sérieux !

Dans ces conditions, je débranche la prise et après quelques secondes, je relance la machine... mais, les Led restent fixes et j'ai l'impression que le processus de boot ne s'enclenche pas. Rien non plus du côté du port JTAG !!! Avec peu d'effort, me reviens à l'esprit une histoire pas terrible au sujet de l'alimentation électrique du Sheevaplug ! Une simple recherche sur le web vous permettra de vous faire une idée.

Pour résumer, les symptômes indiquent une alimentation fatiguée et voilà pourquoi le SheevaPlug ne se lance plus. Il faut donc passer par une petite phase de démontage avant d'ouvrir l'alimentation et constater qu'il y a un peu de dégâts. Concrètement, la faiblesse majeure de cette alimentation se matérialise pas des condensateurs qui grillent (ils s'ouvrent par le dessus, répandant leur isolant brûlant qui donne cette jolie couleur brune dans tout le circuit.

Si on observe les détails, voici la bête:

Vue de l'alimentation du Sheevaplug

Plusieurs solutions s'ouvrent alors à moi:

  • Commander une nouvelle alimentation et attendre
  • Réparer l'alimentation existante
  • Trouver une autre alimentation qui peut faire l'affaire

C'est finalement dans l'ordre inverse que je vais procéder: je vais commencer par utiliser une autre alimentation, le temps d'essayer de réparer l'alimentation pour finir par en commander une autre si je n'y parviens pas.

J'ai donc trouvé une alimentation de substitut qui, pour le moins, n'a pas la même taille que la précédente:

Vue de l'alimentation du Sheevaplug

Mais, après tout, il me fallait du 5V en courant continu pour 2A maxi: une alimentation ATX fournit ça de base (bon, elle fournit aussi du 12V, du 3,3V sur pleins de sorties mais qui peut le plus peut le moins). En fait, je n'avais que ça sous la main... autant en profiter.

Le travail d'adaptation n'a pas pris trop de temps. Il me fallait d'abord un connecteur pour relier la carte-mère du Sheevaplug au 5V. Après une courte analyse, je me rends compte qu'en limant un peu le connecteur de l'alimentation ATX dédié au lecteur de disquette, la forme est parfaite ! De plus, je ne me souviens plus de la dernière fois où j'ai utilisé un lecteur de disquette donc, la récupération de ce connecteur n'aura aucun impact.

Voici le résultat final:

Vue de l'alimentation du Sheevaplug

Les 4 fils ont été soudés ensemble, par paire: une paire pour la masse, l'autre pour le +5V.

Ensuite, il reste à trouver comment faire le branchement. Il suffit de nous inspirer du schéma de la page Wikipédia sur la norme ATX. Nous devons donc brancher la masse sur la prise n°3 et le 5V sur la n°4.

Petite astuce, vous devez "allumer" l'alimentation en reliant la prise PS-ON à la masse: c'est de cette manière que votre ordinateur est capable d'éteindre l'alimentation tout seul ! Pour ma part, j'ai fait un pont en récupérant un vieux fil qui restait.

Vue de l'alimentation du Sheevaplug

Après quelques tests et également après avoir vérifié 3 fois que je n'avais pas inversé la masse et le +5V, j'ai branché l'alimentation ATX. Comme par magie, le SheevaPlug s'est lancé tout seul, comme si rien n'avait bougé depuis sa panne ! Ouf ! L'alimentation d'origine en panne n'a pas fait griller le serveur, c'est l'essentiel.

Après ces tests, j'ai pu "mettre en production":

Sheevaplug en production

En guise de conclusion, j'ai pris un peu de temps pour raconter cette histoire simplement pour donner un moyen supplémentaire de "réparer" temporairement votre machine avec des pièces qu'on peut facilement trouver dans tout bureau de hacker qui a (toujours) des scrupules à balancer un ordinateur à la casse.

Il me reste maintenant à réparer l'alimentation: je vais acheter quelques condos chez le grossiste du coin en prenant les éléments un peu plus costauds (10V au lieu de 6.8V pour les condos incriminés). La solution idéale consisterait à acquérir une nouvelle alimentation car, à partir de fin 2010, elles ont été modifiées et semblent plus fiables.

A suivre...

Posted sam. 26 mai 2012 19:45:15 Tags:

Réparer une Wii Motion Plus

Même le matériel officiel des fabricants de consoles de jeux n'est pas fiable. J'en veux pour preuve l'accessoire Wii Motion Plus que j'ai utilisé moins de 15 jours avant qu'il ne tombe en panne. Ce petit truc qui se rajoute en bas de votre télécommande Wii (le truc qui sert de manette sans fil) est censé ajouter une fonction d'accéléromètre et permettre une meilleure qualité de jeu. Néanmoins, la manière dont il est conçu est pratiquement "defective by design" !

En effet, 15 jours d'utilisation, c'est peu ! Le symptôme du problème était assez simple: le nunchuck n'était plus reconnu: impossible de s'en servir, il ne répondait plus du tout. Après avoir suspecté le dit nunchuck et vérifié qu'il fonctionnait correctement lorsque non branché sur le Wii Motion Plus, j'en suis arrivé à la conclusion que le problème venait plutôt de ce dernier... En bon hackeur, et surtout parce que j'avais égaré le ticket de caisse me permettant de faire jouer la garantie, j'ai désossé l'engin.

A noter que pour cette opération, il vous faudra un embout spécifique: le tri-wing. Pour faire simple, il s'agit d'une empreinte de vis destinée à empêcher le propriétaire de matériel (c'est à dire vous) de réparer son matériel lui-même: c'est juste un embout rare à trouver. Heureusement, j'avais déjà eu des problèmes sur cette console (le lecteur de DVD qui était dézingué) et j'étais déjà équipé de ces embouts à la con. A l'ouverture, j'ai vite compris ce qui pouvait poser problème: le connecteur du nunchuck est relié au reste par une nappe ruban très fine. Un simple test de continuité (avec un multimètre) m'a vite informé que le ruban était quelque peu perturbé: le signal passait de manière trop aléatoire suivant la position de la nappe. Qu'à cela ne tienne, tant qu'à faire de perdre 20€ (le prix d'un Wii Motion Plus), autant tenter l'impossible: remplacer le ruban par des vrais câbles mieux soudés. Grâce à mes années de récupération de pièces électroniques en tout genre (n'oubliez pas: il faut tout récupérer et stocker), j'avais tout ce qui fallait sous la main.

  • Première étape: déssouder la nappe sur le connecteur du nunchuck. L'intérêt de cette étape est de permettre de trouver les câbles qui seront adaptés au diamètre des trous. Il vous faut un fer à souder fin (j'ai un JBL 40ST qui était sans doute un peu trop gros) et surtout, une bonne pompe à déssouder.
  • Etape 2: faire des câbles. En général, vu le diamètre, vous n'aurez pas de pince à dénuder adpatée. Il vous faudra donc les faire vous même. Ma technique est simple: utiliser un couteau bien aiguisé en faisant rouler le fil à dénuder sur un cahier: le résultat est impeccable. Il vous faudra 6 fils, peu importe la couleur.
  • Etape 3: déssouder la nappe sur le circuit principal. C'est assez dur: il n'y a pas de place et vous risquez de déssouder les CMS trop proches. De plus, la nappe est souvent difficile à enlever. Je vous conseille d'utiliser une aiguille fine pour pousser les fils de la nappe lorsque vous appliquez votre fer.
  • Etape 4: Souder. C'est difficile mais pas impossible. Je ne suis pas un très bon soudeur mais j'ai quand même réussit du premier coup. La technique à ne pas oublier: pensez à refroidir votre fer avant la soudure en le passant sur une éponge humide. Ensuite, il faut appliquer le fer sur l'extrémité du fil dénudé qui dépasse du trou. Enfin, appliquer la soudure sur le fil chaud et pas le fer: elle va couler autour du fil et le solidariser avec le trou. Il faut de plus aller assez vite sinon vous aurez des gouttes et ça ne tiendra pas.
  • Etape 5: Faire un test. Avant de remonter l'ensemble, testez le circuit à nu. Si ça ne marche pas mieux, désolé mais vous venez de perdre 20€ (le rpxi du Wii Motion Plus) et une heure de votre précieux temps. Pour vous venger, balancer la Wii par la fenêtre et dites-vous que vous pouvez passer plus de temps à coder ou a travailler sur d'autres projets qui vous tiennent à coeur.
  • Etape 6: Si le test est concluant, remonter le tout en prenant soin de ne pas écraser les fils qui passent moins facilement qu'une nappe.

Malgré la soudure approximative et le temps que ça a pris, ce fut un réel plaisir de voir que ça fonctionnait bien ! Je n'en revenais pas moi-même...

Si vous avez des doutes sur l'ordre et la position des câbles, vous pouvez utiliser ce projet du site instructables qui décrit en images ce que j'ai réalisé.

Par ailleurs, si vous avez des problèmes avec votre machine et que vous souhaitez l'ouvrir pour la réparer je vous recommande l'excellent site: ifixit (à ne pas confondre avec there I fix it): il présente une série de guides très bien réalisés pour vous aider à réparer vos engins.

Enfin, si vous désirez acheter un Wii Motion Plus, je vous recommande plutôt d'acheter la manette complète qui intègre directement l'accéléromètre (on appelle ça une Wii Remote Plus). C'est plus cher mais je pense que c'est moins fragile...

Posted dim. 22 janv. 2012 11:11:37 Tags:

Débuter avec un Arduino

Comme vous avez pu le constater depuis quelques articles, je consacre un peu de mon temps à apprendre comment faire fonctionner un Arduino avec nombre d'outils et d'interfaces différents. Ce faisant, j'apprends également des rudiments d'électronique de manière bien plus concrète que ce que j'ai pu faire à l'école. Moins de théorie, plus de pratique et surtout, plus de manipulations qui permettent de se faire la main et de saisir avec bien plus d'efficacité les principes de fonctionnement de tel ou tel composant.

En trainant régulièrement sur Hackaday, je suis tombé sur une série de vidéos pour bien débuter avec un Arduino. Elles ont été réalisées par Jeremy Blum qui, malgré son jeune âge (environ 20 ans), nous apporte les éléments essentiels de manière très didactique. Les vidéos sont postées sous Youtube et le mieux est de les télécharger dans une bonne résolution (histoire de pouvoir lire le code).

Certes, ce sont des vidéos et elles ont l'inconvénient de ne pas être aussi souples qu'un tutoriel écrit (il faut regarder au fur et à mesure, le code n'est pas disponible immédiatement). Néanmoins, le contenu du tutoriel est vraiment bien fait et les explications de Jeremy très claires. Par exemple, j'ai très bien compris à quoi servaient des résistances de pull-down ou de pull-up alors que ce n'est pas si évident pour un débutant.

De plus, les exemples utilisés par Jeremy sont souvent repris des tutoriaux "officiels", présents sur le site Arduino.cc. Je vous conseille de les réaliser vous même au fur et à mesure que vous regardez les vidéos, c'est très formateur. Les montage les plus impressionants sont sans doute ceux qui utilisent des servos et qui peuvent se piloter avec quelques lignes de code.

Enfin, je vous recommande de consulter le site de référence sur le langage de l'Arduino. Vous pourrez mieux comprendre les fonctions qui sont utilisées et la manière de les appeler et de manipuler des variables.

Hackez bien !

Posted sam. 19 mars 2011 13:53:46 Tags: