Семисегментный LED-индикатор. Эффекты анимации

[MLX90640]

Автор желает прочитать значение бита в исходном байте и перенести это значение в байт результата. То есть, бит-ориентированные действия желает провести.
На языке Си (поскольку он байт-ориентированный) чтение бита выполняется опять же через логическую операцию AND с байтом, в котором содержится бит, и маской, в которой записана 1 в позиции читаемого бита. Запись бита в байт производится логической операцией OR, если записывается 1, или операцией AND, если записывается 0. Однако, если записываемом бейте в позиции этого бита находится 0, то операцию AND можно не применять. Операция 0 OR 0 = 0.

Записать всё в сумме можно в таком варианте:

Код: Выделить всё

result |= ((DDRB & (1<<Rbit)) >> Rbit) << Wbit;

, где Rbit - номер позиции читаемого бита в байте DDRB,
Wbit - номер позиции записываемого бита в байт result.
(1<<Rbit) выдает маску из 0 во всех битах, кроме бита номер Rbit, который будет = 1. Эта маска будет наложена на байт DDRB, при этом результат операции будет содержать значение читаемого бита в позиции номер Rbit. Чтобы записать его в байт result в позиции Wbit, нужно провести сдвиги, сначала вправо на число позиций Rbit, затем влево на число позиций Wbit.

Второй вариант с несколько иным алгоритмом, используя проверку true/false при чтении бита.

Код: Выделить всё

result = (DDRB & (1 << Rbit)) ? result | (1 << Wbit) : result & ~(1 << Wbit);

Тут сложность в понимании того, что используется так называемый тренарный оператор условия. Суть в чем. То, что записано после знака "=" и перед знаком "?" является условием сравнения и аналогично записи if(DDRB & Rbit).
Следующие после "?" два выражения, разделенные знаком ":" являются действиями, исполняемыми по условию предыдущего сравнения. Первое выражение будет выполняется, если результат сравнения "истина" (true), второе выражение выполнится если результат сравнения "ложь" (false), и результат выражений запишется в первую переменную до знака "=", то есть в result. Напомню, что результат сравнения "истина" получается при любом ненулевом значении выражения, а результат "ложь" - при нулевом. То есть, если при выполнении побитовой операции AND получились все нули, то выражение ложно. Если хоть в какой-то позиции есть 1, то результат "истина".
Таким образом, если при чтении бита с номером Rbit там стоит 1, то в result она перенесется в позиции Wbit, а если прочитанный бит = 0, то в result запишется 0 в позиции Wbit.

И третий вариант записи - через структуры с восемью однобитовыми полями. В этом случае запись на Си будет более понятной, типа result.bit2 = DDRB.bit5;

[Dimon456]

Тут сложность в понимании того, что используется так называемый тренарный оператор условия.

Что, проще нет что ли? Давайте предоставим все это компилятору.

Спойлер

Код: Выделить всё

union BytByte {
struct {
unsigned char b0: 1;
unsigned char b1: 1;
unsigned char b2: 1;
unsigned char b3: 1;
unsigned char b4: 1;
unsigned char b5: 1;
unsigned char b6: 1;
unsigned char b7: 1;
} bit;
volatile uint8_t byte;
}__attribute__((packed));

union BytByte myBByte;

union BytByte rezultat;

	myBByte.byte = DDRB;

	rezultat.bit.b0 = myBByte.bit.b1;
	rezultat.bit.b7= myBByte.bit.b0;
	rezultat.bit.b1 = myBByte.bit.b2;
	// и так далее
	rezultat.byte // здесь будет результат

[MLX90640]

Вы не дочитали до конца - я как раз и написал, что есть вариант со структурами и однобитными полями.

[Serzh2000]

Спойлер

//ATMEGA328

//ВЫВОДЫ ATMEGA328 НА СЕГМЕНТЫ
#define A 1
#define B 2
#define C 4
#define D 8
#define E 16
#define F 32
#define G 64

int h1,h0,m1,m0; // h1 - десятки часов, h0 - еденицы часов и так далее
unsigned char digit_out[4], // буфер экрана (нумерация от 0 до 3 плюс четвертый невидимый разряд)
cur_dig; // тек.высвечиваемый символ (позиция)

