TM1637 Tiny Display

https://jasonacox.github.io/TM1637TinyDisplay/
Admin
Arduino library for TM1637 based LED display modules that provides easy-to-use functions for...
Tokens:11,847
Snippets:68
Trust Score:9.7
Update:6 months ago
Show doc for...
Tokens:
Raw
### Initialize and Control TM1637 Display

Source: https://jasonacox.github.io/TM1637TinyDisplay

Demonstrates basic setup, string display, numeric counting, level indication, and split-screen formatting.

```cpp
#include <Arduino.h>
#include <TM1637TinyDisplay.h>

// Define Digital Pins
#define CLK 2
#define DIO 3

// Instantiate TM1637TinyDisplay Class
TM1637TinyDisplay display(CLK, DIO);

void setup() {
  // Initialize Display
  display.begin();
}

void loop() {
  // Say Hello
  display.showString("HELLO");
  delay(500);

  // Clear Screen
  display.clear();

  // We can count!
  for (int x = -100; x <= 100; x++) {
    display.showNumber(x);
  }

  // Level indicator
  for (int x = 0; x <= 100; x = x + 10) {
    display.showLevel(x, false);
    delay(20);
  }
  for (int x = 100; x >= 0; x = x - 10) {
    display.showLevel(x, false);
    delay(20);
  }

  // Split screen for temperature
  display.showString("\xB0", 1, 3);        // Degree Mark, length=1, position=3 (right)
  for (int x = -90; x < 200; x++) {
    display.showNumber(x, false, 3, 0);    // Number, length=3, position=0 (left)
    delay(10);
  }

  // The end
  display.showString("End");
  delay(1000);
}
```

--------------------------------

### Animation Control Methods

Source: https://jasonacox.github.io/TM1637TinyDisplay/TM1637TinyDisplay.h

Methods for starting and stopping non-blocking animations on the display.

```cpp
void startAnimation(const uint8_t (*data)[MAXDIGITS], unsigned int frames = 0, unsigned int ms = 10, bool usePROGMEM = false);
void startAnimation_P(const uint8_t(*data)[MAXDIGITS], unsigned int frames = 0, unsigned int ms = 10);

//! The function used to stop a non-blocking animation
//!
void stopAnimation();
```

--------------------------------

### Animation Control

Source: https://jasonacox.github.io/TM1637TinyDisplay/TM1637TinyDisplay.h

Functions to start and stop animations on the TM1637 display.

```APIDOC
## startAnimation

### Description
Starts a non-blocking animation on the TM1637 display.

### Method
void

### Endpoint
startAnimation(const uint8_t (*data)[MAXDIGITS], unsigned int frames = 0, unsigned int ms = 10, bool usePROGMEM = false)

### Parameters
#### Path Parameters
- None

#### Query Parameters
- None

#### Request Body
- **data** (const uint8_t (*)[MAXDIGITS]) - Pointer to an array of frames for the animation.
- **frames** (unsigned int) - Optional. The number of frames in the animation. Defaults to 0.
- **ms** (unsigned int) - Optional. Time in milliseconds to delay between each frame. Defaults to 10.
- **usePROGMEM** (bool) - Optional. Indicates if the data is stored in PROGMEM. Defaults to false.

### Request Example
```c++
// Example usage (assuming 'animation_data' is defined elsewhere)
// tm1637.startAnimation(animation_data, num_frames, 50);
```

### Response
#### Success Response (200)
- None (void function)

#### Response Example
None
```

```APIDOC
## startAnimation_P

### Description
Starts a non-blocking animation using data stored in PROGMEM.

### Method
void

### Endpoint
startAnimation_P(const uint8_t(*data)[MAXDIGITS], unsigned int frames = 0, unsigned int ms = 10)

### Parameters
#### Path Parameters
- None

#### Query Parameters
- None

#### Request Body
- **data** (const uint8_t(*)[MAXDIGITS]) - Pointer to an array of frames for the animation, stored in PROGMEM.
- **frames** (unsigned int) - Optional. The number of frames in the animation. Defaults to 0.
- **ms** (unsigned int) - Optional. Time in milliseconds to delay between each frame. Defaults to 10.

### Request Example
```c++
// Example usage (assuming 'progmem_animation_data' is defined in PROGMEM)
// tm1637.startAnimation_P(progmem_animation_data, num_frames, 50);
```

### Response
#### Success Response (200)
- None (void function)

#### Response Example
None
```

```APIDOC
## stopAnimation

### Description
Stops a non-blocking animation that is currently running.

### Method
void

### Endpoint
stopAnimation()

### Parameters
#### Path Parameters
- None

#### Query Parameters
- None

#### Request Body
- None

### Request Example
```c++
// tm1637.stopAnimation();
```

### Response
#### Success Response (200)
- None (void function)

#### Response Example
None
```

--------------------------------

### 6-Digit Animation Frame Data

Source: https://jasonacox.github.io/TM1637TinyDisplay/examples/7-segment-animator6.html

This is an example of animation data for a single frame in a 6-digit display. Each element in the array corresponds to a digit, and the byte value represents the state of the segments (HGFEDCBA). Use this format in your sketch.

