Aujourd’hui nous allons nous pencher sur un petit bidule électronique qui ne demande qu’à se faire ouvrir en deux pour révéler ses entrailles. Voici le client:
C’est un « pricer », une étiquette électronique comme on trouve partout désormais. Pour vous en procurer un: démerdez-vous, je ne vais pas vous faire un dessin non plus! N’allez pas en piquer dans un magasin non plus, mais si on réfléchit c’est assez facile d’en trouver un…
Première partie: comment ça fonctionne. Tout ce qui suit est basé sur des documents glanés ici et là sur le site du fabricant (tapez « pricer » sur google), mais en gros ces étiquettes électroniques sont contrôlées par IR, à distance donc. D’après ce que j’ai compris de la démo du commercial neurasthénique de chez Pricer, une interface Web couplée à une grappe d’émetteurs IR permet de mettre à jour les étiquettes à distance, instantanément et de façon groupée à partir d’un unique poste de contrôle. C’est réellement intéressant comme système!
Au niveau de l’aspect extérieur, nous avons en façade un écran LCD, un capteur IR sur la droite. Derrière on aperçoit 3 piles 2023 3V…ca peut toujours servir!
Maintenant, les entrailles. Ca y est, vous avez votre Pricer? Alors le TP d’aujourd’hui va consister à ouvrir le boîtier pour vois comment hacker le tout. Perso j’y suis allé au Dremel, car je n’ai pas l’impression qu’il soit possible d’ouvrir le boîtier sans y aller comme une brute. Allez-y doucement, c’est pas fait pour être ouvert alors ca risque d’être un peu tendu!
Une fois ouvert, voici ce qui reste:
Rien ne vous choque à cet instant?
non?
Pourtant l’écran est toujours allumé, alors que les piles ont été enlevées! Intéressant, non? Ca s’explique simplement par le fait que cet écran est en fait un e-paper, ses pixels sont en fait de petites billes blanches d’un côté, noires de l’autre, que l’on fait pivoter électriquement. De ce fait, les pixels gardent leur étant même lorsqu’on coupe le jus. Excellent choix, avec 3 piles bouton on peut du coup obtenir une longévité hors du commun, car cet écran ne consomme de l’énergie que lorsque l’on change l’affichage!
Passons à la suite, examinons le circuit:
Ahah, voilà qui est intéressant! Trois puces, dont une noyée dans la résine. Rien à faire pour celle-là, concentrons-nous sur les deux autres. Si vous dégainez votre loupe, vous verrez que la première est un ATMEL ATMEGA16L, la seconde un ATMEL952 25128AN.
Deux recherches sur google et deux datasheets plus tard (ici et ici), voici ce qu’on peut apprendre:
- la première (le 16L) est un micro-contrôleur, de la même famille que ceux présents sur les Arduinos
- la seconde (la 25128) est une EEPROM de 128k contrôlable par SPI.
Que du bonheur tout ca! Et si nous allions voir ce qu’elle contient cette EEPROM? Jetons un coup d’oeil à la datasheet:
Notre puce est un 8-lead SOIC (8-lead pour 8 pattes, SOIC pour Small Outline Integrated Circuit). Maintenant le détail des pattes:
- /CS: Chip Select. Si cette entrée est à 0, alors la puce est sélectionnée. Ceci permet d’utiliser plusieurs puces de mémoire. Pour de plus amples explications: Wikipedia, page sur le SPI.
- SO: Serial Out, là où vont sortir les données
- /WP: Write Protect, pour mettre la puce en lecture-seule
- GND: la masse
- SI: Serial Input, là où l’on va injecter les données
- SCK: l’horloge du SPI. Là encore -> Wikipedia.
- /HOLD: pour suspendre les communications.
- VCC: +5V.
Maintenant, dégainez votre meilleur ami, l’Arduino.
Après quelques recherches, j’ai trouvé cette page où est expliqué en détail comment communiquer avec une EEPROM SPI et, suprême coup de bol, tout est expliqué en détail, même le code à envoyer à l’arduino. On gagne du temps! Pour plus de détails, rendez-vous à la page 11 de la datasheet où se trouvent les datagrammes permettant de lire/écrire la mémoire. En gros on bascule /CS, on envoie l’instruction (READ ou WRITE), l’adresse, puis on lis/écrit les données. Pratique, la puce continue à envoyer des données (en mode LECTURE) ou à attendre de nouvelles données tant qu’on n’a pas rebasculé /CS. Même pas besoin d’incrémenter l’adresse!
Enfin bon, c’est beau tout ca, mais va falloir y accéder à la puce, non?!
C’est là qu’on dégaine notre deuxième meilleur pote, le fer à souder. Je recommande vivement la troisième main, sans quoi vous allez vous arracher les cheveux. Utilisez aussi du fil mono-brin, c’est beaucoup plus facile à mettre en place.
On connecte le tout à l’arduino:
Et hop, il n’y à plus qu’à prier!
J’ai un peu modifié le code donné sur le site Arduino pour:
- ne pas écrire par dessus les données qu’on veut lire, bordel de merde!
- mettre les données lues en forme
Ca donne ca:
#define DATAOUT 11//MOSI
#define DATAIN 12//MISO
#define SPICLOCK 13//sck
#define SLAVESELECT 10//ss
//opcodes
#define WREN 6
#define WRDI 4
#define RDSR 5
#define WRSR 1
#define READ 3
#define WRITE 2
byte eeprom_output_data;
byte eeprom_input_data=0;
byte clr;
int address=0;
char spi_transfer(volatile char data) {
SPDR = data; // Start the transmission
while (!(SPSR & (1< return SPDR; // return the received byte
}
void setup() {
Serial.begin(9600);
pinMode(DATAOUT, OUTPUT);
pinMode(DATAIN, INPUT);
pinMode(SPICLOCK,OUTPUT);
pinMode(SLAVESELECT,OUTPUT);
digitalWrite(SLAVESELECT,HIGH); //disable device
}
byte read_eeprom(int EEPROM_address) {
//READ EEPROM
int data;
digitalWrite(SLAVESELECT,LOW);
spi_transfer(READ); //transmit read opcode
spi_transfer((char)(EEPROM_address>>8)); //send MSByte address first
spi_transfer((char)(EEPROM_address)); //send LSByte address
data = spi_transfer(0xFF); //get data byte
digitalWrite(SLAVESELECT,HIGH); //release chip, signal end transfer
return data;
}
void loop() {
eeprom_output_data = read_eeprom(address);
//Serial.print("At 0x");
//Serial.print(address, HEX);
//Serial.print(" = ");
Serial.print("0x");
Serial.print(eeprom_output_data,HEX);
address++;
//when finished dump, enter infinite loop
if (address == 0x4000) {
Serial.println("};");
while(1);
}
Serial.print(", ");
if (!(address%20)) Serial.println("");
//delay(50); //pause for readability
}
Si tout fonctionne bien:
Petite précision: la valeur 0×4000 correspond à la taille de notre EEPROM, soit 128ko.
Voilà, c’est terminé pour cette première partie. Dans la suivante si tout se passe bien (comprendre: « si j’y arrive! »), nous verrons comment est structuré le contenu de cette petite ROM, comment le modifier etc…
