ATNEL tech-forum 2014-08-30T23:49:24+01:00 https://forum.atnel.pl/feed.php?f=58&t=8323&mode 2014-08-30T23:49:24+01:00 2014-08-30T23:49:24+01:00 https://forum.atnel.pl/viewtopic.php?t=8323&p=93572#p93572 <![CDATA[Re: Odbiór paczki danych UART = reset procesora]]> Krauser napisał(a):

Dobrze byłoby wiedzieć co jest źródłem resetu. Wypróbuj lekko zmodyfikowany kod


W terminalu wypisuje mi:
Obrazek

Czyli, jakby wylądował znikąd na początku programu. (?!)

[edit]

Wymieniłem procesor na inną M644, wgrałem program i tylko raz wyrzuca wartość 10 po włączeniu zasilania.
Wychodzi na to, że procesor jest uszkodzony - z czymś takim jeszcze się nie spotkałem. (I raczej bym nie podejrzewał)

Dziękuje Krauser za pomoc.
Temat do zamknięcia.

Statystyki: Napisane przez Sebus — 30 sie 2014, o 23:49

]]> 2014-08-30T20:42:11+01:00 2014-08-30T20:42:11+01:00 https://forum.atnel.pl/viewtopic.php?t=8323&p=93529#p93529 <![CDATA[Re: Odbiór paczki danych UART = reset procesora]]> [syntax=c]#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/delay.h>
#include <stdlib.h>

#define UART_BAUD 115200
#define __UBRR ( F_CPU / 16.0 / UART_BAUD - 0.5 )

volatile char Buffer[256]; // bufor uart
volatile uint8_t BufferlastByte=0; // licznik bajtow w tablicy

void IOpins(void);
void USART_Init( uint16_t baud );
void USART_putc( char c );
void USART_puts( char * s );

uint8_t mcusr_mirror __attribute__ ((section (".noinit"))); //zmienna nie zerowana

void get_mcusr(void) \
__attribute__((naked)) \
__attribute__((section(".init3")));
void get_mcusr(void)
{
mcusr_mirror = MCUSR; //zapisanie źródła resetu
MCUSR = 0;
}


int main(void)
{
char buf[9];

cli();
_delay_ms(3000); // opoznienie zalaczania
IOpins(); // ustawianie we/wy

USART_Init(__UBRR); // inicjalizacja uart
USART_puts("RESET\r\n");
itoa(mcusr_mirror, buf, 2);
USART_puts(buf); //wysłanie źródła resetu na USART
USART_puts("\r\n");

sei(); // przerwania zezwolone
while (1)
{
if (BufferlastByte >200)
{
PORTA^=(1<<PA7);
BufferlastByte=0;
}
}
}


void USART_Init( uint16_t baud )
{
/* Ustawienie prędkości */
UBRR0H = (uint8_t)(baud>>8);
UBRR0L = (uint8_t)baud;
UCSR0B |= (1<<RXEN0)|(1<<TXEN0)|(1<<RXCIE0);
}

void IOpins(void)
{
DDRA |= (1<<PA7); // wyjscie dla LED
}

ISR(USART0_RX_vect)
{
Buffer[BufferlastByte]=UDR0;
if (BufferlastByte <254) BufferlastByte++; // nie pozwol przekroczyc wartosci bufora!
}

void USART_putc( char c )
{
while ( !( UCSR0A & (1<<UDRE0)) )
;
UDR0 = c;
}

void USART_puts( char * s )
{
while(*s)
USART_putc(*s++);
}[/syntax]

Statystyki: Napisane przez Krauser — 30 sie 2014, o 20:42

]]> 2014-08-30T17:33:39+01:00 2014-08-30T17:33:39+01:00 https://forum.atnel.pl/viewtopic.php?t=8323&p=93503#p93503 <![CDATA[Re: Odbiór paczki danych UART = reset procesora]]> Za pisanie post pod postem pewnie mi się oberwie.

Napisałem programik testowy:

[syntax=c]#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/delay.h>
//
volatile char Buffer[256]; // bufor uart
volatile uint8_t BufferlastByte=0; // licznik bajtow w tablicy
//
//
//
void serial_init(void);
void IOpins(void);
//
//
//
int main(void)
{
cli();
_delay_ms(3000); // opoznienie zalaczania
IOpins(); // ustawianie we/wy
serial_init(); // inicjalizacja uart
sei(); // przerwania zezwolone
while (1)
{
if (BufferlastByte >200)
{
PORTA^=(1<<PA7);
BufferlastByte=0;
}
}
}


