Il y a peu, notre lave linge Laden (FL1281) est tombé en panne. Symptômes : Il ne s’allume plus du tout, aucun voyant de la facade ne s’éclaire, et aucun bruit .. rien. Il vient tout juste d’avoir 3 ans. Il s’avère (je vais le découvrir par la suite) que c’est une panne connue et visiblement très courante.

Vu le prix de la bête, et son âge, je décide de l’ouvrir en me disant que cela ne doit pas être bien grave, un fusible, un fil coupé ? Il n’y a donc pas de fusible, étrange, en même temps la norme NF C 15-100 (bâtiment) dit que l’on doit avoir un fusible séparé pour le lave linge donc .. why not. Le 220v est bien présent jusqu’au bornier du panneau de commande.

Panneau frontal Whirlpool FL1281

En démontant le panneau on constate plusieurs choses : La carte électronique porte une référence spécifique Whirlpool; rien ne semble avoir brulé; l’arrivée du 220v est raccordé directement sur le sélecteur principal qui sert de bouton ON/OFF. Cela évite d’avoir une alimentation pour gérer cela, mais nécessite un sélecteur assez sécurisé (ca me choque un peu, et le sélecteur coute du coup, une blinde).

Après quelques tests de continuité, tout semble Ok, le sélecteur fonctionne, il faut donc suivre les pistes, à la sortie du sélecteur on trouve une grosse résistance de 3w nommée R020 (la bien aimée). Elle est HS, elle a donc fait office de fusible.

R020 + LNK304PN

Cette résistance sert en fait à abaisser la tension 220v (et faire fusible au besoin), avant d’attaquer un régulateur à découpage tout intégré 220v AC =>12v DC : LNK304PN. Il y a très peu de régulateurs permettant de faire cela sur le marché avec si peu de composants externes. On notera que Whirlpool dans son extrème bienveillance a quand même pris la peine d’ajouter un tranformateur d’isolement en sortie du LNK304PN. Après un test rapide, je m’aperçois bien entendu que le LNK est HS. (court-circuit entre la patte D entrée et les pattes S)

Schéma d’utilisation typique d’un LNK304PN (datasheet)

Je commande donc les composants suivants chez RadioSpares (les seuls à avoir des LNK304PN en stock). La résistance, la self (par sureté), le régulateur.

• Résistance oxyde métallique 33R 3W (code RS : 2142550)
• LNK304PN, 12V dc, PDIP (code RS : 5254151
• Inductance traversante Epcos, 470uH, 280mA (code RS : 1911169)

Bilan 10.86 € livraison comprise pour 5 jeux complets. Deux jours plus tard, je change le tout, je remonte, ça repart! Banco, Madame est contente, et nous avons économiser 230€. En effet, après recherche, la carte électronique se trouve en SAV pour 145€, il faut à cela rajouter 50€ de frais de programmation. La carte est utilisée sur pleins de modèles de lave ligne Whirlpool, il faut donc programmé une petite EEPROM en fonction du modèle de la machine (Whirlpool, Laden ..) On ajoute à cela les 35€ de main d’oeuvre, et le compte est bon.

Mais pourquoi ? Je me suis tout de suite demandé pourquoi avoir utilisé ce régulateur étrange qui semble être fragile. En fait, en cherchant sur Google, on se rend compte qu’il est utilisé sur quasiment tous les modèles de lave-linge, sèche-linge et lave-vaisselle récents de la marque et que visiblement je ne suis pas le seul à avoir des soucis : https://www.google.fr/search?q=whirlpool+R020&tbm=isch !!

Ce composant a deux avantages majeurs. Il coute quasiment rien, moins de 1€ et remplace un transformateur classique coutant au moins 3 fois plus (et aussi bcp + gros). La référence est stable; il existe des tonnes de régulateurs chinois faisant la même chose (en plus complexe), mais ils ne sont pas pérennes.

En conclusion, en voulant gagner qques euros sur le prix d’un lave-linge à 400€, Whirlpool vend des produits dont la durabilité semble très aléatoire. Une simple surtension suffit à rendre le produit “bon pour la poubelle”. Il ne faut pas se tromper à 230€ la réparation, je pense que la majorité des produits finiront à la déchèterie au bout de qques années (3 c’est pas bcp quand même).  De mon côté, j’ai sourcé le 5 jeux de composants, j’ai donc encore droit à 4 pannes ;)

