SM1628C Помогите разобраться с библиотекой

[ЕвгенийП]

Побалуйтесь с остальными функциями, Вам надо убедиться, что всё работает. Я то вслепую пишу, проверить не на чем, малейшая опечатка …

Я вернулся с перекура, сейчас цифры сделаю.

[Andrew8126]

Вроде бы все проверил. Все зажигается как должно.

[ЕвгенийП]

Тест №2

Позиции (разряды) мне удобнее нумеровать с 0 по 3. Т.е. моя 0 - это Ваша 1 и т.д.

В примере должны выводиться цифры 0-9 с интервалом в 1 сек в позицию 0, потом позиция 0 гаснет и также выводятся цифры в позицию 1, потом 2 и потом в позицию 3.

Если не так, то попробуйте рассказать как , будем чинить.

Спойлер

#define	PIN_CLK	3
#define	PIN_DIO	2
#define	PIN_STB	4	
#define	PIN_IR	13


/////////////////////////////////////////////////////////////
/////////////    ТИПА "библиотека" ДЛЯ TM1668    ////////////
/////////////////////////////////////////////////////////////

//
// при том подключении, что есть
// достаточно 10 байтов на светодиоды и 2 на кнопки
//
#define	LED_DATA_LENGTH	14
#define	KEY_DATA_LENGTH	2

//
// Маски нажатых кнопок (слева направо)
//
#define KEY_1	0xFF609F
#define KEY_2	0xFF22DD
#define KEY_3	0x0008
#define KEY_4	0x0001

constexpr byte symbolMask = 0x0020;

constexpr byte SEG_A_bit = 0;
constexpr byte SEG_B_bit = 1;
constexpr byte SEG_C_bit = 2;
constexpr byte SEG_D_bit = 3;
constexpr byte SEG_E_bit = 4;
constexpr byte SEG_F_bit = 5;
constexpr byte SEG_G_bit = 6;

constexpr byte SEG_A = 1 << SEG_A_bit;
constexpr byte SEG_B = 1 << SEG_B_bit;
constexpr byte SEG_C = 1 << SEG_C_bit;	
constexpr byte SEG_D = 1 << SEG_D_bit;
constexpr byte SEG_E = 1 << SEG_E_bit;
constexpr byte SEG_F = 1 << SEG_F_bit;
constexpr byte SEG_G = 1 << SEG_G_bit;

// Маска для всех - 0x0020
constexpr byte pos_PLAY = 0;
constexpr byte pos_REC = 1;
constexpr byte pos_USB = 2;
constexpr byte pos_DISK = 3;
constexpr byte pos_COLON = 4; // двоеточие
constexpr byte pos_HDD = 5;
constexpr byte pos_LAN = 6;

//
// Символы (цифры / буквы, можно ещё добавить всяких)
//
#define SYMBOL_0 (SEG_A | SEG_B | SEG_C | SEG_D | SEG_E | SEG_F)
#define SYMBOL_1 (SEG_B | SEG_C)
#define SYMBOL_2 (SEG_A | SEG_B | SEG_D | SEG_E | SEG_G)
#define SYMBOL_3 (SEG_A | SEG_B | SEG_C | SEG_D | SEG_G)
#define SYMBOL_4 (SEG_B | SEG_C | SEG_F | SEG_G)
#define SYMBOL_5 (SEG_A | SEG_C | SEG_D | SEG_F | SEG_G)
#define SYMBOL_6 (SEG_A | SEG_C | SEG_D | SEG_E | SEG_F | SEG_G)
#define SYMBOL_7 (SEG_A | SEG_B | SEG_C)
#define SYMBOL_8 (SEG_A | SEG_B | SEG_C | SEG_D | SEG_E | SEG_F | SEG_G)
#define SYMBOL_9 (SEG_A | SEG_B | SEG_C | SEG_D | SEG_F | SEG_G)

#define SYMBOL_MINUS (SEG_G)
#define SYMBOL_A (SEG_A | SEG_B | SEG_C | SEG_E | SEG_F | SEG_G)
#define SYMBOL_C (SEG_A | SEG_E | SEG_F | SEG_D)
#define SYMBOL_E (SEG_A | SEG_D | SEG_E | SEG_F | SEG_G)
#define SYMBOL_H (SEG_B | SEG_C | SEG_E | SEG_F | SEG_G)
#define SYMBOL_P (SEG_A | SEG_B | SEG_E | SEG_F | SEG_G)
#define SYMBOL_G (SEG_A | SEG_E | SEG_F)
#define SYMBOL_L (SEG_D | SEG_E | SEG_F)
#define SYMBOL_F (SEG_A | SEG_E | SEG_F | SEG_G)
#define SYMBOL_d (SEG_B | SEG_C | SEG_D | SEG_E | SEG_G)
#define SYMBOL_b (SEG_C | SEG_D | SEG_E | SEG_F | SEG_G)
#define SYMBOL_rP (SEG_A | SEG_B | SEG_C | SEG_E | SEG_F)

//
// Глобальные переменные
//
static uint16_t ledGRID[LED_DATA_LENGTH / 2]; // текущее состояние экрана
static uint8_t currentBrightness = 1;	// текущая яркость
//
//static uint16_t saveGRID[LED_DATA_LENGTH / 2]; // нужно для сохранения состояния экрана на время теста
//static uint8_t saveBrightness;	// нужно для сохранения яркости на время теста
//
//static IRrecv irrecv(PIN_IR);

//
//	Запись одиночной команды в TM1668
//
void writeSingleCommand(const uint8_t command) {
	digitalWrite(PIN_STB, LOW);
	shiftOut(PIN_DIO, PIN_CLK, LSBFIRST, command);
	digitalWrite(PIN_STB, HIGH);
	delayMicroseconds(1); // Пауза до следующей команды
}

//
//	Запись состояния дисплея в TM1668
//
void updateDisplay(void) {
	writeSingleCommand(0x40);  // запись данных, автоматический адрес 0x40
	digitalWrite(PIN_STB, LOW);
	shiftOut(PIN_DIO, PIN_CLK, LSBFIRST, 0xC0); // Установка адреса в 0
	uint8_t * p= (uint8_t *) ledGRID;
	for (int8_t i = 0; i < LED_DATA_LENGTH; i++, p++) shiftOut(PIN_DIO, PIN_CLK, LSBFIRST, *p); // запись данных
	digitalWrite(PIN_STB, HIGH);
	delayMicroseconds(1); // Пауза до следующей команды
}

/*
//
//	Чтение состояния кнопок с TM1668
//
void readKeyData(uint16_t * data) {
	digitalWrite(PIN_STB, LOW);
	shiftOut(PIN_DIO, PIN_CLK, LSBFIRST, 0x42);  // чтение данных 0x42
	pinMode(PIN_DIO, INPUT_PULLUP);
	delayMicroseconds(1);
	* data = shiftIn(PIN_DIO, PIN_CLK, LSBFIRST) + (shiftIn(PIN_DIO, PIN_CLK, LSBFIRST) << 8);
	pinMode(PIN_DIO, OUTPUT);
	digitalWrite(PIN_STB, HIGH);
}
*/

