Форум программистов, компьютерный форум, киберфорум
Измерительная техника
Войти
Регистрация
Восстановить пароль
 
 
Рейтинг 4.59/63: Рейтинг темы: голосов - 63, средняя оценка - 4.59
2 / 2 / 0
Регистрация: 29.06.2018
Сообщений: 1,045
1

Замена микросхемы 1827ВЕ1-0000000 в Г4-164 на AVR -МК

31.08.2019, 07:43. Просмотров 12120. Ответов 228
Метки нет (Все метки)

Как заменить 1827ВЕ1-0000000 (аналог 586ВЕ1, система команд в книжке Гамкрелидзе, кажется, отрицательная логика на мультиплексированной шине адреса-данных , нестандартный UART ) в Г4-164 на AVR -МК ATMEGA8A, ATMEGA48, ATMEGA8535, используя , например, маскированные прерывания от одного из портов, битвайсовую эмуляцию пинов (шину ПЗУ можно не использовать ), подпрограммы задержки , используя С++, ассемблерные вставки ? Предусмотреть частоты , а которых переключаются фильтры, увеличение девиации в n раз в коэффициентах АЦП при включении делителей на n, таблицу коэффициентов в ЦАП в децибелах (с учетом , например, того , что 31,7-100 мВ , на 31,6 переключается аттенюатор и включается верх напряжения ЦАП ОН ), обработку прерывания от КОП и другие функции , как по инструкции (https://www.astena.ru/teh_3.html ) ?
0
Миниатюры
Замена  микросхемы 1827ВЕ1-0000000 в Г4-164 на AVR -МК  
Вложения
Тип файла: zip img012.zip (1.35 Мб, 5 просмотров)
Тип файла: zip g4-164_shems.zip (5.48 Мб, 4 просмотров)
Тип файла: zip g4-164_teh.zip (5.28 Мб, 4 просмотров)
Programming
Эксперт
94731 / 64177 / 26122
Регистрация: 12.04.2006
Сообщений: 116,782
31.08.2019, 07:43
Ответы с готовыми решениями:

замена микросхемы
Нужно заменить микросхему драйвер двигателя на HDD Smooth 100369972 . На али есть такие схемки но...

Замена микросхемы AT49F002NT
Господа! Если кто знает ,какая микросхема может заменить AT49F002NT?

Замена микросхемы на аналоговую
Привет всем. Какой микросхемой можно заменить микросхему FBBHAQ DM0265RB ? Она с платы...

Hp pavilion g6 замена микросхемы видео-чипа
Здравствуйте, может кто-то есть из сервисного центра? Какой срок гарантии дается при замене...

228
2 / 2 / 0
Регистрация: 29.06.2018
Сообщений: 1,045
19.04.2020, 23:25  [ТС] 221
Как в Algorithm Builder 5.44 сделать загрузку из памяти программ , например , индикации (там еще умножать на 2 или сдвигать адрес на 1 бит влево надо ) ? В ОЗУ может , а там не понимает LPM[Z] , с @ тоже.
0
Вложения
Тип файла: zip AB544.zip (3.06 Мб, 4 просмотров)
Тип файла: zip testsio.zip (17.2 Кб, 2 просмотров)
2 / 2 / 0
Регистрация: 29.06.2018
Сообщений: 1,045
19.04.2020, 23:27  [ТС] 222
А на ассемблере этот метод даже для 8- битных массивов работает.

Добавлено через 40 секунд
Может, версия не созрела ?
0
2 / 2 / 0
Регистрация: 29.06.2018
Сообщений: 1,045
19.04.2020, 23:56  [ТС] 223
Через ZH,ZL пробовать . Для ОЗУ не надо умножать адрес на 2 , для ПЗУ программ надо умножать на 2(особенность процессора ) .
0
Миниатюры
Замена  микросхемы 1827ВЕ1-0000000 в Г4-164 на AVR -МК  
2 / 2 / 0
Регистрация: 29.06.2018
Сообщений: 1,045
20.04.2020, 00:21  [ТС] 224
Листинг программ задержки для 12 и 16 МГц
Код

12MHZ


40us
0000006c <main>:
	__builtin_avr_delay_cycles(__ticks_dc);
  6c:	80 ea       	ldi	r24, 0xA0	; 160
  6e:	8a 95       	dec	r24
  70:	f1 f7       	brne	.-4      	; 0x6e <main+0x2>
  72:	ff cf       	rjmp	.-2      	; 0x72 <main+0x6>

1us
0000006c <main>:
	__builtin_avr_delay_cycles(__ticks_dc);
  6c:	84 e0       	ldi	r24, 0x04	; 4
  6e:	8a 95       	dec	r24
  70:	f1 f7       	brne	.-4      	; 0x6e <main+0x2>
  72:	ff cf       	rjmp	.-2      	; 0x72 <main+0x6>


20us
0000006c <main>:
	#else
		//round up by default
		__ticks_dc = (uint32_t)(ceil(fabs(__tmp)));
	#endif

	__builtin_avr_delay_cycles(__ticks_dc);
  6c:	80 e5       	ldi	r24, 0x50	; 80
  6e:	8a 95       	dec	r24
  70:	f1 f7       	brne	.-4      	; 0x6e <main+0x2>
  72:	ff cf       	rjmp	.-2      	; 0x72 <main+0x6>




50 us

0000006c <main>:
	#else
		//round up by default
		__ticks_dc = (uint32_t)(ceil(fabs(__tmp)));
	#endif

	__builtin_avr_delay_cycles(__ticks_dc);
  6c:	88 ec       	ldi	r24, 0xC8	; 200
  6e:	8a 95       	dec	r24
  70:	f1 f7       	brne	.-4      	; 0x6e <main+0x2>
  72:	ff cf       	rjmp	.-2      	; 0x72 <main+0x6>



/***********************************/
16MHz

50us
0000006c <main>:
	#else
		//round up by default
		__ticks_dc = (uint32_t)(ceil(fabs(__tmp)));
	#endif

	__builtin_avr_delay_cycles(__ticks_dc);
  6c:	87 ec       	ldi	r24, 0xC7	; 199
  6e:	90 e0       	ldi	r25, 0x00	; 0
  70:	01 97       	sbiw	r24, 0x01	; 1
  72:	f1 f7       	brne	.-4      	; 0x70 <main+0x4>
  74:	00 c0       	rjmp	.+0      	; 0x76 <main+0xa>
  76:	00 00       	nop
  78:	ff cf       	rjmp	.-2      	; 0x78 <main+0xc>


40us
0000006c <main>:
	#else
		//round up by default
		__ticks_dc = (uint32_t)(ceil(fabs(__tmp)));
	#endif

	__builtin_avr_delay_cycles(__ticks_dc);
  6c:	85 ed       	ldi	r24, 0xD5	; 213
  6e:	8a 95       	dec	r24
  70:	f1 f7       	brne	.-4      	; 0x6e <main+0x2>
  72:	00 00       	nop
  74:	ff cf       	rjmp	.-2      	; 0x74 <main+0x8>



20us
0000006c <main>:
	#else
		//round up by default
		__ticks_dc = (uint32_t)(ceil(fabs(__tmp)));
	#endif

	__builtin_avr_delay_cycles(__ticks_dc);
  6c:	8a e6       	ldi	r24, 0x6A	; 106
  6e:	8a 95       	dec	r24
  70:	f1 f7       	brne	.-4      	; 0x6e <main+0x2>
  72:	00 c0       	rjmp	.+0      	; 0x74 <main+0x8>
  74:	ff cf       	rjmp	.-2      	; 0x74 <main+0x8>



1us
0000006c <main>:
	#else
		//round up by default
		__ticks_dc = (uint32_t)(ceil(fabs(__tmp)));
	#endif

	__builtin_avr_delay_cycles(__ticks_dc);
  6c:	85 e0       	ldi	r24, 0x05	; 5
  6e:	8a 95       	dec	r24
  70:	f1 f7       	brne	.-4      	; 0x6e <main+0x2>
  72:	00 00       	nop
  74:	ff cf       	rjmp	.-2      	; 0x74 <main+0x8>
Добавлено через 33 секунды
переделать регистры и точку вставки .
0
2 / 2 / 0
Регистрация: 29.06.2018
Сообщений: 1,045
21.04.2020, 04:08  [ТС] 225
Программа деления и вычисления остатка
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
/*
 * Gccapp1.c
 *
 * Created: 20.03.2020 02:09:14
 * Author : USERPC01
 */ 
#define F_CPU 16000000UL
#include <avr/io.h>
#include <avr/pgmspace.h>
#include <util/delay.h>
#include <math.h>
 
 
int main(void)
{
     
 
 
 
 
 
 
 
 
 
    uint8_t DVDCdigits[6];
    
        
        uint8_t divmod(uint32_t in,uint32_t div, uint32_t *rem ){ *rem=(uint32_t)(in%div); return (uint8_t) (in/div); }
 
 
        void GetDVDCDigitsFromUint32_t( uint32_t in)  //"uint24_t"
        {
            
            DVDCdigits[0]=(uint8_t) divmod(  in ,  (uint32_t)100000  ,  &in );
            DVDCdigits[1]=(uint8_t) divmod(  in ,  (uint32_t)10000 ,  &in );
            DVDCdigits[2]=(uint8_t) divmod(  in ,  (uint32_t) 1000 ,  &in );
            DVDCdigits[3]=(uint8_t) divmod(  in ,  (uint32_t)100 ,  &in );
            DVDCdigits[4]=(uint8_t) divmod(  in ,  (uint32_t)10 ,  &in );
            DVDCdigits[5]=(uint8_t) divmod(  in ,  (uint32_t)1  ,  &in );
            
            
            return ;
        }
        
        
        
         uint32_t in1=0;
        
         DDRD=0x00; //
                 DDRC=0xff; //
        
      while (1) 
    {
         
    // goto main1;
    
     
               //for test , for input some data 
              in1+=(uint32_t)PIND;
                  in1+=(uint32_t)PIND<<8;
                  in1+=(uint32_t)PIND<<16;
                  in1+=(uint32_t)PIND<<24;
        
 
 
 
    
    GetDVDCDigitsFromUint32_t(  in1);
     
    
 //for using variables
 PORTC=DVDCdigits[0];
  PORTC=DVDCdigits[1];
  PORTC=DVDCdigits[2];
  PORTC=DVDCdigits[3];
  PORTC=DVDCdigits[4];
   PORTC=DVDCdigits[5];
  
    
    
    
   
   
    
     
        
        
    }
}
Добавлено через 24 секунды
Код
Gccapp1.elf:     file format elf32-avr

Sections:
Idx Name          Size      VMA       LMA       File off  Algn
  0 .text         0000017c  00000000  00000000  00000054  2**1
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
  1 .data         00000000  00800060  00800060  000001d0  2**0
                  CONTENTS, ALLOC, LOAD, DATA
  2 .comment      00000030  00000000  00000000  000001d0  2**0
                  CONTENTS, READONLY
  3 .note.gnu.avr.deviceinfo 0000003c  00000000  00000000  00000200  2**2
                  CONTENTS, READONLY
  4 .debug_aranges 00000020  00000000  00000000  0000023c  2**0
                  CONTENTS, READONLY, DEBUGGING
  5 .debug_info   00000759  00000000  00000000  0000025c  2**0
                  CONTENTS, READONLY, DEBUGGING
  6 .debug_abbrev 000005fc  00000000  00000000  000009b5  2**0
                  CONTENTS, READONLY, DEBUGGING
  7 .debug_line   0000022a  00000000  00000000  00000fb1  2**0
                  CONTENTS, READONLY, DEBUGGING
  8 .debug_frame  00000024  00000000  00000000  000011dc  2**2
                  CONTENTS, READONLY, DEBUGGING
  9 .debug_str    00000318  00000000  00000000  00001200  2**0
                  CONTENTS, READONLY, DEBUGGING
 10 .debug_loc    000002ef  00000000  00000000  00001518  2**0
                  CONTENTS, READONLY, DEBUGGING
 11 .debug_ranges 00000058  00000000  00000000  00001807  2**0
                  CONTENTS, READONLY, DEBUGGING

Disassembly of section .text:

00000000 <__vectors>:
   0:	0c 94 2a 00 	jmp	0x54	; 0x54 <__ctors_end>
   4:	0c 94 34 00 	jmp	0x68	; 0x68 <__bad_interrupt>
   8:	0c 94 34 00 	jmp	0x68	; 0x68 <__bad_interrupt>
   c:	0c 94 34 00 	jmp	0x68	; 0x68 <__bad_interrupt>
  10:	0c 94 34 00 	jmp	0x68	; 0x68 <__bad_interrupt>
  14:	0c 94 34 00 	jmp	0x68	; 0x68 <__bad_interrupt>
  18:	0c 94 34 00 	jmp	0x68	; 0x68 <__bad_interrupt>
  1c:	0c 94 34 00 	jmp	0x68	; 0x68 <__bad_interrupt>
  20:	0c 94 34 00 	jmp	0x68	; 0x68 <__bad_interrupt>
  24:	0c 94 34 00 	jmp	0x68	; 0x68 <__bad_interrupt>
  28:	0c 94 34 00 	jmp	0x68	; 0x68 <__bad_interrupt>
  2c:	0c 94 34 00 	jmp	0x68	; 0x68 <__bad_interrupt>
  30:	0c 94 34 00 	jmp	0x68	; 0x68 <__bad_interrupt>
  34:	0c 94 34 00 	jmp	0x68	; 0x68 <__bad_interrupt>
  38:	0c 94 34 00 	jmp	0x68	; 0x68 <__bad_interrupt>
  3c:	0c 94 34 00 	jmp	0x68	; 0x68 <__bad_interrupt>
  40:	0c 94 34 00 	jmp	0x68	; 0x68 <__bad_interrupt>
  44:	0c 94 34 00 	jmp	0x68	; 0x68 <__bad_interrupt>
  48:	0c 94 34 00 	jmp	0x68	; 0x68 <__bad_interrupt>
  4c:	0c 94 34 00 	jmp	0x68	; 0x68 <__bad_interrupt>
  50:	0c 94 34 00 	jmp	0x68	; 0x68 <__bad_interrupt>

00000054 <__ctors_end>:
  54:	11 24       	eor	r1, r1
  56:	1f be       	out	0x3f, r1	; 63
  58:	cf e5       	ldi	r28, 0x5F	; 95
  5a:	d4 e0       	ldi	r29, 0x04	; 4
  5c:	de bf       	out	0x3e, r29	; 62
  5e:	cd bf       	out	0x3d, r28	; 61
  60:	0e 94 36 00 	call	0x6c	; 0x6c <main>
  64:	0c 94 bc 00 	jmp	0x178	; 0x178 <_exit>

00000068 <__bad_interrupt>:
  68:	0c 94 00 00 	jmp	0	; 0x0 <__vectors>

0000006c <main>:
			return ;
		}
		
		
		
		 uint32_t in1=0;
  6c:	c1 2c       	mov	r12, r1
  6e:	d1 2c       	mov	r13, r1
  70:	76 01       	movw	r14, r12


	uint8_t DVDCdigits[6];
	
		
		uint8_t divmod(uint32_t in,uint32_t div, uint32_t *rem ){ *rem=(uint32_t)(in%div); return (uint8_t) (in/div); }
  72:	0f 2e       	mov	r0, r31
  74:	f0 ea       	ldi	r31, 0xA0	; 160
  76:	4f 2e       	mov	r4, r31
  78:	f6 e8       	ldi	r31, 0x86	; 134
  7a:	5f 2e       	mov	r5, r31
  7c:	66 24       	eor	r6, r6
  7e:	63 94       	inc	r6
  80:	71 2c       	mov	r7, r1
  82:	f0 2d       	mov	r31, r0
  84:	0f 2e       	mov	r0, r31
  86:	f0 e1       	ldi	r31, 0x10	; 16
  88:	8f 2e       	mov	r8, r31
  8a:	f7 e2       	ldi	r31, 0x27	; 39
  8c:	9f 2e       	mov	r9, r31
  8e:	a1 2c       	mov	r10, r1
  90:	b1 2c       	mov	r11, r1
  92:	f0 2d       	mov	r31, r0
		 
	// goto main1;
	
	 
	
	in1+=(uint32_t)PIND;
  94:	30 b3       	in	r19, 0x10	; 16
                  in1+=(uint32_t)PIND<<8;
  96:	80 b3       	in	r24, 0x10	; 16
                  in1+=(uint32_t)PIND<<16;
  98:	40 b3       	in	r20, 0x10	; 16
                  in1+=(uint32_t)PIND<<24;
  9a:	20 b3       	in	r18, 0x10	; 16
  9c:	90 e0       	ldi	r25, 0x00	; 0
  9e:	a0 e0       	ldi	r26, 0x00	; 0
  a0:	b0 e0       	ldi	r27, 0x00	; 0
  a2:	ba 2f       	mov	r27, r26
  a4:	a9 2f       	mov	r26, r25
  a6:	98 2f       	mov	r25, r24
  a8:	88 27       	eor	r24, r24
  aa:	50 e0       	ldi	r21, 0x00	; 0
  ac:	60 e0       	ldi	r22, 0x00	; 0
  ae:	70 e0       	ldi	r23, 0x00	; 0
  b0:	ba 01       	movw	r22, r20
  b2:	55 27       	eor	r21, r21
  b4:	44 27       	eor	r20, r20
  b6:	84 0f       	add	r24, r20
  b8:	95 1f       	adc	r25, r21
  ba:	a6 1f       	adc	r26, r22
  bc:	b7 1f       	adc	r27, r23
  be:	83 0f       	add	r24, r19
  c0:	91 1d       	adc	r25, r1
  c2:	a1 1d       	adc	r26, r1
  c4:	b1 1d       	adc	r27, r1
  c6:	42 2f       	mov	r20, r18
  c8:	50 e0       	ldi	r21, 0x00	; 0
  ca:	60 e0       	ldi	r22, 0x00	; 0
  cc:	70 e0       	ldi	r23, 0x00	; 0
  ce:	74 2f       	mov	r23, r20
  d0:	66 27       	eor	r22, r22
  d2:	55 27       	eor	r21, r21
  d4:	44 27       	eor	r20, r20
  d6:	84 0f       	add	r24, r20
  d8:	95 1f       	adc	r25, r21
  da:	a6 1f       	adc	r26, r22
  dc:	b7 1f       	adc	r27, r23
  de:	c8 0e       	add	r12, r24
  e0:	d9 1e       	adc	r13, r25
  e2:	ea 1e       	adc	r14, r26
  e4:	fb 1e       	adc	r15, r27


	uint8_t DVDCdigits[6];
	
		
		uint8_t divmod(uint32_t in,uint32_t div, uint32_t *rem ){ *rem=(uint32_t)(in%div); return (uint8_t) (in/div); }
  e6:	c7 01       	movw	r24, r14
  e8:	b6 01       	movw	r22, r12
  ea:	a3 01       	movw	r20, r6
  ec:	92 01       	movw	r18, r4
  ee:	0e 94 9a 00 	call	0x134	; 0x134 <__udivmodsi4>
  f2:	02 2f       	mov	r16, r18
  f4:	a5 01       	movw	r20, r10
  f6:	94 01       	movw	r18, r8
  f8:	0e 94 9a 00 	call	0x134	; 0x134 <__udivmodsi4>
  fc:	12 2f       	mov	r17, r18
  fe:	28 ee       	ldi	r18, 0xE8	; 232
 100:	33 e0       	ldi	r19, 0x03	; 3
 102:	40 e0       	ldi	r20, 0x00	; 0
 104:	50 e0       	ldi	r21, 0x00	; 0
 106:	0e 94 9a 00 	call	0x134	; 0x134 <__udivmodsi4>
 10a:	d2 2f       	mov	r29, r18
 10c:	24 e6       	ldi	r18, 0x64	; 100
 10e:	30 e0       	ldi	r19, 0x00	; 0
 110:	40 e0       	ldi	r20, 0x00	; 0
 112:	50 e0       	ldi	r21, 0x00	; 0
 114:	0e 94 9a 00 	call	0x134	; 0x134 <__udivmodsi4>
 118:	c2 2f       	mov	r28, r18
 11a:	2a e0       	ldi	r18, 0x0A	; 10
 11c:	30 e0       	ldi	r19, 0x00	; 0
 11e:	40 e0       	ldi	r20, 0x00	; 0
 120:	50 e0       	ldi	r21, 0x00	; 0
 122:	0e 94 9a 00 	call	0x134	; 0x134 <__udivmodsi4>
	
	GetDVDCDigitsFromUint32_t(  in1);
	 
	
 
 PORTC=DVDCdigits[0];
 126:	05 bb       	out	0x15, r16	; 21
  PORTC=DVDCdigits[1];
 128:	15 bb       	out	0x15, r17	; 21
  PORTC=DVDCdigits[2];
 12a:	d5 bb       	out	0x15, r29	; 21
  PORTC=DVDCdigits[3];
 12c:	c5 bb       	out	0x15, r28	; 21
  PORTC=DVDCdigits[4];
 12e:	25 bb       	out	0x15, r18	; 21
   PORTC=DVDCdigits[5];
 130:	65 bb       	out	0x15, r22	; 21
 132:	b0 cf       	rjmp	.-160    	; 0x94 <main+0x28>