Aimer la lessive ? non pas vraiment

Update 1: Vu le nombre de commentaires, je ne suis clairement pas le seul à avoir eu des soucis avec ce lave-linge. J’attire votre attention sur le fait que la manipulation n’est tout de même pas si évidente qu’elle en a l’air. De nombreux lecteurs ont rencontré des problèmes pour dé-souder le LNK. En effet, les énormes pads thermiques au niveau des pattes n’aident pas du tout. Une solution simple et efficace consiste à couper les pattes du LNK avant de les dé-souder. Perso, j’ai utilisé une pince coupante, mais un bon coup de Dremel au milieu du composant fera également l’affaire.

Update 2 : Au final mon lave-linge a rendu l’âme en début d’année. Il avait presque 5 ans.. Les paliers au niveau du moteur / tambour s’usent, et bien entendu, on ne peut pas les changer. Il faut donc changer tout le bloc tambour, ce qui n’est pas du tout viable économiquement.

Je ne connais pas la durée de vie des lave-linges WhirlPool, mais clairement ce Laden n’auront pas donné bcp de satisfaction. Nous avons décidé de changer pour un modèle Samsung, à voir dans le temps ce que cela donnera.

Here the little story : A friend ask me to repair his bricked Heden cam copy (no-name). So let’s open it, find a serial port and look what’s going on. I used the bus-pirate of course. I discovered that only the bootloader is working, the whole flash seems empty.I searched a long time, and tried severals stuffs, but I was unable to find the right firmware (in the right format) for his no-name camera.

NetOS opened camera

So my friend sent the camera back (warranty), and receive a new one. Now, he ask me to backup the flash memory, to fix the problem if this occurs in a few months again.

The main issue is : The camera has no backup web interface, no MTD dump shell binary (nor ftp, scp..), and it’s not really easy to compile the mtd tools because the system has no library installed (only a few static binary files). I’m unable to backup the firmware throught the OS. Let’s try see the bootloader.

The bootloader has no backup firmware features, but it can dump the memory content (flash included), and it has a builtin “ls” like command that display base memory segments. With the simple “d 0xAAAA”, you can dump the memory at 0xAAAA address. Fine, I decided to write a little script that walk the memory, dump the content and rebuild the binary file.

#!/usr/bin/env python2
import serial,sys,string

log_file = None

def ser_open():
    ser = serial.Serial("/dev/ttyUSB0", 115200, timeout = 0.1)
    return ser

def log(line):
    l=string.split(line,' ')
    data='%s%s%s%s' % (l[1],l[2],l[4],l[5])
    for i in range(0,32,2):
        octet = int(data[i:i+2],16)
        log_file.write('%s' % chr(octet))

def dump(ser,addr):
    s = "d -s 0x%x\n" % addr
    ser.write(s)

    l=[]
    i = 0
    while 1:
        data = ser.read()
        if not data:break
        l.append(data)
        if (data=='\r'):
            s = string.join(l,'')
            if (s[0] == '['):
                log(s)
            l=[]

d = ser_open()
log_file = open('log.raw','a')

img_start = 0x7F0E0000
img_size = 0xC3C00

for i in range(img_start,img_start+img_size+0x100,0x100):
    dump(d,i)
    print "0x%x"% i

As you can see, this code isn’t really clean and well written, but it give me a nice binary file for a given offset and size. Simply dump the memory through serial port, do a little parsing, and store the result in binary file named log.raw.

I used this to backup the camera linux.bin file, and the romfs.img. Of course you can use this to dump the whole memory too. To check if the files are Ok, you can try to g-unzip the Linux Kernel, and mount the romfs.

To check the romfs, I simply mount it with : mount -t roomfs -o loop log.raw ./log

So now, I have a backup for this no-name camera, and next time the whole memory will drop, I will try to restore it ;).