```c++
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },  // Frame 0
```

--------------------------------

### Initialization and Basic Control

Source: https://jasonacox.github.io/TM1637TinyDisplay/TM1637TinyDisplay.h

Functions for initializing the display, setting its orientation, and controlling brightness.

```APIDOC
## Initialization

### begin()

Initialize the display, setting the clock and data pins.

This method should be called once (typically in setup()) before calling any other.
@note It may be unnecessary depending on your hardware configuration.
@param clearDisplay - Clear display and set the brightness to maximum value.

### flipDisplay()

Sets the orientation of the display.
Setting this parameter to true will cause the rendering on digits to be displayed upside down.
@param flip Flip display upside down true/false

### isflipDisplay()

Returns the orientation of the display.
True = Display has been flipped (upside down)

### setBrightness()

Sets the brightness of the display.
The setting takes effect when a command is given to change the data being displayed.
@param brightness A number from 0 (lowest brightness) to 7 (highest brightness)
@param on Turn display on or off
```

--------------------------------

### TM1637TinyDisplay6 Initialization and Basic Usage

Source: https://jasonacox.github.io/TM1637TinyDisplay

Demonstrates how to initialize the TM1637 6-digit display and use basic functions like showing strings and numbers.

```APIDOC
## TM1637TinyDisplay6 Initialization and Basic Usage

### Description
This example shows how to include the TM1637TinyDisplay6 library, define the clock and data pins, initialize the display object, and then display a string and numbers.

### Method
```cpp
// Includes
#include <Arduino.h>
#include <TM1637TinyDisplay6.h>       // Include 6-Digit Display Class Header

// Define Digital Pins
#define CLK 2
#define DIO 3

TM1637TinyDisplay6 display(CLK, DIO); // 6-Digit Display Class

void setup()
{
  display.begin();
  display.showString("digits");
  delay(1000);
  display.showNumber(123456);
  delay(1000);
  display.showNumber(123.456);
  delay(1000);
}
```

### Functions
- `begin()`: Initialize display memory and hardware.
- `showString(const char* str)`: Display an ASCII string.
- `showNumber(int num)`: Display an integer.
- `showNumber(double num)`: Display a floating-point number.
```

--------------------------------

### Display Animation with showAnimation()

Source: https://jasonacox.github.io/TM1637TinyDisplay/examples

Demonstrates how to project a sequence of frames onto a 4-digit display using a multi-dimensional array and the showAnimation function.

```cpp
#include <Arduino.h>
#include <TM1637TinyDisplay.h>

// Define Digital Pins
#define CLK 4
#define DIO 5

// Initialize TM1637TinyDisplay
TM1637TinyDisplay display(CLK, DIO);

// Data from Animator Tool
const uint8_t ANIMATION[12][4] = {
  { 0x08, 0x00, 0x00, 0x00 },  // Frame 0
  { 0x00, 0x08, 0x00, 0x00 },  // Frame 1
  { 0x00, 0x00, 0x08, 0x00 },  // Frame 2
  { 0x00, 0x00, 0x00, 0x08 },  // Frame 3
  { 0x00, 0x00, 0x00, 0x04 },  // Frame 4
  { 0x00, 0x00, 0x00, 0x02 },  // Frame 5
  { 0x00, 0x00, 0x00, 0x01 },  // Frame 6
  { 0x00, 0x00, 0x01, 0x00 },  // Frame 7
  { 0x00, 0x01, 0x00, 0x00 },  // Frame 8
  { 0x01, 0x00, 0x00, 0x00 },  // Frame 9
  { 0x20, 0x00, 0x00, 0x00 },  // Frame 10
  { 0x10, 0x00, 0x00, 0x00 }   // Frame 11
};

void setup() {
  display.setBrightness(0x0f);
}

void loop() {
  // Display Animation sequence
  display.showAnimation(ANIMATION, FRAMES(ANIMATION), TIME_MS(50));
}
```

--------------------------------

### Initialize and Use 6-Digit TM1637 Display

Source: https://jasonacox.github.io/TM1637TinyDisplay

Demonstrates the initialization of the TM1637TinyDisplay6 class and basic usage of display functions like showString and showNumber.

```cpp
// Includes
#include <Arduino.h>
#include <TM1637TinyDisplay6.h>       // Include 6-Digit Display Class Header

// Define Digital Pins
#define CLK 2
#define DIO 3

TM1637TinyDisplay6 display(CLK, DIO); // 6-Digit Display Class

void setup()
{
  display.begin();
  display.showString("digits");
  delay(1000);
  display.showNumber(123456);
  delay(1000);
  display.showNumber(123.456);
  delay(1000);
}
```

--------------------------------

### Protected Display Helper Methods

Source: https://jasonacox.github.io/TM1637TinyDisplay/TM1637TinyDisplay.h

Internal methods for hardware communication and number formatting.

```cpp
protected:
   void bitDelay();

   void start();

   void stop();

   bool writeByte(uint8_t b);

   void showDots(uint8_t dots, uint8_t* digits);
   
   void showNumberBaseEx(int8_t base, uint16_t num, uint8_t dots = 0, bool leading_zero = false, uint8_t length = MAXDIGITS, uint8_t pos = 0);
```