00000134 <__udivmodsi4>:
 134:	a1 e2       	ldi	r26, 0x21	; 33
 136:	1a 2e       	mov	r1, r26
 138:	aa 1b       	sub	r26, r26
 13a:	bb 1b       	sub	r27, r27
 13c:	fd 01       	movw	r30, r26
 13e:	0d c0       	rjmp	.+26     	; 0x15a <__udivmodsi4_ep>

00000140 <__udivmodsi4_loop>:
 140:	aa 1f       	adc	r26, r26
 142:	bb 1f       	adc	r27, r27
 144:	ee 1f       	adc	r30, r30
 146:	ff 1f       	adc	r31, r31
 148:	a2 17       	cp	r26, r18
 14a:	b3 07       	cpc	r27, r19
 14c:	e4 07       	cpc	r30, r20
 14e:	f5 07       	cpc	r31, r21
 150:	20 f0       	brcs	.+8      	; 0x15a <__udivmodsi4_ep>
 152:	a2 1b       	sub	r26, r18
 154:	b3 0b       	sbc	r27, r19
 156:	e4 0b       	sbc	r30, r20
 158:	f5 0b       	sbc	r31, r21

0000015a <__udivmodsi4_ep>:
 15a:	66 1f       	adc	r22, r22
 15c:	77 1f       	adc	r23, r23
 15e:	88 1f       	adc	r24, r24
 160:	99 1f       	adc	r25, r25
 162:	1a 94       	dec	r1
 164:	69 f7       	brne	.-38     	; 0x140 <__udivmodsi4_loop>
 166:	60 95       	com	r22
 168:	70 95       	com	r23
 16a:	80 95       	com	r24
 16c:	90 95       	com	r25
 16e:	9b 01       	movw	r18, r22
 170:	ac 01       	movw	r20, r24
 172:	bd 01       	movw	r22, r26
 174:	cf 01       	movw	r24, r30
 176:	08 95       	ret

