logo elektroda
logo elektroda
X
logo elektroda
Adblock/uBlockOrigin/AdGuard mogą powodować znikanie niektórych postów z powodu nowej reguły.

Kompilator pomija pętlę do-while w kodzie C - jak to naprawić?

5657jz 14 Lut 2012 15:26 3231 40
  • #1 10544698
    5657jz
    Poziom 14  
    Mam taki problem którego nie rozumiem. Patrzę w kod, jak matka na łobuza i nie wiem, co z tym łobuzem zrobić.

    Może zechce Ktoś spojżeć i podpowiedzieć.
    Program wchodzi w główną pentlę "do", wykonuje dwa "for". Nastepnie powinien wejść do petli "do" i tam pozostać do nacisniecia klawisza wyboru.
    Niestety, jest to pomijane w wygenerowanym programie. I napisy są wciąż wyświetlane na ekranie. PS. Żaden klawisz nie ma zwarcia.
    #define  SET_LEFT_PIN		PIN(KL_PORT) & 1<<LEFT_PIN

    I kod:
    do
        {	
    		czysc_ekr_menu1();
    		
    		for(poz_ramki=1;poz_ramki<MAX_POZ_WYSWIETLANYCH+1;poz_ramki++)
    	    {  
    			poz_x_RAMKI=x_RAMKI;
    			poz_y_RAMKI=((poz_ramki*dy_RAMKI)-dy_RAMKI)+y_RAMKI;
    			poz_x1_RAMKI=x_RAMKI+dx_RAMKI;
    			poz_y1_RAMKI=(poz_ramki*dy_RAMKI)+ y_RAMKI;//poz_y_RAMKI;
    
    			LCD_rectangle(  poz_x_RAMKI ,
    			 				poz_y_RAMKI,
    			 				poz_x1_RAMKI,
    			 				poz_y1_RAMKI, 
    			 				(wybor==poz_ramki ? NEGATYW:POZYTYW) ,
    			 				(wybor==poz_ramki ? POZYTYW:NEGATYW));
    	    }
    
    		for(poz_ramki=1;poz_ramki<MAX_POZ_WYSWIETLANYCH+1;poz_ramki++)
    	    {
    			poz_x_NAPISU=x_NAPISU;
    			poz_y_NAPISU=((poz_ramki*dy_RAMKI)-dy_RAMKI)+y_NAPISU;
    
    			 LCD_string(&(menu1[(poz_ramki-1)+przewin].text),
                 				    poz_x_NAPISU,
                  					poz_y_NAPISU,
                 					F3x6,
    								wybor==poz_ramki ? POZYTYW:NEGATYW);
    	    }                                                             
    
    			do                                        /* TO KOD POMIJANY W PROGRAMIE*/                     
    			{
    		 	// obsługa klawiszy menu podrzednego
    				if(~UP_PIN) // wybór w górę
    				{
    					wybor--;
    					if(wybor<1) wybor=1;
    				    if (wybor>MAX_POZ_WYSWIETLANYCH) przewin--;
    					break;	
    				}
    				else if(~DOWN_PIN)  // wybór w dół
    				{
    					wybor++;
    				    if (wybor>24) wybor=24;
    					if (wybor>MAX_POZ_WYSWIETLANYCH) przewin++;
    					break;
    				}
    				else if(~ENTER)          // zatwierdzono wybór
    				{
    					//menu_1(menu1[poz_ramki-1].addr_EE_podmenu);
    					break;
    				}
    			
    			}while(SET_LEFT_PIN);                         /*KONIEC KODU POMINIETEGO*/
    			_delay_ms(WAIT);
    
    	}while(SET_LEFT_PIN);
    }//end menu1
  • #2 10544744
    piti___
    Poziom 23  
    Błąd jest tutaj:
    PIN(KL_PORT) & 1<<LEFT_PIN
    brak nawiasów.
  • #3 10544891
    5657jz
    Poziom 14  
    Niestety to nie bład.
    Mam drugie menu - chodzi prawidłowo.
    Wstawiłem nawiasy. Nie ma to wpływu ani na jedno, ani na drugie menu.
    Petla jest pomijana.
  • #4 10545148
    tplewa
    Poziom 39  
    a zagladales do wygenerowanego kodu asm jak to wyglada ?

    Zerknij w .lss ewentualnie zalacz tutaj ten fragment...
  • #5 10545253
    tmf
    VIP Zasłużony dla elektroda
    Co to jest PIN(KLPORT) ? Wygląda na wywołanie funkcji. Jedyna możliwość, że całość jest pomijana to sytuacja w której na etapie kompilacji widać, że pewne warunki nigdy nie są spełnione i można całość zoptymalizować przez usunięcie.
  • #6 10545443
    5657jz
    Poziom 14  
    #define PIN(x) (*(&x - 2)) 

    Jedno menu chodzi prawidłowo.
    To wycinek .lss
    	do
        {	
    		czysc_ekr_menu1();
        1db2:	0e 94 c5 0c 	call	0x198a	; 0x198a <czysc_ekr_menu1>
    		
    		for(poz_ramki=1;poz_ramki<MAX_POZ_WYSWIETLANYCH+1;poz_ramki++)
        1db6:	81 e0       	ldi	r24, 0x01	; 1
        1db8:	89 83       	std	Y+1, r24	; 0x01
        1dba:	3d c0       	rjmp	.+122    	; 0x1e36 <menu_1+0x446>
    	    {  
    			poz_x_RAMKI=x_RAMKI;
        1dbc:	8c 85       	ldd	r24, Y+12	; 0x0c
        1dbe:	8a 8b       	std	Y+18, r24	; 0x12
    			poz_y_RAMKI=((poz_ramki*dy_RAMKI)-dy_RAMKI)+y_RAMKI;
        1dc0:	89 81       	ldd	r24, Y+1	; 0x01
        1dc2:	88 2f       	mov	r24, r24
        1dc4:	90 e0       	ldi	r25, 0x00	; 0
        1dc6:	01 97       	sbiw	r24, 0x01	; 1
        1dc8:	98 2f       	mov	r25, r24
        1dca:	8f 85       	ldd	r24, Y+15	; 0x0f
        1dcc:	98 9f       	mul	r25, r24
        1dce:	90 2d       	mov	r25, r0
        1dd0:	11 24       	eor	r1, r1
        1dd2:	8d 85       	ldd	r24, Y+13	; 0x0d
        1dd4:	89 0f       	add	r24, r25
        1dd6:	8b 8b       	std	Y+19, r24	; 0x13
    			poz_x1_RAMKI=x_RAMKI+dx_RAMKI;
        1dd8:	9c 85       	ldd	r25, Y+12	; 0x0c
        1dda:	8e 85       	ldd	r24, Y+14	; 0x0e
        1ddc:	89 0f       	add	r24, r25
        1dde:	8c 8b       	std	Y+20, r24	; 0x14
    			poz_y1_RAMKI=(poz_ramki*dy_RAMKI)+ y_RAMKI;//poz_y_RAMKI;
        1de0:	99 81       	ldd	r25, Y+1	; 0x01
        1de2:	8f 85       	ldd	r24, Y+15	; 0x0f
        1de4:	98 9f       	mul	r25, r24
        1de6:	90 2d       	mov	r25, r0
        1de8:	11 24       	eor	r1, r1
        1dea:	8d 85       	ldd	r24, Y+13	; 0x0d
        1dec:	89 0f       	add	r24, r25
        1dee:	8d 8b       	std	Y+21, r24	; 0x15
    
    			LCD_rectangle(  poz_x_RAMKI ,
        1df0:	8a 89       	ldd	r24, Y+18	; 0x12
        1df2:	88 2f       	mov	r24, r24
        1df4:	90 e0       	ldi	r25, 0x00	; 0
        1df6:	2b 89       	ldd	r18, Y+19	; 0x13
        1df8:	62 2f       	mov	r22, r18
        1dfa:	70 e0       	ldi	r23, 0x00	; 0
        1dfc:	2c 89       	ldd	r18, Y+20	; 0x14
        1dfe:	42 2f       	mov	r20, r18
        1e00:	50 e0       	ldi	r21, 0x00	; 0
        1e02:	2d 89       	ldd	r18, Y+21	; 0x15
        1e04:	22 2f       	mov	r18, r18
        1e06:	30 e0       	ldi	r19, 0x00	; 0
        1e08:	a1 e0       	ldi	r26, 0x01	; 1
        1e0a:	b0 e0       	ldi	r27, 0x00	; 0
        1e0c:	fa 81       	ldd	r31, Y+2	; 0x02
        1e0e:	e9 81       	ldd	r30, Y+1	; 0x01
        1e10:	fe 17       	cp	r31, r30
        1e12:	11 f4       	brne	.+4      	; 0x1e18 <menu_1+0x428>
        1e14:	a0 e0       	ldi	r26, 0x00	; 0
        1e16:	b0 e0       	ldi	r27, 0x00	; 0
        1e18:	e1 e0       	ldi	r30, 0x01	; 1
        1e1a:	f0 e0       	ldi	r31, 0x00	; 0
        1e1c:	0a 81       	ldd	r16, Y+2	; 0x02
        1e1e:	19 81       	ldd	r17, Y+1	; 0x01
        1e20:	01 17       	cp	r16, r17
        1e22:	11 f0       	breq	.+4      	; 0x1e28 <menu_1+0x438>
        1e24:	e0 e0       	ldi	r30, 0x00	; 0
        1e26:	f0 e0       	ldi	r31, 0x00	; 0
        1e28:	8d 01       	movw	r16, r26
        1e2a:	7f 01       	movw	r14, r30
        1e2c:	0e 94 35 08 	call	0x106a	; 0x106a <LCD_rectangle>
    
    	do
        {	
    		czysc_ekr_menu1();
    		
    		for(poz_ramki=1;poz_ramki<MAX_POZ_WYSWIETLANYCH+1;poz_ramki++)
        1e30:	89 81       	ldd	r24, Y+1	; 0x01
        1e32:	8f 5f       	subi	r24, 0xFF	; 255
        1e34:	89 83       	std	Y+1, r24	; 0x01
        1e36:	89 81       	ldd	r24, Y+1	; 0x01
        1e38:	86 30       	cpi	r24, 0x06	; 6
        1e3a:	08 f4       	brcc	.+2      	; 0x1e3e <menu_1+0x44e>
        1e3c:	bf cf       	rjmp	.-130    	; 0x1dbc <menu_1+0x3cc>
    			 				poz_y1_RAMKI, 
    			 				(wybor==poz_ramki ? NEGATYW:POZYTYW) ,
    			 				(wybor==poz_ramki ? POZYTYW:NEGATYW));
    	    }
    
    		for(poz_ramki=1;poz_ramki<MAX_POZ_WYSWIETLANYCH+1;poz_ramki++)
        1e3e:	81 e0       	ldi	r24, 0x01	; 1
        1e40:	89 83       	std	Y+1, r24	; 0x01
        1e42:	32 c0       	rjmp	.+100    	; 0x1ea8 <menu_1+0x4b8>
    	    {
    			poz_x_NAPISU=x_NAPISU;
        1e44:	8a 85       	ldd	r24, Y+10	; 0x0a
        1e46:	8e 8b       	std	Y+22, r24	; 0x16
    			poz_y_NAPISU=((poz_ramki*dy_RAMKI)-dy_RAMKI)+y_NAPISU;
        1e48:	89 81       	ldd	r24, Y+1	; 0x01
        1e4a:	88 2f       	mov	r24, r24
        1e4c:	90 e0       	ldi	r25, 0x00	; 0
        1e4e:	01 97       	sbiw	r24, 0x01	; 1
        1e50:	98 2f       	mov	r25, r24
        1e52:	8f 85       	ldd	r24, Y+15	; 0x0f
        1e54:	98 9f       	mul	r25, r24
        1e56:	90 2d       	mov	r25, r0
        1e58:	11 24       	eor	r1, r1
        1e5a:	8b 85       	ldd	r24, Y+11	; 0x0b
        1e5c:	89 0f       	add	r24, r25
        1e5e:	8f 8b       	std	Y+23, r24	; 0x17
    
    			 LCD_string(&(menu1[(poz_ramki-1)+przewin].text),
        1e60:	89 81       	ldd	r24, Y+1	; 0x01
        1e62:	28 2f       	mov	r18, r24
        1e64:	30 e0       	ldi	r19, 0x00	; 0
        1e66:	8b 81       	ldd	r24, Y+3	; 0x03
        1e68:	9c 81       	ldd	r25, Y+4	; 0x04
        1e6a:	82 0f       	add	r24, r18
        1e6c:	93 1f       	adc	r25, r19
        1e6e:	9c 01       	movw	r18, r24
        1e70:	21 50       	subi	r18, 0x01	; 1
        1e72:	30 40       	sbci	r19, 0x00	; 0
        1e74:	c9 01       	movw	r24, r18
        1e76:	82 95       	swap	r24
        1e78:	92 95       	swap	r25
        1e7a:	90 7f       	andi	r25, 0xF0	; 240
        1e7c:	98 27       	eor	r25, r24
        1e7e:	80 7f       	andi	r24, 0xF0	; 240
        1e80:	98 27       	eor	r25, r24
        1e82:	82 0f       	add	r24, r18
        1e84:	93 1f       	adc	r25, r19
        1e86:	8c 53       	subi	r24, 0x3C	; 60
        1e88:	9e 4f       	sbci	r25, 0xFE	; 254
        1e8a:	31 e0       	ldi	r19, 0x01	; 1
        1e8c:	4a 81       	ldd	r20, Y+2	; 0x02
        1e8e:	29 81       	ldd	r18, Y+1	; 0x01
        1e90:	42 17       	cp	r20, r18
        1e92:	09 f0       	breq	.+2      	; 0x1e96 <menu_1+0x4a6>
        1e94:	30 e0       	ldi	r19, 0x00	; 0
        1e96:	6e 89       	ldd	r22, Y+22	; 0x16
        1e98:	4f 89       	ldd	r20, Y+23	; 0x17
        1e9a:	25 e2       	ldi	r18, 0x25	; 37
        1e9c:	03 2f       	mov	r16, r19
        1e9e:	0e 94 0d 05 	call	0xa1a	; 0xa1a <LCD_string>
    			 				poz_y1_RAMKI, 
    			 				(wybor==poz_ramki ? NEGATYW:POZYTYW) ,
    			 				(wybor==poz_ramki ? POZYTYW:NEGATYW));
    	    }
    
    		for(poz_ramki=1;poz_ramki<MAX_POZ_WYSWIETLANYCH+1;poz_ramki++)
        1ea2:	89 81       	ldd	r24, Y+1	; 0x01
        1ea4:	8f 5f       	subi	r24, 0xFF	; 255
        1ea6:	89 83       	std	Y+1, r24	; 0x01
        1ea8:	89 81       	ldd	r24, Y+1	; 0x01
        1eaa:	86 30       	cpi	r24, 0x06	; 6
        1eac:	58 f2       	brcs	.-106    	; 0x1e44 <menu_1+0x454>
                 				    poz_x_NAPISU,
                  					poz_y_NAPISU,
                 					F3x6,
    								wybor==poz_ramki ? POZYTYW:NEGATYW);
    	    }                                                             
    			delay(1);
        1eae:	81 e0       	ldi	r24, 0x01	; 1
        1eb0:	0e 94 58 00 	call	0xb0	; 0xb0 <delay>
    			do                                        /* TO KOD POMIJANY W PROGRAMIE*/                     
    			{
    		 	// obsługa klawiszy menu podrzednego
    				if(~UP_PIN) // wybór w górę
    				{
    					wybor--;
        1eb4:	8a 81       	ldd	r24, Y+2	; 0x02
        1eb6:	81 50       	subi	r24, 0x01	; 1
        1eb8:	8a 83       	std	Y+2, r24	; 0x02
    					if(wybor<1) wybor=1;
        1eba:	8a 81       	ldd	r24, Y+2	; 0x02
        1ebc:	88 23       	and	r24, r24
        1ebe:	11 f4       	brne	.+4      	; 0x1ec4 <menu_1+0x4d4>
        1ec0:	81 e0       	ldi	r24, 0x01	; 1
        1ec2:	8a 83       	std	Y+2, r24	; 0x02
    				    if (wybor>MAX_POZ_WYSWIETLANYCH) przewin--;
        1ec4:	8a 81       	ldd	r24, Y+2	; 0x02
        1ec6:	86 30       	cpi	r24, 0x06	; 6
        1ec8:	28 f0       	brcs	.+10     	; 0x1ed4 <menu_1+0x4e4>
        1eca:	8b 81       	ldd	r24, Y+3	; 0x03
        1ecc:	9c 81       	ldd	r25, Y+4	; 0x04
        1ece:	01 97       	sbiw	r24, 0x01	; 1
        1ed0:	9c 83       	std	Y+4, r25	; 0x04
        1ed2:	8b 83       	std	Y+3, r24	; 0x03
        1ed4:	80 e0       	ldi	r24, 0x00	; 0
        1ed6:	90 e0       	ldi	r25, 0x00	; 0
        1ed8:	a8 e4       	ldi	r26, 0x48	; 72
        1eda:	b2 e4       	ldi	r27, 0x42	; 66
        1edc:	8e a3       	std	Y+38, r24	; 0x26
        1ede:	9f a3       	std	Y+39, r25	; 0x27
        1ee0:	a8 a7       	std	Y+40, r26	; 0x28
        1ee2:	b9 a7       	std	Y+41, r27	; 0x29
     */
    void
    _delay_ms(double __ms)
    {
    	uint16_t __ticks;
    	double __tmp = ((F_CPU) / 4e3) * __ms;
        1ee4:	6e a1       	ldd	r22, Y+38	; 0x26
        1ee6:	7f a1       	ldd	r23, Y+39	; 0x27
        1ee8:	88 a5       	ldd	r24, Y+40	; 0x28
        1eea:	99 a5       	ldd	r25, Y+41	; 0x29
        1eec:	20 e0       	ldi	r18, 0x00	; 0
        1eee:	30 e0       	ldi	r19, 0x00	; 0
        1ef0:	4a ef       	ldi	r20, 0xFA	; 250
        1ef2:	54 e4       	ldi	r21, 0x44	; 68
        1ef4:	0e 94 8c 14 	call	0x2918	; 0x2918 <__mulsf3>
        1ef8:	dc 01       	movw	r26, r24
        1efa:	cb 01       	movw	r24, r22
        1efc:	8a a7       	std	Y+42, r24	; 0x2a
        1efe:	9b a7       	std	Y+43, r25	; 0x2b
        1f00:	ac a7       	std	Y+44, r26	; 0x2c
        1f02:	bd a7       	std	Y+45, r27	; 0x2d
    	if (__tmp < 1.0)
        1f04:	11 e0       	ldi	r17, 0x01	; 1
        1f06:	6a a5       	ldd	r22, Y+42	; 0x2a
        1f08:	7b a5       	ldd	r23, Y+43	; 0x2b
        1f0a:	8c a5       	ldd	r24, Y+44	; 0x2c
        1f0c:	9d a5       	ldd	r25, Y+45	; 0x2d
        1f0e:	20 e0       	ldi	r18, 0x00	; 0
        1f10:	30 e0       	ldi	r19, 0x00	; 0
        1f12:	40 e8       	ldi	r20, 0x80	; 128
        1f14:	5f e3       	ldi	r21, 0x3F	; 63
        1f16:	0e 94 94 16 	call	0x2d28	; 0x2d28 <__ltsf2>
        1f1a:	88 23       	and	r24, r24
        1f1c:	0c f0       	brlt	.+2      	; 0x1f20 <menu_1+0x530>
        1f1e:	10 e0       	ldi	r17, 0x00	; 0
        1f20:	11 23       	and	r17, r17
        1f22:	29 f0       	breq	.+10     	; 0x1f2e <menu_1+0x53e>
    		__ticks = 1;
        1f24:	81 e0       	ldi	r24, 0x01	; 1
        1f26:	90 e0       	ldi	r25, 0x00	; 0
        1f28:	9f a7       	std	Y+47, r25	; 0x2f
        1f2a:	8e a7       	std	Y+46, r24	; 0x2e
        1f2c:	46 c0       	rjmp	.+140    	; 0x1fba <menu_1+0x5ca>
    	else if (__tmp > 65535)
        1f2e:	11 e0       	ldi	r17, 0x01	; 1
        1f30:	6a a5       	ldd	r22, Y+42	; 0x2a
        1f32:	7b a5       	ldd	r23, Y+43	; 0x2b
        1f34:	8c a5       	ldd	r24, Y+44	; 0x2c
        1f36:	9d a5       	ldd	r25, Y+45	; 0x2d
        1f38:	20 e0       	ldi	r18, 0x00	; 0
        1f3a:	3f ef       	ldi	r19, 0xFF	; 255
        1f3c:	4f e7       	ldi	r20, 0x7F	; 127
        1f3e:	57 e4       	ldi	r21, 0x47	; 71
        1f40:	0e 94 34 16 	call	0x2c68	; 0x2c68 <__gtsf2>
        1f44:	18 16       	cp	r1, r24
        1f46:	0c f0       	brlt	.+2      	; 0x1f4a <menu_1+0x55a>
        1f48:	10 e0       	ldi	r17, 0x00	; 0
        1f4a:	11 23       	and	r17, r17
        1f4c:	61 f1       	breq	.+88     	; 0x1fa6 <menu_1+0x5b6>
    	{
    		//	__ticks = requested delay in 1/10 ms
    		__ticks = (uint16_t) (__ms * 10.0);
        1f4e:	6e a1       	ldd	r22, Y+38	; 0x26
        1f50:	7f a1       	ldd	r23, Y+39	; 0x27
        1f52:	88 a5       	ldd	r24, Y+40	; 0x28
        1f54:	99 a5       	ldd	r25, Y+41	; 0x29
        1f56:	20 e0       	ldi	r18, 0x00	; 0
        1f58:	30 e0       	ldi	r19, 0x00	; 0
        1f5a:	40 e2       	ldi	r20, 0x20	; 32
        1f5c:	51 e4       	ldi	r21, 0x41	; 65
        1f5e:	0e 94 8c 14 	call	0x2918	; 0x2918 <__mulsf3>
        1f62:	dc 01       	movw	r26, r24
        1f64:	cb 01       	movw	r24, r22
        1f66:	bc 01       	movw	r22, r24
        1f68:	cd 01       	movw	r24, r26
        1f6a:	0e 94 b8 12 	call	0x2570	; 0x2570 <__fixunssfsi>
        1f6e:	dc 01       	movw	r26, r24
        1f70:	cb 01       	movw	r24, r22
        1f72:	9f a7       	std	Y+47, r25	; 0x2f
        1f74:	8e a7       	std	Y+46, r24	; 0x2e
        1f76:	12 c0       	rjmp	.+36     	; 0x1f9c <menu_1+0x5ac>
        1f78:	88 ec       	ldi	r24, 0xC8	; 200
        1f7a:	90 e0       	ldi	r25, 0x00	; 0
        1f7c:	99 ab       	std	Y+49, r25	; 0x31
        1f7e:	88 ab       	std	Y+48, r24	; 0x30
        1f80:	88 a9       	ldd	r24, Y+48	; 0x30
        1f82:	99 a9       	ldd	r25, Y+49	; 0x31
        1f84:	8c 01       	movw	r16, r24
        1f86:	c8 01       	movw	r24, r16
        1f88:	01 97       	sbiw	r24, 0x01	; 1
        1f8a:	f1 f7       	brne	.-4      	; 0x1f88 <menu_1+0x598>
        1f8c:	8c 01       	movw	r16, r24
        1f8e:	19 ab       	std	Y+49, r17	; 0x31
        1f90:	08 ab       	std	Y+48, r16	; 0x30
    		while(__ticks)
    		{
    			// wait 1/10 ms
    			_delay_loop_2(((F_CPU) / 4e3) / 10);
    			__ticks --;
        1f92:	8e a5       	ldd	r24, Y+46	; 0x2e
        1f94:	9f a5       	ldd	r25, Y+47	; 0x2f
        1f96:	01 97       	sbiw	r24, 0x01	; 1
        1f98:	9f a7       	std	Y+47, r25	; 0x2f
        1f9a:	8e a7       	std	Y+46, r24	; 0x2e
    		__ticks = 1;
    	else if (__tmp > 65535)
    	{
    		//	__ticks = requested delay in 1/10 ms
    		__ticks = (uint16_t) (__ms * 10.0);
    		while(__ticks)
        1f9c:	8e a5       	ldd	r24, Y+46	; 0x2e
        1f9e:	9f a5       	ldd	r25, Y+47	; 0x2f
        1fa0:	00 97       	sbiw	r24, 0x00	; 0
        1fa2:	51 f7       	brne	.-44     	; 0x1f78 <menu_1+0x588>
        1fa4:	17 c0       	rjmp	.+46     	; 0x1fd4 <menu_1+0x5e4>
    			__ticks --;
    		}
    		return;
    	}
    	else
    		__ticks = (uint16_t)__tmp;
        1fa6:	6a a5       	ldd	r22, Y+42	; 0x2a
        1fa8:	7b a5       	ldd	r23, Y+43	; 0x2b
        1faa:	8c a5       	ldd	r24, Y+44	; 0x2c
        1fac:	9d a5       	ldd	r25, Y+45	; 0x2d
        1fae:	0e 94 b8 12 	call	0x2570	; 0x2570 <__fixunssfsi>
        1fb2:	dc 01       	movw	r26, r24
        1fb4:	cb 01       	movw	r24, r22
        1fb6:	9f a7       	std	Y+47, r25	; 0x2f
        1fb8:	8e a7       	std	Y+46, r24	; 0x2e
        1fba:	8e a5       	ldd	r24, Y+46	; 0x2e
        1fbc:	9f a5       	ldd	r25, Y+47	; 0x2f
        1fbe:	9b ab       	std	Y+51, r25	; 0x33
        1fc0:	8a ab       	std	Y+50, r24	; 0x32
        1fc2:	8a a9       	ldd	r24, Y+50	; 0x32
        1fc4:	9b a9       	ldd	r25, Y+51	; 0x33
        1fc6:	8c 01       	movw	r16, r24
        1fc8:	f8 01       	movw	r30, r16
        1fca:	31 97       	sbiw	r30, 0x01	; 1
        1fcc:	f1 f7       	brne	.-4      	; 0x1fca <menu_1+0x5da>
        1fce:	8f 01       	movw	r16, r30
        1fd0:	1b ab       	std	Y+51, r17	; 0x33
        1fd2:	0a ab       	std	Y+50, r16	; 0x32
    				}
    			
    			}while(SET_LEFT_PIN);                         /*KONIEC KODU POMINIETEGO*/
    			_delay_ms(WAIT);
    
    	}while(SET_LEFT_PIN);
        1fd4:	89 e3       	ldi	r24, 0x39	; 57
        1fd6:	90 e0       	ldi	r25, 0x00	; 0
        1fd8:	fc 01       	movw	r30, r24
        1fda:	80 81       	ld	r24, Z
        1fdc:	88 2f       	mov	r24, r24
        1fde:	90 e0       	ldi	r25, 0x00	; 0
        1fe0:	80 71       	andi	r24, 0x10	; 16
        1fe2:	90 70       	andi	r25, 0x00	; 0
        1fe4:	00 97       	sbiw	r24, 0x00	; 0
        1fe6:	09 f0       	breq	.+2      	; 0x1fea <menu_1+0x5fa>
        1fe8:	e4 ce       	rjmp	.-568    	; 0x1db2 <menu_1+0x3c2>
    }//end menu1
  • #7 10545614
    tmf
    VIP Zasłużony dla elektroda
    5657jz napisał:
    #define PIN(x) (*(&x - 2)) 


    To jest błędne. Powinno być volatile, inaczej kompilator to optymalizuje do stałej (bo przecież w pętli się nie zmienia) i wylicza wartość wyrażenia, po czym wywala całą pętlę.
  • #8 10545776
    5657jz
    Poziom 14  
    Nie panimaju.
    Ja rozumiałem tak: Osiagajac koniec pętli, sprawdzanay jest warunek
    (PIN(PORTD) & 1<<2) który przyjmuje wartość 1 lub 0.
    "powinno byc volatile" tz. że mam zadeklarować zmienna volatile, w petli ja sprawdzć, i podstawiac w warunku wyjscia z "do". Tym bardziej nie rozumiem . Bo w drugim menu, pomimo takiego samego kodu nic sie nie wywala.
  • #9 10545892
    tmf
    VIP Zasłużony dla elektroda
    Kompilator nie będzie sprawdzał cyklicznie zmiennej, co do której wie, że się nie zmienia. Jak napiszesz x=1, to wiesz, że tak jest i tego nie sprawdzasz, prawda? To tylko ty wiesz, że twój wskaźnik wskazuje na zasób sprzętowy, jakim jest rejestr PIN i wartość wskazywanej komórki może się zmieniać, musisz tylko przekazać tą informację kompilatorowi - do tego m.in. służy volatile. To, że inny kod działał to może być 100 różnych powodów, najogólniej potraktuj działanie owego innego kodu jak zwykły zbieg okoliczności.
    Poza tym unikaj define - to nie jest zabawka dla początkującego, chyba, że lubisz problemy. W czym to define jest lepsze od zwykłej funkcji?
  • #10 10545935
    5657jz
    Poziom 14  
    Czyli mam zadeklarować zmienną volatile, ją sprawdzać, i podstawić w warunku ? TAK

    I jeszcze dopisek:

    A co by było:
    Kod: C / C++
    Zaloguj się, aby zobaczyć kod
  • #11 10546019
    nsvinc
    Poziom 35  
    Zupełnie nie rozumiesz C.
    Przed typedef nie stawia się hasha
    Typedef z samego kwalifikatora raczej nie przejdzie...

    Po co ci nawiasy do #define ESC, skoro nie przekazujesz do makra żadnego argumentu?

    Czytam ten kod i czytam, i tak naprawdę nie wiem co chcesz tymi makrami i typedefem osiągnąć...
  • #12 10546022
    tmf
    VIP Zasłużony dla elektroda
    volatile to nie jest typ, więc taka definicja nie jest poprawna. Poza tym volatile ma się odnosić do operacji dostępu do pamięci a nie wyrażenia. Najlepiej przestudiuj nagłówek io.h i pliki na które wskazuje, gdzie masz przykłady takich definicji.
    Swoją drogą skąd wziąłeś takie dziwaczne makro?
  • #13 10546391
    5657jz
    Poziom 14  
    Brak mi wiedzy - fakt.
    Trudno jest coś napisać, jak sie nie rozumie, co się robi.
    Jeszcze raz:
    
    // config.h
    #define  KL_PORT             PORTA
    #define  LEFT_PIN            4     
    #define  SET_LEFT_PIN		PIN(KL_PORT) & 1<<LEFT_PIN  
    


    w wyjściu z petli : }while(SET_LEFT_PIN) // puki nie nacisnę klawisza pozostaje w pętli.

    Chcę osiągnąć to aby: Kiedy zmienię procka na inny - w konfiguracji (config.h)
    zmieniając port i pin podłączenia, program działał z nowymi ustawieniami klawisza.
    Szukam rozwiązania co i jak wstawić w warunku.
    Jeśli to powyżej, nie ma prawa działać, to może tak:
     }while(zmienna);      // zmienna to volatile
    

    czy taki
    }while(sprawdz_klawisz( KL_PORT, LEFT_PIN ));
    

    Czy są inne sposoby, o których nie wiem. Jakie ?

    Nie wiem, czy zrozumiale wyłuszczyłem mój cel.
  • #14 10546525
    tmf
    VIP Zasłużony dla elektroda
    Są. Poczytaj o preprocesorze, zobacz jak się tworzy makra, konkretnie co to jest macro Concatenation i jak się tego używa. Zakup książkę o C, na forum się języka nie nauczysz, a błądząc po omacku nic sensownego nie stworzysz. Do tej pory już się dowiedziałeś jak rozwiązać twój problem, ale bez głębszego zrozumienia te informacje są zupełnie nieprzydatne.
  • #15 10546553
    5657jz
    Poziom 14  
    OK. Dzięki.
  • #16 10547060
    Fredy
    Poziom 27  
    Podepnę się pod temat bo sam mam też pewne wątpliwości .

    Jak widać w kodzie który kolega tu wkleił kompilator wyciął fragment kodu bo według niego nie wynikało wprost z kodu że może się zmienić. Przyczyna tkwiła w użyciu odczytu rejestru IO PIN.
    Moje pytanie , co z innymi rejestrami? Dam przykład wprost skopiowany z DS ATMEGI:

    Kod: C / C++
    Zaloguj się, aby zobaczyć kod


    czy tu także istnieje niebezpieczeństwo że kompilator zafiksuje? Przecież rejestr UCSRnA też nie wynika aby miał się zmienić wprost z kodu? A to jest przecież kod wprost od ATMELA.
    Operacje na rejestrach które zmieniają się sprzętowo są bardzo częste. Nie widać aby programiści namiętnie używali Volatile we wszystkich tych przypadkach , a jednak te programy działają.
  • #17 10547595
    alagner
    Poziom 26  
    rejestry są już zadeklarowane jako volatile w odp. pliku nagłówkowym.
  • #18 10547886
    Fredy
    Poziom 27  
    A rejestr PIN czemu nie został zadeklarowany jako volatile?
  • #19 10547943
    tmf
    VIP Zasłużony dla elektroda
    Bo to jego PIN miało tylko przypadkową zbieżność nazw z rejestrem PINx. Zobacz na pokazaną przez niego definicję makra PIN.
  • #20 10548307
    5657jz
    Poziom 14  
    Jeszcze wrócę jako autor tego tematu.
    Zastrzegam że , mało wiem o "C" jak i kompilatorach.
    Otóż: Pętla "do" powyżej miała złą konstrukcje. Szczególnie if-y.
    Definicje PIN(x) w dalszym ciągu uważam za właściwą.
    Sytuację rozwiązał poniższy kod. (dotyczy: wejścia do pętli "do", i korzystania z if-ów. Zagadką dla mnie jest, czemu pętla drugiego menu, o którym pisałem,mimo jej konstrukcji -jak powyżej -działa prawidłowo.
    do                                        /* TO KOD POMIJANY W PROGRAMIE*/                     
    			{  
    				
    		 	// obsługa klawiszy menu podrzednego
    				if(!(PIN(KL_PORT) & 1<<UP_PIN)) // wybór w górę   
    				{
    					wybor--;
    					if(wybor<1) wybor=1;
    				    if (wybor>MAX_POZ_WYSWIETLANYCH) przewin--;
    					break;	
    				}
    				else if(!(PIN(KL_PORT) & 1<<DOWN_PIN))  // wybór w dół   
    				{
    					wybor++;
    				    if (wybor>24) wybor=24;
    					if (wybor>MAX_POZ_WYSWIETLANYCH) przewin++;
    					break;
    				}
    				else if(!(PIN(KL_PORT) & 1<<OK_PIN))          // zatwierdzono wybór  
    				{
    					//menu_1(menu1[poz_ramki-1].addr_EE_podmenu);
    					break;
    				}
    			  
    			}while(SET_LEFT_PIN);     /*KONIEC KODU POMINIETEGO*/
  • #21 10548361
    gaskoin
    Poziom 38  
    5657jz napisał:

    Definicje PIN(x) w dalszym ciągu uważam za właściwą.


    Więc nikt więcej Ci już nie będzie pomagał w tym temacie.
  • #24 10549525
    5657jz
    Poziom 14  
    O co Wam chodzi ?
    Jaki pojazd.? Kto pomógł.? Kto wytłumaczył ?

    Naprowadził mnie "tmf", Dla mnie coś istotnego podpowiedział, na co kiedyś zwrócę uwagę. Serdeczne dzięki.

    Nie wiem, jak zadeklarować rejestr jako volatile. Poprostu nie wiem.
    Co Chcecie od makra PIN - dla mnie: zwraca ono, wartość rejestru PINx
    Nie widzę nic tam przypadkowego?

    Co do książek - dają podstawy. W praktyce - albo po męczarniach samemu sie dojdzie wiedzy, albo Ktoś musi pomóc.
    Więc wytrząsanie sie nad laikiem - na pewno, nie pomoże w ogarnięciu "C"
    A Kogoś raczej zniechęci.
  • #26 10550247
    5657jz
    Poziom 14  
    Treść linku - Znam i rozumiem.
    uC to ATmega 16.

    Jeżeli możesz, wytłumacz mi : cytat od "tmf""

    "#define PIN(x) (*(&x - 2))
    To jest błędne. Powinno być volatile, ....."

    Co miał na myśli, jak z tego zrobić volatile.
    Czy chodziło Mu o to:
    unsigned char volatile zmienna;
    zmienna=PINA; lub zmienna=PIN(PORTA);
     a dalej, już w kodzie:    }while(zmienna & 1<<LEFT_PIN)
    
  • #28 10550322
    gaskoin
    Poziom 38  
    Fredy z punktu widzenia kompilatora różnica jest naprawdę niewielka.
    Rejestry są definiowane jako bezpośrednie miejsce w "pamięci" poprzez ich adres. Do zmiennej możesz się przecież odwołać tak samo.
  • #29 10550356
    5657jz
    Poziom 14  
    No i tego właśnie chcę sie dowiedziec jak to zrobić. REJSTR -volatile
    #define (volatile) REJESTR *(&PINA) ????????????
  • #30 10550370
    Fredy
    Poziom 27  
    gaskoin napisał:
    Fredy z punktu widzenia kompilatora różnica jest naprawdę niewielka.
    Rejestry są definiowane jako bezpośrednie miejsce w "pamięci" poprzez ich adres. Do zmiennej możesz się przecież odwołać tak samo.


    wiem o tym.
    Ale fakt jest faktem , że nikt dotychczas nie podpowiedział jak uporać się z tym problemem.

    Ten banalny fragment kodu, podobno może nie działać prawidłowo :

    Kod: C / C++
    Zaloguj się, aby zobaczyć kod


    w jaki sposób należy go poprawić, aby uzyskać Volatilowość rejestru PIN?
REKLAMA