[Arduino] Afficheur 7 segments / 16 digits (base TM1640)

Bonjour tout le monde !

Aujourd’hui je vous propose un article bien sympa à base d’arduino (pas d’article ROHS ce coup ci ;))

Le sujet du jour porte sur cet afficheur 7 segments à 16 digits de DealExtreme :
http://dx.com/jy-mcu-16x-digital-tube-yellow-led-module-104311

—

L’afficheur :

Que dire dessus …
– 21cm de long,
– 16 digits,
– 7 segments + point décimal par digits,
– une led témoin d’alimentation,
– un contrôleur série TM1640.

16 digits pour même pas 8$ … que demander de plus ?
C’est vraiment une belle bête, je suis très satisfait de mon achat 🙂

—

Le contrôleur :

La petite bête qui contrôle tout le bouzin est un TM1640. C’est un ci « made in china » de la société « Titan micro electronics ».
Le TM1640 permet de contrôler jusqu’à 16 digits via un interface proche du SPI (plus d’info plus bas).

Problème :
Aucun datasheet dans une autre langue que le chinois n’est disponible sur internet … c’est ennuyeux …
Et oui pour moi le chinois … c’est du chinois … 🙂

Mais un mec malin du forum DX en a fait une traduction partielle avec google trad !
http://club.dx.com/forums/Forums.dx/threadid.1013434?page=2
Youpi ! Let’s go !

Tout est détaillé, forme du signal, protocole, commandes, … TOUT 🙂

Voici le plus intéressant :

Forme du signal et protocole :

Carte de la mémoire ram :

Détail de l’agencement des éléments des digits et de la luminosité :

Avec tout ça il est possible de faire un code de test sans problème !

—

A première vue, en analysant la forme du signal on peut voir qu’il s’agit d’une sorte de communication SPI, mais avec la particularité que le signal SS (slave select) est fusionné avec DIN.
Cette particularité étant utilisé comme bit de start / stop.

En gros au lieu d’avoir un port SPI « normal » (SCLK, MOSI, SS) on obtient un port à deux fils SCLK / DIN.
Il suffit donc que je reprenne mon code de « software SPI » et que je fusionne DIN et SS … trop simple 🙂

Bon ok, ma première idée fut d’utiliser une librairie toute prête comme celle ci :
http://code.google.com/p/tm1638-library/

Mais cela n’aurait pas été drôle, c’est tellement plus marrant de partir à l’aventure et de coder le tout soit même 😉

Voici donc ma version maison qui émule un port SPI avec la particularité de fusionner SS et DIN :

/* Pinmapping */
#define PORT_REG PORTB  // Port de sortie sur lequel est câblé le TM1640
#define DDR_REG DDRB    // Registre DDR associé au port de sortie
#define PIN_DIN 4  // PB4 -> D12 // Broche DIN
#define PIN_SCLK 5 // PB5 -> D13 // Broche SCLK

/* Data pin macro*/
#define dataLow() PORT_REG &= ~(1 << PIN_DIN)
#define dataHigh() PORT_REG |= (1 << PIN_DIN)
#define dataSet(x) (x) ? dataHigh() : dataLow()

/* Clock pin macro */
#define clockLow() PORT_REG &= ~(1 << PIN_SCLK)
#define clockHigh() PORT_REG |= (1 << PIN_SCLK)

/* Switch display macro */
#define displayOff() M1640_command(0x80)

/* Table de correspondance chiffre / lettre -> binaire */
byte numericTable[] = {
/* dp, g, f, e, d, c, b, a */
  B00111111, // 0
  B00000110, // 1
  B01011011, // 2
  B01001111, // 3
  B01100110, // 4
  B01101101, // 5
  B01111101, // 6
  B00000111, // 7
  B01111111, // 8
  B01101111, // 9
  B01110111, // A
  B01111100, // B
  B00111001, // C
  B01011110, // D
  B01111001, // E
  B01110001  // F
};