//
// Установить яркость от 0 (выключено) до 8
// (возвращает старую яркость)
//  !!!РАЗОБРАТЬСЯ!!!
static inline uint8_t setBrightness(const uint8_t newBrighness) {
	const uint8_t res = currentBrightness;
	currentBrightness = (newBrighness > 8) ? 8 : newBrighness;
	if (currentBrightness == 0) writeSingleCommand(0x80); // Выключить дисплей
	else writeSingleCommand(0x88 + (currentBrightness - 1)); // Установить яркость
	return res;
}

//
//	Увеличить яркость на 1 (возвращает старую яркость)
//
static inline uint8_t increaseBrightness(void) {
	const uint8_t res = currentBrightness;
	if (currentBrightness < 8) setBrightness(currentBrightness + 1);
	return res;
}

//
//	Уменьшить яркость на 1 (возвращает старую яркость)
//
static inline uint8_t decreaseBrightness(void) {
	const uint8_t res = currentBrightness;
	if (currentBrightness > 0) setBrightness(currentBrightness - 1);
	return res;
}

//
//	Показать тест экрана
// (все символы включены на максимальной яркости)
//
//void showTest(void) {
//	memcpy(saveGRID, ledGRID, sizeof(saveGRID));
//	ledGRID[0] = 0x0FF0;
//	ledGRID[1] = 0x0FF0;
//	ledGRID[2] = 0x0FF0;
//	ledGRID[3] = 0x0FF0;
//	ledGRID[4] = 0x0FF0;
//	ledGRID[5] = 0x0FF0;
//	ledGRID[6] = 0x0FF0;
//	updateDisplay();
//	saveBrightness = setBrightness(8);
//}
//
//	Восстановить экран после теста
//
//void hideTest(void) {
//	memcpy(ledGRID, saveGRID, sizeof(saveGRID));
//	updateDisplay();
//	setBrightness(saveBrightness);
//}

//
//	Показать/скрыть/инвертировать дополнительный символ
//
static inline void showExtraSymbol(const int8_t n) { ledGRID[n] |= symbolMask; }
static inline void hideExtraSymbol(const int8_t n) { ledGRID[n] &= ~symbolMask; }
static inline void invertExtraSymbol(const int8_t n) { ledGRID[n] ^= symbolMask; }

//
//	Показать/скрыть/инвертировать PLAY
//
static inline void showPLAY(void) { showExtraSymbol(pos_PLAY); }
static inline void hidePLAY(void) { hideExtraSymbol(pos_PLAY); }
static inline void invertPLAY(void) { invertExtraSymbol(pos_PLAY); }
//
//	Показать/скрыть/инвертировать REC
//
static inline void showREC(void) { showExtraSymbol(pos_REC); }
static inline void hideREC(void) { hideExtraSymbol(pos_REC); }
static inline void invertREC(void) { invertExtraSymbol(pos_REC); }

//
//	Показать/скрыть/инвертировать USB
//
static inline void showUSB(void) { showExtraSymbol(pos_USB); }
static inline void hideUSB(void) { hideExtraSymbol(pos_USB); }
static inline void invertUSB(void) { invertExtraSymbol(pos_USB); }

//
//	Показать/скрыть/инвертировать DISK
//
static inline void showDISK(void) { showExtraSymbol(pos_DISK); }
static inline void hideDISK(void) { hideExtraSymbol(pos_DISK); }
static inline void invertDISK(void) { invertExtraSymbol(pos_DISK); }

//
//	Показать/скрыть/инвертировать COLON
//
static inline void showCOLON(void) { showExtraSymbol(pos_COLON); }
static inline void hideCOLON(void) { hideExtraSymbol(pos_COLON); }
static inline void invertCOLON(void) { invertExtraSymbol(pos_COLON); }

//
//	Показать/скрыть/инвертировать HDD
//
static inline void showHDD(void) { showExtraSymbol(pos_HDD); }
static inline void hideHDD(void) { hideExtraSymbol(pos_HDD); }
static inline void invertHDD(void) { invertExtraSymbol(pos_HDD); }

//
//	Показать/скрыть/инвертировать LAN
//
static inline void showLAN(void) { showExtraSymbol(pos_LAN); }
static inline void hideLAN(void) { hideExtraSymbol(pos_LAN); }
static inline void invertLAN(void) { invertExtraSymbol(pos_LAN); }

//
//	Показать символ value в позиции digit (0-3)
// при этом, если у цифры горит дополнительный символ, сохраняем его
//
static inline void setSymbol(const int8_t position, uint8_t value) {
	if (position > 3) return; // позиции от 0 до 3. Если не так - нафиг
	constexpr uint16_t digMask[4] = { 0x0200, 0x0100, 0x0080, 0x0040 };
	for (uint8_t i = 0; i < 7; i++) {
		const bool high = value & 1;
		if (high) ledGRID[i] |= digMask[position];
		else ledGRID[i] &= ~digMask[position];
	}
}

//
//	Показать цифру value (0-9) в позиции digit (0-3)
//
static inline void setDigit(const int8_t position, uint8_t value) {
	constexpr static uint8_t digits[] = { SYMBOL_0, SYMBOL_1, SYMBOL_2, SYMBOL_3, SYMBOL_4, SYMBOL_5, SYMBOL_6, SYMBOL_7, SYMBOL_8, SYMBOL_9 };
	if (value > 9) return; // цифра от 0 до 9. Если не так - нафиг
	setSymbol(position, digits[value]);
}

//
//	Показать число m в двух правых цифрах (типа минуты или там секунды)
//
static inline void showMinutes(const int8_t m) {
	setDigit(3, m % 10);
	setDigit(2, m / 10);
}

//
//	Показать число h в двух левых цифрах (типа часы или там минуты)
//
static inline void showHours(const int8_t h) {
	setDigit(1, h % 10);
	setDigit(0, h / 10);
}


//
//	Показать и часы, и минуты
//
static inline void showClock(const int8_t h, const int8_t m) {
	showHours(h);
	showMinutes(m);
}

/////////////////////////////////////////////////////////////
////////////    КОНЕЦ "библиотеки" ДЛЯ TM1668    ////////////
/////////////////////////////////////////////////////////////



void setup(void) {
	//
	// Инициализация пинов
	pinMode(PIN_CLK, OUTPUT);
	pinMode(PIN_DIO, OUTPUT);
	pinMode(PIN_STB, OUTPUT);
	pinMode(PIN_IR, INPUT);
	digitalWrite(PIN_STB, HIGH);
	digitalWrite(PIN_CLK, HIGH);
	//
	// Инициализация экрана
	writeSingleCommand(0x03); // Режим отображения (1 и 2 - ничего не меняется)
	setBrightness(currentBrightness);

	for (uint8_t d = 0; d < 4; d++) {
		for (uint8_t i = 0; i < 10; i++) {
			setDigit(d, i); // выводим 0, 1, 2, ... в позицию d
			delay(1000);
		}
		setSymbol(d, 0); // очистить позицию d
	}
}

void loop (void) {}
///// Всё! Веселье закончилось!

[ЕвгенийП]

Виноват, забыл про сдвиг. Щас будет новый код

[Andrew8126]

Да, а то этот просто гасит дисплей

[ЕвгенийП]

Вот так попробуйте

Спойлер

#define	PIN_CLK	3
#define	PIN_DIO	2
#define	PIN_STB	4	
#define	PIN_IR	13


