Arduino.ru

Коллеги, этот материал для тех, кому попадётся убитый спутниковый ресивер DRS-8300 (он же GS-8300) и захочется использовать его корпус для своих поделок, а также для тех, кому нужен пример подключения микросхемы TM1668 к Ардуино.

Одно время DRS-8300 были весьма популярны, благодаря своей доступности, а сейчас пришло время им отправляться на «утилизацию». Все мои друзья и знакомые используют меня как «предприятие по утилизации отслужившего свой век электронного барахла». Уверен, что у многих коллег по форуму ситуация похожая. Потому решил потратить некоторое время на написание этого материала, в надежде, что он кому-нибудь да пригодится. Да и пример использования TM1668 не помешает, т.к. информации об этой микросхеме в сети не так много.

Итак, достался мне ресивер DRS-8300 во вполне приличном на вид состоянии.

Подумалось, что если выбросить собственно спутниковую начинку (зелёная плата справа), то получим вполне симпатичный корпус, имеющий на борту:

1. шнур «в розетку» с выключателем на задней стороне корпуса;

2. работающий блок питания  на 3,3В, 5В и 24В DC (плата слева). Мощность не проверял – электронная нагрузка разобрана и переделывается, но, судя по дросселям и диодам на плате БП, разумная мощность;

3. работающую переднюю панель с экраном на 4 цифры, двоеточием, четырьмя спец. символами по углам (конвертик, нота, символ питания и символ сигнала), а также с четырьмя кнопками и IR-приёмником для дистанционного пульта;

4. динамик (маленькая писклявка, но именно динамик, а не баззер);

5. девятипиновый DSUB на задней стороне корпуса (остальные разъёмы припаяны к плате ресивера и «уйдут» вместе с нею).

Ну, и, разумеется, мысль: а почему бы не сделать что-то своё в этом корпусе? Но для этого нужно понять как работать с блоком питания и передней панелью.

С блоком проблем нет, на его плате просто подписаны пины разъёма. А вот с передней панелью … вот собственно про это и статья.

Итак, вскрытие показало, что на плате передней панели находится семисегментный индикатор с общим катодом, четыре тактовые кнопки, микросхема TM1668 для управления всем этим добром и, наконец, IR-приёмник.

От передней панели к основной плате идёт 7-пиновый шлейф, оканчивающийся разъёмом JST-EH (мама). Если взять шлейф в руку отверстиями вверх и синей стороной шлейфа к себе,

то распиновка на нём такая (слева направо):

Проще всего работать с инфракрасным приёмником. Подходит библиотека IRremote и практически любой 38 кГц пульт стандарта NEC, например, вот этот, а также все пульты от чего угодно, какие я смог найти у себя дома – коды, конечно, у всех разные, но работают все.

Кнопки же и экран управляются TM1668. Я не буду переписывать здесь весь даташит, отмечу только самые важные моменты.

Микросхема соединяется с МК по трём проводам: CLK, DIO и STB, и поддерживает до 20 (2х10) кнопок и до 70 (7х10) светодиодов с общим чем угодно. STB играет роль «Chip Select».

Вывод на TM1668 осуществляется последовательным интерфейсом, очень похожим на SPI. Всё пересылается младшим битом вперёд (LSBFIRST). Биты считываются на переднем фронте. Собственно SPI нормально работает, если дать ему правильный делитель, т.к. микросхема довольно медленная – импульс часов должен быть не короче 400 наносекунд (это важно, для тех, кто захочет ускорить мой код или использовать SPI – не забывайте!)

К сожалению, ввод информации о нажатых кнопках с SPI не совместим. Он осуществляется по тому же проводу DIO. Нужно передать команду на ввод информации о кнопках, затем переключить DIO на INUP_PULLUP (подтяжка обязательна!!!) и читать информацию также LSBFIRST, но на заднем фронте.