/* Envoi un octet au TM1640 */
void TM1640_write(byte raw) {
  for (byte i = 0; i < 8; ++i) {
    clockLow();
    dataSet(raw & 1);
    raw >>= 1;
    clockHigh();
  }
}

/* Efface le contenu de la ram du TM1640 (= efface l'écran) */
void TM1640_clear(void) {
  dataLow();
  TM1640_write(0xC0);
  for (byte i = 0; i < 16; ++i) TM1640_write(0x00);
  dataHigh();
}

/* Envoi une commande au TM1640 */
void TM1640_command(byte cmd) {
  dataLow();
  TM1640_write(cmd);
  dataHigh();
}

/* Envoi un octet de données au TM1640 chip */
void TM1640_data(byte address, byte data) {
  TM1640_command(0x44);
  dataLow();
  TM1640_write(0xC0 | address);
  TM1640_write(data);
  dataHigh();
}

/* Initialise le TM1640 */
void TM1640_setup(byte intensity) {

  /* Place les broches DIN et SCLK en sortie et à HIGH*/
  DDR_REG |= (1 << PIN_DIN) | (1 << PIN_SCLK);
  PORT_REG |= (1 << PIN_DIN) | (1 << PIN_SCLK);

  /* Initialise le TM1640 et règle la luminosité */
  TM1640_command(0x40);
  TM1640_command(0x88 | (intensity & 7));

  /* Efface le contenu de la ram du TM1640 */
  TM1640_clear();
}

/* setup() */
void setup() {
  TM1640_setup(5); // Initialise le TM1640 avec une luminosité de 5 / 7
}

/* loop() */
void loop() {
  static unsigned long i = 0; // Variable s'incrémentant à l'infini
  static unsigned long t = 0; // Temps en ms du dernier affichage

  /* Rafraîchissement de l'affichage toute les 250ms */ 
  if(millis() - t > 250) {    
    TM1640_data(15, numericTable[i % 10]);
    TM1640_data(14, numericTable[(i / 10) % 10]);
    TM1640_data(13, numericTable[(i / 100) % 10]);
    TM1640_data(12, numericTable[(i / 1000) % 10]);
    TM1640_data(11, numericTable[(i / 10000) % 10]);
    TM1640_data(10, numericTable[(i / 100000) % 10]);
    TM1640_data(9, numericTable[(i / 1000000) % 10]);
    TM1640_data(8, numericTable[(i / 10000000) % 10]);
    TM1640_data(7, numericTable[(i / 100000000) % 10]);
    TM1640_data(6, numericTable[(i / 1000000000) % 10]);
    TM1640_data(5, 0);
    TM1640_data(4, 0);
    TM1640_data(3, 0);
    TM1640_data(2, 0);
    TM1640_data(1, 0);
    TM1640_data(0, 0);

    t = millis();
  }

  ++i;
}

Ce code est très simple, il fournit une série de 5 fonctions bas niveau :
– void TM1640_write(byte raw) pour envoyer un octet brute,
– void TM1640_clear(void) pour effacer la ram du TM1640,
– void TM1640_command(byte cmd) pour envoyer une commande,
– void TM1640_data(byte address, byte data) pour envoyer un octet de données à une adresse précise,
– void TM1640_setup(byte intensity) pour initialiser le TM1640 et régler la luminosité.

Au passage vous remarquerez la présence d’une table de conversion lettres / chiffres -> binaire.
Merci google pour les associations 8 => abcdefg, … et mon script python tiré d’un précédant article sur les afficheurs 7 segments.
Faire cette table à la main aurait été une pure galère …

Niveau hardware / câblage :

Vous avez besoin :
- une carte arduino,
- un afficheur 16 digits sur base TM1640,
- 4 fils mâle / mâle

Le câblage :
Arduino -> TM1640
D13 -> SCLK
D12 -> DIN
VCC -> VCC
GND -> GND

C’est pas compliqué 😉

—

Hop hop hop ! Montage !

Et au final voila ce que ça donne :

Enjoy ! 🙂