need help with TM1621 chip

[DrtacoBella]

I trying to repurpose Philips DC295 (https://www.amazon.fr/Philips-DC295-12-Radio-r%C3%A9veil-daccueil/dp/B00CAJOI52) using esp8266. Have successfully power-on device with arduino and scanned all available display segments. I am still clueless how to use digital segment located at position 7 to 10. Not quit sure how to pass just a digit to these specific segments like some of the examples provided.

I guessing need to come up with this - #69 (comment) .. but not sure, still. If I getting right, I have to store all digital support segment into array for mapping. I noted the line have different LCD object calling.

[maxint-rd]

Hello @DrtacoBella,

Do I understand you well that the display module of your Philips docking station has a TM1621 LCD driver chip and that your first success was getting most segments to light up using the TM16xx library? What version of the TM1621 is it?

Assuming I understand you well I'll give you some information specific to the implementation of LCD support.

Next to TM1622, I have tested the library with TM1621 and TM1621D using 4-COM/2-SEG layouts. In TM1621.h these are the (hardcoded) segment layouts that are supported:

// LCD segment/digit manipulation, depending on LCD segment wiring
#define TM1621_LAYOUT_DEFAULT 0x00                            // no special mapping: order PGFE_DCBA
#define TM1621_LAYOUT_4C2S_PGFE_DCBA TM1621_LAYOUT_DEFAULT    // no special mapping: order PGFE_DCBA
#define TM1621_LAYOUT_4C2S_ABCP_FGED_REV 0x01                 // Address SEG9-SEG22; 4-com/2-seg per digit, 7-segments, order S1:CBA, S0:DEGF
#define TM1621_LAYOUT_PDC6X1 TM1621_LAYOUT_4C2S_ABCP_FGED_REV // 6-digit 7-segment display with dots on positions 4,5,6 and 3 level segments controlled by dots 1, 2 and 3
#define TM1621D_LAYOUT_4C2S_0CBA_DEGF 0x04                    // 4-com/2-seg per digit, 7-segments, order S1:CBA, S0:DEGF

These layouts are used to do some display specific segment manipulation. In the comments of TM1621.cpp you can find more information about the various layouts, including one copied from the TM1621 datasheet.

Since the TM1621 class is derived from the TM16xxIC class, you can define a segment map and use setSegmentMap() to change the order of up to 16 segments to match your display, That method expects a pointer to a const byte array containing 16 bytes specifying the mapping of the segments. For example:
const byte SEGMAP_14SEG_DM8BA10[] PROGMEM = {15, 13, 9, 8, 1, 5, 4, 7, 11, 6, 14, 12, 10, 2, 3, 0};

That is the mapping for the digits of the DM8BA10 LCD-display module (as used in TM1622.h to make the TM1622_DM8BA10 class). Basically that mapping says that segment 0 should become segment 15, segment 1 should be segment 13, etc.

The implementation in TM1621.cpp first applies that segment mapping, just before processing the chosen layout.

I recommend you to modify the setSegmentsDebug example to identify the segment numbers as used in your display, You need to change the segment counter and call setSegments16(). For more info you can indeed read issue #69, eg. this comment. You can use this snippet for the inner loop:

   Serial.print("Seg: ");
    for(byte nSeg=0; nSeg<NUM_SEGMENTS; nSeg++) 
    {
      Serial.print(nSeg);
      if(NUM_SEGMENTS>8) module.setSegments16(bit(nSeg), nPos);
      else  module.setSegments(bit(nSeg), nPos);
      delay(500);
    }
   Serial.println(".");

Hopefully this information makes sense. If not, please ask me what you need to know.

[DrtacoBella]

I am using TM16xx library to turn on these LCD module and not quit sure the version of TM1621.

I already got it down to specific required segments, following code what I works for my board -
for (byte nPos = 0; nPos < 17; nPos++) { // 16 positions (columns) on TM1621
Serial.print(nPos);
Serial.print("::");
{
for (int nVal = 1; nVal <= 0xFF; nVal = nVal * 2) // max ?? segments on TM1621 module.
{
module.setSegments(nVal, nPos); // note: you can use setSegments16() when module class supports > 8 segments (TM1638, TM1668)
Serial.print(nVal);
delay(100);
Serial.print(",");
}
}
Serial.println(".");

setSegmentMap(), I don't understand it's function as does it covers all NUM_SEGMENTS <-- rows? :) ..I believe it's for single 8 segments panel. I do need to map it out as the LCD turn on (seg 0) from center of panel to left. I took another look at this function and still doesn't work as i thought. Rearrange the order and that caused some segment not working, like goes missing.

As workaround, I plan to map hex to digit and use following function to set desire values
module.setDisplayDigit(hex, 7, true);. The 8 segment panel is at seg 7, 8, 9 and 10. ... no traction yet.

Side: I thought upload picture into this comment section but it fails.. thinking it would help others who using similar board configurations. I took me awhile just powering on alone.

update:

The layout appears like this
/// LCD Layout
// SEG 6/22 - right side panel
// SEG 7 - 10/ 23 - 26 - Main 8 digit ; not sure why two set SEG mirrored.
// SEG 11 /27 - left side panel
// SEG 0(WED),SEG 2(THU),SEG 4(SAT),SEG 11(SUN),SEG 12(MON),SEG 14(TUE) - POSITION - (16) | SEG 1 - 4 (FRI) ... all tie to POSITION 16 except for (FRI) ..
// SEG 27 - POSITION - 16(SUN), 32(FM), 64(PM)
// SEG 28- 31 ... first two alphanumeric segment SEG 0 - 5 last three alphanumeric

Is there a away I can dump character to a specific SEG/POSITION to view it's result? I am able to figure out at some extend to enable 8 segment but the alphanumeric, I have no clue where to begin.

[maxint-rd]

You found yourself a nice challenge! Hopefully the TM16xx library can help a bit. Unfortunately I don't have a display similar as yours to join your experiments, so my ability to help is limited.

I am using TM16xx library to turn on these LCD module and not quit sure the version of TM1621.

The main difference between the various TM1621 models is the number of segments supported. This library combines the various nibbles assuming specific layouts, mainly those that I have in my collection and I could test myself. TM1622 supports 8 commons. The TM1622 class is derived from TM1621 and I have a DM8BA10 alphanumeric module that uses a TM1622.

I'm not quite sure to what extend the TM1621 class will fully support your specific needs. The segment combination of your LCD brings some complexity that most likely eventually requires a separate (derived) class.

Adding a picture could definitely be helpful for other readers. (Should be relatively easy using the "Add Files"-paperclip below the edit field). In the picture below this post, I took a detail from the Amazon page and added some segment letters.

From your information and the picture I understand that the display is a combination of

• four 7-segments digits at the first row, with colon between second and third digit;
• five 14-segment alphanumeric digits at the second row (possibly with a dot as 15th);
• various symbols spread all over the display, including those for the weekday at the bottom.

So, the challenge is perhaps the alpha-numeric digits. These would need 14 or 15 segments per digit (and dot?). Perhaps you can check these by replacing the inner loop of your code by the snippet I provided earlier? [Untested:] Maybe you can even use the TM1621 and TM1622 classes at the same time!

I'm not sure if I fully understand your finding concerning the LCD lay out. Have you determined if each digits has its own position when calling setSegments? My interpretation of your layout findings is that the top digits have their segments spread out over the assumed 8 segments per position in the TM1621 class. This could be usable for the top row, but perhaps the second row needs more. You could experiment using the TM1622 class to see if that can address the second row.
You can try this function to switch on using AlphaNumeric, with or without segment map:

virtual void setAlphaNumeric(bool fAlpha=true, const byte *pMap=NULL);

The standard layout is segments A-G+DP on segments 0-7 for 7-segment displays. For 14-segment Alphanumeric digits I chose the order A-G1, DP, G2-H-N:

   |---A---|          Bit Segment     Bit Segment
   |\  |  /|          [0]       A    [ 8]      G2
   F H J K B          [1]       B    [ 9]       H
   |  \|/  |          [2]       C    [10]       J
   |-G1-G2-|          [3]       D    [11]       K
   |  /|\  |          [4]       E    [12]       L
   E N M L C          [5]       F    [13]       M
   |/  |  \|          [6]      G1    [14]       N
   |---D---| DP       [7]      DP

Using a mapping array you can move the 16 segments per digit around and for instance state that the A segment is not on 0, but on 7 instead.

Is there a away I can dump character to a specific SEG/POSITION to view it's result?

You can use this method to display a single character on a specific position:
module.sendAsciiChar(position, character, dot);

if setAlphaNumeric(true); was called, then sendAsciiChar() will use a 14-segment font and use setSegments16() to display it.

Hopefully this information is helpful for your experiments. I'm looking forward to read more about your progress and wish you best of luck!

[maxint-rd]

Hello @DrtacoBella, I did some more thinking about your specific LCD and want to add some things.

First some additional remarks: I used the term segment rather loosely to mean the segments that form a single digit (7-segment, 14-segment, etc).

For LED displays, each digit usually has one individual common connection, making the position correspond with the COM. When dealing with LCD's and the TM1621/TM1622 each digit is often driven by four or more COM (common) lines with two or more SEG lines. The memory addresses are organized as 4-COM per nibble. When sending data the TM1621/TM1622 classes send only 4 bits per address.

For TM1621 the currently supported layouts are all 4COM-2SEG. This is good for up to 8 segments per digit. When setting one position it sends two 4-bit nibbles, addressing 2-SEG x 4-COM bits in the chip's memory.

For TM1622 the default implementation is for 1-SEG x 8-COM. By sending two nibbles it sets 8 bits per position. Currently the TM1622_DM8BA10 class is the only class aimed at 2-SEG x 8-COM, sending 4 nibbles per position. If you want to experiment, you could try using setSegments16() with that class. The goal would be to see if using that class can treat the alphanumeric digits as one digit per position.

Not having your display at hand, severely limits me in what I can do for you.
However, I could implement another generic layout to the TM1621 class, adding support for 16 segments per position. Using that layout would result in setSegments16() driving 4-SEG x 4-COM lines for each position. This may not fully be the solution, but could be a step in getting you closer to your goal.

[DrtacoBella]

didn't get much done today, expect hunting down characters for 8 segments unit with pen and paper; sendAsciiChar() helps for this task.

I don't see an issue with layout yet. Maybe later once sort out this will raise as issue but will work fine. If I can toggle individual segment using sendAsciiChar() or setSegments(); it'll just work. Based on available datasheet, this is a 4COM-31SEG TM1621 chip.

Temporary, ignoring 14-segment module due to my current limitation <-- skills dealing with LCD. I notice two SEG required to toggle single 14 segment unit, unlike 7-segment unit. For now I will ignore it because feeling seriously a newbie with LCD panel - unexpected! For the record, I didn't know COM and SEG until you mentioned it, which made me dig further into datasheet... I got some idea how it works.

You found yourself a nice challenge!
it would have been fun if at least I worked on LED/LCD panels before.

I have tried TM1622 headers, it works seamless and didn't notice any difference.. I also use both , TM1621and Tm1622 class side by side without issues. <--- you hearing this from a newbie :), not a good feedback ..

I am confident able to map out the displays within few days, keeping finger crossed. The 14-segments - consider nice to have for now.

[maxint-rd]

TM1621and Tm1622 class side by side without issues. <--- you hearing this from a newbie :), not a good feedback ..