00000178 <_exit>:
 178:	f8 94       	cli

0000017a <__stop_program>:
 17a:	ff cf       	rjmp	.-2      	; 0x17a <__stop_program>
Добавлено через 2 минуты
А на Алгоритм билдере как это сделать эффективнее (входные и выходные переменные условные, чтобы компилятор думал,что они используются , тогда этот фрагмент можно использовать , кроме классического "школьного" метода, но для двоичных чисел )?

Добавлено через 26 минут
Умножение на 10 для 16-битных чисел (140 дБ)
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
/*
 * Gccapp1.c
 *
 * Created: 20.03.2020 02:09:14
 * Author : USERPC01
 */ 
#define F_CPU 16000000UL
#include <avr/io.h>
#include <avr/pgmspace.h>
#include <util/delay.h>
#include <math.h>
//#include "vrefparser.h"
//#include "sharedvars.h"
  #define low_byte(x)   ( (uint8_t)(((x)>>0) & 0xFF))
  #define high_byte(x)   ( (uint8_t)(((x)>>8) & 0xFF))
 
int main(void)
{
     
    uint16_t Mul10(uint16_t inp){return (uint16_t) (inp*10);}
        uint16_t in1=0;
        
        in1+=(uint16_t)PIND;
        in1+=(uint16_t)PINB;
        
        uint16_t out=Mul10( in1);
        PORTA=low_byte(out);
        PORTC=high_byte(out);   
        
        
        
        
      while (1) 
    {
         
    // goto main1;
 
    
 
    
    }
    
     
 
 
}


Код

Gccapp1.elf:     file format elf32-avr

Sections:
Idx Name          Size      VMA       LMA       File off  Algn
  0 .text         00000096  00000000  00000000  00000054  2**1
                  CONTENTS, ALLOC, LOAD, READONLY, CODE
  1 .data         00000000  00800060  00800060  000000ea  2**0
                  CONTENTS, ALLOC, LOAD, DATA
  2 .comment      00000030  00000000  00000000  000000ea  2**0
                  CONTENTS, READONLY
  3 .note.gnu.avr.deviceinfo 0000003c  00000000  00000000  0000011c  2**2
                  CONTENTS, READONLY
  4 .debug_aranges 00000020  00000000  00000000  00000158  2**0
                  CONTENTS, READONLY, DEBUGGING
  5 .debug_info   00000612  00000000  00000000  00000178  2**0
                  CONTENTS, READONLY, DEBUGGING
  6 .debug_abbrev 00000591  00000000  00000000  0000078a  2**0
                  CONTENTS, READONLY, DEBUGGING
  7 .debug_line   000001ce  00000000  00000000  00000d1b  2**0
                  CONTENTS, READONLY, DEBUGGING
  8 .debug_frame  00000024  00000000  00000000  00000eec  2**2
                  CONTENTS, READONLY, DEBUGGING
  9 .debug_str    000002e9  00000000  00000000  00000f10  2**0
                  CONTENTS, READONLY, DEBUGGING
 10 .debug_loc    00000058  00000000  00000000  000011f9  2**0
                  CONTENTS, READONLY, DEBUGGING
 11 .debug_ranges 00000010  00000000  00000000  00001251  2**0
                  CONTENTS, READONLY, DEBUGGING

Disassembly of section .text:

00000000 <__vectors>:
   0:	0c 94 2a 00 	jmp	0x54	; 0x54 <__ctors_end>
   4:	0c 94 34 00 	jmp	0x68	; 0x68 <__bad_interrupt>
   8:	0c 94 34 00 	jmp	0x68	; 0x68 <__bad_interrupt>
   c:	0c 94 34 00 	jmp	0x68	; 0x68 <__bad_interrupt>
  10:	0c 94 34 00 	jmp	0x68	; 0x68 <__bad_interrupt>
  14:	0c 94 34 00 	jmp	0x68	; 0x68 <__bad_interrupt>
  18:	0c 94 34 00 	jmp	0x68	; 0x68 <__bad_interrupt>
  1c:	0c 94 34 00 	jmp	0x68	; 0x68 <__bad_interrupt>
  20:	0c 94 34 00 	jmp	0x68	; 0x68 <__bad_interrupt>
  24:	0c 94 34 00 	jmp	0x68	; 0x68 <__bad_interrupt>
  28:	0c 94 34 00 	jmp	0x68	; 0x68 <__bad_interrupt>
  2c:	0c 94 34 00 	jmp	0x68	; 0x68 <__bad_interrupt>
  30:	0c 94 34 00 	jmp	0x68	; 0x68 <__bad_interrupt>
  34:	0c 94 34 00 	jmp	0x68	; 0x68 <__bad_interrupt>
  38:	0c 94 34 00 	jmp	0x68	; 0x68 <__bad_interrupt>
  3c:	0c 94 34 00 	jmp	0x68	; 0x68 <__bad_interrupt>
  40:	0c 94 34 00 	jmp	0x68	; 0x68 <__bad_interrupt>
  44:	0c 94 34 00 	jmp	0x68	; 0x68 <__bad_interrupt>
  48:	0c 94 34 00 	jmp	0x68	; 0x68 <__bad_interrupt>
  4c:	0c 94 34 00 	jmp	0x68	; 0x68 <__bad_interrupt>
  50:	0c 94 34 00 	jmp	0x68	; 0x68 <__bad_interrupt>

00000054 <__ctors_end>:
  54:	11 24       	eor	r1, r1
  56:	1f be       	out	0x3f, r1	; 63
  58:	cf e5       	ldi	r28, 0x5F	; 95
  5a:	d4 e0       	ldi	r29, 0x04	; 4
  5c:	de bf       	out	0x3e, r29	; 62
  5e:	cd bf       	out	0x3d, r28	; 61
  60:	0e 94 36 00 	call	0x6c	; 0x6c <main>
  64:	0c 94 49 00 	jmp	0x92	; 0x92 <_exit>

00000068 <__bad_interrupt>:
  68:	0c 94 00 00 	jmp	0	; 0x0 <__vectors>

0000006c <main>:
		 uint32_t in1=0;
		*/
	uint16_t Mul10(uint16_t inp){return (uint16_t) (inp*10);}
		uint16_t in1=0;
		
		in1+=(uint16_t)PIND;
  6c:	80 b3       	in	r24, 0x10	; 16
		in1+=(uint16_t)PINB;
  6e:	26 b3       	in	r18, 0x16	; 22
		
		
		
		 uint32_t in1=0;
		*/
	uint16_t Mul10(uint16_t inp){return (uint16_t) (inp*10);}
  70:	30 e0       	ldi	r19, 0x00	; 0
  72:	28 0f       	add	r18, r24
  74:	31 1d       	adc	r19, r1
  76:	c9 01       	movw	r24, r18
  78:	88 0f       	add	r24, r24
  7a:	99 1f       	adc	r25, r25
  7c:	22 0f       	add	r18, r18
  7e:	33 1f       	adc	r19, r19
  80:	22 0f       	add	r18, r18
  82:	33 1f       	adc	r19, r19
  84:	22 0f       	add	r18, r18
  86:	33 1f       	adc	r19, r19
  88:	82 0f       	add	r24, r18
  8a:	93 1f       	adc	r25, r19
		
		in1+=(uint16_t)PIND;
		in1+=(uint16_t)PINB;
		
		uint16_t out=Mul10( in1);
		PORTA=low_byte(out);
  8c:	8b bb       	out	0x1b, r24	; 27
		PORTC=high_byte(out);	
  8e:	95 bb       	out	0x15, r25	; 21
  90:	ff cf       	rjmp	.-2      	; 0x90 <main+0x24>

00000092 <_exit>:
  92:	f8 94       	cli

00000094 <__stop_program>:
  94:	ff cf       	rjmp	.-2      	; 0x94 <__stop_program>