/////////////////////////////////////////////////////////////
/////////////    ТИПА "библиотека" ДЛЯ TM1668    ////////////
/////////////////////////////////////////////////////////////

//
// при том подключении, что есть
// достаточно 10 байтов на светодиоды и 2 на кнопки
//
#define	LED_DATA_LENGTH	14
#define	KEY_DATA_LENGTH	2

//
// Маски нажатых кнопок (слева направо)
//
#define KEY_1	0xFF609F
#define KEY_2	0xFF22DD
#define KEY_3	0x0008
#define KEY_4	0x0001

constexpr byte symbolMask = 0x0020;

constexpr byte SEG_A_bit = 0;
constexpr byte SEG_B_bit = 1;
constexpr byte SEG_C_bit = 2;
constexpr byte SEG_D_bit = 3;
constexpr byte SEG_E_bit = 4;
constexpr byte SEG_F_bit = 5;
constexpr byte SEG_G_bit = 6;

constexpr byte SEG_A = 1 << SEG_A_bit;
constexpr byte SEG_B = 1 << SEG_B_bit;
constexpr byte SEG_C = 1 << SEG_C_bit;	
constexpr byte SEG_D = 1 << SEG_D_bit;
constexpr byte SEG_E = 1 << SEG_E_bit;
constexpr byte SEG_F = 1 << SEG_F_bit;
constexpr byte SEG_G = 1 << SEG_G_bit;

// Маска для всех - 0x0020
constexpr byte pos_PLAY = 0;
constexpr byte pos_REC = 1;
constexpr byte pos_USB = 2;
constexpr byte pos_DISK = 3;
constexpr byte pos_COLON = 4; // двоеточие
constexpr byte pos_HDD = 5;
constexpr byte pos_LAN = 6;

//
// Символы (цифры / буквы, можно ещё добавить всяких)
//
#define SYMBOL_0 (SEG_A | SEG_B | SEG_C | SEG_D | SEG_E | SEG_F)
#define SYMBOL_1 (SEG_B | SEG_C)
#define SYMBOL_2 (SEG_A | SEG_B | SEG_D | SEG_E | SEG_G)
#define SYMBOL_3 (SEG_A | SEG_B | SEG_C | SEG_D | SEG_G)
#define SYMBOL_4 (SEG_B | SEG_C | SEG_F | SEG_G)
#define SYMBOL_5 (SEG_A | SEG_C | SEG_D | SEG_F | SEG_G)
#define SYMBOL_6 (SEG_A | SEG_C | SEG_D | SEG_E | SEG_F | SEG_G)
#define SYMBOL_7 (SEG_A | SEG_B | SEG_C)
#define SYMBOL_8 (SEG_A | SEG_B | SEG_C | SEG_D | SEG_E | SEG_F | SEG_G)
#define SYMBOL_9 (SEG_A | SEG_B | SEG_C | SEG_D | SEG_F | SEG_G)

#define SYMBOL_MINUS (SEG_G)
#define SYMBOL_A (SEG_A | SEG_B | SEG_C | SEG_E | SEG_F | SEG_G)
#define SYMBOL_C (SEG_A | SEG_E | SEG_F | SEG_D)
#define SYMBOL_E (SEG_A | SEG_D | SEG_E | SEG_F | SEG_G)
#define SYMBOL_H (SEG_B | SEG_C | SEG_E | SEG_F | SEG_G)
#define SYMBOL_P (SEG_A | SEG_B | SEG_E | SEG_F | SEG_G)
#define SYMBOL_G (SEG_A | SEG_E | SEG_F)
#define SYMBOL_L (SEG_D | SEG_E | SEG_F)
#define SYMBOL_F (SEG_A | SEG_E | SEG_F | SEG_G)
#define SYMBOL_d (SEG_B | SEG_C | SEG_D | SEG_E | SEG_G)
#define SYMBOL_b (SEG_C | SEG_D | SEG_E | SEG_F | SEG_G)
#define SYMBOL_rP (SEG_A | SEG_B | SEG_C | SEG_E | SEG_F)

//
// Глобальные переменные
//
static uint16_t ledGRID[LED_DATA_LENGTH / 2]; // текущее состояние экрана
static uint8_t currentBrightness = 1;	// текущая яркость
//
//static uint16_t saveGRID[LED_DATA_LENGTH / 2]; // нужно для сохранения состояния экрана на время теста
//static uint8_t saveBrightness;	// нужно для сохранения яркости на время теста
//
//static IRrecv irrecv(PIN_IR);

//
//	Запись одиночной команды в TM1668
//
void writeSingleCommand(const uint8_t command) {
	digitalWrite(PIN_STB, LOW);
	shiftOut(PIN_DIO, PIN_CLK, LSBFIRST, command);
	digitalWrite(PIN_STB, HIGH);
	delayMicroseconds(1); // Пауза до следующей команды
}

//
//	Запись состояния дисплея в TM1668
//
void updateDisplay(void) {
	writeSingleCommand(0x40);  // запись данных, автоматический адрес 0x40
	digitalWrite(PIN_STB, LOW);
	shiftOut(PIN_DIO, PIN_CLK, LSBFIRST, 0xC0); // Установка адреса в 0
	uint8_t * p= (uint8_t *) ledGRID;
	for (int8_t i = 0; i < LED_DATA_LENGTH; i++, p++) shiftOut(PIN_DIO, PIN_CLK, LSBFIRST, *p); // запись данных
	digitalWrite(PIN_STB, HIGH);
	delayMicroseconds(1); // Пауза до следующей команды
}

/*
//
//	Чтение состояния кнопок с TM1668
//
void readKeyData(uint16_t * data) {
	digitalWrite(PIN_STB, LOW);
	shiftOut(PIN_DIO, PIN_CLK, LSBFIRST, 0x42);  // чтение данных 0x42
	pinMode(PIN_DIO, INPUT_PULLUP);
	delayMicroseconds(1);
	* data = shiftIn(PIN_DIO, PIN_CLK, LSBFIRST) + (shiftIn(PIN_DIO, PIN_CLK, LSBFIRST) << 8);
	pinMode(PIN_DIO, OUTPUT);
	digitalWrite(PIN_STB, HIGH);
}
*/

//
// Установить яркость от 0 (выключено) до 8
// (возвращает старую яркость)
//  !!!РАЗОБРАТЬСЯ!!!
static inline uint8_t setBrightness(const uint8_t newBrighness) {
	const uint8_t res = currentBrightness;
	currentBrightness = (newBrighness > 8) ? 8 : newBrighness;
	if (currentBrightness == 0) writeSingleCommand(0x80); // Выключить дисплей
	else writeSingleCommand(0x88 + (currentBrightness - 1)); // Установить яркость
	return res;
}

//
//	Увеличить яркость на 1 (возвращает старую яркость)
//
static inline uint8_t increaseBrightness(void) {
	const uint8_t res = currentBrightness;
	if (currentBrightness < 8) setBrightness(currentBrightness + 1);
	return res;
}

//
//	Уменьшить яркость на 1 (возвращает старую яркость)
//
static inline uint8_t decreaseBrightness(void) {
	const uint8_t res = currentBrightness;
	if (currentBrightness > 0) setBrightness(currentBrightness - 1);
	return res;
}