I say congratulations. You're perhaps not quite the noob that some newbies sometimes are. I congratulate you on your perseverance and your patience. Where there's a will, there's a way!

If you have time, could you perhaps also try the TM1622_DM8BA10 class that is included with the TM1622.h header? That one does address 4 nibbles per position. Just make sure to call setSegments16() with a 16 bit value for the segments.

For the record, I didn't know COM and SEG until you mentioned it, which made me dig further into datasheet...

I didn't know much about LCD's or the TM1621, until recently I decided to also do some digging and I learned a lot from figuring out how to get my LCD modules working. The fun came once I got the display to do something tiny. At that moment I just knew it would be only a matter of time... and some more time... and some tinkering... and more reading... and a bit more patience... ;-)

[DrtacoBella]

@maxint-rd do you see any possibility for module.sendAsciiChar() causes LCD to retain power for next inputl; not issuing clear(). I notice overlap and difficult to narrow down to specific required digit. Example, "8" .. which appear from 0x35 input, the problem is "_" of segment was filled by 0x34 input earlier and not clean up for next module.sendAsciiChar() input. So, when I run sendAsciiChar() just for specific input, let's say 0x35 input it will give me incomplete 8 ..

[maxint-rd]

Hmmm.... Ascii 0x35 normally would result in displaying the character '5'.
The sendAsciiChar() function doesn't clear by design, since it is used in the process of displaying full strings of text. It should however set some segments off and the others on. I wonder what the overlap is that you are experiencing. Perhaps you need to clear the position or the whole display explicitly to properly see the effect of calling sendAsciiChar().