Добавлено через 31 минуту
Код
	uint16_t Mul10(uint16_t inp){return (uint16_t) (inp*10);} 

//r24 lowbyte
//r18 highbyte

(X<<1)+(X<<3)
 


  70:	30 e0       	ldi	r19, 0x00	; r19=0
  72:	32 2f       	mov	r19, r18     ; highbyte->r19
  74:	22 27       	eor	r18, r18     ; r18=0 
  76:	28 0f       	add	r18, r24     ;  r18+=lowbyte
  78:	31 1d       	adc	r19, r1       ;  r19+=lowbyte:0+
  7a:	c9 01       	movw	r24, r18     ;  r18:r19->r24:r25   (lowbyte:highbyte <<1  ,    lowbyte:highbyte +=lowbyte:highbyte )

  7c:	88 0f       	add	r24, r24
  7e:	99 1f       	adc	r25, r25     ; r24:r25<<1

  80:	22 0f       	add	r18, r18
  82:	33 1f       	adc	r19, r19      ; r18:r19<<1   

  84:	22 0f       	add	r18, r18
  86:	33 1f       	adc	r19, r19      ; r18:r19<<1   

  88:	22 0f       	add	r18, r18
  8a:	33 1f       	adc	r19, r19     ; r18:r19<<1        (  r18:r19<<3 )

  8c:	82 0f       	add	r24, r18     ; ResLowByte=r24+r18
  8e:	93 1f       	adc	r25, r19     ; ResHighByte=r25+r18+carry ,  result=    (X<<1)+(X<<3)
Добавлено через 1 час 37 минут
https://en.wikipedia.org/wiki/Division_algorithm

Добавлено через 1 час 34 минуты
https://github.com/MoSync/gcc/... r/libgcc.S

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
/*******************************************************
       Division 32 / 32 => (result + remainder)
*******************************************************/
#define r_remHH r31 /* remainder High */
#define r_remHL r30
#define r_remH  r27
#define r_remL  r26 /* remainder Low */
 
/* return: remainder */
#define r_arg1HH r25    /* dividend High */
#define r_arg1HL r24
#define r_arg1H  r23
#define r_arg1L  r22    /* dividend Low */
 
/* return: quotient */
#define r_arg2HH r21    /* divisor High */
#define r_arg2HL r20
#define r_arg2H  r19
#define r_arg2L  r18    /* divisor Low */
    
#define r_cnt __zero_reg__  /* loop count (0 after the loop!) */
 
#if defined (L_udivmodsi4)
    .global __udivmodsi4
    .func   __udivmodsi4
__udivmodsi4:
    ldi r_remL, 33  ; init loop counter
    mov r_cnt, r_remL
    sub r_remL,r_remL
    sub r_remH,r_remH   ; clear remainder and carry
    mov_l   r_remHL, r_remL
    mov_h   r_remHH, r_remH
    rjmp    __udivmodsi4_ep ; jump to entry point
__udivmodsi4_loop:
        rol r_remL      ; shift dividend into remainder
    rol r_remH
    rol r_remHL
    rol r_remHH
        cp  r_remL,r_arg2L  ; compare remainder & divisor
    cpc r_remH,r_arg2H
    cpc r_remHL,r_arg2HL
    cpc r_remHH,r_arg2HH
    brcs    __udivmodsi4_ep ; remainder <= divisor
        sub r_remL,r_arg2L  ; restore remainder
        sbc r_remH,r_arg2H
        sbc r_remHL,r_arg2HL
        sbc r_remHH,r_arg2HH
__udivmodsi4_ep:
        rol r_arg1L     ; shift dividend (with CARRY)
        rol r_arg1H
        rol r_arg1HL
        rol r_arg1HH
        dec r_cnt       ; decrement loop counter
        brne    __udivmodsi4_loop
                ; __zero_reg__ now restored (r_cnt == 0)
    com r_arg1L
    com r_arg1H
    com r_arg1HL
    com r_arg1HH
; div/mod results to return registers, as for the ldiv() function
    mov_l   r_arg2L,  r_arg1L   ; quotient
    mov_h   r_arg2H,  r_arg1H
    mov_l   r_arg2HL, r_arg1HL
    mov_h   r_arg2HH, r_arg1HH
    mov_l   r_arg1L,  r_remL    ; remainder
    mov_h   r_arg1H,  r_remH
    mov_l   r_arg1HL, r_remHL
    mov_h   r_arg1HH, r_remHH
    ret
    .endfunc
#endif /* defined (L_udivmodsi4) */
 
#if defined (L_divmodsi4)
    .global __divmodsi4
    .func   __divmodsi4
__divmodsi4:
        bst     r_arg1HH,7  ; store sign of dividend
        mov     __tmp_reg__,r_arg1HH
        eor     __tmp_reg__,r_arg2HH   ; r0.7 is sign of result
    rcall   __divmodsi4_neg1 ; dividend negative : negate
    sbrc    r_arg2HH,7
    rcall   __divmodsi4_neg2 ; divisor negative : negate
    rcall   __udivmodsi4    ; do the unsigned div/mod
    rcall   __divmodsi4_neg1 ; correct remainder sign
    rol __tmp_reg__
    brcc    __divmodsi4_exit
__divmodsi4_neg2:
    com r_arg2HH
    com r_arg2HL
    com r_arg2H
    neg r_arg2L     ; correct divisor/quotient sign
    sbci    r_arg2H,0xff
    sbci    r_arg2HL,0xff
    sbci    r_arg2HH,0xff
__divmodsi4_exit:
    ret
__divmodsi4_neg1:
    brtc    __divmodsi4_exit
    com r_arg1HH
    com r_arg1HL
    com r_arg1H
    neg r_arg1L     ; correct dividend/remainder sign
    sbci    r_arg1H, 0xff
    sbci    r_arg1HL,0xff
    sbci    r_arg1HH,0xff
    ret
    .endfunc
#endif /* defined (L_divmodsi4) */
0
2 / 2 / 0
Регистрация: 29.06.2018
Сообщений: 1,045
21.04.2020, 16:49  [ТС] 226
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <math.h>
 
 
int32_t  div_const( int32_t N , uint32_t D  )
{
int32_t Q=0;
int32_t R=(int32_t )N; 
 
while(R>=D){ Q++; R-=D; }
printf ("\nN=%ld R=%ld  Q=%ld  D=%ld",N,R,Q,D); 
return  R;
}
 
 
int main()
{
int32_t n=1597501;
int32_t r; 
 
r =div_const(n , 100000   );
r =div_const(r , 10000   );
r =div_const(r , 1000   );
r =div_const(r , 100   );
r =div_const(r , 10   );
printf ("\nr= %d ", (int)r);
return 0;
}
Добавлено через 38 минут
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <math.h>
 
/*
int32_t  div_const( int32_t N , uint32_t D  )
{
uint8_t Q=0;
int32_t R=(int32_t )N; 
while(R>=D){ Q++; R-=D; }
printf ("\nN=%ld R=%ld  Q=%ld  D=%ld",N,R,Q,D); 
 
 
return  R;
}
*/
void GetDigits ( int32_t N )
{
uint8_t Q=0;
int32_t R=(int32_t )N; 
while(R>=100000){ Q++; R-=100000; }
printf ("\n  R=%ld  Q=%d   " ,R,Q );
 
Q=0;    
 
while(R>=10000){ Q++; R-=10000; }
printf ("\n  R=%ld  Q=%d   " ,R,Q );
 
Q=0;    
    
while(R>=1000){ Q++; R-=1000; }
printf ("\n  R=%ld  Q=%d   " ,R,Q );    
 
Q=0;    
    
while(R>=100){ Q++; R-=100; }
printf ("\n  R=%ld  Q=%d   " ,R,Q );
 
Q=0;    
 
while(R>=10){ Q++; R-=10; }
printf ("\n  R=%ld  Q=%d   " ,R,Q );
 
printf ("\nN   R=%d   ", (int)R  );
 
}
 
int main()
{
int32_t n=1590000;
//int32_t r=n;  
 
GetDigits ( n );
 
//r =div_const(n , 1000000   );
/*
r =div_const(r , 100000   );
r =div_const(r , 10000   );
r =div_const(r , 1000   );
r =div_const(r , 100   );
r =div_const(r , 10   );
printf ("\nr= %d ", (int)r);
*/
return 0;
}
Добавлено через 25 минут
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <math.h>
 
/*
int32_t  div_const( int32_t N , uint32_t D  )
{
uint8_t Q=0;
int32_t R=(int32_t )N; 
while(R>=D){ Q++; R-=D; }
printf ("\nN=%ld R=%ld  Q=%ld  D=%ld",N,R,Q,D); 
 
 
return  R;
}
*/
uint8_t digits[6];
 
void GetDigits ( int32_t N )
{
uint8_t Q=0;
int32_t R=(int32_t )N;
 
 
//Q=0; 
//while(R>=1000000){ Q++; R-=1000000; }
//printf ("\n  R=%ld  Q=%d   " ,R,Q );
//digits[6]=Q;
 
 
while(R>=100000){ Q++; R-=100000; }
//printf ("\n  R=%ld  Q=%d   " ,R,Q );
 digits[5]=Q;
Q=0;    
while(R>=10000){ Q++; R-=10000; }
//printf ("\n  R=%ld  Q=%d   " ,R,Q );
digits[4]=Q;
Q=0;    
while(R>=1000){ Q++; R-=1000; }
//printf ("\n  R=%ld  Q=%d   " ,R,Q );
digits[3]=Q;    
Q=0;    
while(R>=100){ Q++; R-=100; }
//printf ("\n  R=%ld  Q=%d   " ,R,Q );
digits[2]=Q;
Q=0;    
while(R>=10){ Q++; R-=10; }
//printf ("\n  R=%ld  Q=%d   " ,R,Q );
digits[1]=Q;
 
digits[0]=(uint8_t) R;
//printf ("\n    R=%d   ", (int)R  );
 
}
 
