Display

VIM878 HT1621B Display Teil 2

Die Platinen von Oshpark (18.08.2016) und Elecrow (16.08.2016) sind da, es kann losgehen mit dem Displaymodul.

oshpark_elecrow
links oshpark, rechts elecrow

Der silkscreen ist leider verpfuscht. Ich habe aus Bequemlichkeit die Eagle-Dateien geschickt, so dass der Hersteller auch die tnames (Kurznamen z. B. JP1 o.ä.) mitgedruckt hat, eigentlich  sollten es nur die tvalues (Bauteilewerte) und die tplaces (Umrisse der Bauteile) sein.

Es folgt die teilbestückte Platine, am schwierigsten ist die Bestückung des HT1621B, wobei nicht das Löten (mit breiter meißelförmiger Spitze, viel Flußmittel und zügigem Überstreichen) schwierig ist, sondern die richtige Platzierung und Fixierung des Chips:

teilbestückt
teilbestückt

 

teilbestückt
teilbestückt

 

vollbestückt
vollbestückt

 

vollbestückt
vollbestückt

 

vollbestückt
vollbestückt

 

in Funktion
in Funktion (Charakterdarstellung)

 

in Funktion
in Funktion (Zähler)

Leider habe ich erst jetzt gesehen, dass schon jemand vor mir praktisch genau diese Platine gebaut hat:

TWI Display at www.akafugu.jp

Schade, das wäre eine gute Inspiration gewesen.

VIM878 HT1621B Display Teil 1

Seit einiger Zeit gibt es bei Pollin ein LC-Glas zu kaufen, das VIM878 von Varitronics:

www.pollin.de LCD_Modul_VARITRONIX_VIM878

Der HT1621B reicht gerade noch aus, um dieses Glas mit 4 Commons und 32 Segmenten anzusteuern.

Besonders erklärungsbedürftig ist die hierfür konstruierte Hardware nicht, man schließt alle COM-Anschlüsse des HT1621B an die passenden Pins des Displays. Die Segmente 1 .. 16 werden an die Segmentanschlüsse 0 bis 15 des HT1621B angeschlossen, die Segment 32 bis 17 an die Segmentanschlüsse 16-31.

Letzteres ist bewußt in umgekehrter Reihenfolge angeordnet, um die Programmierung zu vereinfachen. Durch die gespiegelte Reihenfolge werden nämlich die Segmente im Speicher des HT1621B in derselben Reihenfolge angeordnet wie die Segmente 1 bis 16. Näheres verrät das Datenblatt des VIM 878 bei analytischer Betrachtung. 😉 (siehe auch meinen Beitrag vom 25.06.2016)

Dieses Mal habe ich auch noch den Buzzer-Anschluß (JP2) mit vorgesehen, für alle Fälle.

Schaltplan:

Schaltplan
Schaltplan

Layout:

Layout
Layout

(bestellt am 31.07.2016 bei oshpark -3 Stück- und am 02.08.2016 bei elecrow -10 Stück-)

VIM878 8 Stellen 14 Segment Display Glas

Bei Pollin gibt es mit dem VIM878 ein spannendes 8-stelliges 14-Segment LC-Display mit Datenblatt zu kaufen. Das möchte ich gern mit meiner HT1621B-Universalplatine testen. Also Datenblatt gründlich lesen:

Datenblattausschnitt Datenblattausschnitt_2

Wenn man die Pins des LCD fortlaufend mit dem HT1621B verdrahtet, werden zunächst die Segmentteile der Digits 1 bis 8 und dann wieder rückwärts laufend von 8 bis 1 den Speicherstellen des Display-RAM zugeordnet. Segmentblock/Pin 1 (1D, 1E, 1F, CA1) liegt dann also auf Adresse 0, Segmentblock/Pin 32 (1M, 1N, 1G, 1H) auf Speicherstelle 31. Das könnte für die Programmierung umständlich werden, da zum Schreiben eines Digit alle zu diesem Digit gehörenden Segmente angeschaltet werden müssen. Man müßte für zwei Teile des Digits aufwärts zählen, für die weiteren zwei Teile dann rückwärts und das mit jeweils unterschiedlichen Abständen im Speicher.