void serial_init(void)
{
UBRR0H=0; // raczej niepotrzebne
UBRR0L=11; // (115200 @ 22,1184MHz)
UCSR0B|=(1<<RXEN0)|(1<<TXEN0)|(1<<RXCIE0); // tx/rx + zezwolenie przerwania na odbior
}

void IOpins(void)
{
DDRA |= (1<<PA7); // wyjscie dla LED
}

ISR(USART0_RX_vect)
{
Buffer[BufferlastByte]=UDR0;
if (BufferlastByte <254) BufferlastByte++; // nie pozwol przekroczyc wartosci bufora!
}[/syntax]

Kod jest raczej bez sensu. Odbieram bajty, uzupełniam tablicę, a w pętli głównej mam warunek, który sprawdza, czy jest odebrane ponad 200 bajtów - jeśli tak, to zmienia stan pinu PA7 i resetuje zmienną.
W przerwaniu także warunek, który nie dopuszcza do pisania poza zakres tablicy i jest on o 1 element mniejszy, niż sama tablica.

W Br@y terminal puszczam 32 bajty z opóźnieniem co 100ms - przez kilka sekund dioda migocze, po czym następuje reset procesora (widać to po tym, że dioda raz świeci ciągłym światłem przez 3s lub nie świeci przez ten sam okres czasu)

Zmieniłem kwarc na 2x wolniejszy, ustawiłem rejestr UBRRL, zmieniłem dyrektywę f_cpu w opcjach projektu Atmel Studio 6.2 i dalej to samo :cry:

O co tu chodzi? Bo ja już nie wiem...

Pozdrawiam.

Statystyki: Napisane przez Sebus — 30 sie 2014, o 17:33

]]> 2014-08-28T20:16:11+01:00 2014-08-28T20:16:11+01:00 https://forum.atnel.pl/viewtopic.php?t=8323&p=93303#p93303 <![CDATA[Odbiór paczki danych UART = reset procesora]]>
To są moje (jakby to powiedzieć) pierwsze kroki z pisaniem w C.

Nabazgrałem sobie niby prosty program, który powinien odebrać paczkę danych, sprawdzić, czy jest jej koniec oraz wysłać zawartość bufora na PORT C + ustawianie sygnałów sterujących na PORT A - Pomijam kwestie, typu timeout - to zostawiam na później do oprogramowania.
Długość paczki danych jest zmienna i zawiera się (na razie) w przedziale od 3 do ok. 32 bajtów.
Generalnie, jest to strumień danych dla układu PSG AY-3-8913 który wysyłam z komputera.
W skrócie - µP odbiera bajty; sprawdza, czy jest koniec (znaki eb w buforze); odczekuje odpowiednią ilość przerwań; wysyła dane do PSG, wysyła znak 'n' poprzez UART i cykl powinien się powtarzać...
Niestety, program na µP wysypuje się czasami na pierwszym wysłanym znaku poprzez port szeregowy, czasami można wysłać około 11kB - muzyka wydobywa się z układu, dopóki procesor się nie zawiesi/nie zresetuje.

Od strony technicznej -> Płytka uniwersalna UM-17, ATMEGA644 w podstawce, kilkanaście kondensatorów blokujących 100nF na linii zasilania, jak i przy samym procku + kilka szt elektrolitów 10..47uF na linii zasilania, /RESET podciągnięty rezystorem 3k9 + dodatkowo kondensator 2,2nF; kwarc 22,1184MHz z przylutowaną obudową do masy oraz kondensatorami 33pF (niestety tylko takie miałem w szufladzie); układ dźwiękowy jest na zwykłej stykówce - także tutaj mnóstwo kondensatorów 100nF oraz 10uF i kabelki podpinanie przez goldpiny. Zasilanie biorę z zasilacza laboratoryjnego.

Podobny kod (o dziwo) śmiga mi na attiny2313V@28,224MHz - ale tam odbieram na sztywno ramkę 4 bajtów i ustawiam preskaler/rejestr OCR w celu wygenerowania częstotliwości 1,764MHz dla PSG oraz odpada mi przerwanie timer'a - wykorzystuje sprzętowe zmienianie stanu pinu na przeciwny (tryb CTC + toggle OC0B)

Podejrzewam, że najprawdopodobniej dochodzi do kolizji przy przerwaniach, ale nie mogę tego rozgryźć. Gdzie popełniłem błąd?

Mogę dać mini bibliotekę do obsługi hd44780 (lcd595.h/lcd595.c pisaną dawno temu) ale wątpię, by tam występował problem, gdyż tylko raz wysyłam ciąg znaków do LCD, poza tym dotychczas nie było z nią problemów w innych zastosowaniach.