This method seems really crude (and dirty), but it work without too much trouble, and can be tweaked for a lot of systems. It should work on every Linux embedded system with an dump memory feature in the bootloader (quite every one).

Enjoy memory ;)

There is a bunch of USB DAC on the market right now, but most of them aren’t really top quality. As I don’t want to loose some time to build the USB part, I decided to buy a USB DAC Kit. After a little search on Ebay I found this one :

This kit sports an CS8416+CS4398 combot plus an NE5532 output buffer, but as I want it to be a little audiophile, I will drop the NE5532 in favor of an simple tube preamp.

For the tube part, I think I will go for an 12AX7 or something similar. I really think 6SN7 are better, but this tube are overkill for an preamp I think.

Update, some links for the tube output :

• http://www.shine7.com/audio/12ax7_pre.htm
• http://diyaudioprojects.com/Tubes/12AX7_Preamp/

/Enjoy tube sound

First step: Simply use the Arduino IDE and the Wire lib. I use an Seeeduino because I need an Arduino that works at 3.3v level. Here the code :

#include <Wire.h>
void setup()
{
  Wire.begin(4);                // join i2c bus with address #4
  Wire.onReceive(receiveEvent); // register event
  Wire.onRequest(requestEvent); // register event
  Serial.begin(38400);           // start serial for output
  Serial.println("Boot Ok");
}

void loop()
{ delay(100); }

void receiveEvent(int howMany)
{
  char c = NULL;
  while(Wire.available()) // loop through all
  {
    c = Wire.receive(); // receive byte as a character
    Serial.print(c);         // print the character
  }
  Serial.println();
  Serial.println("===");
}

void requestEvent()
{
  Serial.println("read");
  Wire.send("Hello world from Arduino");
}

To test the Arduino I used a Bus Pirate, this is quite simple and fun, here a little snipset of my initial test with the BP (note the string are different). The I2C slave is at the 0×4 address (check the setup()).

Searching I2C address space. Found devices at:
0x08(0x04 W) 0x09(0x04 R) 

Read content from the device, 'ABCD'
I2C>[0x09 rrrrrr]
I2C START BIT
WRITE: 0x09 ACK
READ: 0x41
READ:  ACK 0x42
READ:  ACK 0x43
READ:  ACK 0x44
READ:  ACK 0xFF
READ:  ACK 0xFF
NACK
I2C STOP BIT
I2C>

send content to the device 'ABC'
I2C>[0x08 0x41 0x42 0x43]
I2C START BIT
WRITE: 0x08 ACK
WRITE: 0x41 ACK
WRITE: 0x42 ACK
WRITE: 0x43 ACK
I2C STOP BIT

Second step: Plug the Arduino to the NGW100. I used the wrapping technique. Simply connect SDA, SCL, and GND. (NGW100 pinouts : SDA=>9, SCL=>10, GND=>2)

On Linux, load the I2C-GPIO kernel module. On OpenWRT (used on the NGW100), simply load the kmod-i2c-gpio package.

Final step: If everything is Ok, we can now test the communication. I used a small piece of C code to deal with I2C on Linux.

#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <linux/i2c-dev.h>
#include <sys/ioctl.h>
#include <fcntl.h>

void i2c_run(void) {
    int file;
    char filename[40];
    int addr = 0x4;
    char buf[32] = {0};
    int i;

    sprintf(filename,"/dev/i2c-0");
    if ((file = open(filename,O_RDWR)) < 0) {
        printf("Failed to open the bus.");
        exit(1);
    }

    if (ioctl(file,I2C_SLAVE,addr) < 0) {
        printf("Failed to acquire bus access and/or talk to slave.\n");
        exit(1);
    }

    i = 24;
    // read I2C
    if (read(file,buf,i) != i) {
      printf("Failed to read from the i2c bus.\n");
    } else {
      printf("Read %d bytes from I2C: [%s]\n",i,buf);
    }

    sprintf(buf,"IC2 from Linux to Arduino");
    i = strlen(buf);
    if (write(file,buf,i) != i) {
        printf("Failed to write to the i2c bus.\n");
    } else {
      printf("Sent %d bytes to I2C: [%s]\n",i,buf);
    }
}