--------------------------------

### String Scrolling Methods

Source: https://jasonacox.github.io/TM1637TinyDisplay/TM1637TinyDisplay.h

Methods for initiating non-blocking string scrolling across the display.

```cpp
void startStringScroll(const char s[], unsigned int ms = DEFAULT_SCROLL_DELAY, bool usePROGMEM = false);
void startStringScroll_P(const char s[], unsigned int ms = DEFAULT_SCROLL_DELAY);
```

--------------------------------

### Private Member Variables

Source: https://jasonacox.github.io/TM1637TinyDisplay/TM1637TinyDisplay.h

Internal state variables for pin configuration, brightness, and animation tracking.

```cpp
private:
  uint8_t m_pinClk;
  uint8_t m_pinDIO;
  uint8_t m_brightness;
  unsigned int m_bitDelay;
  unsigned int m_scrollDelay;
  bool m_flipDisplay;
  uint8_t digits[MAXDIGITS];
  uint8_t digitsbuf[MAXDIGITS];

  unsigned long m_animation_start;
  unsigned int m_animation_frames;
  unsigned int m_animation_last_frame;
  unsigned int m_animation_frame_ms;
  uint8_t (*m_animation_sequence)[MAXDIGITS];
  uint8_t *m_animation_string;
  uint8_t m_animation_type;
};

#endif // __TM1637TINYDISPLAY__
```

--------------------------------

### Display String

Source: https://jasonacox.github.io/TM1637TinyDisplay/TM1637TinyDisplay.h

Functions to display strings on the TM1637 display. `showString` displays a string from RAM, while `showString_P` displays a string from PROGMEM (flash memory). Both support optional length, position, and dot/colon configurations.

```APIDOC
## showString

### Description
Displays a string from RAM on the TM1637 display.

### Method
void

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **s** (const char[]) - The string to be shown.
- **length** (uint8_t) - Optional. The number of digits to set. Defaults to MAXDIGITS.
- **pos** (uint8_t) - Optional. The position of the most significant digit (0 - leftmost, 3 - rightmost). Defaults to 0.
- **dots** (uint8_t) - Optional. Dot/Colon enable bitmask. Defaults to 0.

### Request Example
```c
showString("12:34", 4, 0, 0b01000000); // Displays "12:34" with colon enabled
```

### Response
None

## showString_P

### Description
Displays a string from PROGMEM (flash memory) on the TM1637 display. If the string is longer than 4 characters, it will scroll.

### Method
void

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **s** (const char[]) - The string to be shown (must be in PROGMEM).
- **scrollDelay** (uint8_t) - Optional. The delay, in microseconds, before scrolling to the next frame. (Note: This parameter seems to be described but not present in the function signature provided in the text. Assuming it's a typo or intended for a different context).
- **length** (uint8_t) - Optional. The number of digits to set. Defaults to MAXDIGITS.
- **pos** (uint8_t) - Optional. The position of the most significant digit (0 - leftmost, 3 - rightmost). Defaults to 0.
- **dots** (uint8_t) - Optional. Dot/Colon enable bitmask. Defaults to 0.

### Request Example
```c
const char myString[] PROGMEM = "Hello";
showString_P(myString);
```

### Response
None
```

--------------------------------

### TM1637 Tiny Display Header Definitions

Source: https://jasonacox.github.io/TM1637TinyDisplay/TM1637TinyDisplay.h

Contains hardware abstraction for PROGMEM, segment bitmasks, command constants, and the TM1637TinyDisplay class definition.