//
//	Показать тест экрана
// (все символы включены на максимальной яркости)
//
//void showTest(void) {
//	memcpy(saveGRID, ledGRID, sizeof(saveGRID));
//	ledGRID[0] = 0x0FF0;
//	ledGRID[1] = 0x0FF0;
//	ledGRID[2] = 0x0FF0;
//	ledGRID[3] = 0x0FF0;
//	ledGRID[4] = 0x0FF0;
//	ledGRID[5] = 0x0FF0;
//	ledGRID[6] = 0x0FF0;
//	updateDisplay();
//	saveBrightness = setBrightness(8);
//}
//
//	Восстановить экран после теста
//
//void hideTest(void) {
//	memcpy(ledGRID, saveGRID, sizeof(saveGRID));
//	updateDisplay();
//	setBrightness(saveBrightness);
//}

//
//	Показать/скрыть/инвертировать дополнительный символ
//
static inline void showExtraSymbol(const int8_t n) { ledGRID[n] |= symbolMask; }
static inline void hideExtraSymbol(const int8_t n) { ledGRID[n] &= ~symbolMask; }
static inline void invertExtraSymbol(const int8_t n) { ledGRID[n] ^= symbolMask; }

//
//	Показать/скрыть/инвертировать PLAY
//
static inline void showPLAY(void) { showExtraSymbol(pos_PLAY); }
static inline void hidePLAY(void) { hideExtraSymbol(pos_PLAY); }
static inline void invertPLAY(void) { invertExtraSymbol(pos_PLAY); }
//
//	Показать/скрыть/инвертировать REC
//
static inline void showREC(void) { showExtraSymbol(pos_REC); }
static inline void hideREC(void) { hideExtraSymbol(pos_REC); }
static inline void invertREC(void) { invertExtraSymbol(pos_REC); }

//
//	Показать/скрыть/инвертировать USB
//
static inline void showUSB(void) { showExtraSymbol(pos_USB); }
static inline void hideUSB(void) { hideExtraSymbol(pos_USB); }
static inline void invertUSB(void) { invertExtraSymbol(pos_USB); }

//
//	Показать/скрыть/инвертировать DISK
//
static inline void showDISK(void) { showExtraSymbol(pos_DISK); }
static inline void hideDISK(void) { hideExtraSymbol(pos_DISK); }
static inline void invertDISK(void) { invertExtraSymbol(pos_DISK); }

//
//	Показать/скрыть/инвертировать COLON
//
static inline void showCOLON(void) { showExtraSymbol(pos_COLON); }
static inline void hideCOLON(void) { hideExtraSymbol(pos_COLON); }
static inline void invertCOLON(void) { invertExtraSymbol(pos_COLON); }

//
//	Показать/скрыть/инвертировать HDD
//
static inline void showHDD(void) { showExtraSymbol(pos_HDD); }
static inline void hideHDD(void) { hideExtraSymbol(pos_HDD); }
static inline void invertHDD(void) { invertExtraSymbol(pos_HDD); }

//
//	Показать/скрыть/инвертировать LAN
//
static inline void showLAN(void) { showExtraSymbol(pos_LAN); }
static inline void hideLAN(void) { hideExtraSymbol(pos_LAN); }
static inline void invertLAN(void) { invertExtraSymbol(pos_LAN); }

//
//	Показать символ value в позиции digit (0-3)
// при этом, если у цифры горит дополнительный символ, сохраняем его
//
static inline void setSymbol(const int8_t position, uint8_t value) {
	if (position > 3) return; // позиции от 0 до 3. Если не так - нафиг
	constexpr uint16_t digMask[4] = { 0x0200, 0x0100, 0x0080, 0x0040 };
	for (uint8_t i = 0; i < 7; i++) {
		const bool high = value & 1;
		if (high) ledGRID[i] |= digMask[position];
		else ledGRID[i] &= ~digMask[position];
		value >>= 1;
	}
}

//
//	Показать цифру value (0-9) в позиции digit (0-3)
//
static inline void setDigit(const int8_t position, uint8_t value) {
	constexpr static uint8_t digits[] = { SYMBOL_0, SYMBOL_1, SYMBOL_2, SYMBOL_3, SYMBOL_4, SYMBOL_5, SYMBOL_6, SYMBOL_7, SYMBOL_8, SYMBOL_9 };
	if (value > 9) return; // цифра от 0 до 9. Если не так - нафиг
	setSymbol(position, digits[value]);
}

//
//	Показать число m в двух правых цифрах (типа минуты или там секунды)
//
static inline void showMinutes(const int8_t m) {
	setDigit(3, m % 10);
	setDigit(2, m / 10);
}

//
//	Показать число h в двух левых цифрах (типа часы или там минуты)
//
static inline void showHours(const int8_t h) {
	setDigit(1, h % 10);
	setDigit(0, h / 10);
}


//
//	Показать и часы, и минуты
//
static inline void showClock(const int8_t h, const int8_t m) {
	showHours(h);
	showMinutes(m);
}

/////////////////////////////////////////////////////////////
////////////    КОНЕЦ "библиотеки" ДЛЯ TM1668    ////////////
/////////////////////////////////////////////////////////////



void setup(void) {
	//
	// Инициализация пинов
	pinMode(PIN_CLK, OUTPUT);
	pinMode(PIN_DIO, OUTPUT);
	pinMode(PIN_STB, OUTPUT);
	pinMode(PIN_IR, INPUT);
	digitalWrite(PIN_STB, HIGH);
	digitalWrite(PIN_CLK, HIGH);
	//
	// Инициализация экрана
	writeSingleCommand(0x03); // Режим отображения (1 и 2 - ничего не меняется)
	setBrightness(currentBrightness);

	for (uint8_t d = 0; d < 4; d++) {
		for (uint8_t i = 0; i < 10; i++) {
			setDigit(d, i); // выводим 0, 1, 2, ... в позицию d
			delay(1000);
		}
		setSymbol(d, 0); // очистить позицию d
	}
}

void loop (void) {}
///// Всё! Веселье закончилось!

[Andrew8126]

Нет, пустой дисплей. Доп. символы зажигаются если вставить функцию, а разряды все пустые

[ЕвгенийП]

Что-то опять забыл. Сейчас посмотрю. У Вас монитора порта работает? Я могу что-то вывести в Serial, чтобы Вы мне показали, что выводится?

[Andrew8126]

Да. работает

[Andrew8126]

Монитор порта, это же в программе Arduino IDE? Если он то работает

[ЕвгенийП]

Тваю ж дивизию! updateDisplay() забыл!!! Вы ж знаете, что он нужен, следите тоже.

Спойлер

#define	PIN_CLK	3
#define	PIN_DIO	2
#define	PIN_STB	4	
#define	PIN_IR	13


/////////////////////////////////////////////////////////////
/////////////    ТИПА "библиотека" ДЛЯ TM1668    ////////////
/////////////////////////////////////////////////////////////

//
// при том подключении, что есть
// достаточно 10 байтов на светодиоды и 2 на кнопки
//
#define	LED_DATA_LENGTH	14
#define	KEY_DATA_LENGTH	2

//
// Маски нажатых кнопок (слева направо)
//
#define KEY_1	0xFF609F
#define KEY_2	0xFF22DD
#define KEY_3	0x0008
#define KEY_4	0x0001

constexpr byte symbolMask = 0x0020;