int main()
{
  i2c_run();
  return 0;
}

As you can see this code is a bit rude, but works really well : Read the I2C bus, and send a sample string, a proof ? :)

Of course, I used string values but in real life a small protocol shoud be used. Another important thing: I used a NGW100 but you can use the same idea on all Linux embedded board like the Fonera, or anything else.

Update: Of course you can use the i2c-tools on Linux to detect your own device. To do that : Grab the i2c-tools source, and cross compile it for the AVR32. (You only have to change the CC path in the Makefile).

/Enjoy small Linux

After the classic blink test, I decided to go for a network test. But I don’t have any magnetic Ethernet module right now (In fact, I should have one, but I’m unable to find it). So let’s go for a magnetic less ! The doc on the mbed dedicated page say that should be fine. I decided to pull the RJ45 socket from an old broken WRT54.

The main issue is to figure out how to solder this RJ45 on a veroboard. Here comes the fun part, I remembered that radio-amateur use a technique called “dead bug soldering”. Check this guidelines from the NASA for examples.

I decided to give it a try :

Just glue the RJ45 on the veroboard and use a common wrapping technique : Not so bad ;)

The next step is to flash a network example to test.

That’s really fun, the mbed works pretty well. I secretly hopes that somebody will come with a mbed like with opensource hardware and software.

Enjoy wired networks ;)

• USB to TTL PCB cost a bit of money : you can find some on Ebay around 7€ (shipped) and 15$ on Sparfun !!!  That’s about 2 or 5 times the cost of the microcontoler !
• USB to RS232 cost 1.70$ (shipped) but need some extra level shifting and doesn’t really feet on a PCB (need a DB9 connector …)

In fact, USB to RS232 is a mass product, and the cost is really low. I decided to order a couple of this, just to look if I can use this stuff on a PCB. So I bought a 1.70$ USB to RS232 on Ebay.

I decided to rip the plastic off the DB9 and discovered a really tiny PCB. I removed the DB9, and decided to pass this little PCB to a scope session. How the hell do they manage to do a USB to RS232 with only a couple of external components ? They is no big capacitor for level shifter  (remember  RS232 is a +12/-12v ) ? The answer is simple, they don’t !!

This device isn’t RS232 compliant at all, the signals on the DB9 are TTL compliant, but not RS232. The ouput is between 0/5V and the input can handle -12/+12V but works great with a 0/5V too. I simply removed used pads on one side and added a couple on pins.

Please note that RX pin is missing on this pix but needed of course. The next step : How can I use this with an AVR Atmega (I used a Atmega8 but any will do the trick). Serial connection on a micro is TTL like this board, but the TTL signal is just inverted. A “1″ on the RS232 side is a -12V and +5V on a TTL, and a 0 on the RS232 side is a + 12V and a 0v on the TTL. You can find all the information here.

In fact MAX232 do both level shitting and inverting, but as I’m to lazy to wire a MAX232 (and will destroy the cheap aspect of this hack), I decided to handle this by software. This mean, I won’t be able to use the Atmega serial builtin port but need to write some additional code, to do the RS232 encoding/decoding by hand. Let’s give it a try :

I simply put this on a verroboard, connect VCC to USB Vcc, GND, RX and TX  to random pins on the AVR and let’s go to RS232 software serial. This can be done easily in fact, and I managed to handle 19200bauds with the internal 8Mhz clock of the Atmega. Above you will find the popular uart_putc() and uart_getc() ..

 #define UART_TX	D,1
 #define UART_RX	D,2
 #define UART_DELAY	52 // 1/9600 = 104uS : 1/19200 = 52uS


 void uart_putc(char c)
 {
   uchar i;
   uchar temp;

   // start
   set_output(UART_TX);
   _delay_us(UART_DELAY);
   clr_output(UART_TX);

   for(i=0;i<8;i++)
   {
     temp = c&1;
     if (temp==0)
       set_output(UART_TX);
     else
       clr_output(UART_TX);
     _delay_us(UART_DELAY);

      c = c >>1;
   }

   // stop
   set_output(UART_TX);
   _delay_us(UART_DELAY);
   clr_output(UART_TX);

   _delay_us(UART_DELAY);
 }

 uchar uart_getc()
 {
   uchar i;
   uchar ib = 0;
   uchar currentChar=0;

   while (ib != 1)
     ib = get_input(UART_RX);

   _delay_us(UART_DELAY/2); // middle of the start bit
   for(i=0;i<8;i++)
     {
       _delay_us(UART_DELAY);
       ib = get_input(UART_RX);

       if (ib ==0)
 	currentChar |= 1<<i; // this is a 1
     }
   return currentChar;
 }