```cpp
//  TM1637 Tiny Display
//  Arduino tiny library for TM1637 LED Display
//
//  Author: Jason A. Cox - @jasonacox - https://github.com/jasonacox
//  Date: 27 June 2020
//
//  Based on TM1637Display library at https://github.com/avishorp/TM1637
//
//  This library is free software; you can redistribute it and/or
//  modify it under the terms of the GNU Lesser General Public
//  License as published by the Free Software Foundation; either
//  version 2.1 of the License, or (at your option) any later version.
//
//  This library is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
//  Lesser General Public License for more details.
//
//  You should have received a copy of the GNU Lesser General Public
//  License along with this library; if not, write to the Free Software
//  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

#ifndef __TM1637TINYDISPLAY__
#define __TM1637TINYDISPLAY__

// Include PROGMEM Support
#include <inttypes.h>
#ifdef __AVR__
#include <avr/pgmspace.h>
#elif defined(ESP8266) || defined(ESP32)
#include <pgmspace.h>
#else
#define pgm_read_byte(addr)                                                    \
  (*(const unsigned char *)(addr)) // workaround for non-AVR
#endif

#define SEG_A   0b00000001
#define SEG_B   0b00000010
#define SEG_C   0b00000100
#define SEG_D   0b00001000
#define SEG_E   0b00010000
#define SEG_F   0b00100000
#define SEG_G   0b01000000
#define SEG_DP  0b10000000

#define BRIGHT_LOW  0x00
#define BRIGHT_0    0x00
#define BRIGHT_1    0x01
#define BRIGHT_2    0x02
#define BRIGHT_3    0x03
#define BRIGHT_4    0x04
#define BRIGHT_5    0x05
#define BRIGHT_6    0x06
#define BRIGHT_7    0x07
#define BRIGHT_HIGH 0x0f

#define ON    1
#define OFF   0

// TM1637 Commands
//
// Communication Sequence (Automatic Address)
//     Cmd1: Start + CmdSetData + ACK + Stop + 
//     Cmd2+Data: Start + CmdSetAddress + ACK + (Data + ACK) * N + 
//     Cmd3: Start + CmdDisplay + ACK + Stop
//
// Communication Sequence (Fixed Address)
//     Cmd1: Start + CmdSetData + ACK + Stop
//     Cmd2+Data: (Start + Command + ACK + Data + ACK) * N + Stop +
//     Cmd3: Start + Command3 + ACK + Stop
//
// CmdSetData - Data command settings (byte) - TM1637_I2C_COMM1
// B7 B6 B5 B4 B3 B2 B1 B0 - Function Description
// 0  1  0  0  _  _  0  0  - (Data read/write) Write data to display register
// 0  1  0  0  _  _  1  0  - (Data read/write) Read key scan data
// 0  1  0  0  _  0  _  _  - (Address mode) Automatic address adding
// 0  1  0  0  _  1  _  _  - (Address mode) Fixed address
// 0  1  0  0  1  _  _  _  - (Test mode) Normal mode
// 0  1  0  0  1  _  _  _  - (Test mode) Test mode
//
// CmdSetAddress - Set Address - Digit (byte) - TM1637_I2C_COMM2
// B7 B6 B5 B4 B3 B2 B1 B0 - Function Description
// 1  1  0  0  0  0  0  0  - Digit 1 - C0H Grid1
// 1  1  0  0  0  0  0  1  - Digit 2 - C1H Grid2
// 1  1  0  0  0  0  1  0  - Digit 3 - C2H Grid3
// 1  1  0  0  0  0  1  1  - Digit 4 - C3H Grid4
// 1  1  0  0  0  1  0  0  - Digit 5 - C4H Grid5
// 1  1  0  0  0  1  0  1  - Digit 6 - C5H Grid6
// 
// CmdDisplay - Set Display - Digit (byte) - TM1637_I2C_COMM3
// B7 B6 B5 B4 B3 B2 B1 B0 - Function Description
// 1  0  0  0  _  0  0  0  - Brightness - Pulse width is set as 1/16
// 1  0  0  0  _  0  0  1  - Brightness - Pulse width is set as 2/16
// 1  0  0  0  _  0  1  0  - Brightness - Pulse width is set as 4/16
// 1  0  0  0  _  0  1  1  - Brightness - Pulse width is set as 10/16
// 1  0  0  0  _  1  0  0  - Brightness - Pulse width is set as 11/16
// 1  0  0  0  _  1  0  1  - Brightness - Pulse width is set as 12/16
// 1  0  0  0  _  1  1  0  - Brightness - Pulse width is set as 13/16
// 1  0  0  0  _  1  1  1  - Brightness - Pulse width is set as 14/16
// 1  0  0  0  0  _  _  _  - Display OFF
// 1  0  0  0  1  _  _  _  - Display ON

#define TM1637_I2C_COMM1    0x40  // CmdSetData       0b01000000
#define TM1637_I2C_COMM2    0xC0  // CmdSetAddress    0b11000000
#define TM1637_I2C_COMM3    0x80  // CmdDisplay       0b10000000

#define MAXDIGITS           4     // Total number of digits   

#define DEFAULT_BIT_DELAY     100
#define DEFAULT_SCROLL_DELAY  100
#define DEFAULT_FLIP          false

#define FRAMES(a)     sizeof(a)/4
#define TIME_MS(t)    t
#define TIME_S(t)     t*1000

class TM1637TinyDisplay {

public:
  //! Initialize a TM1637TinyDisplay object.
  //!
  //! @param pinClk - The number of the digital pin connected to the clock pin of the module
  //! @param pinDIO - The number of the digital pin connected to the DIO pin of the module
  //! @param bitDelay - The delay, in microseconds, between bit transition on the serial
  //!                   bus connected to the display
  //! @param flip - Flip display orientation (default=false)
  TM1637TinyDisplay(uint8_t pinClk, uint8_t pinDIO, unsigned int bitDelay = DEFAULT_BIT_DELAY, 
```

--------------------------------

### Display Custom Animations

Source: https://jasonacox.github.io/TM1637TinyDisplay

Uses a multi-dimensional array to define frame patterns and the showAnimation function to render them.