constexpr byte SEG_A_bit = 0;
constexpr byte SEG_B_bit = 1;
constexpr byte SEG_C_bit = 2;
constexpr byte SEG_D_bit = 3;
constexpr byte SEG_E_bit = 4;
constexpr byte SEG_F_bit = 5;
constexpr byte SEG_G_bit = 6;

constexpr byte SEG_A = 1 << SEG_A_bit;
constexpr byte SEG_B = 1 << SEG_B_bit;
constexpr byte SEG_C = 1 << SEG_C_bit;	
constexpr byte SEG_D = 1 << SEG_D_bit;
constexpr byte SEG_E = 1 << SEG_E_bit;
constexpr byte SEG_F = 1 << SEG_F_bit;
constexpr byte SEG_G = 1 << SEG_G_bit;

// Маска для всех - 0x0020
constexpr byte pos_PLAY = 0;
constexpr byte pos_REC = 1;
constexpr byte pos_USB = 2;
constexpr byte pos_DISK = 3;
constexpr byte pos_COLON = 4; // двоеточие
constexpr byte pos_HDD = 5;
constexpr byte pos_LAN = 6;

//
// Символы (цифры / буквы, можно ещё добавить всяких)
//
constexpr byte SYMBOL_0 = (SEG_A | SEG_B | SEG_C | SEG_D | SEG_E | SEG_F);
constexpr byte SYMBOL_1 = (SEG_B | SEG_C);
constexpr byte SYMBOL_2 = (SEG_A | SEG_B | SEG_D | SEG_E | SEG_G);
constexpr byte SYMBOL_3 = (SEG_A | SEG_B | SEG_C | SEG_D | SEG_G);
constexpr byte SYMBOL_4 = (SEG_B | SEG_C | SEG_F | SEG_G);
constexpr byte SYMBOL_5 = (SEG_A | SEG_C | SEG_D | SEG_F | SEG_G);
constexpr byte SYMBOL_6 = (SEG_A | SEG_C | SEG_D | SEG_E | SEG_F | SEG_G);
constexpr byte SYMBOL_7 = (SEG_A | SEG_B | SEG_C);
constexpr byte SYMBOL_8 = (SEG_A | SEG_B | SEG_C | SEG_D | SEG_E | SEG_F | SEG_G);
constexpr byte SYMBOL_9 = (SEG_A | SEG_B | SEG_C | SEG_D | SEG_F | SEG_G);
;
constexpr byte SYMBOL_MINUS = (SEG_G);
constexpr byte SYMBOL_A = (SEG_A | SEG_B | SEG_C | SEG_E | SEG_F | SEG_G);
constexpr byte SYMBOL_C = (SEG_A | SEG_E | SEG_F | SEG_D);
constexpr byte SYMBOL_E = (SEG_A | SEG_D | SEG_E | SEG_F | SEG_G);
constexpr byte SYMBOL_H = (SEG_B | SEG_C | SEG_E | SEG_F | SEG_G);
constexpr byte SYMBOL_P = (SEG_A | SEG_B | SEG_E | SEG_F | SEG_G);
constexpr byte SYMBOL_G = (SEG_A | SEG_E | SEG_F);
constexpr byte SYMBOL_L = (SEG_D | SEG_E | SEG_F);
constexpr byte SYMBOL_F = (SEG_A | SEG_E | SEG_F | SEG_G);
constexpr byte SYMBOL_d = (SEG_B | SEG_C | SEG_D | SEG_E | SEG_G);
constexpr byte SYMBOL_b = (SEG_C | SEG_D | SEG_E | SEG_F | SEG_G);
constexpr byte SYMBOL_rP = (SEG_A | SEG_B | SEG_C | SEG_E | SEG_F);

//
// Глобальные переменные
//
static uint16_t ledGRID[LED_DATA_LENGTH / 2]; // текущее состояние экрана
static uint8_t currentBrightness = 1;	// текущая яркость
//
//static uint16_t saveGRID[LED_DATA_LENGTH / 2]; // нужно для сохранения состояния экрана на время теста
//static uint8_t saveBrightness;	// нужно для сохранения яркости на время теста
//
//static IRrecv irrecv(PIN_IR);

//
//	Запись одиночной команды в TM1668
//
void writeSingleCommand(const uint8_t command) {
	digitalWrite(PIN_STB, LOW);
	shiftOut(PIN_DIO, PIN_CLK, LSBFIRST, command);
	digitalWrite(PIN_STB, HIGH);
	delayMicroseconds(1); // Пауза до следующей команды
}

//
//	Запись состояния дисплея в TM1668
//
void updateDisplay(void) {
	writeSingleCommand(0x40);  // запись данных, автоматический адрес 0x40
	digitalWrite(PIN_STB, LOW);
	shiftOut(PIN_DIO, PIN_CLK, LSBFIRST, 0xC0); // Установка адреса в 0
	uint8_t * p= (uint8_t *) ledGRID;
	for (int8_t i = 0; i < LED_DATA_LENGTH; i++, p++) shiftOut(PIN_DIO, PIN_CLK, LSBFIRST, *p); // запись данных
	digitalWrite(PIN_STB, HIGH);
	delayMicroseconds(1); // Пауза до следующей команды
}

/*
//
//	Чтение состояния кнопок с TM1668
//
void readKeyData(uint16_t * data) {
	digitalWrite(PIN_STB, LOW);
	shiftOut(PIN_DIO, PIN_CLK, LSBFIRST, 0x42);  // чтение данных 0x42
	pinMode(PIN_DIO, INPUT_PULLUP);
	delayMicroseconds(1);
	* data = shiftIn(PIN_DIO, PIN_CLK, LSBFIRST) + (shiftIn(PIN_DIO, PIN_CLK, LSBFIRST) << 8);
	pinMode(PIN_DIO, OUTPUT);
	digitalWrite(PIN_STB, HIGH);
}
*/

//
// Установить яркость от 0 (выключено) до 8
// (возвращает старую яркость)
//  !!!РАЗОБРАТЬСЯ!!!
static inline uint8_t setBrightness(const uint8_t newBrighness) {
	const uint8_t res = currentBrightness;
	currentBrightness = (newBrighness > 8) ? 8 : newBrighness;
	if (currentBrightness == 0) writeSingleCommand(0x80); // Выключить дисплей
	else writeSingleCommand(0x88 + (currentBrightness - 1)); // Установить яркость
	return res;
}

//
//	Увеличить яркость на 1 (возвращает старую яркость)
//
static inline uint8_t increaseBrightness(void) {
	const uint8_t res = currentBrightness;
	if (currentBrightness < 8) setBrightness(currentBrightness + 1);
	return res;
}

//
//	Уменьшить яркость на 1 (возвращает старую яркость)
//
static inline uint8_t decreaseBrightness(void) {
	const uint8_t res = currentBrightness;
	if (currentBrightness > 0) setBrightness(currentBrightness - 1);
	return res;
}

//
//	Показать тест экрана
// (все символы включены на максимальной яркости)
//
//void showTest(void) {
//	memcpy(saveGRID, ledGRID, sizeof(saveGRID));
//	ledGRID[0] = 0x0FF0;
//	ledGRID[1] = 0x0FF0;
//	ledGRID[2] = 0x0FF0;
//	ledGRID[3] = 0x0FF0;
//	ledGRID[4] = 0x0FF0;
//	ledGRID[5] = 0x0FF0;
//	ledGRID[6] = 0x0FF0;
//	updateDisplay();
//	saveBrightness = setBrightness(8);
//}
//
//	Восстановить экран после теста
//
//void hideTest(void) {
//	memcpy(ledGRID, saveGRID, sizeof(saveGRID));
//	updateDisplay();
//	setBrightness(saveBrightness);
//}