unsigned char digits[] = {
(A+B+C+D+E+F), // 0
(B+C), // 1
(A+B+D+E+G), // 2
(A+B+C+D+G), // 3
(B+C+F+G), // 4
(A+C+D+F+G), // 5
(A+C+D+E+F+G), // 6
(A+B+C), // 7
(A+B+C+D+E+F+G), // 8
(A+B+C+D+F+G) // 9
};

byte mask = 0xFF;
void setup() {
DDRD = 0xFF; // порт D на OUTPUT
DDRB = 0xFF; // порт B на OUTPUT
cli();
TCCR1A = 0b00000000; // OC1A Отключен
TCCR1B = 0b00001011; // делитель 64, сброс при совпадении 1A (режим СТС)
OCR1A = 0x041; // 5ms
TIMSK1 = 0b0000010; // запусе прерывания А таймера 1
sei();

}
void loop() {


////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
h1=2; //тут будем читать потом время
h0=1;
m1=5;
m0=8;
for (int i =0; i<7;++i){ // это сколько кадров

if (i==0) mask=F; // первый эффект
if (i==1) mask=F+A;
if (i==2) mask=F+A+B;
if (i==3) mask=F+A+B+G;
if (i==4) mask=F+A+B+G+E;
if (i==5) mask=F+A+B+G+E+D;
if (i==6) mask=F+A+B+G+E+D+C;
if (i==7) mask=F+A+B+G+E+D+C+D;

digit_out[0] = h1; // первай разряд
digit_out[1] = h0; // второй разряд
digit_out[2] = m1; // третий разряд
digit_out[3] = m0; // четвертый разряд


delay(20);
}
delay(100);
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

h1=2; //тут будем читать потом время
h0=0;
m1=4;
m0=7;
for (int i =0; i<5;++i){ // это сколько кадров

if (i==0) mask=A; // второй эффект
if (i==1) mask=A+F+B;
if (i==2) mask=A+F+B+G;
if (i==3) mask=A+F+B+G+E+C;
if (i==4) mask=A+F+B+G+E+C+D;


digit_out[0] = h1; // первай разряд
digit_out[1] = h0; // второй разряд
digit_out[2] = m1; // третий разряд
digit_out[3] = m0; // четвертый разряд


delay(40);
}
delay(100);
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
ISR(TIMER1_COMPA_vect) { //обработчик прерывания по совпадению А таймера 1, счетчик сбрасывается в 0

PORTD&=0b11110000; // потушить все (разряды - off)
PORTB=digits[digit_out[cur_dig]]& mask; // символ на экран
PORTD |= (1<<cur_dig); // засветить нужный разряд (бит знакоместа - on)

cur_dig++; if (cur_dig > 3) {
cur_dig = 0;

}
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

правильно я Вас понял или нет, НО получилось !!!
спасибо Вам за учебу, терпение и доброту

[Demiurg]

Молодца!!! Захотел. Сделал.

[Serzh2000]

с анимацией цифр понятно



а как чтоб они ездили туда-суда?



может кто подкинет идею, совет, предложение любой помощи буду рад.

[MLX90640]

А это так называемая "бегущая строка". И есть два пути. Второй из них заключается в том, чтобы при сдвиге цифр влево просто переносить байты цифр в буфере дисплея левее, начиная слева. Допустим, есть буфер
buf[4], в котором buf[0] - самый левый разряд, а buf[3] - самый правый. Так вот, каждый шаг анимации бегущей строки будет представлен шагами:
- копируем из buf[1] в buf[0],
- копируем из buf[2] в buf[1],
- копируем из buf[3] в buf[2],
- в buf[3] записываем "пустой символ".
И так - 4 раза. Всё число "уйдет" с дисплея влево. А чтобы новое число "вошло" справа налево, нужно в последнем пункте вместо "пустого" символа записать символ "вдвигаемого" числа, начиная с левого его края.

Первый же способ делается на указателях. В этом случае ничего не копируется, инкрементируется только указатель на начало отображения строки в дисплей, сдвигаясь по строке. То есть, допустим, есть строка chat txt[4+4], которую нужно сдвинуть по дисплею влево. Эта строка должна быть вдвое длиннее количества разрядов на дисплее, и в последних четырех байтах содержать "пустой" символ. Функция, принимающая строку для отображения в дисплей, будет брать строку txt[], смещаясь по ней на одну позицию вправо, от начала к концу.

[Serzh2000]

Второй из них заключается в том, чтобы при сдвиге цифр влево просто переносить байты цифр в буфере дисплея левее, начиная слева. Допустим, есть буфер
buf[4], в котором buf[0] - самый левый разряд, а buf[3] - самый правый. Так вот, каждый шаг анимации бегущей строки будет представлен шагами:

да, этот способ я опробовал и он работает, но если бы выводить на экран два показания, скажем часы и температуру. а если выводить несколько показаний часы, несколько температур, день недели...
я не соображу как это написать вместо h1(часы) ,t1(температуру) d1(день )...

Спойлер

for (byte i =0; i<4;++i){ // это сколько кадров

unsigned int AA[] = { 0, 0, 0,h1}; // h1- десятки часов
unsigned int BB[] = { 0, 0,h1,h0}; // h0- еденицы часов
unsigned int CC[] = { 0,h1,h0,m1}; // m1- десятки минут
unsigned int DD[] = {h1,h0,m1,m0}; // m0- еденицы минут


digit_out[0] = AA; //высветить первый разряд
digit_out[1] = BB; //высветить второй разряд
digit_out[2] = CC; //высветить третий разряд
digit_out[3] = DD; //высветить четвертый разряд

delay(100);
}

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

Код: Выделить всё

ISR(TIMER1_COMPA_vect) {      //обработчик прерывания по совпадению А таймера 1, счетчик сбрасывается в 0
 
 PORTD&=0b11110000;                   // потушить все (разряды - off)
 PORTB=digits[digit_out[cur_dig]]&maska;     // символ на экран
 PORTD |= (1<<cur_dig);    // засветить нужный разряд (бит знакоместа - on)

 cur_dig++; if (cur_dig > 3) {
    cur_dig = 0;

    }
  }

в принципе сделать 8 разрядов не сложно, но опять же я не пойму как написать , что высвечивать этим разрядам
если изображение меняется

[MLX90640]

Для разрядов индикатора нужно создать отдельный буфер, не привязанный к часам-минутам или температуре. Вот так: byte buf[4]; Из этого буфера динамичская индикация берет очередное значение для зажигания сегментов в очередном разряде. И в этот же буфер бубут ложиться значения сегментов другой функцией, которая называется LED_Print и выполняет преобразование входного числа в комбинацию зажигаемых сегментов.
Вот так:

Код: Выделить всё

/* кодирование сегментов в байте */
#define SEG_A		(1 << 0)
#define SEG_B		(1 << 1)
#define SEG_C		(1 << 2)
#define SEG_D		(1 << 3)
#define SEG_E		(1 << 4)
#define SEG_F		(1 << 5)
#define SEG_G		(1 << 6)
#define SEG_dp		(1 << 7)

/* символы шрифта */
#define BLANK		0
#define CH_0		(SEG_A | SEG_B | SEG_C | SEG_D | SEG_E | SEG_F        )
#define CH_1		(        SEG_B | SEG_C                                )
#define CH_2		(SEG_A | SEG_B |         SEG_D | SEG_E         | SEG_G)
#define CH_3		(SEG_A | SEG_B | SEG_C | SEG_D                 | SEG_G)
#define CH_4		(        SEG_B | SEG_C                 | SEG_F | SEG_G)
#define CH_5		(SEG_A         | SEG_C | SEG_D         | SEG_F | SEG_G)
#define CH_6		(SEG_A         | SEG_C | SEG_D | SEG_E | SEG_F | SEG_G)
#define CH_7		(SEG_A | SEG_B | SEG_C                                )
#define CH_8		(SEG_A | SEG_B | SEG_C | SEG_D | SEG_E | SEG_F | SEG_G)
#define CH_9		(SEG_A | SEG_B | SEG_C | SEG_D         | SEG_F | SEG_G)

#define CH_DASH		(                                                SEG_G)
#define CH_DNDASH	(                        SEG_D                        )

const uint8_t font[] =
{CH_0, CH_1, CH_2, CH_3, CH_4, CH_5, CH_6, CH_7, CH_8, CH_9};

#define NUM_DIG			4		// число разрядов в индикаторе
static uint8_t buf[NUM_DIG];  // буфер хранения данных о сегментах в разрядах

/** -------------------------------------------------------
 * @brief	Преобразование текстовой строки в данные для сегментов
 * 			индикатора.
 * @param *str - входная текстовая строка в кодировке ANSI
 * @param len - длина строки
 */
void DND_Print(char *str, uint8_t len)
{
	uint8_t digit = 0;
	uint8_t dotsign[NUM_DIG] = {0, 0, 0, 0};

	/* преобразование текстовой строки */
	while(len--)
	{
		switch(*str){
		/* цифры */
		case '0' ... '9':
			buf[digit] = font[*str - '0'];
			break;


		/* тире */
		case '-': buf[digit] = CH_DASH;
			break;
		case '_': buf[digit] = CH_DNDASH;
			break;
		/* десятичные точки*/
		case '.':
		case ',':
			/* для индикатора с разделительным двоеточием */
			if(digit == 2)
			{
				dotsign[3] = SEG_dp;
			}
			digit--;
			break;
		/* разделительные точки */
		case ':':
			/* для индикатора с разделительным двоеточием */
			if(digit == 2)
			{
				dotsign[2] = SEG_dp;
				dotsign[3] = SEG_dp;
			}
			digit--;
			break;
		default: buf[digit] = BLANK;
		}
	str++;				// следующий символ в строке
	digit++;			// следующий разряд
	if(digit > NUM_DIG) break;
	}

	/* добавление признака точек в разряды*/
	for(digit = 0; digit < NUM_DIG; digit++)
	{
		buf[digit] |= dotsign[digit];
	}
}

Работа динамической индикации обеспечивается вот этой функцией, вызываемой через равные промежутки времени по прерыванию таймера:

Код: Выделить всё

/** -------------------------------------------------------
 * @brief	Поразрядное переключение шагов динамической индикации.
 */
#ifdef USE_SEGMENT_ANIMATION
  #include "fx.h"
#endif
void DND_DynaScan(void)
{
	static uint8_t digit = 0;

#ifdef USE_SEGMENT_ANIMATION
	uint8_t mask;

	mask = DND_SegAnimation_GetMask(digit);
	DND_DigitOut(digit, buf[digit] & mask);
#else
	DND_DigitOut(digit, buf[digit]);  // для варианта без анимации сегментов
#endif

	digit++;
	if(digit >= NUM_DIG) digit = 0;
}

А вывод текстовой строки на дисплей выглядит вот так:

Код: Выделить всё

DND_Print("1259", 4);  // фиксированная текстовая строка в формате ANSI

или

Код: Выделить всё

	char str[10];
	uint8_t len;

	len = sprintf(str, "%02d:%02d", current_time.tm_hour, current_time.tm_min);
	DND_Print(str, len);

функция sprintf является стандартной и выполняет форматированное преобразование чисел в ANSI-кодированный текст. В принципе, для нужд часов можно обойтись простым преобразованием числа в ANSI-строку любым доступным способом.

Добавлено after 10 minutes 42 seconds:
Да... Если всё написанное выше слишком сложно для понимания, то можно существенно упростить функции, сделав их по-топорному, вот так:

Код: Выделить всё

/* кодирование сегментов для цифр такое же как выше */
const uint8_t font[] =
{CH_0, CH_1, CH_2, CH_3, CH_4, CH_5, CH_6, CH_7, CH_8, CH_9};

/* Преобразование чисел от 0 до 9 в сегменты индикатора */
void DND_Print(byte d0, byte d1, byte d2, byte d3)
{
	buf[0] = font[d0];
	buf[1] = font[d1];
	buf[2] = font[d2];
	buf[3] = font[d3];
}

и тогда вы в эту функцию просто передаете 4 обезличенных числа в своих знакоместах, и не важно, десятки ли это минут или единицы градусов.

[Serzh2000]

переварю/подумаю

[MLX90640]

Да, это довольно сложно для восприятия. Тут надо неплохо знать язык программирования Си. Впрочем, можно упростить. Я там добавил немного

[Demiurg]

Дело не в си, или каком другом языке. Алгоритмы. Потом реализация.

[Serzh2000]

Да... Если всё написанное выше слишком сложно для понимания, то можно существенно упростить функции, сделав их по-топорному,

никак не въеду в суть "по-топорному" можно еще по подробнее разжевать этот метод, в чем тут смысл

[MLX90640]

А смысл как бы вот в том, что... Вот определили мы комбинации битов для зажигания сегментов в цифрах
#define CH_0 (SEG_A | SEG_B | SEG_C | SEG_D | SEG_E | SEG_F )
теперь, чтобы попроще сделать выбор этих комбинаций, создаем массив из десяти однобайтных переменных и сразу в этот массив кладем вышеопределенные комбинации:
const uint8_t font[10] = {CH_0, CH_1, CH_2, CH_3, CH_4, CH_5, CH_6, CH_7, CH_8, CH_9};
Таким образом, получается, что например 5-й элемент массива font[5] содержит комбинацию сегментов для цифры 5. И теперь получается прямая зависимость между числом единиц или десятков с комбинациями для зажигания сегментов в разрядах.
То есть, если например число десятков часов dHour = 5, то отобразить цифру 5 можно просто выбрав 5-й индекс в массиве, вот так:
Port = font[dHour];
В Port будет передано значение из пятого элемента массива font[].

Функция void DND_Print(byte d0, byte d1, byte d2, byte d3) принимает числовые значения d0, d1, d2, d3 в диапазоне 0-9 для каждого разряда (цифры, которые нужно на дисплей вывести), преобразует эти числа показанным выше методом в комбинации сегментов и кладет в массив переменных buf[4], из которого потом в нужные моменты переключения разрядов функция DND_DynaScan() забирает уже готовые комбинации для передачи в выходной порт для зажигания сегментов.
Такой алгоритм через промежуточный буфер buf[] сделан для того, чтобы разделить работу динамической индикации, непрерывно через интервалы читающей значения зажигаемых сегментов из buf[], и функции, преобразующей любые числа в комбинации сегментов. То есть, для этих функций не имеет значения, что именно отображается - часы с минутами, температура, дата или еще что.
Задачу разложения целого числа из переменной в поразрядное представление от 0 до 9 - это будет выполнять другая функция.

[Ivanoff-iv]

Тоже так делаю, но ради автоматизации знакогенератора - если окажется удобнее развести контакты порта по сегментам не по порядку, пожалуйста, разводи как удобно, но в коде, вот в этом месте, пропиши цифры в соответствии с разводкой, например:

Код: Выделить всё

#define SEG_A      (1 << 5)
#define SEG_B      (1 << 7)
#define SEG_C      (1 << 0)
#define SEG_D      (1 << 3)
#define SEG_E      (1 << 1)
#define SEG_F      (1 << 4)
#define SEG_G      (1 << 6)
#define SEG_dp     (1 << 2)

и весь знакогенератор,
(а у меня он обычно гораздо шире, чем 10 цифр... цифры лежат в массиве, остальное вызывается по дефайну, в т.ч. и сегменты по отдельности)
вобщем всё будет автоматически пересчитано, перерисовано и приведено в соответствие со схемой!

Добавлено after 1 minute 23 seconds:
поэтому я этот код выделил в отдельный файл и целиком его из проекта в проект таскаю...

Добавлено after 33 minutes 24 seconds:
Вот примерное содержание файлов:
SETUP.C

Спойлер

Код: Выделить всё

//Setup
#define DisablePWM       //отключение ШИМ выходов (мне для протеуса)
#define EnDebug          //включение порта отладки (reset) мне для протеуса

//полярность дисплеев
#define DISPLAY_U_CC   //#define DISPLAY_U_CA или #define DISPLAY_U_CC при отсутствии - автоопределение
#define DISPLAY_I_CC   //#define DISPLAY_I_CA или #define DISPLAY_I_CC при отсутствии - автоопределение
//соответствие сегмента и номера ноги порта D
#define Seg_A       5  //0
#define Seg_B       0  //1
#define Seg_C       1  //2
#define Seg_D       6  //3
#define Seg_E       7  //4
#define Seg_F       2  //5
#define Seg_G       3  //6
#define Seg_P       4  //7

//#define ShowLogo       //показать лого
..........
..........

в этом файле служебные и отладочные настройки проекта (файл показан не весь, там дальше прописаны длительности задержек, количество импульсов и прочее... закомментированные номера - в соответствии с отладочной платой, подставленые - с прототипом)
Если проект делается для кого-то, то этот кто-то допускается только в этот файл.

7SEG.C

Спойлер

Код: Выделить всё

//Digits
//Описание цифр семисегментного индикатора и функции, связанные с экраном

//расстановка единиц в маске
#define _A_  (1<<Seg_A)
#define _B_  (1<<Seg_B)
#define _C_  (1<<Seg_C)
#define _D_  (1<<Seg_D)
#define _E_  (1<<Seg_E)
#define _F_  (1<<Seg_F)
#define _G_  (1<<Seg_G)
#define _P_  (1<<Seg_P)
#define ___  (0       )

//знакогенератор
#define _0  (_A_|_B_|_C_|_D_|_E_|_F_|___)
#define _1  (___|_B_|_C_|___|___|___|___)
#define _2  (_A_|_B_|___|_D_|_E_|___|_G_)
#define _3  (_A_|_B_|_C_|_D_|___|___|_G_)
#define _4  (___|_B_|_C_|___|___|_F_|_G_)
#define _5  (_A_|___|_C_|_D_|___|_F_|_G_)
#define _6  (_A_|___|_C_|_D_|_E_|_F_|_G_)
#define _7  (_A_|_B_|_C_|___|___|___|___)
#define _8  (_A_|_B_|_C_|_D_|_E_|_F_|_G_)
#define _9  (_A_|_B_|_C_|_D_|___|_F_|_G_)
#define _A  (_A_|_B_|_C_|___|_E_|_F_|_G_)
#define _B  (___|___|_C_|_D_|_E_|_F_|_G_)
#define _c  (___|___|___|_D_|_E_|___|_G_)
#define _C  (_A_|___|___|_D_|_E_|_F_|___)
#define _D  (___|_B_|_C_|_D_|_E_|___|_G_)
#define _E  (_A_|___|___|_D_|_E_|_F_|_G_)
#define _F  (_A_|___|___|___|_E_|_F_|_G_)
#define _G  (_A_|_B_|___|___|___|_F_|_G_)   //°
#define _U  (___|_B_|_C_|_D_|_E_|_F_|___)   
#define _t  (___|___|___|_D_|_E_|_F_|_G_)   
#define _P  (_A_|_B_|___|___|_E_|_F_|_G_)
#define _r  (___|___|___|___|_E_|___|_G_)   
#define _o  (___|___|_C_|_D_|_E_|___|_G_)
#define _n  (___|___|_C_|___|_E_|___|_G_)   
#define _Z  (___|___|___|___|___|___|___)   //выкюченный разряд
#define _N  (___|___|___|___|___|___|_G_)   // "-"

const unsigned char DIG[]={_0,_1,_2,_3,_4,_5,_6,_7,_8,_9};
//flash unsigned char DIG[]={_0,_1,_2,_3,_4,_5,_6,_7,_8,_9,_a,_b,_C,_d,_e,_f};

#if (defined(DISPLAY_U_CC) && defined(DISPLAY_U_CA))
#error "Conflict on DISPLAY_U mode"
#endif
#if (defined(DISPLAY_I_CC) && defined(DISPLAY_I_CA))
#error "Conflict on DISPLAY_I mode"
#endif
.......
.......

начало файла, работающего с 7 сегментным индикатором... далее идут процедуры гашения и зажигания разряда дисплея, они работают только с буфером дисплея и портами выводящими информацию на индикатор
остальной код, в т.ч. и код, реализующий спецэффекты, работает только с буфером.

[MLX90640]

Я тоже тут не полный код привожу, потому как в полном виде он будет слишком сложен для понимания автором вопроса. Я уже и без того упростил до минимально разумного варианта.

Есть два способа адаптации под распиновку: либо менять цифры (положение битов) в знакогенераторе, либо записать функцию вывода таким образом, чтобы она преобразовывала входную комбинацию из знакогенератора в выходную комбинацию на порты. Годится любой способ, в зависимости от того, нужно ли сделать более оптимальную работу кода или более универсальную библиотеку. Для случая посегментной анимации пересчитывать положение битов в знакогерераторе и в картах сегментной анимации - это уж не шибко кошерно, потому что есть еще одно, частное ограничение - сегменты могут быть разведены не на одном порту, а на разных. На том же STM32 у вас не шибко то большой выбор последовательно расположенных портов на 8 выходов. Да и то, часть из нужных выходов могут быть занятыми другими не менее важными функциями. Например, SPI1 как назло вклинивается в PA5-PA7. Так что полюбасу понадобится функция "перепиновки", так сказать. Посему, знакогенератор желателен независимый от распиновки индикатора. Но это на вкус и цвет. Комуто хватает и просто заменить цифры в дефайнах знакогенератора.

Буквы на семисегментнике отображать не особо весело. Я работал с 16-сегментными ЖКД, вот там замечательно буквы показываются. Но тем не менее, на 7-сегментном тоже можно. Лично я использую массив const с символами цифр и букв, а за основу беру парсер ANSI-строки:

Код: Выделить всё

		switch(*str){
		/* цифры */
		case '0' ... '9':
			buf[digit] = font[*str - '0'];
			break;

#ifdef USE_LETTERS
		/* буквы */
		case 'A' ... 'U':
			buf[digit] = font[*str - 'A' + 10];
			break;
		case 'a' ... 'u':
			buf[digit] = font[*str - 'a' + 10];
			break;
#endif

		/* тире */
		case '-': buf[digit] = CH_DASH;
			break;
		case '_': buf[digit] = CH_DNDASH;
			break;
		/* десятичные точки*/
		case '.':
		case ',':
			/* для индикатора с разделительным двоеточием */
			if(digit == 2)
			{
				dotsign[3] = SEG_dp;
			}
			digit--;
			break;
		/* разделительные точки */
		case ':':
			/* для индикатора с разделительным двоеточием */
			if(digit == 2)
			{
				dotsign[2] = SEG_dp;
				dotsign[3] = SEG_dp;
			}
			digit--;
			break;
		default: buf[digit] = BLANK;

[Serzh2000]

что касается портов вся ясно

Спойлер

#define A 1
#define B 4
#define C 16
#define D 64
#define E 128
#define F 2
#define G 8

static flash unsigned char digits[] = {
(A+B+C+D+E+F), // 0
(B+C), // 1
(A+B+D+E+G), // 2
(A+B+C+D+G), // 3
(B+C+F+G), // 4
(A+C+D+F+G), // 5
(A+C+D+E+F+G), // 6
(A+B+C), // 7
(A+B+C+D+E+F+G), // 8
(A+B+C+D+F+G), // 9
(A+B+C+E+F+G), // A - 10
(C+D+E+F+G), // b - 11
(A+D+E+F), // C - 12
(B+C+D+E+G), // d - 13
(A+D+E+F+G), // E - 14
(A+E+F+G), // F - 15
(G), // 16 - знак минус
(A+B+F+G), // 17 - символ градус цельсия
(0), // 18 - пусто
(C+E+G), // n
(D+E+F+G) // t
};

#define MINUS 16
#define GRADUS 17
#define PROBEL 18
#define SYMBOL_A 10
#define SYMBOL_B 11
#define SYMBOL_C 12
#define SYMBOL_D 13
#define SYMBOL_E 14
#define SYMBOL_F 15
#define SYMBOL_N 19
#define SYMBOL_T 20

читаем время дату

Спойлер

// --------------------------- прочесть время из DS1307 ------------------------------------
void read_time(void) {
rtc_get_time(&myhour, &mymin, &mysec);
rtc_get_date(&mydate, &mymonth, &myyear);

} //----------------------------------------------------------------------------------------

загоняем в буфер и ждем когда понадобится

Спойлер

//---------- экранный буфер --- (индикация времени )--------
void view_time(void) {


if (indicate == IND_CLOCK) { // час : мин
if (hour0) { digit_out[0] = (myhour >> 4) ? (myhour >> 4) : (PROBEL); }
else { digit_out[0] = myhour >> 4; }

digit_out[1] = myhour & 0x0F;
digit_out[2] = mymin >> 4;
digit_out[3] = mymin & 0x0F;
}

Спойлер

// --------- экранный буфер------- (индикация даты) ------------------
void view_date(void) {
if (indicate == IND_CLOCK) { // день - месяц
digit_out[0] = mydate >> 4;
digit_out[1] = mydate & 0x0F;
digit_out[2] = mymonth >> 4;
digit_out[3] = mymonth & 0x0F;
}
} //----------------------------------------------------------------------------------------

понадобилось выводим

Спойлер

//======= индикация времени ======
//==============
if ((indicate == IND_CLOCK) && ((t_ind_date!=0) || ((devices >= 1) && (t_ind_term != 0)))) {
effect_down(); // эффект
read_time(); // читаем время
view_time(); //в буфере

zpt_4=0;
zpt_BLINK=1; // включить мигающую запятую

effect_up(); // эффект
}

if (indicate == IND_CLOCK) {
zpt_BLINK=1; // включить мигающую запятую

for (j=0;j<tc1;j++){ // сколько секунд показывать "время"
read_time(); // читаем время
view_time(); // в буфере
set_ind(); // дает задержку в 0,2 сек
set_yarkost(); // яркось 0-10

if (indicate != IND_CLOCK) break; // если был выход из индикации времени
}
} //^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

с датой и температурой также читаем- буфер- понадобилось выводим.

Функция void DND_Print(byte d0, byte d1, byte d2, byte d3) принимает числовые значения d0, d1, d2, d3

d0, d1, d2, d3 мне нужно воткнуть в буфер на пример так
----------------------------------------------------------------------------------
if (indicate == IND_CLOCK) { // час : мин
if (hour0) { d0 = (myhour >> 4) ? (myhour >> 4) : (PROBEL); }
else { d0 = myhour >> 4; }

d1 = myhour & 0x0F;
d2 = mymin >> 4;
d3 = mymin & 0x0F;
------------------------------------------------------------------------------------
// --------- что у нас будет в экранном буфере ? ------- (индикация даты) ------------------
void view_date(void) {
if (indicate == IND_DATE) { // день - месяц
d0 = mydate >> 4;
d1 = mydate & 0x0F;
d2 = mymonth >> 4;
d3 = mymonth & 0x0F;
}
} //----------------------------------------------------------------------------------------

а эффект туда-суда по экрану выводить так???
void effect_down (void) {
int i;
for (i =0; i<4;++i){

unsigned int AA[] = {PROBEL,PROBEL,PROBEL,d0};
unsigned int BB[] = {PROBEL,PROBEL,d0,d1};
unsigned int CC[] = {PROBEL,d0,d1,d2};
unsigned int DD[] = {d0,d1,d2,d3};


digit_out[0] = AA; //разряды 1-4
digit_out[1] = BB;
digit_out[2] = CC;
digit_out[3] = DD;

delay_ms(300);

}
}
// -----------------------------------------------------------------------------------------

только CodeVisionAVR ругается и не хочет принимать byte d0, byte d1, byte d2, byte d3
а Функцию void DND_Print(byte d0, byte d1, byte d2, byte d3) я не знаю куда приделать

[Dimon456]

Serzh2000, напиши где нибудь сверху

Код: Выделить всё

#define byte unsigned char

[Ivanoff-iv]

а зачем тебе всякие "минусы" в массив загонять? оставь их просто дефайнами...
1) если дефайн не вызывается, то он и места не занимает (а архив занимает)
2) получение числа из дефайна происходит в несколько раз быстрее, чем из массива
3) число типа чар подставляемое непосредственно занимает во флеше во много раз меньше места, чем код, позволяющий достать значение из массива.

Но! в массиве удобно и экономично алфавит хранить, чтобы к символам (цифрам) добираться без лишних условий.

[MLX90640]

Сорян, надо было char написать. Просто я тыщщу лет уже как не работаю с AVR.
Функция DND_Print() - это собственно функция, преобразующая четыре числа в комбинации сегментов. И ставить её туда, где требуется в этот момент вывести на дисплей новую информацию.
У нас просто разный стиль написания. Я пишу в таком стиле, для меня он удобен.

Опять же, почему я говорю за таблицу символов в виде массива const char font[], так потому, что так обеспечивается наиболее быстрое сопоставление входной строки и комбинации сегментов для её отображение. Нет перебора условий сравнения, есть прямая зависимость между входным числом и индексом массива. Табличный метод - нормальная практика. Представьте, что у вас 16-сегментный индикатор, полноценно отображающий почти полторы сотни символов. И перебором условий через if или switch вы сделаете ужос полный. А табличный метод - другое дело. Навряд ли 10 или даже 120 байт в программной или даже оперативной памяти отнимут последний кусок памяти. Впрочем, я уже давно не пишу для мелких AVR/PIC с ограниченными ресурсами.

По поводу бегущей строки. Опять же, нужна отдельная функция, которая будет вызываться в нужный момент и принимать в себя 4 числа для текущего отображения и внутри этой функции сдвигать их на одну позицию через равные промежутки времени. Можно их реализовать хоть через Delay. Потому что с прерываниями будет сложнее.
Вообще, все эти штуки делаются на так называемых конечных автоматах.