To clear a specific position, the base class method is clearDisplayDigit(). That function eventually is equivalent to setSegments(0, pos). Alternatively you probably could also use sendAsciiChar() to write the space character (ascii 32 or 0x20), setting all segment values to be off.

To clear the entire display, the TM1621 class has its own implementation of clearDisplay() (which may act slightly different than the parent implementations).

[DrtacoBella]

Ascii 0x35 .. I when retest and learn that's not the case for this LCD ..

I have completed 8 Segments mapping. I ended using binary mapping, which looks like this:

const byte digit[] = {
0b11010111, // 0
0b00000110, // 1
0b11100011, // 2
0b10100111, // 3
0b00110110, // 4
0b10110101, // 5
0b11110101, // 6
0b00000111, // 7
0b11110111, // 8
0b00110111, // 9
};


I ended using the clearDisplay(), I will need to use clearDisplayDigit() on final coding. It helps turn off segment which remain turned on.

Now digging into 16 segment, I wondering if TM16xx library handles for these use case:

r=0b11100001; // 0
l=0b00001010; // 0

r=0b01100000; // 1
l=0b00000000; // 1

r=0b11100100; // A
l=0b00001110; // A

r=0b01101000; // M ??
l=0b10001011; // M ??

module.setSegments16(l, 28);
module.setSegments16(r, 29);