int main()
{
int32_t n=1599998;
//int32_t r=n;  
 
GetDigits ( n );
 
//r =div_const(n , 1000000   );
/*
r =div_const(r , 100000   );
r =div_const(r , 10000   );
r =div_const(r , 1000   );
r =div_const(r , 100   );
r =div_const(r , 10   );
printf ("\nr= %d ", (int)r);
*/
printf ("\ndigit= %d ", (int)digits[5]); 
printf ("\ndigit= %d ", (int)digits[4]); 
printf ("\ndigit= %d ", (int)digits[3]); 
printf ("\ndigit= %d ", (int)digits[2]); 
printf ("\ndigit= %d ", (int)digits[1]);
printf ("\ndigit= %d ", (int)digits[0]); 
 
 
return 0;
}
Добавлено через 1 минуту
Для преобразования числа ДДПКД в цифры ДДПКД (в старшем разряде 0...15 ).

Добавлено через 15 минут
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
void GetDVDCDigitsFromUint32_t( uint32_t in)  //"uint24_t" 
{
 
int32_t R=(int32_t )in;
uint8_t Q=0;
while(R>=100000){ Q++; R-=100000; }
 DVDCdigits[0]=Q;  //optimize numbers 
Q=0;    
while(R>=10000){ Q++; R-=10000; }
DVDCdigits[1]=Q;
Q=0;    
while(R>=1000){ Q++; R-=1000; }
DVDCdigits[2]=Q;    
Q=0;    
while(R>=100){ Q++; R-=100; }
DVDCdigits[3]=Q;
Q=0;    
while(R>=10){ Q++; R-=10; }
DVDCdigits[4]=Q;
DVDCdigits[5]=(uint8_t) R;
 
return ;    
}
Добавлено через 23 минуты
исправить порядок определения поддиапазонов (при выработке для ДПКД вначале старый диапазон для программы ) .

Добавлено через 2 часа 18 минут
Способ обрабатывать только цифры
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
void GetBand(uint8_t  freq[7]  , uint8_t  Mode_Freq )
{
printf("\n **Getband : Freq=  "  ) ;
printf(" %d  %d  %d  %d  %d  %d  %d  \n" ,freq[6],freq[5] ,freq[4] ,freq[3] ,freq[2] ,freq[1] ,freq[5]  ) ;
 
 
if (Mode_Freq==1)
{
//Freq_Value=(uint32_t) freq_fromdigits1( freq );       
//printf("\n Getband Freq= %ld ", Freq_Value ) ;
 
//600-639.999
if((freq[5]==6)&&( freq[4]<4 )) { SetCompFreq1_25kHz() ; CurrentState.Band=BAND_0 ;  PM_BandOk=1;  return ; } 
 
if(freq[5]==5)
{
//560-599.999
if(( freq[4]>=6)&&( freq[4]<10)) { SetCompFreq1_25kHz() ; CurrentState.Band=BAND_1 ;  PM_BandOk=1;  return ; }   
//520-559.999
if(( freq[4]>=2)&&( freq[4]<6 )) { SetCompFreq1_25kHz() ; CurrentState.Band=BAND_2;   PM_BandOk=1;  return ; }  
//***500-519.999  (480-519.999)
if(( freq[4]>=0)&&( freq[4]<2 ))  { SetCompFreq1_25kHz() ; CurrentState.Band=BAND_3;   PM_BandOk=1;  return ; }
}
 
if(freq[5]==4)
{
//480-499.999  (480-519.999)
if(( freq[4]>=8)&&( freq[4]<10 )) { SetCompFreq1_25kHz() ; CurrentState.Band=BAND_3;   PM_BandOk=1;  return ; } 
  
//448-479.999
   //***450-479.999  (448-479.999)
if(( freq[4]>=5)&&( freq[4]<8 ))  { SetCompFreq1_25kHz() ; CurrentState.Band=BAND_4;   PM_BandOk=1;  return ; } 
   //*** 448-449.999 (448-479.999)
if(( freq[4]==4)&&(freq[3]>=8)&&(freq[3]<10)) { SetCompFreq1_25kHz() ; CurrentState.Band=BAND_4;   PM_BandOk=1;  return ; }   
   //*** 440-447.999
if(( freq[4]==4)&&(freq[3]<8)){ SetCompFreq1_25kHz() ; CurrentState.Band=BAND_5;   PM_BandOk=1;  return ; } 
//400-439.999
if((freq[5]==4)&&( freq[4]>=0)&&( freq[4]<4 )) { SetCompFreq1_25kHz() ; CurrentState.Band=BAND_6;   PM_BandOk=1;  return ; } 
}
 
if(freq[5]==3)
{
//360-399.999
if(( freq[4]>=6)&&(freq[4]<10)) { SetCompFreq1_25kHz() ; CurrentState.Band=BAND_7;   PM_BandOk=1;  return ; } 
//320-359.99
if(( freq[4]>=2)&&(freq[4]<6)) { SetCompFreq1_25kHz() ; CurrentState.Band=BAND_8;   PM_BandOk=1;  return ; } 
//300-319.999
if(( freq[4]>=0)&&(freq[4]<2)) { SetCompFreq1_25kHz() ; CurrentState.Band=BAND_9;   PM_BandOk=1;  return ; } 
}
 
if(freq[5]==2)
{
//280-299.999
if(( freq[4]>=8)&&( freq[4]<10 )) { SetCompFreq1_25kHz() ; CurrentState.Band=BAND_10;  PM_BandOk=1;  return ; } 
//260-279.999
if(( freq[4]>=6)&&( freq[4]<8 )) { SetCompFreq1_25kHz() ; CurrentState.Band=BAND_11;  PM_BandOk=1;  return ; }   
//240-259.999
if(( freq[4]>=4)&&( freq[4]<6 )) { SetCompFreq1_25kHz() ; CurrentState.Band=BAND_12;  PM_BandOk=1;  return ; }  
//224.000-239.999  
   //230-239.999
if (freq[4]==3)   { SetCompFreq1_25kHz() ; CurrentState.Band=BAND_13;  PM_BandOk=1;  return ; } 
   //224-229.999
if ((freq[4]==2)&(freq[3]>=4)&&(freq[3]<10)) { SetCompFreq1_25kHz() ; CurrentState.Band=BAND_13;  PM_BandOk=1;  return ; } 
 
//220-223.999
if((freq[4]==2)&&( freq[3]>=0)&&(freq[3]<4)) { SetCompFreq1_25kHz() ; CurrentState.Band=BAND_14;  PM_BandOk=1;  return ; } 
//200-219.999
if((freq[4]>=0)&&(freq[4]<2)) { SetCompFreq1_25kHz() ; CurrentState.Band=BAND_15;  PM_BandOk=1;  return ; } 
}
 
if(freq[5]==1) 
{
//180-199.999
if((freq[4]>=8)&&(freq[4]<10)) { SetCompFreq1_25kHz() ; CurrentState.Band=BAND_16;  PM_BandOk=1;  return ; } 
//160-179.999
if((freq[4]>=6)&&(freq[4]<8)) { SetCompFreq1_25kHz() ; CurrentState.Band=BAND_17;  PM_BandOk=1;  return ; } 
}
 
}
else 
{
//Freq_Value=(uint32_t) freq_fromdigits  ( freq );      
 //printf("\n Getband Freq= %ld ", Freq_Value ) ;
if(freq[6]==1)
{
 
//150-159.9999
if(freq[5]==5)  { SetCompFreq1kHz();  CurrentState.Band=BAND_18; PM_BandOk=1;    return ;} 
//140-149.9999
if(freq[5]==4) { SetCompFreq1kHz();  CurrentState.Band=BAND_19; PM_BandOk=1;    return ;}       
//130-139.9999
if(freq[5]==3)  { SetCompFreq1kHz();  CurrentState.Band=BAND_20; PM_BandOk=1;    return ;} 
//120-129.9999
if(freq[5]==2) { SetCompFreq1kHz();  CurrentState.Band=BAND_21; PM_BandOk=1;    return ;}   
//112-119.9999
if((freq[5]==1)&&(freq[4]>=2)&&(freq[4]<10))  { SetCompFreq1kHz();  CurrentState.Band=BAND_22; PM_BandOk=1;    return ;}  
//110-111.9999
if((freq[5]==1)&&(freq[4]>=0)&&(freq[4]<2)) { SetCompFreq1kHz();  CurrentState.Band=BAND_23; PM_BandOk=1;    return ;} 
//100-109.9999
if(freq[5]==0) { SetCompFreq1kHz();  CurrentState.Band=BAND_24; PM_BandOk=1;    return ;} 
}
 
if(freq[6]==0)
{
//90-99.9999
if(freq[5]==9) { SetCompFreq1kHz();   CurrentState.Band=BAND_25; PM_BandOk=1;    return ;} 
//80-89.9999
if(freq[5]==8) { SetCompFreq1kHz();   CurrentState.Band=BAND_26; PM_BandOk=1;    return ; } 
//75-79.9999
if((freq[5]==7)&&(freq[4]>=5)&&(freq[4]<10)) { SetCompFreq1kHz();  CurrentState.Band=BAND_27;  PM_BandOk=1;     return ; } 
//70-74.9999
if((freq[5]==7)&&(freq[4]>=0)&&(freq[4]<5)) { SetCompFreq1kHz();  CurrentState.Band=BAND_28;  PM_BandOk=1;     return ; } 
//65-69.9999
if((freq[5]==6)&&(freq[4]>=5)&&(freq[4]<10)) { SetCompFreq1kHz();  CurrentState.Band=BAND_29;  PM_BandOk=1;     return ; } 
//60-64.9999
if((freq[5]==6)&&(freq[4]>=0)&&(freq[4]<5)) { SetCompFreq1kHz();  CurrentState.Band=BAND_30;  PM_BandOk=1;     return ; } 
 
//56-59.9999
if((freq[5]==5)&&(freq[4]>=6)&&(freq[4]<10)) { SetCompFreq1kHz();  CurrentState.Band=BAND_31;  PM_BandOk=1;     return ; }   
//55-55.9999
if((freq[5]==5)&&(freq[4]==5)) { SetCompFreq1kHz();  CurrentState.Band=BAND_32;  PM_BandOk=1;     return ; }  
//50-54.9999
if((freq[5]==5)&&(freq[4]>=0)&&(freq[4]<5)) { SetCompFreq1kHz();  CurrentState.Band=BAND_33;  PM_BandOk=1;     return ; } 
//45-49.9999
if((freq[5]==4)&&(freq[4]>=5)&&(freq[4]<10)) { SetCompFreq1kHz();  CurrentState.Band=BAND_34;  PM_BandOk=0;     return ; } 
//40-44.9999
if((freq[5]==4)&&(freq[4]>=0)&&(freq[4]<5)) { SetCompFreq1kHz();  CurrentState.Band=BAND_35;  PM_BandOk=0;     return ; } 
//28-39.9999  : 28...29.9999, 30-39.9999
   //30-39.39999 
if((freq[5]==3)&&(freq[4]>=0)&&(freq[4]<10)) { SetCompFreq1kHz();  CurrentState.Band=BAND_36;  PM_BandOk=0;     return ; } 
   //28-29.9999
if((freq[5]==2)&&(freq[4]>=8)&&(freq[4]<10)) { SetCompFreq1kHz();  CurrentState.Band=BAND_36;  PM_BandOk=0;     return ; } 
 
//20-27.9999
if((freq[5]==2)&&(freq[4]>=0)&&(freq[4]<8)) { SetCompFreq1kHz();  CurrentState.Band=BAND_37;  PM_BandOk=0;     return ; } 
//14-19.9999
if((freq[5]==1)&&(freq[4]>=4)&&(freq[4]<10)) { SetCompFreq1kHz();  CurrentState.Band=BAND_38;  PM_BandOk=0;     return ; } 
 
 
//12-13.9999
if((freq[5]==1)&&(freq[4]>=2)&&(freq[4]<4)) { SetCompFreq1kHz();   CurrentState.Band=BAND_39;  PM_BandOk=0;     return ; }  
 
//0.1-11.9999:   10.0-11.9999, 9.9999-1.0000  0.1000-0.9999
//10.0-11.9999
if((freq[5]==1)&&(freq[4]<2)) { SetCompFreq1kHz();   CurrentState.Band=BAND_40;  PM_BandOk=0;     return ; } 
//9.9999-1.0000
if((freq[5]==0)&&(freq[4]>=1)&&(freq[4]<10)) { SetCompFreq1kHz();   CurrentState.Band=BAND_40;  PM_BandOk=0;     return ; } 
//0.1000-0.9999
if((freq[5]==0)&&(freq[4]==0)&&(freq[3]>=1)) { SetCompFreq1kHz();   CurrentState.Band=BAND_40;  PM_BandOk=0;     return ; }  
 
}
 
}
return ;
}
Добавлено через 2 минуты
Тогда программа выработки кодов ДДПКД и преобразователь кодов к ней вводом массива сформированных цифр из структуры(хотя так 6..7 байт вместо 4 , но переменная временная ) :