```cpp
// Data from Animator Tool
const uint8_t ANIMATION[12][4] = {
  { 0x08, 0x00, 0x00, 0x00 },  // Frame 0
  { 0x00, 0x08, 0x00, 0x00 },  // Frame 1
  { 0x00, 0x00, 0x08, 0x00 },  // Frame 2
  { 0x00, 0x00, 0x00, 0x08 },  // Frame 3
  { 0x00, 0x00, 0x00, 0x04 },  // Frame 4
  { 0x00, 0x00, 0x00, 0x02 },  // Frame 5
  { 0x00, 0x00, 0x00, 0x01 },  // Frame 6
  { 0x00, 0x00, 0x01, 0x00 },  // Frame 7
  { 0x00, 0x01, 0x00, 0x00 },  // Frame 8
  { 0x01, 0x00, 0x00, 0x00 },  // Frame 9
  { 0x20, 0x00, 0x00, 0x00 },  // Frame 10
  { 0x10, 0x00, 0x00, 0x00 }   // Frame 11
};

  // Display Animation sequence
  display.showAnimation(ANIMATION, FRAMES(ANIMATION), TIME_MS(50));
```

--------------------------------

### Begin Non-Blocking Animation on TM1637

Source: https://jasonacox.github.io/TM1637TinyDisplay/TM1637TinyDisplay.h

Initiates a non-blocking animation. Specify whether the animation data is in PROGMEM.

```cpp
void Animate(bool usePROGMEM, unsigned int frames = 0);
```

--------------------------------

### Play Animation from PROGMEM on TM1637

Source: https://jasonacox.github.io/TM1637TinyDisplay/TM1637TinyDisplay.h

Plays an animation sequence stored in PROGMEM. This is useful for animations that do not need to be changed at runtime, saving RAM.

```cpp
const uint8_t Example[2][4] = 
{
 {
  0b00001000,
  0b00000000,
  0b00000000,
  0b00000000
 },
 {
  0b00000000,
  0b00001000,
  0b00000000,
  0b00000000
 }
};
void showAnimation_P(const uint8_t data[][4], unsigned int frames = 0, unsigned int ms = 10);
```

--------------------------------

### Play Animation on TM1637

Source: https://jasonacox.github.io/TM1637TinyDisplay/TM1637TinyDisplay.h

Plays a sequence of raw LED segment data to create an animation. The data is provided as a multi-dimensional array.

```cpp
const uint8_t Example[2][4] = 
{
 {
  0b00001000,
  0b00000000,
  0b00000000,
  0b00000000
 },
 {
  0b00000000,
  0b00001000,
  0b00000000,
  0b00000000
 }
};
void showAnimation(const uint8_t data[][4], unsigned int frames = 0, unsigned int ms = 10);
```

--------------------------------

### Display String from PROGMEM on TM1637

Source: https://jasonacox.github.io/TM1637TinyDisplay/TM1637TinyDisplay.h

Displays a string stored in PROGMEM (read-only flash memory) on the TM1637 display. Ideal for static strings to save RAM.

```cpp
void showString_P(const char s[], uint8_t length = MAXDIGITS, uint8_t pos = 0, uint8_t dots = 0);
```

--------------------------------

### Text and Buffer Manipulation

Source: https://jasonacox.github.io/TM1637TinyDisplay/TM1637TinyDisplay.h

Functions for controlling text scrolling, writing raw buffer data, and reading the buffer.

```APIDOC
## Text and Buffer Manipulation

### setScrolldelay()

Sets the delay used to scroll string text (in ms).
The setting takes effect when a showString() command send an argument with over four characters.
@param scrollDelay A number in milliseconds (default is 200)

### writeBuffer()

Write the digitsbuf[] to the Display
This function renders the buffer of segment settings in digitbuf[] to the device.

### readBuffer()

Create and return a copy the digitsbuf[] in buffercopy
This copies the buffer of segment settings into the memory location provided.
@param buffercopy Memory location of an array of at least MAXDIGITS size
```

--------------------------------

### Utility Functions

Source: https://jasonacox.github.io/TM1637TinyDisplay/TM1637TinyDisplay.h

Functions for encoding digits for 7-segment displays and displaying strings with scrolling capabilities.

```APIDOC
## encodeDigit

### Description
Translates a single digit (0-15) into its corresponding 7-segment display code. Handles hexadecimal digits (A-F).

### Method
uint8_t

### Parameters
#### Path Parameters
- **digit** (uint8_t) - Required - A number between 0 to 15.

### Returns
A code representing the 7 segment image of the digit (LSB - segment A; bit 6 - segment G; bit 7 - always zero).

## showString

### Description
Displays a string on the screen. If the string exceeds 4 characters, it will scroll across the display.

### Method
void

### Parameters
#### Path Parameters
- **s** (const char*) - Required - The string to be shown.
- **scrollDelay** (uint16_t) - Optional - The delay, in microseconds, before scrolling to the next frame. (Note: This parameter is mentioned in the description but not explicitly in the function signature provided in the text. Assuming it's intended to be part of the function call if supported).
- **length** (uint8_t) - Optional - The number of digits to set. (Note: This parameter seems misplaced for a string function, typically length is determined by the string itself. Assuming it might control the display area width for the string).
- **pos** (uint8_t) - Optional - The position of the most significant digit (0 - leftmost, 3 - rightmost). (Note: This parameter seems misplaced for a string function, typically position is determined by the string itself. Assuming it might control the starting position of the string).
- **dots** (uint8_t) - Optional - Dot/Colon enable. The argument is a bitmask, with each bit corresponding to a dot between the digits (or colon mark). Defaults to 0.
```