I turned to binary as it offer better visibility for LCD mapping, and also bitwise logic help tweak some of these binary on fly. However, I may be reinventing the wheel or working from some cave somewhere :)... For 16 Segments, I ended need to create two bit switch for 2 Seg position - like above located as SEG28 abd SEG29. Just feeling not using the library correctly.

Update:

I was right about using the library, just understand what TM16XX_NUMBER_FONT[] use case...

[maxint-rd]

Great! Nice to read you have made further progress...

For the alphanumeric characters on the second row, I suggest you to experiment using the TM1622_DM8BA10 class that is included with the TM1622.h header? That one does address 4 nibbles per position. Just make sure to call setSegments16() with a 16 bit value for the segments. In a future release of the TM1621 class I could add accommodations for using 16 segments. Currently that's not implemented because I didn't need it for my display modules.

FYI, regarding your 8-bit patterns you list in the const byte digit[] array; that is what I call the font. It contains the segment patterns to use to display each digit. The sendAsciiChar() method has a parameter to specify the used font:

void sendAsciiChar(byte pos, char c, bool dot, const byte font[] = TM16XX_FONT_DEFAULT);

The fonts used by the TM16xx library can be found in TM16xxFonts.h

The default segment layout used by those fonts is like this:

Segment labels:
 -- A --
|       |
F       B
 -- G --