Как видите, здесь возможна ситуация, о которой говорилось выше, при описании подключения пина DIO – с обеих сторон может оказаться OUTPUT, причём в разных состояниях. Для защиты от такой неприятности и сделана схема защиты на полевом транзисторе на плате панели.

Всего на микросхему можно вывести до 14 байтов (7 пар по два байта, в каждых 2-ух байтах использутся 10 бит для 10-сегментного индикатора). Ввести можно до 5 байтов. В устройстве DRS-8300 распаяны не все выводы TM1668, потому я ввожу и вывожу меньшее количество информации в примере, который приведён в конце.

Подключения кнопок и сегментов светодиодного индикатора к ногам TM1668 в принципе можно вызвонить на плате, но я не парился, а просто вычислил их программно (читал и смотрел, что прочитается и, наоборот, подавал и смотрел, что загорается).

В итоге, родился вот такой проверочный скетч. Прошу не искать в нём никакого смысла – ничего разумного он не делает, просто проверяет, что всё работает, всё ли понято правильно.

Подключение к пинам ардуино:

CLK - 13
DIO - 11
STB - 10
IR  - 7

Здесь нет никакой «специализации», можно подключаться к любым другим пинам. Распиновка указана в define в начале скетча.

Скетч при запуске пишет на экране слово «ПОПА», держит его 5 секунд, затем начинает отсчёт секунд. При этом двоеточие гаснет и зажигается раз в полсекунды.

Кнопки (слева направо): 1-ая – уменьшение яркости, вплоть до выключения экрана; 2-ая – увеличение яркости; 3-я – переключение дополнительных символов экрана по кругу; и 4-ая – сброс отсчёта времени в 0.

Наконец, при поступлении команды с дистанционного пульта (любой) выполняется тест экрана – ненадолго зажигаются ВСЕ светодиоды, какие есть, затем экран восстанавливается.

Скетч написан по-быстрому, на коленке и далёк от «образца для подражания», но он даёт пример работы с передней панелью DRS-8300 (особенно с микросхемой TM1668) и, надеюсь, кому-нибудь пригодится.

#include <IRremote.h>

//
//	Подключение пинов
// 	разъём отверстиями кверху и синей стороной шлейфа к себе, тогда рсапиновка:
//		GND	3,3V	CLK	DIO	STB	OUT-IR	5V
//
#define	PIN_CLK	13
#define	PIN_DIO	11
#define	PIN_STB	10	
#define	PIN_IR	7


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

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

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

//
// Подключено 5 "цифр". 
// 0-ая - это двоеточие, залействовано только два младших бита
// 1-4 - собственно цифры слева направо.
// В цифрах задействовано 7 битов под сегменты (с 0-го по 6-ой)
// и 7-ой бит под доплнительный символ (питание, конверт и т.п.) 
//
#define	SEG_A	0x01	// цифры с 1 по 4
#define	SEG_B	0x02	// цифры с 1 по 4
#define	SEG_C	0x04	// цифры с 1 по 4
#define	SEG_D	0x08	// цифры с 1 по 4
#define	SEG_E	0x10	// цифры с 1 по 4
#define	SEG_F	0x20	// цифры с 1 по 4
#define	SEG_G	0x40	// цифры с 1 по 4

#define	SEG_H	0x80 // Дополнительный символ (	// цифры с 1 по 4)
#define	SEG_ENVELOP	SEG_H // только 1-ая цифра
#define	SEG_ANTENNA	SEG_H // только 2-ая цифра
#define	SEG_POWER	SEG_H // только 3-я цифра
#define	SEG_MUSIC	SEG_H // только 4-ая цифра

#define	SEG_UDOT	0x01	// Верхняя точка двоеточия (только 0-ая цифра)
#define	SEG_LDOT	0x02	// Нижняя точка двоеточия (только 0-ая цифра)
#define	SYMBOL_COLON	(SEG_UDOT | SEG_LDOT)	// Двоеточие (только 0-ая цифра)

