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

atmega8a-pu + bootloader + przerwania - dziwne zachowanie timer1

DmZ 28 Lut 2012 23:09 1523 5
REKLAMA
  • #1 10613160
    DmZ
    Poziom 18  
    Witam. mam mały kłopot z przerwaniami w bootloaderze na wymienionym procesorze (dataszit o ile mnie oczy nie mylą, mowi ze adresacja sekcji pamieci flash jest taka sama jak w zwyklej atmedze8)

    proc ustawiony na wielkosc sekcji boot na 1024 słowa, po resecie wskakuje do bootloadera.
    program skompilowany pod 0xC00 czyli w makefile de facto adres .text jest 0x1800 (korzystam z avrstudio4 wiec to automatycznie ustawia)

    uruchamiam proca, bootloader sie odpala ładnie. bez przerwań, chodzi pięknie, inkrementuje sobie zmienna i wywala tekst na rs232 gdzie widze ze jest ciągłość i ze cały czas uruchomiony jest bootloader - w sensie że nie resetuje proca.

    teraz jak dodam obsluge przerwań to owszem wykonują się jakies cuda, ale nie te co potrzeba. timer1 generuje przerwanie, ale procesor zachowuje się tak jakby nie było ono w ogole oprogramowane i wyskakuje z bootloadera nie wchodząc w obsługę przerwania.

    program skompilowany na adres 0x000 chodzi bez błędów, timer działa jak trzeba. to samo skompilowane pod 0xc00 i wsadzone na 0x1800 nie działa.

    nie wiem co moze byc przyczyna moje błedy czy co, ale powoli konczą mi sie pomysly.

    Proc chodzi na 8MHz wewn. Jakby ktos mógł przetestowac to baudrate = 38400

    Poniżej kod 'bootloadera' uproszczony do minimum, pozbawiony funkcji zapisujacych w pamieci. ot taki maly programik odpalany w sekcji bootloadera, korzystający z przerwań.

    Kod: text
    Zaloguj się, aby zobaczyć kod


    Timer wywala przerwanie co około 5 sekund wiec trzeba poczekać.


    Jakby ktoś przytomniejszym niż mój wzrokiem to obejrzał i doradził co robie źle byłbym wdziędzny.

    Pozdrawiam
    Dmz
  • REKLAMA
  • #2 10613213
    tmf
    VIP Zasłużony dla elektroda
    A jak masz ustawione fusebity? Nie przesuwałeś tabeli wektorów przerwań?
    Pokaż wygenerowany plik lss, tam znajdziesz odpowiedzi. Najpewniej jeśli przesunąłeś sekcję .text do bootloadera to zrobiłeś to razem z tabelą wektorów przerwań, przy braku ustawienia IVSEL procesor bierze wektory przerwań spod adresu 1 i kolejnych, a tam masz same 0xFFFF.
  • REKLAMA
  • #3 10613309
    DmZ
    Poziom 18  
    tablica wektorow przerwań jest ustawiona na bootloader. chyba ze to źle robie...

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



    *.lss poniżej:

    boottest2.elf:     file format elf32-avr
    
    Sections:
    Idx Name          Size      VMA       LMA       File off  Algn
      0 .text         00000158  00001800  00001800  00000094  2**1
                      CONTENTS, ALLOC, LOAD, READONLY, CODE
      1 .data         0000002a  00800060  00001958  000001ec  2**0
                      CONTENTS, ALLOC, LOAD, DATA
      2 .bss          00000002  0080008a  0080008a  00000216  2**0
                      ALLOC
      3 .debug_aranges 00000020  00000000  00000000  00000216  2**0
                      CONTENTS, READONLY, DEBUGGING
      4 .debug_pubnames 0000008e  00000000  00000000  00000236  2**0
                      CONTENTS, READONLY, DEBUGGING
      5 .debug_info   00000228  00000000  00000000  000002c4  2**0
                      CONTENTS, READONLY, DEBUGGING
      6 .debug_abbrev 0000016e  00000000  00000000  000004ec  2**0
                      CONTENTS, READONLY, DEBUGGING
      7 .debug_line   0000027b  00000000  00000000  0000065a  2**0
                      CONTENTS, READONLY, DEBUGGING
      8 .debug_frame  00000090  00000000  00000000  000008d8  2**2
                      CONTENTS, READONLY, DEBUGGING
      9 .debug_str    000000dd  00000000  00000000  00000968  2**0
                      CONTENTS, READONLY, DEBUGGING
     10 .debug_loc    00000040  00000000  00000000  00000a45  2**0
                      CONTENTS, READONLY, DEBUGGING
     11 .debug_ranges 00000018  00000000  00000000  00000a85  2**0
                      CONTENTS, READONLY, DEBUGGING
    
    Disassembly of section .text:
    
    00001800 <__vectors>:
        1800:	12 c0       	rjmp	.+36     	; 0x1826 <__ctors_end>
        1802:	2c c0       	rjmp	.+88     	; 0x185c <__bad_interrupt>
        1804:	2b c0       	rjmp	.+86     	; 0x185c <__bad_interrupt>
        1806:	2a c0       	rjmp	.+84     	; 0x185c <__bad_interrupt>
        1808:	29 c0       	rjmp	.+82     	; 0x185c <__bad_interrupt>
        180a:	28 c0       	rjmp	.+80     	; 0x185c <__bad_interrupt>
        180c:	27 c0       	rjmp	.+78     	; 0x185c <__bad_interrupt>
        180e:	26 c0       	rjmp	.+76     	; 0x185c <__bad_interrupt>
        1810:	4f c0       	rjmp	.+158    	; 0x18b0 <__vector_8>
        1812:	24 c0       	rjmp	.+72     	; 0x185c <__bad_interrupt>
        1814:	23 c0       	rjmp	.+70     	; 0x185c <__bad_interrupt>
        1816:	22 c0       	rjmp	.+68     	; 0x185c <__bad_interrupt>
        1818:	21 c0       	rjmp	.+66     	; 0x185c <__bad_interrupt>
        181a:	20 c0       	rjmp	.+64     	; 0x185c <__bad_interrupt>
        181c:	1f c0       	rjmp	.+62     	; 0x185c <__bad_interrupt>
        181e:	1e c0       	rjmp	.+60     	; 0x185c <__bad_interrupt>
        1820:	1d c0       	rjmp	.+58     	; 0x185c <__bad_interrupt>
        1822:	1c c0       	rjmp	.+56     	; 0x185c <__bad_interrupt>
        1824:	1b c0       	rjmp	.+54     	; 0x185c <__bad_interrupt>
    
    00001826 <__ctors_end>:
        1826:	11 24       	eor	r1, r1
        1828:	1f be       	out	0x3f, r1	; 63
        182a:	cf e5       	ldi	r28, 0x5F	; 95
        182c:	d4 e0       	ldi	r29, 0x04	; 4
        182e:	de bf       	out	0x3e, r29	; 62
        1830:	cd bf       	out	0x3d, r28	; 61
    
    00001832 <__do_copy_data>:
        1832:	10 e0       	ldi	r17, 0x00	; 0
        1834:	a0 e6       	ldi	r26, 0x60	; 96
        1836:	b0 e0       	ldi	r27, 0x00	; 0
        1838:	e8 e5       	ldi	r30, 0x58	; 88
        183a:	f9 e1       	ldi	r31, 0x19	; 25
        183c:	02 c0       	rjmp	.+4      	; 0x1842 <.do_copy_data_start>
    
    0000183e <.do_copy_data_loop>:
        183e:	05 90       	lpm	r0, Z+
        1840:	0d 92       	st	X+, r0
    
    00001842 <.do_copy_data_start>:
        1842:	aa 38       	cpi	r26, 0x8A	; 138
        1844:	b1 07       	cpc	r27, r17
        1846:	d9 f7       	brne	.-10     	; 0x183e <.do_copy_data_loop>
    
    00001848 <__do_clear_bss>:
        1848:	10 e0       	ldi	r17, 0x00	; 0
        184a:	aa e8       	ldi	r26, 0x8A	; 138
        184c:	b0 e0       	ldi	r27, 0x00	; 0
        184e:	01 c0       	rjmp	.+2      	; 0x1852 <.do_clear_bss_start>
    
    00001850 <.do_clear_bss_loop>:
        1850:	1d 92       	st	X+, r1
    
    00001852 <.do_clear_bss_start>:
        1852:	ac 38       	cpi	r26, 0x8C	; 140
        1854:	b1 07       	cpc	r27, r17
        1856:	e1 f7       	brne	.-8      	; 0x1850 <.do_clear_bss_loop>
        1858:	56 d0       	rcall	.+172    	; 0x1906 <main>
        185a:	7c c0       	rjmp	.+248    	; 0x1954 <_exit>
    
    0000185c <__bad_interrupt>:
        185c:	d1 cf       	rjmp	.-94     	; 0x1800 <__vectors>
    
    0000185e <waitms>:
    #include <avr/boot.h>
    #include <avr/interrupt.h> 
     volatile uint8_t T1;  
     volatile char T2;
    void waitms(char x) 
    { 
        185e:	08 c0       	rjmp	.+16     	; 0x1870 <waitms+0x12>
    unsigned char a, b;  
    for( ; x > 0; --x) 
      for(b = 10; b > 0; --b) 
       for(a = 100; a > 0; --a) 
       __asm("nop"); 
        1860:	00 00       	nop
    void waitms(char x) 
    { 
    unsigned char a, b;  
    for( ; x > 0; --x) 
      for(b = 10; b > 0; --b) 
       for(a = 100; a > 0; --a) 
        1862:	91 50       	subi	r25, 0x01	; 1
        1864:	e9 f7       	brne	.-6      	; 0x1860 <waitms+0x2>
     volatile char T2;
    void waitms(char x) 
    { 
    unsigned char a, b;  
    for( ; x > 0; --x) 
      for(b = 10; b > 0; --b) 
        1866:	21 50       	subi	r18, 0x01	; 1
        1868:	11 f0       	breq	.+4      	; 0x186e <waitms+0x10>
        186a:	94 e6       	ldi	r25, 0x64	; 100
        186c:	f9 cf       	rjmp	.-14     	; 0x1860 <waitms+0x2>
     volatile uint8_t T1;  
     volatile char T2;
    void waitms(char x) 
    { 
    unsigned char a, b;  
    for( ; x > 0; --x) 
        186e:	81 50       	subi	r24, 0x01	; 1
        1870:	88 23       	and	r24, r24
        1872:	11 f0       	breq	.+4      	; 0x1878 <waitms+0x1a>
        1874:	2a e0       	ldi	r18, 0x0A	; 10
        1876:	f9 cf       	rjmp	.-14     	; 0x186a <waitms+0xc>
        1878:	08 95       	ret
    
    0000187a <USART_Init>:
    } 
    
    void USART_Init( unsigned int ubrr) 
    { 
    /* Set baud rate */ 
    UBRRH = (unsigned char)(ubrr>>8); 
        187a:	90 bd       	out	0x20, r25	; 32
    UBRRL = (unsigned char)ubrr; 
        187c:	89 b9       	out	0x09, r24	; 9
    /* Enable receiver and transmitter */ 
    UCSRB = (1<<RXEN)|(1<<TXEN); 
        187e:	88 e1       	ldi	r24, 0x18	; 24
        1880:	8a b9       	out	0x0a, r24	; 10
    /* Set frame format: 8data, 2stop bit */ 
    UCSRC = (1<<URSEL)|(1<<USBS)|(3<<UCSZ0); 
        1882:	8e e8       	ldi	r24, 0x8E	; 142
        1884:	80 bd       	out	0x20, r24	; 32
    UCSRB = (1<<RXEN)|(1<<TXEN)|(1<<RXC); // zezwolenie na przerwania od uarta
        1886:	88 e9       	ldi	r24, 0x98	; 152
        1888:	8a b9       	out	0x0a, r24	; 10
    } 
        188a:	08 95       	ret
    
    0000188c <USART_Transmit>:
    
    void USART_Transmit( unsigned char data ) 
    { 
    while ( !( UCSRA & (1<<UDRE)) ) ;
        188c:	5d 9b       	sbis	0x0b, 5	; 11
        188e:	fe cf       	rjmp	.-4      	; 0x188c <USART_Transmit>
    UDR = data; 
        1890:	8c b9       	out	0x0c, r24	; 12
    } 
        1892:	08 95       	ret
    
    00001894 <USART_Receive>:
    
    unsigned char USART_Receive( void ) 
    { 
    while ( !(UCSRA & (1<<RXC)) ); 
        1894:	5f 9b       	sbis	0x0b, 7	; 11
        1896:	fe cf       	rjmp	.-4      	; 0x1894 <USART_Receive>
    return UDR; 
        1898:	8c b1       	in	r24, 0x0c	; 12
    } 
        189a:	08 95       	ret
    
    0000189c <pisztekst>:
    
    void pisztekst(char *text) // wyswietlenie textu 
    { 
        189c:	fc 01       	movw	r30, r24
        189e:	04 c0       	rjmp	.+8      	; 0x18a8 <pisztekst+0xc>
    UCSRB = (1<<RXEN)|(1<<TXEN)|(1<<RXC); // zezwolenie na przerwania od uarta
    } 
    
    void USART_Transmit( unsigned char data ) 
    { 
    while ( !( UCSRA & (1<<UDRE)) ) ;
        18a0:	5d 9b       	sbis	0x0b, 5	; 11
        18a2:	fe cf       	rjmp	.-4      	; 0x18a0 <pisztekst+0x4>
    return UDR; 
    } 
    
    void pisztekst(char *text) // wyswietlenie textu 
    { 
    while (*text)USART_Transmit
        18a4:	31 96       	adiw	r30, 0x01	; 1
    } 
    
    void USART_Transmit( unsigned char data ) 
    { 
    while ( !( UCSRA & (1<<UDRE)) ) ;
    UDR = data; 
        18a6:	8c b9       	out	0x0c, r24	; 12
    return UDR; 
    } 
    
    void pisztekst(char *text) // wyswietlenie textu 
    { 
    while (*text)USART_Transmit
        18a8:	80 81       	ld	r24, Z
        18aa:	88 23       	and	r24, r24
        18ac:	c9 f7       	brne	.-14     	; 0x18a0 <pisztekst+0x4>
    (*text++); 
    } 
        18ae:	08 95       	ret
    
    000018b0 <__vector_8>:
    
    ISR (TIMER1_OVF_vect) 
     { 
        18b0:	1f 92       	push	r1
        18b2:	0f 92       	push	r0
        18b4:	0f b6       	in	r0, 0x3f	; 63
        18b6:	0f 92       	push	r0
        18b8:	11 24       	eor	r1, r1
        18ba:	8f 93       	push	r24
        18bc:	9f 93       	push	r25
         T1++; 
        18be:	80 91 8b 00 	lds	r24, 0x008B
        18c2:	8f 5f       	subi	r24, 0xFF	; 255
        18c4:	80 93 8b 00 	sts	0x008B, r24
    	 T2++;
        18c8:	80 91 8a 00 	lds	r24, 0x008A
        18cc:	8f 5f       	subi	r24, 0xFF	; 255
        18ce:	80 93 8a 00 	sts	0x008A, r24
    	PORTB ^= T1;
        18d2:	98 b3       	in	r25, 0x18	; 24
        18d4:	80 91 8b 00 	lds	r24, 0x008B
        18d8:	89 27       	eor	r24, r25
        18da:	88 bb       	out	0x18, r24	; 24
    	USART_Transmit(T2);
        18dc:	80 91 8a 00 	lds	r24, 0x008A
    UCSRB = (1<<RXEN)|(1<<TXEN)|(1<<RXC); // zezwolenie na przerwania od uarta
    } 
    
    void USART_Transmit( unsigned char data ) 
    { 
    while ( !( UCSRA & (1<<UDRE)) ) ;
        18e0:	5d 9b       	sbis	0x0b, 5	; 11
        18e2:	fe cf       	rjmp	.-4      	; 0x18e0 <__vector_8+0x30>
    UDR = data; 
        18e4:	8c b9       	out	0x0c, r24	; 12
     { 
         T1++; 
    	 T2++;
    	PORTB ^= T1;
    	USART_Transmit(T2);
     }
        18e6:	9f 91       	pop	r25
        18e8:	8f 91       	pop	r24
        18ea:	0f 90       	pop	r0
        18ec:	0f be       	out	0x3f, r0	; 63
        18ee:	0f 90       	pop	r0
        18f0:	1f 90       	pop	r1
        18f2:	18 95       	reti
    
    000018f4 <init>:
    
    
     void init(void) 
     { 
         TCCR1A = (0<<WGM11) | (0<<WGM10); 
        18f4:	1f bc       	out	0x2f, r1	; 47
         TCCR1B = (0<<WGM13) | (0<<WGM12) | (1<<CS12) | (0<<CS11) | (1<<CS10); 
        18f6:	85 e0       	ldi	r24, 0x05	; 5
        18f8:	8e bd       	out	0x2e, r24	; 46
         sei(); 
        18fa:	78 94       	sei
         TIMSK = (1<<TOIE1); 
        18fc:	84 e0       	ldi	r24, 0x04	; 4
        18fe:	89 bf       	out	0x39, r24	; 57
         DDRB = 0xff; 
        1900:	8f ef       	ldi	r24, 0xFF	; 255
        1902:	87 bb       	out	0x17, r24	; 23
     } 
        1904:	08 95       	ret
    
    00001906 <main>:
                          
    
     int main(void) 
     { 
    
     	T2 = 'a';
        1906:	81 e6       	ldi	r24, 0x61	; 97
        1908:	80 93 8a 00 	sts	0x008A, r24
    	cli();  
        190c:	f8 94       	cli
    	DDRB = 0xff;
        190e:	8f ef       	ldi	r24, 0xFF	; 255
        1910:	87 bb       	out	0x17, r24	; 23
    	PORTB = 0xff;
        1912:	88 bb       	out	0x18, r24	; 24
    } 
    
    void USART_Init( unsigned int ubrr) 
    { 
    /* Set baud rate */ 
    UBRRH = (unsigned char)(ubrr>>8); 
        1914:	10 bc       	out	0x20, r1	; 32
    UBRRL = (unsigned char)ubrr; 
        1916:	8c e0       	ldi	r24, 0x0C	; 12
        1918:	89 b9       	out	0x09, r24	; 9
    /* Enable receiver and transmitter */ 
    UCSRB = (1<<RXEN)|(1<<TXEN); 
        191a:	88 e1       	ldi	r24, 0x18	; 24
        191c:	8a b9       	out	0x0a, r24	; 10
    /* Set frame format: 8data, 2stop bit */ 
    UCSRC = (1<<URSEL)|(1<<USBS)|(3<<UCSZ0); 
        191e:	8e e8       	ldi	r24, 0x8E	; 142
        1920:	80 bd       	out	0x20, r24	; 32
    UCSRB = (1<<RXEN)|(1<<TXEN)|(1<<RXC); // zezwolenie na przerwania od uarta
        1922:	88 e9       	ldi	r24, 0x98	; 152
        1924:	8a b9       	out	0x0a, r24	; 10
     	T2 = 'a';
    	cli();  
    	DDRB = 0xff;
    	PORTB = 0xff;
    	USART_Init(12);
    	MCUCR = (1<<IVCE);
        1926:	81 e0       	ldi	r24, 0x01	; 1
        1928:	85 bf       	out	0x35, r24	; 53
      	MCUCR = (1<<IVSEL); 
        192a:	82 e0       	ldi	r24, 0x02	; 2
        192c:	85 bf       	out	0x35, r24	; 53
    	 pisztekst("init");
        192e:	80 e6       	ldi	r24, 0x60	; 96
        1930:	90 e0       	ldi	r25, 0x00	; 0
        1932:	b4 df       	rcall	.-152    	; 0x189c <pisztekst>
     }
    
    
     void init(void) 
     { 
         TCCR1A = (0<<WGM11) | (0<<WGM10); 
        1934:	1f bc       	out	0x2f, r1	; 47
         TCCR1B = (0<<WGM13) | (0<<WGM12) | (1<<CS12) | (0<<CS11) | (1<<CS10); 
        1936:	85 e0       	ldi	r24, 0x05	; 5
        1938:	8e bd       	out	0x2e, r24	; 46
         sei(); 
        193a:	78 94       	sei
         TIMSK = (1<<TOIE1); 
        193c:	84 e0       	ldi	r24, 0x04	; 4
        193e:	89 bf       	out	0x39, r24	; 57
         DDRB = 0xff; 
        1940:	8f ef       	ldi	r24, 0xFF	; 255
        1942:	87 bb       	out	0x17, r24	; 23
    	 pisztekst("init");
         init(); 
         while (1) 
         { 
           
    	if(T2 == 'd'){
        1944:	80 91 8a 00 	lds	r24, 0x008A
        1948:	84 36       	cpi	r24, 0x64	; 100
        194a:	e1 f7       	brne	.-8      	; 0x1944 <main+0x3e>
    		pisztekst("tu bootloader w ogole nie wchodzi..");
        194c:	85 e6       	ldi	r24, 0x65	; 101
        194e:	90 e0       	ldi	r25, 0x00	; 0
        1950:	a5 df       	rcall	.-182    	; 0x189c <pisztekst>
        1952:	f8 cf       	rjmp	.-16     	; 0x1944 <main+0x3e>
    
    00001954 <_exit>:
        1954:	f8 94       	cli
    
    00001956 <__stop_program>:
        1956:	ff cf       	rjmp	.-2      	; 0x1956 <__stop_program>
    
  • REKLAMA
  • Pomocny post
    #4 10613362
    tmf
    VIP Zasłużony dla elektroda
    Zmieniasz wektory w rejestrze MCUCR, a odpowiednie bity są w rejestrze GICR. Więc table jest nie tam gdzie trzeba.
  • REKLAMA
  • #5 10613405
    DmZ
    Poziom 18  
    działa takie coś:

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


    powrot tablic na miejsce jak rozumiem:


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



    pozdrawiam i dzięki za pomoc :)
  • #6 10621825
    DmZ
    Poziom 18  
    witam sorki ze odgrzebuje,

    ale mam jeszcze jedno zasadnicze pytanie.
    otóż wlasnie pisze program od strony pc karmiący bootloader danymi, ale mam kłopot z obróbką pliku hex po stronie pc - o ile taka w ogole jest potrzebna.

    pare zdan wyjasnienia: w sieci pracuje pare urządzeń. kazde adresowane. wiec protokół w skrocie jest taki ze ramka jest stała pod wzgledem dlugosci i posiada stałą ilosc miejsca w ramce na przesyłane dane (6 bajtow).

    wiec dane przesyłąne do proca oczywiscie musze sobie posklejac.
    to nie problem.

    pytanie brzmi - jak przygotowac plik po stronie PC?
    zrobilem sobie taki parserek zgodnie z dokumentacja intel hex. i dopoki nie trafie na taki kwiatek:

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


    jak narazie odrywalem czesc adresu i typu danych, crc, przesyłałem po 4 bajty gołego kodu i sklejałem jako strone po kolei.
    dopoki nie ma zajawek innymi adresami / dziurami wszystko idzie gładko.

    więc tu moje pytanie. jak 'obrobić' plik po stronie pc? czy razem z bajtami przesylac adres kazdego bajtu?


    edit
    -------------------
    pomieszało mi sie. w intel hex najpierw idzie ilosc danych a pozniej adres ;)
    chyba wszystko jasne.
REKLAMA