Nothing more to say, this hack works really great, and I can now build a bunch of USB board without paying so much. The only drawback of this approach is that you can’t use an interrupt for the uart_getc() so you have deal with that in your code. Another approach would use a single transistor for the RX pin to make the RX compliant w/ the AVR serial builtin routine.

You can find the whole project C files + Makefile in a zip here. I think this little hack is really useful, so please send it to all to your DIYer friends, this can save them money, time …

// Enjoy cheap USB ? :)

At the first test, I discovered that the transceiver come with a couple of IR leds. I have to glue each IR led in front of each part of your equipment I want to drive. For me, the cable receiver, the DVD, the Dvico, and the AV amp .. I tried this, but that’s a mess, each led is soldered on a single string, and tend to move. Not really a nice experience. This is simple to crappy to be use.

I decided to mod it to be able to use a single IR led, with a better gain. The first step is to find the right place to place my mod. Just open the transceiver, locate the power supply (Vcc/Gnd) and the IR transistor. I was quite easy, the only trick is to solder the wire for the IR transistor just before the base resistor. Here is the result.

You can find a better pix, in the gallery. I used a scope to find the IR transistor, but this can be done without.

Let’s build a simple IR booster, that’s connect to this pins, and everything will be fine. I used an common BC547 but any common transistor will do the job.

The result :

As you can see, this is small. I placed this near my cable receiver and every is working nicely. I can now control every equipment (cable, DVD, Dvico) for my room without any lag, or IR lost signal.

I managed to fix this cheap video sender without to much effort, I’m happy. This kind of hack can be used in a couple video sender device. The hardest part is to find the IR transistor, the rest is simply the same.

Enjoy TV from bed ;)

The main issue here, is that I used my main computer to monitor an 1wire network of external, heating and rooms temperature. I used a small Arduino card and a couple of Python scripts to populate some munin graph, like this one:

As you can see on this graph, I use a reference temperature from Guipavas. This stuff is public, and I use the Weather.com for the info. All works fine for about an year now. But when I switched to my new little box (300Mhz..) the python script used to monitor the 1wire network and gather weather.com reference was a bit heavier than excepted for this little box.

I first thought to rewrite this in pure C, but having to deal w/ xml parsing (libxml) and Posix serial in C .. That’s the little story, I decided to rewrite this script (and other) in Vala. I will not dump the Vala introduction here, but to be short it’s a new language that produce C used by Gnome Desktop. The syntax tend to be a C# like, and it has a lot of libraries and doesn’t need the bloat of an interpreter (nor VM). My first test was to listen to the Arduino serial port.

public void run()
{
ser = new Serial.POSIX();
loop = new GLib.MainLoop();
ser.speed=Serial.Speed.B38400;
ser.received_data.connect(parseSerial);
loop.run();
}

I used a Serial.vala wrapper found on the net, this is simple and neat. Just added some string parsing, and I get my Arduino 1wire network working w/ Vala .. The next is the Weather.com parsing which will be covered in a future post.
To conclude, the Vala result is fine. The result binary is small 38KB, it has quite a lot of dependencies (libsoup,glib, pthread, gobject..) and consume more memory than my python script. Python interpreter + Elementtree (xml parsing) + pyserial eat around 8.9MB of RAM, while the my Vala code eat 12.3MB. But keep in mind that’s this is with all the shared libraries. So, if you use a couple of script like me, this memory isn’t a big deal, because it will be used across different process without any overhead.

In meantimes, the main difference between the two version is the speed, here come some results with the time command of the weather.com functions only (I dropped the serial IO stuff for this test) :