E       C
|       |
 -- D --  .DP

The default order of the segment bits is as follows:

 -- 0 --
|       |
5       1
 -- 6 --
4       2
|       |
 -- 3 --  .7

As you can see there, the patterns for digits 0-9 are slightly different:

const PROGMEM byte TM16XX_NUMBER_FONT[] = {
  0b00111111, // 0
  0b00000110, // 1
  0b01011011, // 2
  0b01001111, // 3
  0b01100110, // 4
  0b01101101, // 5
  0b01111101, // 6
  0b00000111, // 7
  0b01111111, // 8
  0b01101111, // 9
};

One difference with your findings is that the highest bit (bit 7) that represents the decimal point (DP) is always 0 in my fonts. That's because this dot gets set separately.

In the same file you can also find font definitions for displaying an approximation of alphabetic characters on a 7-segment display, as well as all alphanumeric characters for displaying on 14-segment segment displays. In this earlier reaction I mentioned the standard order for those.

Whenever the segment order is different from the predetermined standard order, I use the setSegmentMap() method, to supply an array that tells the library which segment should replace which to make it conform to that standard. The alternative is to make a different font array that matches the particular segment order.

Hope this is helpful information. Wish you good luck and further progress.

[DrtacoBella]

TM1622_DM8BA10 class that is included with the TM1622.h

i tried this but wondering if should continue as this adds a drag in exploration. I have set two class one for 8 segment and TM1622_DM8BA10 class for 16 segment; I noticed the position changed for new class and limited to 10 unlike TM1621 which is goes up to 31. I fix the positioning and the only hiccup now, the 16 segment hacks affecting 8 segment panels. Some of the bits set for 16 segment is effecting 8 segment, which I don't know why. I do notice new class blocks two position segment as single block for 16 segment LCD, which I needed; maybe that overlap into 8 segment.

setSegmentMap()

Oh, boy!!! I am working from a cave... if I knew the actual usage for this map, life would be little easier for 8 segment work. I am don't know the difference between SEG position and LCD bits, until sort out the 8 segment bits. Now, trying setSegmentMap() make sense. :) ... didn't I told yah am a newbie. .. I should have remapped my 8 segment to your standard 8 segment as first step.

[maxint-rd]

I tried this but wondering if should continue as this adds a drag in exploration.

The main reason for me to let you try the TM1622_DM8BA10 class is that currently that class is the only one to support writing 16-bit segments to a position. If you can use that class to confirm that the alphanumeric characters on the second row use one such position per character, then I can go ahead and make a modification to the TM1621 class to support alphanumeric characters. (Your conclusion that it then has less positions is correct).

Eventually I think you would like to use plain text functions such as print() and setDisplayToString() to easily display text/numbers.

To get there will require some iterations of development and testing. Because I don't have your lcd at hand, you will be responsible for the testing. On my part I intend to do some coding to support your project. At this point I envision two activities:

• 1. Add some code to the TM1621 class to allow you to use the setSegments16() method, possibly with additional segment mapping, (Currently that class only supports the display modules I have in my collection).
• 2. Make a custom class for those areas that require specific manipulation to conform to your lcd.

To get an idea you can look at the implementation of the TM1622_DM8BA10 class in TM1622.h and TM1622.cpp.
While it relies on the TM1621/TM1622 basis, it has some custom code to handle the panel specifics. (The DM8BA10 LCD module has 10 16-segment digits plus 9 dots in between. The dots are on 3 separate addresses and require special manipulation. The A and D segments are split and by duplicating A to A1/A2 and D to D1/D2 the 14-segment font can be used).

FYI: TM1621 has max. 32-SEG x 4-COM. The 8-segment digits in your panel seem to use 2-SEG x 4-COM per digit. In TM16xx terms that means 16 positions x 8 segments.
I'm hoping that the alphanumeric digits use 4-SEG x 4-COM. I intend to add some code to the TM1621 class to allow you to use the setSegments16() method, possibly with additional segment mapping where needed.