Deshalb habe ich anders verdrahtet. Ich habe die Segmentblöcke 1 bis 16 den Speicheradressen 0 .. 15 zugeordnet und dann die Segmentblöcke 32 bis 21 den Speicheradressen 16 .. 31. Der Abstand zwischen den zusammengehörigen zwei Segmentblöcken (Pin 1, 2, und Pin 32, 31) im Speicher des HT1621B ist jetzt konstant. (Besser wäre natürlich, eine universellere Softwarelösung zu finden, weil es sicher auch Displays geben wird, bei denen die Segmente nicht so strukturiert den Pins zugeordnet sind. Aber Zeit ist wie immer knapp.)

Alles schnell verdrahten und los geht es. Eine Arduino-Bibliothek zum schnellen Testen ist bereits vorhanden, wenn auch für 7-Segment-Displays.

Ein paar Bilder vom Aufbau:

VerkabelungVerkabelung_2 Verkabelung_3 Verkabelung_4 Verkabelung_5

Pollin Display HB10401

Pollin verkauft derzeit o.g. Display aus der Siemens Logo 12/24RC.

Siemens Logo
Siemens Logo

 

Siemens Logo Aufbau
Siemens Logo Aufbau

Leider sind im Internet keine Anschlußbelegungen zu finden. (Oder ich habe nicht gründlich genug gesucht 😉

Tasten
Tasten

 

Stecker
Stecker

Anbei eine erste Untersuchung der Belegung der auf dem Display vorhandenen Buchse:

Buchse beschriftet
Buchse beschriftet

Hierbei meint T_xx den jeweiligen Anschluß des Tastenfeldes, D0 .. 7 sind die Datenleitungen des LCD, CONx meint die LCD-Steuersignale (Diese Leitungen gehen alle zum LCD_Controller)

 

EDIT: Im Mikrocontroller-Forum war jemand schneller und hat bereits die vollständige Belegung herausgefunden und getestet.

Nokia 5110 am STM8S105

benutzte hardware
benutzte hardware
STM8S105 auf Adapterplatine
STM8S105 auf Adapterplatine
Anzeige Text
Anzeige Text
Anzeige Text 2
Anzeige Text 2

Die Software zum Schnelltest wurde von http://shelvin.de/lcd-display-nokia-5110-ansteuern/ übernommen und adaptiert:

// LCD Display vom Nokia 5110
// http://www.youtube.com/playlist?list=PLjzGSu1yGFjXWp5F4BPJg4ZJFbJcWeRzk
//
// Matthias Busse Version 1.3 vom 13.9.2014
// http://shelvin.de/lcd-display-nokia-5110-ansteuern/
//
// überarbeitet für STM8S105 von Uwe Grassow am 03.01.2016

#include <iostm8s105s4.h>
#include <intrinsics.h>
#include <stdint.h>
// #include "stm8_18b20.c"

static const uint8_t ASCII[][5] = {// ASCII Tabelle mit Fonts
 {0x00, 0x00, 0x00, 0x00, 0x00} // 20  
,{0x00, 0x00, 0x5f, 0x00, 0x00} // 21 !
,{0x00, 0x07, 0x00, 0x07, 0x00} // 22 "
,{0x14, 0x7f, 0x14, 0x7f, 0x14} // 23 #
,{0x24, 0x2a, 0x7f, 0x2a, 0x12} // 24 $
,{0x23, 0x13, 0x08, 0x64, 0x62} // 25 %
,{0x36, 0x49, 0x55, 0x22, 0x50} // 26 &
,{0x00, 0x05, 0x03, 0x00, 0x00} // 27 '
,{0x00, 0x1c, 0x22, 0x41, 0x00} // 28 (
,{0x00, 0x41, 0x22, 0x1c, 0x00} // 29 )
,{0x14, 0x08, 0x3e, 0x08, 0x14} // 2a *
,{0x08, 0x08, 0x3e, 0x08, 0x08} // 2b +
,{0x00, 0x50, 0x30, 0x00, 0x00} // 2c ,
,{0x08, 0x08, 0x08, 0x08, 0x08} // 2d -
,{0x00, 0x60, 0x60, 0x00, 0x00} // 2e .
,{0x20, 0x10, 0x08, 0x04, 0x02} // 2f /
,{0x3e, 0x51, 0x49, 0x45, 0x3e} // 30 0
,{0x00, 0x42, 0x7f, 0x40, 0x00} // 31 1
,{0x42, 0x61, 0x51, 0x49, 0x46} // 32 2
,{0x21, 0x41, 0x45, 0x4b, 0x31} // 33 3
,{0x18, 0x14, 0x12, 0x7f, 0x10} // 34 4
,{0x27, 0x45, 0x45, 0x45, 0x39} // 35 5
,{0x3c, 0x4a, 0x49, 0x49, 0x30} // 36 6
,{0x01, 0x71, 0x09, 0x05, 0x03} // 37 7
,{0x36, 0x49, 0x49, 0x49, 0x36} // 38 8
,{0x06, 0x49, 0x49, 0x29, 0x1e} // 39 9
,{0x00, 0x36, 0x36, 0x00, 0x00} // 3a :
,{0x00, 0x56, 0x36, 0x00, 0x00} // 3b ;
,{0x08, 0x14, 0x22, 0x41, 0x00} // 3c <
,{0x14, 0x14, 0x14, 0x14, 0x14} // 3d =
,{0x00, 0x41, 0x22, 0x14, 0x08} // 3e >
,{0x02, 0x01, 0x51, 0x09, 0x06} // 3f ?
,{0x32, 0x49, 0x79, 0x41, 0x3e} // 40 @
,{0x7e, 0x11, 0x11, 0x11, 0x7e} // 41 A
,{0x7f, 0x49, 0x49, 0x49, 0x36} // 42 B
,{0x3e, 0x41, 0x41, 0x41, 0x22} // 43 C
,{0x7f, 0x41, 0x41, 0x22, 0x1c} // 44 D
,{0x7f, 0x49, 0x49, 0x49, 0x41} // 45 E
,{0x7f, 0x09, 0x09, 0x09, 0x01} // 46 F
,{0x3e, 0x41, 0x49, 0x49, 0x7a} // 47 G
,{0x7f, 0x08, 0x08, 0x08, 0x7f} // 48 H
,{0x00, 0x41, 0x7f, 0x41, 0x00} // 49 I
,{0x20, 0x40, 0x41, 0x3f, 0x01} // 4a J
,{0x7f, 0x08, 0x14, 0x22, 0x41} // 4b K
,{0x7f, 0x40, 0x40, 0x40, 0x40} // 4c L
,{0x7f, 0x02, 0x0c, 0x02, 0x7f} // 4d M
,{0x7f, 0x04, 0x08, 0x10, 0x7f} // 4e N
,{0x3e, 0x41, 0x41, 0x41, 0x3e} // 4f O
,{0x7f, 0x09, 0x09, 0x09, 0x06} // 50 P
,{0x3e, 0x41, 0x51, 0x21, 0x5e} // 51 Q
,{0x7f, 0x09, 0x19, 0x29, 0x46} // 52 R
,{0x46, 0x49, 0x49, 0x49, 0x31} // 53 S
,{0x01, 0x01, 0x7f, 0x01, 0x01} // 54 T
,{0x3f, 0x40, 0x40, 0x40, 0x3f} // 55 U
,{0x1f, 0x20, 0x40, 0x20, 0x1f} // 56 V
,{0x3f, 0x40, 0x38, 0x40, 0x3f} // 57 W
,{0x63, 0x14, 0x08, 0x14, 0x63} // 58 X
,{0x07, 0x08, 0x70, 0x08, 0x07} // 59 Y
,{0x61, 0x51, 0x49, 0x45, 0x43} // 5a Z
,{0x00, 0x7f, 0x41, 0x41, 0x00} // 5b [
,{0x02, 0x04, 0x08, 0x10, 0x20} // 5c ¥
,{0x00, 0x41, 0x41, 0x7f, 0x00} // 5d ]
,{0x04, 0x02, 0x01, 0x02, 0x04} // 5e ^
,{0x40, 0x40, 0x40, 0x40, 0x40} // 5f _
,{0x00, 0x01, 0x02, 0x04, 0x00} // 60 `
,{0x20, 0x54, 0x54, 0x54, 0x78} // 61 a
,{0x7f, 0x48, 0x44, 0x44, 0x38} // 62 b
,{0x38, 0x44, 0x44, 0x44, 0x20} // 63 c
,{0x38, 0x44, 0x44, 0x48, 0x7f} // 64 d
,{0x38, 0x54, 0x54, 0x54, 0x18} // 65 e
,{0x08, 0x7e, 0x09, 0x01, 0x02} // 66 f
,{0x0c, 0x52, 0x52, 0x52, 0x3e} // 67 g
,{0x7f, 0x08, 0x04, 0x04, 0x78} // 68 h
,{0x00, 0x44, 0x7d, 0x40, 0x00} // 69 i
,{0x20, 0x40, 0x44, 0x3d, 0x00} // 6a j 
,{0x7f, 0x10, 0x28, 0x44, 0x00} // 6b k
,{0x00, 0x41, 0x7f, 0x40, 0x00} // 6c l
,{0x7c, 0x04, 0x18, 0x04, 0x78} // 6d m
,{0x7c, 0x08, 0x04, 0x04, 0x78} // 6e n
,{0x38, 0x44, 0x44, 0x44, 0x38} // 6f o
,{0x7c, 0x14, 0x14, 0x14, 0x08} // 70 p
,{0x08, 0x14, 0x14, 0x18, 0x7c} // 71 q
,{0x7c, 0x08, 0x04, 0x04, 0x08} // 72 r
,{0x48, 0x54, 0x54, 0x54, 0x20} // 73 s
,{0x04, 0x3f, 0x44, 0x40, 0x20} // 74 t
,{0x3c, 0x40, 0x40, 0x20, 0x7c} // 75 u
,{0x1c, 0x20, 0x40, 0x20, 0x1c} // 76 v
,{0x3c, 0x40, 0x30, 0x40, 0x3c} // 77 w
,{0x44, 0x28, 0x10, 0x28, 0x44} // 78 x
,{0x0c, 0x50, 0x50, 0x50, 0x3c} // 79 y
,{0x44, 0x64, 0x54, 0x4c, 0x44} // 7a z
,{0x00, 0x08, 0x36, 0x41, 0x00} // 7b {
,{0x00, 0x00, 0x7f, 0x00, 0x00} // 7c |
,{0x00, 0x41, 0x36, 0x08, 0x00} // 7d }
,{0x10, 0x08, 0x08, 0x10, 0x08} // 7e ?
,{0x78, 0x46, 0x41, 0x46, 0x78} // 7f ?
};

// Definition der benutzten Ports

#define RST PC_ODR_ODR1
#define CE PC_ODR_ODR2
#define DC PC_ODR_ODR3
#define DIN PC_ODR_ODR5
#define CLK PC_ODR_ODR6
#define BL PC_ODR_ODR7

#define DS18B20_Pin PG_IDR_IDR0;

#define LOW 0
#define HIGH 1
#define ON 1
#define OFF 0

void InitialisePort(){

  PC_DDR = 0xFF;                // alles output
  PC_CR1 = 0xFF;
  PC_CR2 = 0xFF;
  PC_ODR = 0x00;                // alle Ausgänge auf LOW
  PG_DDR_DDR0 = 0;
}

// Write byte to the module.

void shiftOut(uint8_t cmd) {

  uint8_t i;

  for (i = 8; i > 0; i--) {
    CLK = LOW;                                  // SPI_SCK = 0;
    if (cmd & 0x80) DIN = HIGH; else DIN = LOW; // SPI_MO = cmd & 0x80;
    cmd = cmd << 1;
    __no_operation();
    __no_operation();
    CLK = HIGH;                                 // SPI_SCK = 1;
  }
}

void LcdWriteCmd(uint8_t cmd){
  // Kommando an Display senden
  DC = LOW;             // DC pin is low for commands
  CE = LOW;
  shiftOut(cmd);        // transmit serial data
  CE = HIGH;
}

void LcdWriteData(uint8_t cmd){
  // Daten an Display senden
  DC = HIGH;            // DC pin is high for data
  CE = LOW;
  shiftOut(cmd);        // transmit serial data
  CE = HIGH;
}

void LcdClearScreen() {
  // Bildschirm leeren
  for(int i=0; i < 504; i++)
    LcdWriteData(0x00);
}

void LcdXY(int x, int y) {
  // an X / Y Position gehen
  LcdWriteCmd(0x80|x); // Spalte
  LcdWriteCmd(0x40|y); // Zeile
}

void LcdWriteCharacter(char character) {
  // ASCII Zeichen ausgeben aus der Tabelle oben
  for(int i=0; i < 5; i++) LcdWriteData(ASCII[character - 0x20][i]);
  LcdWriteData(0x00); 
}


void LcdWriteString(char *characters) {
  // String ausgeben
  while(*characters) LcdWriteCharacter(*characters++);
}

void drawLine(void) {
    unsigned char j;
    for(j=0; j< 84; j++) { // top
    LcdXY (j,0);
    LcdWriteData (0x01); //
      }
    for(j=0; j< 84; j++) { //Bottom
    LcdXY (j,5);
    LcdWriteData (0x80); //
    }

    for(j=0; j< 6; j++) { // Right
    LcdXY (83,j);
    LcdWriteData (0xff); //
      }
    for(j=0; j< 6; j++) {// Left    
    LcdXY (0,j);     
    LcdWriteData (0xff); //       
   }  
  }     


// klassische delay-Routine, Zeiten müssen noch berechnet werden, bisher Pi*Daumen geschätzt
volatile void delay(int millisek)
{
  int i=0; int j=0;
  for (j = 0; j < millisek; j++)
  {
    for (i=0; i<2000; i++) __no_operation();
  }
}

void LCDLight(uint8_t on_or_off)
{
    // Turn the backlight on or off by passing a bool value
    // The backlight takes 3.3V and can be either on or off
    
    if (on_or_off)
    {
        BL = ON;
    }
    else
    {
        BL = OFF;
    }
}


void main(){

  // setup
  InitialisePort();
  RST = LOW;
  delay(1);
  RST = HIGH; 
  LcdWriteCmd(0x21); // LCD extended commands
  LcdWriteCmd(0xB3); //  Set LCD Vop (Contrast) 
  // 0xB0 for 5V, 0xB1 for 3.3v, 0xBF if screen too dark
  LcdWriteCmd(0x04); // set temp coefficent
  LcdWriteCmd(0x14); // LCD bias mode 1:40
  LcdWriteCmd(0x20); // LCD basic commands
  LcdWriteCmd(0x0C); // LCD normal displaymode
  // 0x0D for inverse, 0x0C for normal


  LCDLight(ON);
  delay (100);
  LCDLight(OFF);
  delay (100);
  LCDLight(ON);
  delay (100);
  LCDLight(OFF);
  delay (100);
  LCDLight(ON);
  delay (100);
  LcdClearScreen();
  
  drawLine();
  LcdXY(25,2);
  LcdWriteString("Hallo");

// loop
  while(1)
  {
  
  LcdXY(30,3);
  LcdWriteString("Hallo Welt!");
  delay(500);
  
  LcdXY(30,3);
  LcdWriteString("Hallo Uwe! ");
  delay(500);
  }

Inbetriebnahme HT1621B

Der HT1621B wartet auf seinen Einsatz bei einem Display. Ich habe mir dazu das 2 x 9 Pin Display (siehe hier) aus dem Pollin-Sortiment ausgesucht:

Display 2 x 9 Pins
Display 2 x 9 Pins (an den unteren drei Pins wurden vom Transport zerstörte Anschlüsse gefixt)

Die Beschaltung folgt der dort genannten Pinbelegung (Pin2 untere Reihe auf Seg0, Pin3 auf Seg1, …) bis auf eine Ausnahme: Pin 9 der oberen Reihe wurde auf Segment 8 gelegt, damit der Code systematischer werden kann.

Segmentzuordnung
Segmentzuordnung

Es gibt eine Arduino-Bibliothek zum Download für den HT1621B. Drei ganz wesentliche Probleme hat diese Bibliothek:

  • Leider hat der Autor seine Bibliothek speziell auf sein Display zugeschnitten. In den Dateien wird nur mit sogenannten „magic numbers“ gearbeitet.
  • Der Speicherinhalt wird nicht zurückgelesen und modifiziert oder ein Abbild im Speicher gehalten, so dass man davon ausgehen muss, dass jeder Schreibvorgang den vorhergehenden Inhalt des Segments löscht. Das ist besonders ärgerlich, wenn z.B. Sonderzeichen eingeschaltet  werden. Dies löscht einzelne Segmente einer Ziffer, die auf demselben Segmentanschluss liegen. Das Schreiben von Sonderzeichen und Zahlen ist nicht kombiniert. Diese Bibliothek ist ausserhalb des dort verkauften Displays somit eine reine Demo und im praktischen Einsatz ohne Änderungen nicht wirklich brauchbar.
  • Beim HT1621B werden die Speicheradresse mit dem MSB zuerst, die Daten jedoch mit dem LSB zuerst herausgeschoben. Der Autor hat nicht klar kommuniziert, dass er – vermutlich aus Gründen der Vereinfachung – die Daten in seinem Programm mit dem MSB zuerst herausschiebt. Man muss also die Daten im Vergleich zum Datenblatt des HT1621B genau verkehrt herum aufbauen. Das ist enorm wichtig für den Aufbau der COM-Segment-Tabelle im Programm. Segment 0 im HT1621B-Speicher landet so auf Bit 7 in der Tabelle, Segment 1 auf Bit 6 usw. Da er mit „magic numbers“ arbeitet, kommt man darauf erst nach verzweifeltem Testen 😉 und nachfolgender Programmanalyse.

Vorteil ist jedoch die gute Überschaubarkeit des Codes. Es wurde auf jeglichen Schnickschnack verzichtet.

Ich versuche jetzt, diese Bibliothek an mein Display anzupassen und dabei gleichzeitig etwas universeller zu machen. Die grundlegende Senderoutine wird so umgestellt, dass immer nur vier Bit Daten gesendet werden. Das ist in „umgekehrter“ Logik übersichtlicher und einfacher zu codieren und entspricht mehr der inneren Logik des HT1621B mit 32 x 4 Bit Speicher. Die Sonderzeichen sind nun universeller kodiert. Es können auch Buchstaben (vorerst ‚O‘, ‚F‘, ’n‘) angezeigt werden. Das habe ich bereits fertig.

Display 2x9 Pins im Test
Display 2×9 Pins im Test

 

Versuchsaufbau
Versuchsaufbau

Nächster Schritt ist dann, die Schreibroutine so anzupassen, dass der bereits vorhandene Inhalt nicht mehr überschrieben wird. Wenn alles fertig und mit einem weiteren Display getestet ist, werde ich die Quelldateien unter Beachtung der ursprünglichen Lizenz veröffentlichen.

 

Anzeigemodul mit VQE21 (alias „die grüne Pest“)

Die VQE21-Lichtschachtanzeigen aus DDR-Produktion gibt es bei Pollin seit langem als häufige Beilage in jedem LCD/LED-Sortiment. Diese Anzeigen sind allerdings nur sehr eingeschränkt zu gebrauchen. Eine Idee, den Nutzen etwas zu erhöhen, ist das Kombinieren zweier Anzeigen, indem die zweite auf den Kopf gestellt angefügt wird. So hat man immerhin 2,5 Stellen („188“) und weitere Segmente für Funktionsanzeigen als 7-Segment-Anzeige zur Verfügung, statt nur 1,5 Stellen.

Der Schaltplan ist eine eingekürzte Version und deshalb etwas unübersichtlich. Ursprünglich war eine Doppelanzeige geplant, also insgesamt vier VQE21.

 

VQE21 Schaltplan
VQE21 Schaltplan
VQE21 Layout
VQE21 Layout

 

 

 

 

 

 

 

 

 

Platine oben
Platine oben
Platine unten
Platine unten

 

 

 

 

 

 

 

 

 

 

Seitenansicht
Seitenansicht
Draufsicht
Draufsicht

 

 

 

 

 

 

Ansicht von unten
Ansicht von unten

HT1621B breakout universelle Adapterplatine 2

Die Adapterplatine kam schließlich Mitte August an, wurde bestückt und kurz getestet. Leider geriet das Projekt etwas in Vergessenheit. Hier jetzt das erste Bild von der „Hochzeit“ mit einem WD-T1703L. Zum allerersten Testen wurden lediglich die Commons und drei Segmentpins angeschlossen. Infos zum Display WD-T1703L finden sich hier: WD-T1703L-7ELNa

HT1621B und WD-T1703L
HT1621B-breakout und WD-T1703L

Weitere Bilder und Testergebnisse folgen später.


Ergänzung:

Der Aufbau wurde noch etwas geändert:

  • Lochrasterplatte fiel weg
  • aus R=10 kOhm (103) wurde R=1 kOhm (102) für besseren Kontrast

Die Verkabelung der Beleuchtung mit zwei weißen China-3mm-„strawhat“-LED ist auf den Bildern noch sehr provisorisch, auch das habe ich später geändert:

Gesamtaufbau
Gesamtaufbau

Gesteuert wird mit einem chinesischen Arduino-Nano-Clone (im Hintergrund zu sehen) und einem Arduino-Sketch.

Beispiel 1
Beispiel 1

 

Beispiel 2
Beispiel 2

 

Beispiel 3
Beispiel 3

Weitere Bilder:

Beleuchtung
Beleuchtung

 

Beleuchtung
Beleuchtung

 

geänderter Widerstand
geänderter Widerstand

HT1621B breakout universelle Adapterplatine 1

Der HT1621B ist derzeit günstig (0,68 €/Stk. bei meiner Bestellung im Juni) bei Ebay zu bekommen. Hierbei handelt es sich um einen seriell ansteuerbaren LCD-Controller mit max. 4 Commons und max. 32 Segmenten.

Innenschaltung aus dem Datenblatt
Innenschaltung aus dem Datenblatt

Damit ist er ideal brauchbar für die LCD-Gläser aus dem LCD/LED-Sortiment von Pollin. Das Gehäuse ist etwas gewöhnungsbedürftig für einen Bastler, denn es ist ein SSOP48 mit 0,64 mm Pinabstand.

HT1621B pinout aus dem Datenblatt
HT1621B pinout aus dem Datenblatt
HT1621B
HT1621B

Leider gibt es bei Ebay dafür keine fertigen Adapter. Deshalb habe ich mir heute bei ITEAD eine selbstentworfene, universelle, auf der Applikationsschaltung aus dem Datenblatt

Applikationsschaltung aus dem Datenblatt
Applikationsschaltung aus dem Datenblatt

basierende Adapterplatine bestellt. Sämtliche Common-Anschlüsse und sämtliche Segmentanschlüsse wurden im DIL-Raster herausgeführt. Die serielle Schnittstelle zum Mikrocontroller wurde Arduino-like quer zur DIL-Reihe angeordnet. Damit ist die Platine auch Steckbrett-tauglich. Die Leitungsführung ist nahezu vollständig einseitig. Damit ist sie prinzipiell auch im Heimlabor herstellbar, wenn man die Chemie gut beherrscht. (Also nicht von mir. 😉 ) Um die Preisstufen von ITEAD auszulasten, wurden die Produktionsdaten als zweifacher Nutzen erstellt.

HT1621B breakout Layout
HT1621B breakout Layout