Przepraszam za te gryzmoły poniżej - stare nawyki z TASM/Pascal/Basic, rozdzielczości 80x25 znaków itp... Musze się ogarnąć :/

[syntax=c]#include <avr/io.h>
#include <avr/interrupt.h>
#include <stdlib.h>
#include <util/delay.h>
#include <avr/sleep.h>
#include <avr/pgmspace.h>
#include <lcd595.h>
//
uint8_t Buffer[40]; // bufor uart
volatile uint8_t BufferlastByte=0; // licznik bajtow/index tablicy
volatile uint8_t delay=0;
uint8_t CREG0=0; // zamiast struktury... ekhm...
uint8_t intcount=0; // licznik przerwan;
#define PLAYBACK 7
#define PBACK CREG0|=(1<<PLAYBACK)
#define PSTOP CREG0&=~(1<<PLAYBACK)

#define REGISTER PORTA|=(1<<PA7)
#define PSGDATA PORTA&=~(1<<PA7)
#define RESET_H PORTA|=(1<<PA6)
#define RESET_L PORTA&=~(1<<PA6)

void serial_init(void)
{
UBRR0H=0;
UBRR0L=47; // (57600 @ 22,1184MHz)
UCSR0A|=(1<<U2X0); // ...
UCSR0B|=(1<<RXEN0)|(1<<TXEN0)|(1<<RXCIE0); // tx/rx + zezwolenie przerwania na odbior
//UCSR0C|=(1<<UCSZ01)|(1<<UCSZ00); // 8n1
}

void serial_tx(char data) // zerzniete z PDF'a
{
while(!(UCSR0A & (1<<UDRE0)));
UDR0 = data;
}

void IOpins(void)
{
DDRA |= (1<<PA7)|(1<<PA6); // Data/Register + RESET
DDRD = 0xFC;
//PORTD = 0x00;
DDRC=0xFF;
//PORTC = 0x00;
}

void timer0_init(void)
{
TCCR0A|=(1<<WGM01); // CTC
OCR0A=107; // 5ms @ 22,1184MHz
TIMSK0|=(1<<OCIE0A); // zezwolenie na przerwanie
TCCR0B|=(1<<CS02)|(1<<CS00); // preskaler -> 1024
}

void Check_data (void)
{
if (Buffer[BufferlastByte-1] == 'b' && Buffer[BufferlastByte-2] == 'e') // paczka konczy sie znakami "eb"
{
if (Buffer[BufferlastByte-3] == 0xFF) {intcount=3; BufferlastByte-=4;} // jesli Bufferlastbyte-3 zawiera 0xFF, ustawiamy delay na 20ms i zmniejszamy wartosc ostatnio odebranego bajtu
if (Buffer[BufferlastByte-4] == 0xFE) {intcount=((Buffer[BufferlastByte-3]+1)*3); BufferlastByte-=5;} // jesli Bufferlastbyte-4 zawiera 0xFE ustawiamy delay na odpowiednia ilosc (n przerwan) i zmniejszamy wartosc ostatnio odebranego bajtu
PBACK; // zalaczamy mozliwosc wejscia do procedury odtwarzania
}
}

void send_psg (void)
{
PSTOP; // wylaczamy mozliwosc wejscia do tej procedury, dopoki nie nadejdze pelna paczka danych
uint8_t i=1;
while (delay<=intcount); // oczekuj na odpowiednia ilosc przerwan
while (i <= BufferlastByte)
{
REGISTER;
PORTC=Buffer[i];
i++;
PSGDATA;
PORTC=Buffer[i];
i++;
}
intcount=0;
BufferlastByte=0;
delay=0;
serial_tx('n'); // wyslij znak do programu na pc w celu wyslania nowej paczki danych
}

int main(void)
{
cli();
_delay_ms(1000); // opoznienie zalaczania
IOpins();
serial_init();
lcd_init();
timer0_init();
set_sleep_mode(SLEEP_MODE_IDLE);
sleep_enable();
RESET_L;
REGISTER;
lcd_addr(0);
lcd_write_text("Waiting for data"); // marnujemy troche SRAM na napis...
RESET_H;
sei();
while (1)
{
Check_data();
if (CREG0 & (1<<PLAYBACK)) {send_psg();}
//sleep_cpu(); // dobranoc
}
}

ISR(USART0_RX_vect)
{
Buffer[BufferlastByte]=UDR0;
if (BufferlastByte < 40) {BufferlastByte++;} // nie pozwol przekroczyc wartosci
//UDR0=Buffer; // echo
}

ISR(TIMER0_COMPA_vect)
{
delay++;
}[/syntax]

Statystyki: Napisane przez Sebus — 28 sie 2014, o 20:16

]]>