jkx@brick:~$ time python weather.py
Temp:    20
Pres:    1021.0 hPa
Wind:    19 km/s

real    0m2.105s
user    0m1.468s
sys     0m0.216s

jkx@brick:~$ time ./weather
Temp:    20 deg
Pres:    1021.0 hPa
Wind:    19 km/s

real    0m0.427s
user    0m0.084s
sys     0m0.032s

Ok, Python takes 4x the Vala time for the same stuff. Of course this piece of code isn’t exactly the same, and evolve an network access, but I tested this a couple of times, and the result is always ~ the same, so I decide to look closer, and found that despite Python interpreter load quite speedy, ElementTree + urllib2 take 1.35sec to import

I get it, this system has a really small CPU and importing libs from harddrive takes times .. which doesn’t occur with my Vala code, the binary is small, and all dependency are already loaded by the OS itself. To conclude, Python is still my favorite language but running python script on small system has an overhead which I must take care, and avoiding loading / unloading libs is the key. A single python process, with some script loaded will be a better choice. And for small custom apps used on this kind of system, Vala seems to be a good alternative.

// Enjoy the sun

The AVR Dragon is nice because you can use it as a small developpement device without any other requirement: Simply drop the needed ATMega on the board, some little wrapping for : Jtag + power supply.

As you can see, this is compact and nothing else is needed. The power supply come from the USB port, and I soldered a DIP on the board.. and that’s it.

I use the Jtag connector, so now I can use a real debugger instead of playing with the UART. Simply put a breakpoint, and enjoy :) By this way, I figure out that most of the time I simply push some stuff in arrays, and inspect them with debugger. This is really efficient. For example, last week I need to fix a timing issue with a IR sensor, simply wrap the little board, and push all interrupts in a array with the related timing. Of course, this can be done with a serial connection too, but it will take more time, and even worst if you encounter a bug, you will have to find where is it (the UART printf, or the code itself) ..

So, how to use this with a Linux OS ?

First you need to use AVaRICE to program the ATMega with a command like this :

avarice -g -j usb --erase --program --file main.hex :4242

Here the result:

AVaRICE flash the hex file to the ATMega, and wait for a GDB connection on port 4242. GDB is fine, but not really visual ;)

Let’s take a look at DDD

To use DDD with avr-gdb (the gdb for AVR), you need to edit a config file, for example gdb.conf and put this in :

file main.out
target remote localhost:4242

And the final command, just launch DDD like this :

ddd --debugger "avr-gdb -x gdb.conf"

Next step: Simply place some breakpoint, and the press “Cont” inue button in DDD. Et voilà :

I hope this little tuto will help people looking for a nice AVR debuger for the AVR on Linux (or any OSS system). The AVR Dragon is definitively a must have for low budget user in AVR scene.

Enjoy bug ? :)

I already talk to my friend Bernt about this. He says he already used a cheap gas hot air gun with good result. Ok, he isn’t really an hobbist, and have a professional soldering station at work, but …

Tomorrow morning, he was waiting for me at my work, and gave me a gas hot air gun (plus additional soldering tip) ..what a great a present ! Thank you guy. In fact, they just started to sell this cheap stuff on their shop: Splashelec.

Fine, so it’s time to give it a try no ?

Hum, guess what, I don’t have any electronic flux at home. In fact this cost too much too ! (and you can’t stock it for a long time..) but I have some plumber paste on my desk. I use this stuff for wifi antenna not electronic but it should be fine.

Simply apply the paste with a brush and use the iron to melt it a bit. As I’m new to hot air soldering, I decided to use a normal iron to do that. Next step remove the surplus with some water. In fact, you can use a normal solder here, but using the paste is a bit easier to apply …

Ok ready to play ! Fire !

And the final step, place the chip on the board. Mount the heat blower on the gun and light it. Set it around the max temperature, and gently approach the chip pins. Don’t be afraid to take your time, chips are made for a reflow process, so they can handle hot air without too much issue.

Here’s the result

Fine no ? ;) The soldering is quite perfect, it’s my first time with an hot air soldering gun so.. but I’m really happy. It’s really easier than a normal soldering iron.