C++
1
2
3
4
5
6
7
8
void ParseCodesDVDC(){  
printf("\nParseCodesDVDC") ; 
/* insert subroutines here*/
 
GetCoeffDVDC(CurrentState.Band ,CurrentState.freq  );
Flag[2]|=MASK_FLAG_DISP_FREQ;
Flag[3]|=MASK_FLAG_DVDC_CODE ;
}

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
uint32_t freq_fromdigits1 ( uint8_t freq[7])
{
uint32_t result=0;
 
for(uint8_t i=0x00; i<freq[0];i++) { result+=(uint32_t) 1; }
for(uint8_t i=0x00; i<freq[1];i++) { result+=(uint32_t)10;  } 
for(uint8_t i=0x00; i<freq[2];i++) { result+=(uint32_t)100;  } 
for(uint8_t i=0x00; i<freq[3];i++) { result+=(uint32_t)1000;  }
for(uint8_t i=0x00; i<freq[4];i++) { result+=(uint32_t)10000;  }
for(uint8_t i=0x00; i<freq[5];i++) { result+=(uint32_t)100000;  } 
 return result;
}
 
 
 
 
void  GetCoeffDVDC(uint8_t BandValue  , uint8_t freq[7]  )
{
    
    
    
    
 printf("\n ****** BandValue =%d Freq=[%d][%d][%d][%d][%d][%d][%d]   " , BandValue , freq[6],freq[5],freq[4],freq[3],freq[2],freq[1],freq[0] );
/*  Kddpkd_num= freq*Kd/5)  for f= 1.25 kHz
 Kddpkd_num=freq*Kd/4  for f=1 kHz
*/
      
 //uint32_t FreqValue=freq_fromdigits_div10(freq); 
 
 
// 640.000...1279998 , Kddpkd=freq/5=(freq/10)  *2 ;
if((BandValue>=BAND_0 )&&(BandValue<=BAND_8 ))  
{ 
SetCompFreq1_25kHz(); 
GetDVDCDigitsFromUint32_t((uint32_t)((freq_fromdigits1( freq )) <<1) );  
return ; 
} 
//640000...1279996  , Kddpkd=(freq*2 /5);   =(freq/10)  *4 ;    
if((BandValue>=BAND_9)&&(BandValue<=BAND_17 ))
{ 
SetCompFreq1_25kHz(); 
GetDVDCDigitsFromUint32_t((uint32_t)((freq_fromdigits1( freq )) <<2));   
return ;} 
 /* *************** */            
uint32_t Freq_Value=0;
 //Kddpkd=freq ; 
 
 
 
for(uint8_t i=0x00; i<freq[0]; i++) { Freq_Value+=(uint32_t) 1; }
for(uint8_t i=0x00; i<freq[1]; i++) { Freq_Value+=(uint32_t)10;  } 
for(uint8_t i=0x00; i<freq[2]; i++) { Freq_Value+=(uint32_t)100;  } 
for(uint8_t i=0x00; i<freq[3]; i++) { Freq_Value+=(uint32_t)1000;  }
for(uint8_t i=0x00; i<freq[4]; i++) { Freq_Value+=(uint32_t)10000;  }
for(uint8_t i=0x00; i<freq[5]; i++) { Freq_Value+=(uint32_t)100000;  } 
for(uint8_t i=0x00; i<freq[6]; i++) { Freq_Value+=(uint32_t)1000000;  } 
 
 
if((BandValue>=BAND_18)&&(BandValue<=BAND_26)){ SetCompFreq1kHz(); GetDVDCDigitsFromUint32_t(Freq_Value);   return; } 
 //  Kddpkd=freq*2 ;   
if((BandValue>=BAND_27)&&(BandValue<=BAND_35 )){ SetCompFreq1kHz(); GetDVDCDigitsFromUint32_t((uint32_t)(Freq_Value<<1));  return ;} 
 // Kddpkd=freq*4 ;   
if((BandValue==BAND_36)||(BandValue==BAND_37 )){ SetCompFreq1kHz(); GetDVDCDigitsFromUint32_t((uint32_t)(Freq_Value<<2)); return ; } 
  // Kddpkd=freq*8 ;  
if((BandValue==BAND_38)){ SetCompFreq1kHz(); GetDVDCDigitsFromUint32_t((uint32_t)(Freq_Value<<3)); return ;  } 
  
/********************************** mixer on  *******************************/
// Kddpkd=freq ;   
if((BandValue==BAND_39)||(BandValue==BAND_40 )) { SetCompFreq1kHz() ; Freq_Value+=1000000; GetDVDCDigitsFromUint32_t((uint32_t)(Freq_Value)); return ; }  
 
  return  ;
}
Добавлено через 59 секунд
Придумать бы что-нибудь быстрее и компактнее по регистрам, но это может быть так(устранить мелкие баги ).

Добавлено через 52 минуты
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <math.h>
 
/*
int32_t  div_const( int32_t N , uint32_t D  )
{
uint8_t Q=0;
int32_t R=(int32_t )N; 
while(R>=D){ Q++; R-=D; }
printf ("\nN=%ld R=%ld  Q=%ld  D=%ld",N,R,Q,D); 
 
 
return  R;
}
*/
uint8_t digits[6];
 
void GetDigits ( int32_t N )
{
uint8_t Q=0;
int32_t R=(int32_t )N;
 
 
//Q=0; 
//while(R>=1000000){ Q++; R-=1000000; }
//printf ("\n  R=%ld  Q=%d   " ,R,Q );
//digits[6]=Q;
 
 
while(R>=100000){ Q++; R-=100000; }
//printf ("\n  R=%ld  Q=%d   " ,R,Q );
 digits[5]=Q;
Q=0;    
while(R>=10000){ Q++; R-=10000; }
//printf ("\n  R=%ld  Q=%d   " ,R,Q );
digits[4]=Q;
Q=0;    
while(R>=1000){ Q++; R-=1000; }
//printf ("\n  R=%ld  Q=%d   " ,R,Q );
digits[3]=Q;    
Q=0;    
while(R>=100){ Q++; R-=100; }
//printf ("\n  R=%ld  Q=%d   " ,R,Q );
digits[2]=Q;
Q=0;    
while(R>=10){ Q++; R-=10; }
//printf ("\n  R=%ld  Q=%d   " ,R,Q );
digits[1]=Q;
 
digits[0]=(uint8_t) R;
//printf ("\n    R=%d   ", (int)R  );
 
}
 
int main()
{
int32_t n=1599997;
//int32_t r=n;  
for (n=0;n<=1599999;n++){
 
GetDigits ( n );
 
//r =div_const(n , 1000000   );
/*
r =div_const(r , 100000   );
r =div_const(r , 10000   );
r =div_const(r , 1000   );
r =div_const(r , 100   );
r =div_const(r , 10   );
printf ("\nr= %d ", (int)r);
*/
//printf ("\ndigit= %d ", (int)digits[5]  ); 
//printf ("\ndigit= %d ", (int)digits[4] ); 
//printf ("\ndigit= %d ", (int)digits[3] ); 
//printf ("\ndigit= %d ", (int)digits[2] ); 
//printf ("\ndigit= %d ", (int)digits[1] );
//printf ("\ndigit= %d ", (int)digits[0] );
 
 
 int32_t res=0;
res+=(int32_t)digits[0];
res+=(int32_t)digits[1]*10;
res+=(int32_t)digits[2]*100;
res+=(int32_t)digits[3]*1000;
res+=(int32_t)digits[4]*10000;
res+=(int32_t)digits[5]*100000;
if (res-(n) !=0) {printf  ("\n result= %ld ", res-(n));}
}
 
 
 
return 0;
}
Добавлено через 34 секунды
тест на ошибку деления

Добавлено через 17 минут
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <math.h>
 
/*
int16_t  div_const( uint16_t N , uint16_t D  )
{
uint16_t Q=0;
int16_t R=(int16_t )N; 
while(R>=D){ Q++; R-=D; }
printf ("\nN=%ld R=%ld  Q=%ld  D=%ld",N,R,Q,D); 
 
 
return  R;
}
*/
 