--------------------------------

### Displaying Numbers

Source: https://jasonacox.github.io/TM1637TinyDisplay/TM1637TinyDisplay.h

Functions to display decimal and hexadecimal numbers with customizable formatting, including decimal points, leading zeros, and dot control.

```APIDOC
## showNumber

### Description
Displays a double-precision floating-point number, supporting decimal points. The display length and position can be controlled.

### Method
void

### Parameters
#### Path Parameters
- **num** (double) - Required - The number to be shown.
- **decimal_length** (uint8_t) - Optional - The number of digits to show after the decimal point. Defaults to MAXDIGITS. Anything over 4 will do best fit.
- **length** (uint8_t) - Optional - The number of digits to set. The user must ensure that the number to be shown fits to the number of digits requested (for example, if two digits are to be displayed, the number must be between 0 to 99). Defaults to MAXDIGITS.
- **pos** (uint8_t) - Optional - The position of the most significant digit (0 - leftmost, 3 - rightmost). Defaults to 0.

### showNumberDec

### Description
Displays a signed integer as a decimal number. Allows control over dots/colons, leading zeros, display length, and position.

### Method
void

### Parameters
#### Path Parameters
- **num** (int) - Required - The number to be shown.
- **dots** (uint8_t) - Optional - Dot/Colon enable. The argument is a bitmask, with each bit corresponding to a dot between the digits (or colon mark). Defaults to 0.
- **leading_zero** (bool) - Optional - When true, leading zeros are displayed. Otherwise unnecessary digits are blank. NOTE: leading zero is not supported with negative numbers. Defaults to false.
- **length** (uint8_t) - Optional - The number of digits to set. The user must ensure that the number to be shown fits to the number of digits requested. Defaults to MAXDIGITS.
- **pos** (uint8_t) - Optional - The position of the most significant digit (0 - leftmost, 3 - rightmost). Defaults to 0.

### showNumberHex

### Description
Displays an unsigned hexadecimal number. Allows control over dots/colons, leading zeros, display length, and position.

### Method
void

### Parameters
#### Path Parameters
- **num** (uint16_t) - Required - The number to be shown.
- **dots** (uint8_t) - Optional - Dot/Colon enable. The argument is a bitmask, with each bit corresponding to a dot between the digits (or colon mark). Defaults to 0.
- **leading_zero** (bool) - Optional - When true, leading zeros are displayed. Otherwise unnecessary digits are blank. Defaults to false.
- **length** (uint8_t) - Optional - The number of digits to set. The user must ensure that the number to be shown fits to the number of digits requested. Defaults to MAXDIGITS.
- **pos** (uint8_t) - Optional - The position of the most significant digit (0 - leftmost, 3 - rightmost). Defaults to 0.
```

--------------------------------

### ASCII Encoding Method

Source: https://jasonacox.github.io/TM1637TinyDisplay/TM1637TinyDisplay.h

Converts an ASCII character into the corresponding 7-segment display bitmask.

```cpp
uint8_t encodeASCII(uint8_t chr);
```

--------------------------------

### Display Animation

Source: https://jasonacox.github.io/TM1637TinyDisplay/TM1637TinyDisplay.h

Functions to display animations on the TM1637 display using raw LED segment data. `showAnimation` uses data from RAM, while `showAnimation_P` uses data from PROGMEM.

```APIDOC
## showAnimation

### Description
Displays a sequence of raw LED segment data to create an animation on the TM1637 display.

### Method
void

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **data** (const uint8_t[][4]) - A multi-dimensional array containing the LED segment data. Format: data[frames][4].
- **frames** (unsigned int) - Optional. The number of frames in the sequence to animate. Defaults to 0.
- **ms** (unsigned int) - Optional. The time in milliseconds to delay between each frame. Defaults to 10.

### Request Example
```c
const uint8_t animationData[2][4] = {
  {0b00001000, 0b00000000, 0b00000000, 0b00000000},
  {0b00000000, 0b00001000, 0b00000000, 0b00000000}
};
showAnimation(animationData, 2, 50);
```

### Response
None

## showAnimation_P

### Description
Displays a sequence of raw LED segment data from PROGMEM (flash memory) to create an animation on the TM1637 display.

### Method
void

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **data** (const uint8_t[][4]) - A multi-dimensional array containing the LED segment data (must be in PROGMEM). Format: data[frames][4].
- **frames** (unsigned int) - Optional. The number of frames in the sequence to animate. Defaults to 0.
- **ms** (unsigned int) - Optional. The time in milliseconds to delay between each frame. Defaults to 10.

### Request Example
```c
const uint8_t animationData_P[] PROGMEM = {
  0b00001000, 0b00000000, 0b00000000, 0b00000000,
  0b00000000, 0b00001000, 0b00000000, 0b00000000
};
// Note: The PROGMEM array structure for multi-dimensional arrays might require specific handling.
// Assuming a flattened array or a different PROGMEM structure for demonstration.
// showAnimation_P(animationData_P, 2, 50);
```

### Response
None
```