//
// Символы (цифры / буквы, можно ещё добавить всяких)
//
#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 uint8_t digits[] = { SYMBOL_0, SYMBOL_1, SYMBOL_2, SYMBOL_3, SYMBOL_4, SYMBOL_5, SYMBOL_6, SYMBOL_7, SYMBOL_8, SYMBOL_9 };
//
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);  // запись данных, автоматический адрес
	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);  // чтение данных
	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] = 3;
	ledGRID[1] = 0xFF;
	ledGRID[2] = 0xFF;
	ledGRID[3] = 0xFF;
	ledGRID[4] = 0xFF;
	updateDisplay();
	saveBrightness = setBrightness(8);
}
//
//	Восстановить экран после теста
//
void hideTest(void) {
	memcpy(ledGRID, saveGRID, sizeof(saveGRID));
	updateDisplay();
	setBrightness(saveBrightness);
}

//
//	Показать/скрыть/инвертировать дополнительный символ на цифре n
// Одополнительные символы по цифрам:
// 	1-ая - конверт
// 	2-ая - сигнал (антенна), а может громоксть?
// 	3-я  - значок питания
// 	4-ая - нота (типа музыка)
//
static inline void showExtraSymbol(const int8_t n) { ledGRID[n] |= SEG_H; }
static inline void hideExtraSymbol(const int8_t n) { ledGRID[n] &= ~SEG_H; }
static inline void invertExtraSymbol(const int8_t n) { ledGRID[n] ^= SEG_H; }

//
//	Показать/скрыть/инвертировать конверт
//
static inline void showEnvelope(void) { showExtraSymbol(1); }
static inline void hideEnvelope(void) { hideExtraSymbol(1); }
static inline void invertEnvelope(void) { invertExtraSymbol(1); }

//
//	Показать/скрыть/инвертировать антенну
//
static inline void showAntenna(void) { showExtraSymbol(2); }
static inline void hideAntenna(void) { hideExtraSymbol(2); }
static inline void invertAntenna(void) { invertExtraSymbol(2); }

//
//	Показать/скрыть/инвертировать символ питания
//
static inline void showPower(void) { showExtraSymbol(3); }
static inline void hidePower(void) { hideExtraSymbol(3); }
static inline void invertPower(void) { invertExtraSymbol(3); }

//
//	Показать/скрыть/инвертировать ноту
//
static inline void showMusic(void) { showExtraSymbol(4); }
static inline void hideMusic(void) { hideExtraSymbol(4); }
static inline void invertMusic(void) { invertExtraSymbol(4); }

//
//	Показать/скрыть/инвертировать верхнюю точку двоеточия
//
static inline void showUpperDot(void) { ledGRID[0] |= SEG_UDOT; }
static inline void hideUpperDot(void) { ledGRID[0] &= ~SEG_UDOT; }
static inline void invertUpperDot(void) { ledGRID[0] ^= SEG_UDOT; }

//
//	Показать/скрыть/инвертировать нижнюю точку двоеточия
//
static inline void showLowerDot(void) { ledGRID[0] |= SEG_LDOT; }
static inline void hideLowerDot(void) { ledGRID[0] &= ~SEG_LDOT; }
static inline void invertLowerDot(void) { ledGRID[0] ^= SEG_LDOT; }

//
//	Показать/скрыть/инвертировать двоеточие
//
static inline void showColon(void) { ledGRID[0] |= SYMBOL_COLON; }
static inline void hideColon(void) { ledGRID[0] &= ~SYMBOL_COLON; }
static inline void invertColon(void) { ledGRID[0] ^= SYMBOL_COLON; }

//
//	Показать цифру value (0-9) в позиции digit (1-4)
// при этом, если у цифры горит дополнительный символ, сохраняем его
//
static inline void setDigit(const int8_t digit, const uint8_t value) {
	if (digit < 1 || digit > 4) return; // цифры у нас с 1-ой по 4-ую слева направо
	ledGRID[digit] = value | (ledGRID[digit] & SEG_H); // не обижать дополнительный символ, если есть
}

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