int16_t  div_5( uint16_t N   )
{
int16_t Q=0;
int16_t R=(int16_t ) N; 
while(R>=0x0005){ Q++; R-=0x0005; }
//printf ("\nN=%ld R=%ld  Q=%ld  ",N,R,Q ); 
return  (int16_t)Q;
}
 
  
 
 
int main()
{
 uint16_t n ;
 int delta; 
 for(n=0; n<=4000; n++)
 {
 
 delta= (int)(n/5)-div_5(n);
 if(delta!=0)
  { printf ("\ndelta=% d , n=%d  ",delta,(int)n  ); }
 }
 
 
 
return 0;
}
Для ЧМ, с запасом , тест на ошибку деления,сравнивается с компьютерным делением для Си++ .

Добавлено через 21 минуту
Можно внедрить другой алгоритм для ЧМ при делении на 5
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
 
 
 
uint16_t  GetFMValueFromDigits(uint8_t fm_digits[3])
{
uint16_t FM_Value=0;
 
 
for (uint8_t  i=0;i<fm_digits[0] ; i++) { FM_Value+=1; }
for (uint8_t  i=0;i<fm_digits[1] ; i++) { FM_Value+=10; }
for (uint8_t  i=0;i<fm_digits[2] ; i++) { FM_Value+=100; } 
return FM_Value ;
}
 
uint16_t GetFMValueFromDigits_div10(uint8_t fm_digits[3])
{
uint16_t FM_Value=0;
 
for (uint8_t  i=0;i<fm_digits[1] ; i++) { FM_Value+=1 ; }
for (uint8_t  i=0;i<fm_digits[2] ; i++) { FM_Value+=10 ; } 
return  FM_Value;
}
/*
uint8_t DACFM;
uint8_t AttCorFM;
uint8_t FM_DAC_LFO;
**/
 
uint16_t  div_5( uint16_t N   )
{
int16_t Q=0;
int16_t R=(int16_t ) N; 
while(R>=0x0005){ Q++; R-=0x0005; }
//printf ("\nN=%ld R=%ld  Q=%ld  ",N,R,Q ); 
return  (uint16_t)Q;
}
 
 
void GetCodeFM (uint8_t fm_digits[3], uint8_t FMCommaPos,  uint8_t  BandValue    )
{
 
uint16_t FM_Value ;
FM_Value=GetFMValueFromDigits( fm_digits );
 
//320-639.999 MHz   
if ((BandValue>=BAND_0 )&&(BandValue<=BAND_8 )) {
             
 
if (FMCommaPos==2) {
if((FM_Value>=100) && (FM_Value<=995 ))  {         //995->    199(796),  000
 DACFM=(uint8_t)(div_5(FM_Value));
 AttCorFM=(uint8_t)ATTCORRFM_OFF;
 FM_DAC_LFO=ATT_R53; 
   
return  ;  }}
 
if (FMCommaPos==1) {     
if((FM_Value>=100)&&(FM_Value<=995 )){         //99.5->    199(796),   011
DACFM=(uint8_t)(div_5(FM_Value));
 AttCorFM=ATTCORRFM_OFF;
 FM_DAC_LFO=ATT_R59;
return  ;  }}
 
 
if (FMCommaPos==0) {     
if(FM_Value<=995){         //9.95->    199(796),   011
 DACFM=(uint8_t)(div_5(FM_Value));
 AttCorFM=ATTCORRFM_ON;
 FM_DAC_LFO=ATT_R59; 
return  ;
 }}
 
}
 
//
//160.000-319.999 MHz   
if ((BandValue>=BAND_9)&&(BandValue<=BAND_17 ))                 
{
if (FMCommaPos==2) {
if((FM_Value>=100) &&(FM_Value<=500 ) )  {         //500->    200(800),  000
 DACFM=(uint8_t)(div_5(FM_Value<<1));
 AttCorFM=ATTCORRFM_OFF;
 FM_DAC_LFO=ATT_R53;  
return  ;
 }}
 
if (FMCommaPos==1) {     
if( (FM_Value>=100)&&( FM_Value<=995 )){         //99.5->    199(796),   001
 DACFM=(uint8_t)(div_5(FM_Value));
 AttCorFM=ATTCORRFM_OFF;
 FM_DAC_LFO=ATT_R57;
return  ;
 }}
 
 
if (FMCommaPos==0) {     
if( FM_Value<=995 ){         //9.95->    199(796),   001
 DACFM=(uint8_t)(div_5(FM_Value));
 AttCorFM=ATTCORRFM_ON;
 FM_DAC_LFO=ATT_R57;  
return  ;
}}
 
}
 
//80.0000-159.9999MHz 
if ((BandValue>=BAND_18)&&(BandValue<=BAND_26))                  
{
    
if (FMCommaPos==2) {
if((FM_Value>=100) &&(FM_Value<=250 ))  {         //250->    200(800),  000
 DACFM=(uint8_t)(div_5(FM_Value<<2));
 AttCorFM=ATTCORRFM_OFF;
 FM_DAC_LFO=ATT_R53;  
return  ;
 }}
 
if (FMCommaPos==1) {     
if( (FM_Value>=100)&&( FM_Value<=995 )){         //99.5->    199(796),   010
 DACFM=(uint8_t)(div_5(FM_Value));
 AttCorFM=ATTCORRFM_OFF;
 FM_DAC_LFO=ATT_R55; 
return  ;
}}
 
 
if (FMCommaPos==0) {     
if( FM_Value<=995 ){         //9.95->    199(796),   010
 DACFM=(uint8_t)(div_5(FM_Value));
 AttCorFM=ATTCORRFM_ON;
 FM_DAC_LFO=ATT_R55; 
return ;
 }}
}
 
//40.0000-79.9999MHz
if ((BandValue>=BAND_27)&&(BandValue<=BAND_35 ))                  
{
if (FMCommaPos==2) {
if((FM_Value>=100) &&(FM_Value<=125 ))  {         //100->    160(640),  000
 DACFM=(uint8_t)(div_5(FM_Value<<3));
 AttCorFM=ATTCORRFM_OFF;
 FM_DAC_LFO=ATT_R53;  
return  ;
 }}
 
if (FMCommaPos==1) {     
if( (FM_Value>=100)&&( FM_Value<=995 )){         //99.5->    199(796),   100
 DACFM=(uint8_t)div_5(FM_Value);
 AttCorFM=ATTCORRFM_OFF;
 FM_DAC_LFO=ATT_R54; 
return  ;
}}
 
if (FMCommaPos==0) {     
if( FM_Value<=995 ){      //9.95->    199(796),   100
 DACFM=(uint8_t)(div_5(FM_Value));
 AttCorFM=ATTCORRFM_ON;
 FM_DAC_LFO=ATT_R54;  
return  ;
}}
}
 
 
//20.0000-39.9999MHz
if ((BandValue==BAND_36)||(BandValue==BAND_37 ))                 
{
 
if (FMCommaPos==1) {     
if( (FM_Value>=100)&&( FM_Value<=500 )){         //50.0->    200(800),   100
 
 DACFM=(uint8_t)((GetFMValueFromDigits_div10( fm_digits ))<<2);
 AttCorFM=ATTCORRFM_OFF;
 FM_DAC_LFO=ATT_R54;
return  ;
 }}
 
if (FMCommaPos==0) {     
if( FM_Value<=995 ){      //9.95->    199(796),  101
 DACFM=(uint8_t)div_5(FM_Value);
 AttCorFM=ATTCORRFM_ON;
 FM_DAC_LFO=ATT_R58; 
return  ;
 }}
}
 
 
//14.0000-19.9999MHz
if ( BandValue==BAND_38 )                  
{
 
if (FMCommaPos==1) {     
if( (FM_Value>=100)&&( FM_Value<=250 )){         //25.0->    200(800),   100
 DACFM=(uint8_t)(GetFMValueFromDigits_div10( fm_digits ))<<3;
 AttCorFM=ATTCORRFM_OFF;
 FM_DAC_LFO=ATT_R54; 
return  ;
}}
 
if (FMCommaPos==0) {     
if( FM_Value<=995 ){      //9.95->    199(796),  110
 DACFM=(uint8_t)div_5(FM_Value);
 AttCorFM=ATTCORRFM_ON;
 FM_DAC_LFO=ATT_R56;  
return  ;
}}
}
 
if ((BandValue==BAND_39)||(BandValue==BAND_40 ))                  
{
 
if (FMCommaPos==1) {     
if( (FM_Value>=100)&&( FM_Value<=995 )){         //99.5->    199(796),   000
 DACFM=(uint8_t)div_5(FM_Value);
 AttCorFM=ATTCORRFM_OFF;
 FM_DAC_LFO=ATT_R55; 
return  ;
}}
 
if (FMCommaPos==0) {     
if( FM_Value<=995 ){      //9.95->    199(796),  010
 DACFM=(uint8_t)div_5(FM_Value);
 AttCorFM=ATTCORRFM_ON;
 FM_DAC_LFO=ATT_R55;
return  ;  
//MIX_ON
}}
 
}
 
 
return  ; 
}
, привести подобные
0
2 / 2 / 0
Регистрация: 29.06.2018
Сообщений: 1,045
21.04.2020, 16:50  [ТС] 227
Можно внедрить другой алгоритм для ЧМ при делении на 5
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
 
 
 
uint16_t  GetFMValueFromDigits(uint8_t fm_digits[3])
{
uint16_t FM_Value=0;
 
 
for (uint8_t  i=0;i<fm_digits[0] ; i++) { FM_Value+=1; }
for (uint8_t  i=0;i<fm_digits[1] ; i++) { FM_Value+=10; }
for (uint8_t  i=0;i<fm_digits[2] ; i++) { FM_Value+=100; } 
return FM_Value ;
}
 
uint16_t GetFMValueFromDigits_div10(uint8_t fm_digits[3])
{
uint16_t FM_Value=0;
 
for (uint8_t  i=0;i<fm_digits[1] ; i++) { FM_Value+=1 ; }
for (uint8_t  i=0;i<fm_digits[2] ; i++) { FM_Value+=10 ; } 
return  FM_Value;
}
/*
uint8_t DACFM;
uint8_t AttCorFM;
uint8_t FM_DAC_LFO;
**/
 