--------------------------------

### Display String on TM1637

Source: https://jasonacox.github.io/TM1637TinyDisplay/TM1637TinyDisplay.h

Displays a string on the TM1637 display. Supports scrolling for longer strings and custom dot/colon configurations.

```cpp
void showString(const char s[], uint8_t length = MAXDIGITS, uint8_t pos = 0, uint8_t dots = 0);
```

--------------------------------

### TM1637TinyDisplay6 Library Functions

Source: https://jasonacox.github.io/TM1637TinyDisplay

A comprehensive list of functions available in the TM1637TinyDisplay library for controlling the 6-digit display.

```APIDOC
## TM1637TinyDisplay6 Functions

### Description
The TM1637TinyDisplay library provides a single class, `TM1637TinyDisplay`, with various functions to control the 6-digit display.

### Functions List
- `begin()`: Initialize display memory and hardware (call in `setup()`)
- `clear()`: Clear the display.
- `showNumber(int num)`: Display an integer and floating point numbers (positive or negative).
- `showNumberDec(int num, uint8_t dec, bool showLeadingZeros)`: Display a number with ability to manually set decimal points or colon.
- `showNumberHex(int num, uint8_t dec)`: Display a number in hexadecimal format and set decimal point or colon.
- `showString(const char* str)`: Display an ASCII string of text with optional scrolling for long strings.
- `startStringScroll(const char* str)`: Begins a non-blocking scrolling of a string message.
- `showLevel(int level, int max_level)`: Use display LEDs to simulate a level indicator (vertical or horizontal).
- `showAnimation(const uint8_t *frames, int num_frames, int delay_ms)`: Display a sequence of frames to render an animation.
- `startAnimation(const uint8_t *frames, int num_frames, int delay_ms)`: Begins a non-blocking animation of a sequence of frames.
- `Animate()`: Worker routine to be called regularly which handles animations and scrolling in a non-blocking manner.
- `stopAnimation()`: Stops non-blocking animation.
- `setSegments(const uint8_t *segments)`: Directly set the value of the LED segments in each digit.
- `setBrightness(uint8_t brightness)`: Sets the brightness of the display.
- `setScrolldelay(int delay_ms)`: Sets the speed for text scrolling.
- `flipDisplay(bool flip)`: Sets/flips the orientation of the display.
- `isflipDisplay()`: Returns orientation of the display (True = flip).
- `readBuffer()`: Returns current display segment values.

### PROGMEM Functions
Large string or animation data can be left in Flash instead of being loaded into SRAM to save memory.
- `showAnimation_P(const uint8_t *frames, int num_frames, int delay_ms)`: Display a sequence of frames to render an animation (in PROGMEM).
- `showString_P(const char* str)`: Display an ASCII string of text with optional scrolling for long strings (in PROGMEM).
- `startAnimation_P(const uint8_t *frames, int num_frames, int delay_ms)`: Begins a non-blocking animation of a sequence of frames stored in PROGMEM.
- `startStringScroll_P(const char* str)`: Begins a non-blocking scrolling of a string message stored in PROGMEM.
```

--------------------------------

### Manage Non-Blocking Animations on TM1637

Source: https://jasonacox.github.io/TM1637TinyDisplay/TM1637TinyDisplay.h

Handles the event loop for non-blocking animations. Returns true if an animation is in progress, false otherwise. Can optionally loop animations.

```cpp
bool Animate(bool loop = false);
```

--------------------------------

### Display Level Indicator on TM1637

Source: https://jasonacox.github.io/TM1637TinyDisplay/TM1637TinyDisplay.h

Shows a level indicator on the display, representing a percentage from 0 to 100. Can be oriented horizontally or vertically.

```cpp
void showLevel(unsigned int level = 100, bool horizontal = true);
```

--------------------------------

### Segment and Number Display

Source: https://jasonacox.github.io/TM1637TinyDisplay/TM1637TinyDisplay.h

Functions for displaying raw segment data and decimal numbers.

```APIDOC
## Segment and Number Display

### setSegments()

Display arbitrary data on the module
This function receives raw segment values as input and displays them. The segment data is given as a byte array, each byte corresponding to a single digit. Within each byte, bit 0 is segment A, bit 1 is segment B etc.
The function may either set the entire display or any desirable part on its own. The first digit is given by the @ref pos argument with 0 being the leftmost digit. The @ref length argument is the number of digits to be set. Other digits are not affected.
@param segments An array of size @ref length containing the raw segment values
@param length The number of digits to be modified
@param pos The position from which to start the modification (0 - leftmost, 3 - rightmost)

### setSegments()

Update a single digit segment values
This function receives raw segment values as input and displays them. The segment data is a single byte @ref A to update the digit as specified by @ref pos argument with 0 being the leftmost digit.
@param A An byte containing the raw segment values
@param pos The position from which to start the modification (0 - leftmost, 3 - rightmost)

### clear()

Clear the display

### showNumber()

Display a decimal number
Display the given argument as a decimal number.
@param num The number to be shown
@param leading_zero When true, leading zeros are displayed. Otherwise unnecessary digits are blank. NOTE: leading zero is not supported with negative numbers.
@param length The number of digits to set. The user must ensure that the number to be shown fits to the number of digits requested (for example, if two digits are to be displayed, the number must be between 0 to 99)
@param pos The position of the most significant digit (0 - leftmost, 3 - rightmost)

### showNumber()

Display a decimal number
Display the given argument as a decimal number.
@param num The number to be shown
@param leading_zero When true, leading zeros are displayed. Otherwise unnecessary digits are blank. NOTE: leading zero is not supported with negative numbers.
@param length The number of digits to set. The user must ensure that the number to be shown fits to the number of digits requested (for example, if two digits are to be displayed, the number must be between 0 to 99)
@param pos The position of the most significant digit (0 - leftmost, 3 - rightmost)

### showNumber()

Display a decimal number with floating point
Display the given argument as a decimal number. Decimal point will only show up on displays
```