//
//	Показать/скрыть/инвертировать дополнительный символ
//
static inline void showExtraSymbol(const int8_t n) { ledGRID[n] |= symbolMask; }
static inline void hideExtraSymbol(const int8_t n) { ledGRID[n] &= ~symbolMask; }
static inline void invertExtraSymbol(const int8_t n) { ledGRID[n] ^= symbolMask; }

//
//	Показать/скрыть/инвертировать PLAY
//
static inline void showPLAY(void) { showExtraSymbol(pos_PLAY); }
static inline void hidePLAY(void) { hideExtraSymbol(pos_PLAY); }
static inline void invertPLAY(void) { invertExtraSymbol(pos_PLAY); }
//
//	Показать/скрыть/инвертировать REC
//
static inline void showREC(void) { showExtraSymbol(pos_REC); }
static inline void hideREC(void) { hideExtraSymbol(pos_REC); }
static inline void invertREC(void) { invertExtraSymbol(pos_REC); }

//
//	Показать/скрыть/инвертировать USB
//
static inline void showUSB(void) { showExtraSymbol(pos_USB); }
static inline void hideUSB(void) { hideExtraSymbol(pos_USB); }
static inline void invertUSB(void) { invertExtraSymbol(pos_USB); }

//
//	Показать/скрыть/инвертировать DISK
//
static inline void showDISK(void) { showExtraSymbol(pos_DISK); }
static inline void hideDISK(void) { hideExtraSymbol(pos_DISK); }
static inline void invertDISK(void) { invertExtraSymbol(pos_DISK); }

//
//	Показать/скрыть/инвертировать COLON
//
static inline void showCOLON(void) { showExtraSymbol(pos_COLON); }
static inline void hideCOLON(void) { hideExtraSymbol(pos_COLON); }
static inline void invertCOLON(void) { invertExtraSymbol(pos_COLON); }

//
//	Показать/скрыть/инвертировать HDD
//
static inline void showHDD(void) { showExtraSymbol(pos_HDD); }
static inline void hideHDD(void) { hideExtraSymbol(pos_HDD); }
static inline void invertHDD(void) { invertExtraSymbol(pos_HDD); }

//
//	Показать/скрыть/инвертировать LAN
//
static inline void showLAN(void) { showExtraSymbol(pos_LAN); }
static inline void hideLAN(void) { hideExtraSymbol(pos_LAN); }
static inline void invertLAN(void) { invertExtraSymbol(pos_LAN); }

//
//	Показать символ value в позиции digit (0-3)
// при этом, если у цифры горит дополнительный символ, сохраняем его
//
static inline void setSymbol(const int8_t position, uint8_t value) {
	if (position > 3) return; // позиции от 0 до 3. Если не так - нафиг
	constexpr uint16_t digMask[4] = { 0x0200, 0x0100, 0x0080, 0x0040 };
	for (uint8_t i = 0; i < 7; i++) {
		const bool high = value & 1;
		if (high) ledGRID[i] |= digMask[position];
		else ledGRID[i] &= ~digMask[position];
		value >>= 1;
	}
}

//
//	Показать цифру value (0-9) в позиции digit (0-3)
//
static inline void setDigit(const int8_t position, uint8_t value) {
	constexpr static uint8_t digits[] = { SYMBOL_0, SYMBOL_1, SYMBOL_2, SYMBOL_3, SYMBOL_4, SYMBOL_5, SYMBOL_6, SYMBOL_7, SYMBOL_8, SYMBOL_9 };
	if (value > 9) return; // цифра от 0 до 9. Если не так - нафиг
	setSymbol(position, digits[value]);
}

//
//	Показать число m в двух правых цифрах (типа минуты или там секунды)
//
static inline void showMinutes(const int8_t m) {
	setDigit(3, m % 10); // единицы минут
	setDigit(2, m / 10); // десятки минут
}

//
//	Показать число h в двух левых цифрах (типа часы или там минуты)
//
static inline void showHours(const int8_t h) {
	setDigit(1, h % 10); // единицы часов
	setDigit(0, h / 10); // десятки часов
}


//
//	Показать и часы, и минуты
//
static inline void showClock(const int8_t h, const int8_t m) {
	showCOLON();
	showHours(h);
	showMinutes(m);
}

/////////////////////////////////////////////////////////////
////////////    КОНЕЦ "библиотеки" ДЛЯ TM1668    ////////////
/////////////////////////////////////////////////////////////



void setup(void) {
	//
	// Инициализация пинов
	pinMode(PIN_CLK, OUTPUT);
	pinMode(PIN_DIO, OUTPUT);
	pinMode(PIN_STB, OUTPUT);
	pinMode(PIN_IR, INPUT);
	digitalWrite(PIN_STB, HIGH);
	digitalWrite(PIN_CLK, HIGH);
	//
	// Инициализация экрана
	writeSingleCommand(0x03); // Режим отображения (1 и 2 - ничего не меняется)
	setBrightness(currentBrightness);

//	showClock(12, 34); // показать время 12:34
//	updateDisplay();
//	delay(5000);
//	showClock(1, 5); // показать время 01:05
	

	for (uint8_t d = 0; d < 4; d++) {
		for (uint8_t i = 0; i < 10; i++) {
			setDigit(d, i); // выводим 0, 1, 2, ... в позицию d
			updateDisplay();
			delay(1000);
			
		}
		setSymbol(d, 0); // очистить позицию d
		updateDisplay();
	}

}

void loop (void) {}
///// Всё! Веселье закончилось!

Монитором порта пока не пользуюсь, но буду иметь в виду, если опять не получится.

[Andrew8126]

только хотел написать про это, но вы опередили.
да, заработал. идет отсчет с 0 до 9 с 0 по 3 разряды

[ЕвгенийП]

Всё чисто? Без проблем?

[Andrew8126]

Да, проходит тест чисто и гладко. потом экран гаснет

[ЕвгенийП]

Сейчас должно показать время 12:34, потом 5 сек пауза время 01:05 (как я это делаю смотрите строки №№ 310-314).

Если перевраны позиции цифр (типа там минуты вместо часов или единицы вместо десятков), то полезьте в строки №№ 267-278, там увидите позиции в которые выводятся единицы и десятки часов и минут (они у нас от 0 до 3). Измените позиции так, чтобы время показывалось правильно и скопируйте этот кусок для меня, чтобы я у себя поправил.

Я пока займусь выводом 4-значного числа.

Спойлер

#define	PIN_CLK	3
#define	PIN_DIO	2
#define	PIN_STB	4	
#define	PIN_IR	13


/////////////////////////////////////////////////////////////
/////////////    ТИПА "библиотека" ДЛЯ TM1668    ////////////
/////////////////////////////////////////////////////////////

//
// при том подключении, что есть
// достаточно 10 байтов на светодиоды и 2 на кнопки
//
#define	LED_DATA_LENGTH	14
#define	KEY_DATA_LENGTH	2