//
//	Показать число h в двух левых цифрах (типа часы или там минуты)
//
static inline void showHours(const int8_t h) {
	setDigit(2, digits[h % 10]);
	setDigit(1, digits[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);
	//
	// Пишем на экране слово ПОПА
	setDigit(1, SYMBOL_rP);
	setDigit(2, SYMBOL_0);
	setDigit(3, SYMBOL_rP);
	setDigit(4, SYMBOL_A);
	updateDisplay();
	//
	// Даём 5 секунд полюбоваться
	delay(5000);
	//
	// Рисуем нулевое время
	showClock(0, 0);
	showColon();
	updateDisplay();
	//
	//  Приступаем к слушанию "эфира"
	irrecv.enableIRIn(); // Слушаем пульт
}

//
//	Функция обработки кнопки №3
// Гасит текущий доп. символ и зажигает следующий
//
static void swicthExtraSymbol(void) {
	static int8_t extraSymbol = 0;
	if (extraSymbol) ledGRID[extraSymbol] &= ~SEG_H; 
	extraSymbol = (extraSymbol + 1) % 5;
	if (extraSymbol) ledGRID[extraSymbol] |= SEG_H; 
}

void loop(void) {
	static int8_t m = 0, s = 0;	// минуты и секунды для показа
	static uint32_t oldMillis = 0;	// запомненное состояние счётчика миллисекунд
	static bool alreadyBlinked = false;	// флаг. Если true, то на этой секунде двоеточием уже мигали
	bool haveToUpdate = false;	// Если true, то в конце нужно обновить экран
	
	const uint32_t currMillis = millis();
	const uint32_t diffMillis = currMillis - oldMillis;

	//
	// Двоеточием мигаем вдвое чаще, чем меняются цифры
	//
	if (! alreadyBlinked && diffMillis >= 500) {
		invertColon();
		haveToUpdate = true;
		alreadyBlinked = true;
	}

	//
	//	Пришла пора сменить цифру
	//
	if (diffMillis >= 1000) {
		s++;
		if (s == 60) {
			s = 0;
			m = (m + 1) % 60;
		}
		showClock(m, s);
		invertColon();
		haveToUpdate = true;
		alreadyBlinked = false;
		oldMillis = currMillis;
	}

	//
	//	Читаем состояние кнопок
	// и отрабатываем команды
	//
	static uint16_t keys = 0;
	uint16_t newKeys;
	readKeyData(& newKeys);
	if (keys != newKeys) {
		keys = newKeys;
		if (keys & KEY_1) {	// уменьшить яркость
			decreaseBrightness();
		}
		if (keys & KEY_2) {	// увеличить яркость
			increaseBrightness();
		}
		if (keys & KEY_3)	{	// включить следующий доп. символ
			swicthExtraSymbol(); 
			haveToUpdate = true;
		}
		if (keys & KEY_4)  {	// сбросить время в 0
			m = 0; 
			s = 0; 
			showClock(m, s);
			haveToUpdate = true;
			oldMillis = currMillis;
		}
	}

	//
	// Если пришла команда с пульта (любая, кроме символа повтора),
	// Показываем тест экрана
	//
	decode_results results;
	if (irrecv.decode(&results)) {
		if (results.value != 0xFFFFFFFFUL) {
			showTest();
			delay(1000);
			hideTest();
		}
		irrecv.resume();
	}

	if (haveToUpdate) updateDisplay(); // Обновляем экран, если нужно
}

///// Всё! Веселье закончилось!

Вот, как всё это работает:

Тест экрана - горят все светодиода, какие есть

Ну, вот, теперь у меня есть хороший корпус с питанием, передней панелью – можно для чего-нибудь приспособить!