uint16_t  div_5( uint16_t N   )
{
int16_t Q=0;
int16_t R=(int16_t ) N; 
while(R>=0x0005){ Q++; R-=0x0005; }
//printf ("\nN=%ld R=%ld  Q=%ld  ",N,R,Q ); 
return  (uint16_t)Q;
}
 
 
void GetCodeFM (uint8_t fm_digits[3], uint8_t FMCommaPos,  uint8_t  BandValue    )
{
 
uint16_t FM_Value ;
FM_Value=GetFMValueFromDigits( fm_digits );
 
//320-639.999 MHz   
if ((BandValue>=BAND_0 )&&(BandValue<=BAND_8 )) {
             
 
if (FMCommaPos==2) {
if((FM_Value>=100) && (FM_Value<=995 ))  {         //995->    199(796),  000
 DACFM=(uint8_t)(div_5(FM_Value));
 AttCorFM=(uint8_t)ATTCORRFM_OFF;
 FM_DAC_LFO=ATT_R53; 
   
return  ;  }}
 
if (FMCommaPos==1) {     
if((FM_Value>=100)&&(FM_Value<=995 )){         //99.5->    199(796),   011
DACFM=(uint8_t)(div_5(FM_Value));
 AttCorFM=ATTCORRFM_OFF;
 FM_DAC_LFO=ATT_R59;
return  ;  }}
 
 
if (FMCommaPos==0) {     
if(FM_Value<=995){         //9.95->    199(796),   011
 DACFM=(uint8_t)(div_5(FM_Value));
 AttCorFM=ATTCORRFM_ON;
 FM_DAC_LFO=ATT_R59; 
return  ;
 }}
 
}
 
//
//160.000-319.999 MHz   
if ((BandValue>=BAND_9)&&(BandValue<=BAND_17 ))                 
{
if (FMCommaPos==2) {
if((FM_Value>=100) &&(FM_Value<=500 ) )  {         //500->    200(800),  000
 DACFM=(uint8_t)(div_5(FM_Value<<1));
 AttCorFM=ATTCORRFM_OFF;
 FM_DAC_LFO=ATT_R53;  
return  ;
 }}
 
if (FMCommaPos==1) {     
if( (FM_Value>=100)&&( FM_Value<=995 )){         //99.5->    199(796),   001
 DACFM=(uint8_t)(div_5(FM_Value));
 AttCorFM=ATTCORRFM_OFF;
 FM_DAC_LFO=ATT_R57;
return  ;
 }}
 
 
if (FMCommaPos==0) {     
if( FM_Value<=995 ){         //9.95->    199(796),   001
 DACFM=(uint8_t)(div_5(FM_Value));
 AttCorFM=ATTCORRFM_ON;
 FM_DAC_LFO=ATT_R57;  
return  ;
}}
 
}
 
//80.0000-159.9999MHz 
if ((BandValue>=BAND_18)&&(BandValue<=BAND_26))                  
{
    
if (FMCommaPos==2) {
if((FM_Value>=100) &&(FM_Value<=250 ))  {         //250->    200(800),  000
 DACFM=(uint8_t)(div_5(FM_Value<<2));
 AttCorFM=ATTCORRFM_OFF;
 FM_DAC_LFO=ATT_R53;  
return  ;
 }}
 
if (FMCommaPos==1) {     
if( (FM_Value>=100)&&( FM_Value<=995 )){         //99.5->    199(796),   010
 DACFM=(uint8_t)(div_5(FM_Value));
 AttCorFM=ATTCORRFM_OFF;
 FM_DAC_LFO=ATT_R55; 
return  ;
}}
 
 
if (FMCommaPos==0) {     
if( FM_Value<=995 ){         //9.95->    199(796),   010
 DACFM=(uint8_t)(div_5(FM_Value));
 AttCorFM=ATTCORRFM_ON;
 FM_DAC_LFO=ATT_R55; 
return ;
 }}
}
 
//40.0000-79.9999MHz
if ((BandValue>=BAND_27)&&(BandValue<=BAND_35 ))                  
{
if (FMCommaPos==2) {
if((FM_Value>=100) &&(FM_Value<=125 ))  {         //100->    160(640),  000
 DACFM=(uint8_t)(div_5(FM_Value<<3));
 AttCorFM=ATTCORRFM_OFF;
 FM_DAC_LFO=ATT_R53;  
return  ;
 }}
 
if (FMCommaPos==1) {     
if( (FM_Value>=100)&&( FM_Value<=995 )){         //99.5->    199(796),   100
 DACFM=(uint8_t)div_5(FM_Value);
 AttCorFM=ATTCORRFM_OFF;
 FM_DAC_LFO=ATT_R54; 
return  ;
}}
 
if (FMCommaPos==0) {     
if( FM_Value<=995 ){      //9.95->    199(796),   100
 DACFM=(uint8_t)(div_5(FM_Value));
 AttCorFM=ATTCORRFM_ON;
 FM_DAC_LFO=ATT_R54;  
return  ;
}}
}
 
 
//20.0000-39.9999MHz
if ((BandValue==BAND_36)||(BandValue==BAND_37 ))                 
{
 
if (FMCommaPos==1) {     
if( (FM_Value>=100)&&( FM_Value<=500 )){         //50.0->    200(800),   100
 
 DACFM=(uint8_t)((GetFMValueFromDigits_div10( fm_digits ))<<2);
 AttCorFM=ATTCORRFM_OFF;
 FM_DAC_LFO=ATT_R54;
return  ;
 }}
 
if (FMCommaPos==0) {     
if( FM_Value<=995 ){      //9.95->    199(796),  101
 DACFM=(uint8_t)div_5(FM_Value);
 AttCorFM=ATTCORRFM_ON;
 FM_DAC_LFO=ATT_R58; 
return  ;
 }}
}
 
 
//14.0000-19.9999MHz
if ( BandValue==BAND_38 )                  
{
 
if (FMCommaPos==1) {     
if( (FM_Value>=100)&&( FM_Value<=250 )){         //25.0->    200(800),   100
 DACFM=(uint8_t)(GetFMValueFromDigits_div10( fm_digits ))<<3;
 AttCorFM=ATTCORRFM_OFF;
 FM_DAC_LFO=ATT_R54; 
return  ;
}}
 
if (FMCommaPos==0) {     
if( FM_Value<=995 ){      //9.95->    199(796),  110
 DACFM=(uint8_t)div_5(FM_Value);
 AttCorFM=ATTCORRFM_ON;
 FM_DAC_LFO=ATT_R56;  
return  ;
}}
}
 
if ((BandValue==BAND_39)||(BandValue==BAND_40 ))                  
{
 
if (FMCommaPos==1) {     
if( (FM_Value>=100)&&( FM_Value<=995 )){         //99.5->    199(796),   000
 DACFM=(uint8_t)div_5(FM_Value);
 AttCorFM=ATTCORRFM_OFF;
 FM_DAC_LFO=ATT_R55; 
return  ;
}}
 
if (FMCommaPos==0) {     
if( FM_Value<=995 ){      //9.95->    199(796),  010
 DACFM=(uint8_t)div_5(FM_Value);
 AttCorFM=ATTCORRFM_ON;
 FM_DAC_LFO=ATT_R55;
return  ;  
//MIX_ON
}}
 
}
 
 
return  ; 
}
, привести "подобные" в условиях , переставить условия
0
2 / 2 / 0
Регистрация: 29.06.2018
Сообщений: 1,045
22.04.2020, 22:56  [ТС] 228
C++
1
2
3
4
5
6
7
8
uint16_t  div_5( uint16_t N   )
{
int16_t Q=0;
int16_t R=(int16_t ) N; 
while(R>=0x0005){ Q++; R-=0x0005; }
//printf ("\nN=%ld R=%ld  Q=%ld  ",N,R,Q ); 
return  (uint16_t)Q;
}
компактно, но медленно (до 200 циклов).
Есть ли быстрее и компактно?

Добавлено через 5 часов 33 минуты
Исправить баг с кодами фильтров (R42 , проверить другие ), способ отправки еще оптимизируется, там пока заглушка.

Добавлено через 3 часа 18 минут
https://electronics.stackexcha... n-atmega32

Добавлено через 14 минут
Для пробуждения АТМЕГА32А нужно Int2 или уровни для Int0, Int1 , кварц не шумит примерно в Power-down Mode режиме, а это уровнем, если уровнем, будет глючить вызов прерывания, от спящего режима лучше отказаться и правильно экранировать схему, снабдить блокировочными конденсаторами (в некоторых партиях не впаивают конденсатор и транзистор глушения тактовой частоты).

Добавлено через 50 минут
НА алгоритм билдере биты не байты, если через точку, но с загрузкой из памяти программ через загрузку в ZH,ZL удвоенного значения адреса таблицы подумать (отдельно загружается ).

Добавлено через 57 минут
Баг со скан -кодом кнопок 8 и 9
0
2 / 2 / 0
Регистрация: 29.06.2018
Сообщений: 1,045
23.04.2020, 13:17  [ТС] 229
Некоторые фрагменты программ на Алгоритм билдере 5.44
0
Вложения
Тип файла: zip ab.zip (41.3 Кб, 0 просмотров)
IT_Exp
Эксперт
87844 / 49110 / 22898
Регистрация: 17.06.2006
Сообщений: 92,604
23.04.2020, 13:17

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

Acer aspire 5602wlmi замена сгоревшей микросхемы PG1AY 6900AS
помогите пожалуйста в ноутбуке Acer aspire 5602wlmi сгорела микросхема &quot;PG1AY 6900AS&quot; найти такую...

СМА Samsung Q1235, Замена микросхемы STK621-015. Есть аналог!!!
Здравствуйте! Подскажите возможна ли замена Микросхемы STK621-015 на STK621-140 трёхфазный инвертор...

Нужно печатать число П(Пи) почему всегда печатает 4.0000000
#include &lt;stdio.h&gt; #include &lt;Windows.h&gt; int main() { int n,i; float a,PI=0; printf(&quot;n=&quot;);...

Модуль Whirlpool домино, замена микросхемы lnk 304 pn на lnk 305 pn
Всем прывет в модуле сгарела микросхема lnk 304 pn под рукой аказалась lnk 305 pn она падходит.


Искать еще темы с ответами

Или воспользуйтесь поиском по форуму:
229
Ответ Создать тему
Опции темы

КиберФорум - форум программистов, компьютерный форум, программирование
Powered by vBulletin® Version 3.8.9
Copyright ©2000 - 2020, vBulletin Solutions, Inc.