//
// Маски нажатых кнопок (слева направо)
//
#define KEY_1	0xFF609F
#define KEY_2	0xFF22DD
#define KEY_3	0x0008
#define KEY_4	0x0001

constexpr byte symbolMask = 0x0020;

constexpr byte SEG_A_bit = 0;
constexpr byte SEG_B_bit = 1;
constexpr byte SEG_C_bit = 2;
constexpr byte SEG_D_bit = 3;
constexpr byte SEG_E_bit = 4;
constexpr byte SEG_F_bit = 5;
constexpr byte SEG_G_bit = 6;

constexpr byte SEG_A = 1 << SEG_A_bit;
constexpr byte SEG_B = 1 << SEG_B_bit;
constexpr byte SEG_C = 1 << SEG_C_bit;	
constexpr byte SEG_D = 1 << SEG_D_bit;
constexpr byte SEG_E = 1 << SEG_E_bit;
constexpr byte SEG_F = 1 << SEG_F_bit;
constexpr byte SEG_G = 1 << SEG_G_bit;

// Маска для всех - 0x0020
constexpr byte pos_PLAY = 0;
constexpr byte pos_REC = 1;
constexpr byte pos_USB = 2;
constexpr byte pos_DISK = 3;
constexpr byte pos_COLON = 4; // двоеточие
constexpr byte pos_HDD = 5;
constexpr byte pos_LAN = 6;

//
// Символы (цифры / буквы, можно ещё добавить всяких)
//
constexpr byte SYMBOL_0 = (SEG_A | SEG_B | SEG_C | SEG_D | SEG_E | SEG_F);
constexpr byte SYMBOL_1 = (SEG_B | SEG_C);
constexpr byte SYMBOL_2 = (SEG_A | SEG_B | SEG_D | SEG_E | SEG_G);
constexpr byte SYMBOL_3 = (SEG_A | SEG_B | SEG_C | SEG_D | SEG_G);
constexpr byte SYMBOL_4 = (SEG_B | SEG_C | SEG_F | SEG_G);
constexpr byte SYMBOL_5 = (SEG_A | SEG_C | SEG_D | SEG_F | SEG_G);
constexpr byte SYMBOL_6 = (SEG_A | SEG_C | SEG_D | SEG_E | SEG_F | SEG_G);
constexpr byte SYMBOL_7 = (SEG_A | SEG_B | SEG_C);
constexpr byte SYMBOL_8 = (SEG_A | SEG_B | SEG_C | SEG_D | SEG_E | SEG_F | SEG_G);
constexpr byte SYMBOL_9 = (SEG_A | SEG_B | SEG_C | SEG_D | SEG_F | SEG_G);
;
constexpr byte SYMBOL_MINUS = (SEG_G);
constexpr byte SYMBOL_A = (SEG_A | SEG_B | SEG_C | SEG_E | SEG_F | SEG_G);
constexpr byte SYMBOL_C = (SEG_A | SEG_E | SEG_F | SEG_D);
constexpr byte SYMBOL_E = (SEG_A | SEG_D | SEG_E | SEG_F | SEG_G);
constexpr byte SYMBOL_H = (SEG_B | SEG_C | SEG_E | SEG_F | SEG_G);
constexpr byte SYMBOL_P = (SEG_A | SEG_B | SEG_E | SEG_F | SEG_G);
constexpr byte SYMBOL_G = (SEG_A | SEG_E | SEG_F);
constexpr byte SYMBOL_L = (SEG_D | SEG_E | SEG_F);
constexpr byte SYMBOL_F = (SEG_A | SEG_E | SEG_F | SEG_G);
constexpr byte SYMBOL_d = (SEG_B | SEG_C | SEG_D | SEG_E | SEG_G);
constexpr byte SYMBOL_b = (SEG_C | SEG_D | SEG_E | SEG_F | SEG_G);
constexpr byte SYMBOL_rP = (SEG_A | SEG_B | SEG_C | SEG_E | SEG_F);

//
// Глобальные переменные
//
static uint16_t ledGRID[LED_DATA_LENGTH / 2]; // текущее состояние экрана
static uint8_t currentBrightness = 1;	// текущая яркость
//
//static uint16_t saveGRID[LED_DATA_LENGTH / 2]; // нужно для сохранения состояния экрана на время теста
//static uint8_t saveBrightness;	// нужно для сохранения яркости на время теста
//
//static IRrecv irrecv(PIN_IR);

//
//	Запись одиночной команды в TM1668
//
void writeSingleCommand(const uint8_t command) {
	digitalWrite(PIN_STB, LOW);
	shiftOut(PIN_DIO, PIN_CLK, LSBFIRST, command);
	digitalWrite(PIN_STB, HIGH);
	delayMicroseconds(1); // Пауза до следующей команды
}

//
//	Запись состояния дисплея в TM1668
//
void updateDisplay(void) {
	writeSingleCommand(0x40);  // запись данных, автоматический адрес 0x40
	digitalWrite(PIN_STB, LOW);
	shiftOut(PIN_DIO, PIN_CLK, LSBFIRST, 0xC0); // Установка адреса в 0
	uint8_t * p= (uint8_t *) ledGRID;
	for (int8_t i = 0; i < LED_DATA_LENGTH; i++, p++) shiftOut(PIN_DIO, PIN_CLK, LSBFIRST, *p); // запись данных
	digitalWrite(PIN_STB, HIGH);
	delayMicroseconds(1); // Пауза до следующей команды
}

/*
//
//	Чтение состояния кнопок с TM1668
//
void readKeyData(uint16_t * data) {
	digitalWrite(PIN_STB, LOW);
	shiftOut(PIN_DIO, PIN_CLK, LSBFIRST, 0x42);  // чтение данных 0x42
	pinMode(PIN_DIO, INPUT_PULLUP);
	delayMicroseconds(1);
	* data = shiftIn(PIN_DIO, PIN_CLK, LSBFIRST) + (shiftIn(PIN_DIO, PIN_CLK, LSBFIRST) << 8);
	pinMode(PIN_DIO, OUTPUT);
	digitalWrite(PIN_STB, HIGH);
}
*/

//
// Установить яркость от 0 (выключено) до 8
// (возвращает старую яркость)
//  !!!РАЗОБРАТЬСЯ!!!
static inline uint8_t setBrightness(const uint8_t newBrighness) {
	const uint8_t res = currentBrightness;
	currentBrightness = (newBrighness > 8) ? 8 : newBrighness;
	if (currentBrightness == 0) writeSingleCommand(0x80); // Выключить дисплей
	else writeSingleCommand(0x88 + (currentBrightness - 1)); // Установить яркость
	return res;
}

//
//	Увеличить яркость на 1 (возвращает старую яркость)
//
static inline uint8_t increaseBrightness(void) {
	const uint8_t res = currentBrightness;
	if (currentBrightness < 8) setBrightness(currentBrightness + 1);
	return res;
}

//
//	Уменьшить яркость на 1 (возвращает старую яркость)
//
static inline uint8_t decreaseBrightness(void) {
	const uint8_t res = currentBrightness;
	if (currentBrightness > 0) setBrightness(currentBrightness - 1);
	return res;
}