--------------------------------

### String Scrolling

Source: https://jasonacox.github.io/TM1637TinyDisplay/TM1637TinyDisplay.h

Functions to scroll a string across the TM1637 display.

```APIDOC
## startStringScroll

### Description
Begins a non-blocking scroll of a string across the TM1637 display.

### Method
void

### Endpoint
startStringScroll(const char s[], unsigned int ms = DEFAULT_SCROLL_DELAY, bool usePROGMEM = false)

### Parameters
#### Path Parameters
- None

#### Query Parameters
- None

#### Request Body
- **s** (const char[]) - The string to scroll.
- **ms** (unsigned int) - Optional. Time in milliseconds to delay between each character scroll. Defaults to DEFAULT_SCROLL_DELAY.
- **usePROGMEM** (bool) - Optional. Indicates if the string data is stored in PROGMEM. Defaults to false.

### Request Example
```c++
// tm1637.startStringScroll("Hello World", 100);
```

### Response
#### Success Response (200)
- None (void function)

#### Response Example
None
```

```APIDOC
## startStringScroll_P

### Description
Begins a non-blocking scroll of a string stored in PROGMEM across the TM1637 display.

### Method
void

### Endpoint
startStringScroll_P(const char s[], unsigned int ms = DEFAULT_SCROLL_DELAY)

### Parameters
#### Path Parameters
- None

#### Query Parameters
- None

#### Request Body
- **s** (const char[]) - The string to scroll, stored in PROGMEM.
- **ms** (unsigned int) - Optional. Time in milliseconds to delay between each character scroll. Defaults to DEFAULT_SCROLL_DELAY.

### Request Example
```c++
// Example usage with PROGMEM string
// tm1637.startStringScroll_P(PROGMEM_STRING_VARIABLE, 100);
```

### Response
#### Success Response (200)
- None (void function)

#### Response Example
None
```

--------------------------------

### Animation Control

Source: https://jasonacox.github.io/TM1637TinyDisplay/TM1637TinyDisplay.h

Functions to manage non-blocking animations on the TM1637 display.

```APIDOC
## Animate

### Description
This is the event loop function to enable non-blocking animations. It returns TRUE when an animation is still occurring and FALSE when no animation is active.

### Method
bool

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **loop** (bool) - Optional. If true, the animation will loop when it ends. Defaults to false.

### Request Example
```c
if (Animate(true)) {
  // Animation is still running
} else {
  // Animation has finished
}
```

### Response
#### Success Response (200)
- **return value** (bool) - TRUE if an animation is occurring, FALSE otherwise.

## Begin Non-Blocking Animation

### Description
This function is used to begin a non-blocking animation. It prepares the display to play an animation sequence without blocking the main program flow.

### Method
void (Implicitly, as it's a setup function for animation)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **usePROGMEN** (bool) - Indicates if the passed animation data is coming from a PROGMEM defined variable.
- **frames** (unsigned int) - The number of frames in the sequence to animate.

### Request Example
```c
// Assuming animation data is prepared and stored in PROGMEM
// BeginAnimation(true, numberOfFrames);
```

### Response
None
```

--------------------------------

### Character Encoding

Source: https://jasonacox.github.io/TM1637TinyDisplay/TM1637TinyDisplay.h

Function to encode ASCII characters into 7-segment display codes.

```APIDOC
## encodeASCII

### Description
Translates a single ASCII character into its corresponding 7-segment display code.
ASCII characters between 0-32 and 128-255 will result in a blank display.

### Method
uint8_t

### Endpoint
encodeASCII(uint8_t chr)

### Parameters
#### Path Parameters
- None

#### Query Parameters
- None

#### Request Body
- **chr** (uint8_t) - The ASCII value of the character to encode.

### Request Example
```c++
// uint8_t segment_code = tm1637.encodeASCII('A');
```

### Response
#### Success Response (200)
- **return value** (uint8_t) - A code representing the 7-segment image of the digit. The LSB corresponds to segment A, bit 6 to segment G, and bit 7 is always zero.

#### Response Example
```json
{
  "example": "segment_code_value"
}
```
```
Tokens:
Raw