//
//	Показать тест экрана
// (все символы включены на максимальной яркости)
//
//void showTest(void) {
//	memcpy(saveGRID, ledGRID, sizeof(saveGRID));
//	ledGRID[0] = 0x0FF0;
//	ledGRID[1] = 0x0FF0;
//	ledGRID[2] = 0x0FF0;
//	ledGRID[3] = 0x0FF0;
//	ledGRID[4] = 0x0FF0;
//	ledGRID[5] = 0x0FF0;
//	ledGRID[6] = 0x0FF0;
//	updateDisplay();
//	saveBrightness = setBrightness(8);
//}
//
//	Восстановить экран после теста
//
//void hideTest(void) {
//	memcpy(ledGRID, saveGRID, sizeof(saveGRID));
//	updateDisplay();
//	setBrightness(saveBrightness);
//}

//
//	Показать/скрыть/инвертировать дополнительный символ
//
static inline void showExtraSymbol(const int8_t n) { ledGRID[n] |= symbolMask; }
static inline void hideExtraSymbol(const int8_t n) { ledGRID[n] &= ~symbolMask; }
static inline void invertExtraSymbol(const int8_t n) { ledGRID[n] ^= symbolMask; }

//
//	Показать/скрыть/инвертировать PLAY
//
static inline void showPLAY(void) { showExtraSymbol(pos_PLAY); }
static inline void hidePLAY(void) { hideExtraSymbol(pos_PLAY); }
static inline void invertPLAY(void) { invertExtraSymbol(pos_PLAY); }
//
//	Показать/скрыть/инвертировать REC
//
static inline void showREC(void) { showExtraSymbol(pos_REC); }
static inline void hideREC(void) { hideExtraSymbol(pos_REC); }
static inline void invertREC(void) { invertExtraSymbol(pos_REC); }

//
//	Показать/скрыть/инвертировать USB
//
static inline void showUSB(void) { showExtraSymbol(pos_USB); }
static inline void hideUSB(void) { hideExtraSymbol(pos_USB); }
static inline void invertUSB(void) { invertExtraSymbol(pos_USB); }

//
//	Показать/скрыть/инвертировать DISK
//
static inline void showDISK(void) { showExtraSymbol(pos_DISK); }
static inline void hideDISK(void) { hideExtraSymbol(pos_DISK); }
static inline void invertDISK(void) { invertExtraSymbol(pos_DISK); }

//
//	Показать/скрыть/инвертировать COLON
//
static inline void showCOLON(void) { showExtraSymbol(pos_COLON); }
static inline void hideCOLON(void) { hideExtraSymbol(pos_COLON); }
static inline void invertCOLON(void) { invertExtraSymbol(pos_COLON); }

//
//	Показать/скрыть/инвертировать HDD
//
static inline void showHDD(void) { showExtraSymbol(pos_HDD); }
static inline void hideHDD(void) { hideExtraSymbol(pos_HDD); }
static inline void invertHDD(void) { invertExtraSymbol(pos_HDD); }

//
//	Показать/скрыть/инвертировать LAN
//
static inline void showLAN(void) { showExtraSymbol(pos_LAN); }
static inline void hideLAN(void) { hideExtraSymbol(pos_LAN); }
static inline void invertLAN(void) { invertExtraSymbol(pos_LAN); }

//
//	Показать символ value в позиции digit (0-3)
// при этом, если у цифры горит дополнительный символ, сохраняем его
//
static inline void setSymbol(const int8_t position, uint8_t value) {
	if (position > 3) return; // позиции от 0 до 3. Если не так - нафиг
	constexpr uint16_t digMask[4] = { 0x0200, 0x0100, 0x0080, 0x0040 };
	for (uint8_t i = 0; i < 7; i++) {
		const bool high = value & 1;
		if (high) ledGRID[i] |= digMask[position];
		else ledGRID[i] &= ~digMask[position];
		value >>= 1;
	}
}

//
//	Показать цифру value (0-9) в позиции digit (0-3)
//
static inline void setDigit(const int8_t position, uint8_t value) {
	constexpr static uint8_t digits[] = { SYMBOL_0, SYMBOL_1, SYMBOL_2, SYMBOL_3, SYMBOL_4, SYMBOL_5, SYMBOL_6, SYMBOL_7, SYMBOL_8, SYMBOL_9 };
	if (value > 9) return; // цифра от 0 до 9. Если не так - нафиг
	setSymbol(position, digits[value]);
}

//
//	Показать число m в двух правых цифрах (типа минуты или там секунды)
//
static inline void showMinutes(const int8_t m) {
	setDigit(3, m % 10); // единицы минут
	setDigit(2, m / 10); // десятки минут
}

//
//	Показать число h в двух левых цифрах (типа часы или там минуты)
//
static inline void showHours(const int8_t h) {
	setDigit(1, h % 10); // единицы часов
	setDigit(0, h / 10); // десятки часов
}


//
//	Показать и часы, и минуты
//
static inline void showClock(const int8_t h, const int8_t m) {
	showCOLON();
	showHours(h);
	showMinutes(m);
}

/////////////////////////////////////////////////////////////
////////////    КОНЕЦ "библиотеки" ДЛЯ TM1668    ////////////
/////////////////////////////////////////////////////////////



void setup(void) {
	//
	// Инициализация пинов
	pinMode(PIN_CLK, OUTPUT);
	pinMode(PIN_DIO, OUTPUT);
	pinMode(PIN_STB, OUTPUT);
	pinMode(PIN_IR, INPUT);
	digitalWrite(PIN_STB, HIGH);
	digitalWrite(PIN_CLK, HIGH);
	//
	// Инициализация экрана
	writeSingleCommand(0x03); // Режим отображения (1 и 2 - ничего не меняется)
	setBrightness(currentBrightness);

	showClock(12, 34); // показать время 12:34
	updateDisplay();
	delay(5000);
	showClock(1, 5); // показать время 01:05
	updateDisplay();
	

//	for (uint8_t d = 0; d < 4; d++) {
//		for (uint8_t i = 0; i < 10; i++) {
//			setDigit(d, i); // выводим 0, 1, 2, ... в позицию d
//			updateDisplay();
//			delay(1000);
//			
//		}
//		setSymbol(d, 0); // очистить позицию d
//		updateDisplay();
//	}

}

void loop (void) {}
///// Всё! Веселье закончилось!

[BOOM]

Считаю нужно полноценно оформить тему: какой контроллер, какая библиотека, что менялось и как заработало.

Евгений Петрович, вы не против?

[Andrew8126]

Все верно показывает

[ЕвгенийП]

@BOOM

полноценно оформить тему

Не получится. У этих контроллеров народ распаивает сегменты и разряды куда удобнее, поэтому в каждом изделии будет много своих констант. Например, прежде, чем начать, я у себя посмотрел и увидел, что в 2017 один парень на старом форуме уже просил меня повоевать с этой микросхемой и я тогда также вслепую воевал, но у него другие бита отвечают за разряды и сегменты. Оно ведь как распаяешь, так и будет - только программируй правильно.

[ЕвгенийП]

@Andrew8126

Все верно показывает

Ну, Вы поняли как это делать, да.

Большое (четырёхзначное) число нужно? Или нет? Что-то другое?

[b707]

@ЕвгенийП
Вопрос по коду
А в чем смысл в такой программе делать все функции статик инлайн?
(я не стараюсь подколоть, просто интересно)