ATNEL tech-forum

Re: Atmega128A i 2 UARTY

2016-09-05T08:10:03+01:00

drezzill napisał(a):

a czy nie jest tak, że jeśli te zmienne są w różnych plikach i nie są extern to wtedy to są zupełnie różne zmienne?

A skąd takie pomysły w ogóle ?

Gdybyś dał specyfikator static każdej takiej zmiennej to wtedy nie będą sobie przeszkadzać nawzajem ... pomimo to nie jest w ogóle dobrym pomysłem dublowanie nazw zmiennych i to jeszcze globalnych dla pliku w różnych plikach. Sam widzisz że im więcej takich pomysłów tym więcej problemów.

Statystyki: Napisane przez mirekk36 — 5 wrz 2016, o 08:10

Re: Atmega128A i 2 UARTY

2016-09-05T08:00:30+01:00

rskup a czy nie jest tak, że jeśli te zmienne są w różnych plikach i nie są extern to wtedy to są zupełnie różne zmienne?

Situs nie czekam na flagę TX comlete tylko UDRE i wtedy wysyłam kolejny znak. jak skończą się znaki, to nie obsługuję już przerwania UDRE. Wyłączam to w tym miejscu

[syntax=c]...
else {
// zerujemy flagę przerwania występującego gdy bufor pusty
UCSR1B &= ~(1< }[/syntax]

Statystyki: Napisane przez drezzill — 5 wrz 2016, o 08:00

Re: Atmega128A i 2 UARTY

2016-09-04T19:03:52+01:00

A czekasz na ustawienie znacznika txc? a jak tak to czy zerujesz go wpisując mu jeden?

Statystyki: Napisane przez Situs — 4 wrz 2016, o 19:03

Re: Atmega128A i 2 UARTY

2016-09-04T17:56:22+01:00

Twój problem nie ma nic wspólnego z inicjalizacją / obsługą UARTów. Jest to przyczyna o której napisałem na samym początku:

rskup napisał(a):

A przypadkiem nie używasz tych samych buforów / zmiennych do obsługi obu UARTów?

Dla obu UARTów używasz globalnych zmiennych dla Head-a i Tail-a o tej samej nazwie. Albo zmień UART_RxHead, UART_RxTail, UART_TxHead, UART_TxTail na nazwy zawierające numer portu (dodaj 1 jak dla innych elementów dotyczących UART1) albo zadeklaruje je jako static.

--
Pozdrawiam,
Robert

Statystyki: Napisane przez rskup — 4 wrz 2016, o 17:56

Re: Atmega128A i 2 UARTY

2016-08-31T12:51:04+01:00

mkuart0.h

[syntax=c]/*
* mkuart.h
*
* Created on: 2010-09-04
* Autor: Mirosław Kardaś
*/

#ifndef MKUART0_H_
#define MKUART0_H_

#define UART0_BAUD 115200// tu definiujemy interesującą nas prędkość
#define __UBRR0 ((F_CPU+UART0_BAUD*8UL) / (16UL*UART0_BAUD)-1) // obliczamy UBRR dla U2X=0

// definicje na potrzeby RS485
//#define UART_DE_PORT PORTD

#define UART0_RX_BUF_SIZE 128 // definiujemy bufor o rozmiarze 32 bajtów
// definiujemy maskę dla naszego bufora
#define UART0_RX_BUF_MASK ( UART0_RX_BUF_SIZE - 1)

#define UART0_TX_BUF_SIZE 128 // definiujemy bufor o rozmiarze 16 bajtów
// definiujemy maskę dla naszego bufora
#define UART0_TX_BUF_MASK ( UART0_TX_BUF_SIZE - 1)

// deklaracje funkcji publicznych

void USART0_Init( uint16_t baud );

char uart0_getc(void);
void uart0_putc( char data );
void uart0_puts(char *s);
void uart0_puts_const(const char *s);
void uart0_putint(int value, int radix);
#endif /* MKUART0_H_ */[/syntax]

mkuart1.h

[syntax=c]/*
* mkuart.h
*
* Created on: 2010-09-04
* Autor: Mirosław Kardaś
*/

#ifndef MKuart1_H_
#define MKuart1_H_

#define UART1_BAUD 115200// tu definiujemy interesującą nas prędkość
#define __UBRR1 ((F_CPU+UART1_BAUD*8UL) / (16UL*UART1_BAUD)-1) // obliczamy UBRR dla U2X=0

// definicje na potrzeby RS485
//#define UART_DE_PORT PORTD

#define UART1_RX_BUF_SIZE 128 // definiujemy bufor o rozmiarze 32 bajtów
// definiujemy maskę dla naszego bufora
#define UART1_RX_BUF_MASK ( UART1_RX_BUF_SIZE - 1)

#define UART1_TX_BUF_SIZE 128 // definiujemy bufor o rozmiarze 16 bajtów
// definiujemy maskę dla naszego bufora
#define UART1_TX_BUF_MASK ( UART1_TX_BUF_SIZE - 1)

// deklaracje funkcji publicznych

void USART1_Init( uint16_t baud );

char uart1_getc(void);
void uart1_putc( char data );
void uart1_puts(char *s);
void uart1_puts_const(const char *s);
void uart1_putint(int value, int radix);
#endif /* MKUART1_H_ */[/syntax]

Rozmiar zmiennej zmieniłem, żeby przetestować ogromne bufory i taka została.

edit:

Może ktoś ma gotową bibliotekę do Atmegi 128? Albo Atmegę i sprawdziłby tą bibliotekę, może to wina hardwarowa?

Na stronie 253 dokumentacji atmegi128A jest napisane " When the function writes to the
UCSRC Register, the URSEL bit (MSB) must be set due to the sharing of I/O location by UBRRH and
UCSRC ". Czy powinienem ustawić najwyższy bit w UCSRmC przy zapisie? w opisie rejestru UCSRmC nie ma nic o URSEL, a najwyższy bit jest na szaro. W podanym przez nich sposobie inicjalizacji na stronie 253-254 także nie ustawiają tego bitu.

edit2:

Użyłem biblioteki od Peter Fleury i działa, więc coś źle robię z inicjalizacją. Muszę przepisać tak jak jest u Petera

Statystyki: Napisane przez drezzill — 31 sie 2016, o 12:51

Re: Atmega128A i 2 UARTY

2016-08-31T12:47:11+01:00

[syntax=c]volatile uint16_t UART_RxHead;[/syntax]
Dlaczego w jednym pliku zmienna jest 2 bajtowa, a w drugim 1 bajtowa?

Statystyki: Napisane przez ShutDownSystem — 31 sie 2016, o 12:47

Re: Atmega128A i 2 UARTY

2016-08-31T12:36:27+01:00

ShutDownSystem napisał(a):

Nie powinno być USCR1C ?

Powinno, ale to nie ma w tym wypadku znaczenie, bo i tak używa domyślnych wartości konfiguracji portu

A wszystko masz w porządku w mkuart1.h i mkuart0.h?

--
Pozdrawiam,
Robert

Statystyki: Napisane przez rskup — 31 sie 2016, o 12:36

Re: Atmega128A i 2 UARTY

2016-08-31T12:32:04+01:00

Przejrzałem wszystkie takie błędy po twoim pierwszym poście i już je poprawiłem. Niepotrzebnie jeszcze raz zmieniałem bibliotekę przed wrzuceniem jej tutaj. Myślałem, że będzie "czysta" bez moich ingerencji, a przeoczyłem te dwie rzeczy. Już podmieniłem kod na taki, który mam uruchomiony i nie działa

Statystyki: Napisane przez drezzill — 31 sie 2016, o 12:32

Re: Atmega128A i 2 UARTY

2016-08-31T12:21:52+01:00

[syntax=c]UCSR0C = (1<Nie powinno być USCR1C ?

Statystyki: Napisane przez ShutDownSystem — 31 sie 2016, o 12:21

Re: Atmega128A i 2 UARTY

2016-08-31T12:18:15+01:00

Powinno być:) Poprawiłem, ale to i tak jest w przerwaniu odbiorczym i jeszcze go nie użyłem.

Statystyki: Napisane przez drezzill — 31 sie 2016, o 12:18

Re: Atmega128A i 2 UARTY

2016-08-31T12:14:12+01:00

[syntax=c]data = UDR0; //pobieramy natychmiast bajt danych z bufora sprzętowego[/syntax]
W obu plikach występuje ta linijka. Nie powinno być w mkuart1.c UDR1?

Statystyki: Napisane przez ShutDownSystem — 31 sie 2016, o 12:14

Re: Atmega128A i 2 UARTY

2016-08-31T12:21:16+01:00

tak wygląda plik mkuart1.h

[syntax=c]/*
* mkuart1.c
*
* Created on: 2010-09-04
* Autor: MirosĹ‚aw KardaĹ›
*/
#include
#include
#include

#include "mkuart1.h"

// definiujemy w końcu nasz bufor UART1_RxBuf
volatile char UART1_RxBuf[UART1_RX_BUF_SIZE];
// definiujemy indeksy określające ilość danych w buforze
volatile uint16_t UART_RxHead; // indeks oznaczający „głowę węża”
volatile uint16_t UART_RxTail; // indeks oznaczający „ogon węża”

// definiujemy w końcu nasz bufor UART1_RxBuf
volatile char UART1_TxBuf[UART1_TX_BUF_SIZE];
// definiujemy indeksy określające ilość danych w buforze
volatile uint16_t UART_TxHead; // indeks oznaczający „głowę węża”
volatile uint16_t UART_TxTail; // indeks oznaczający „ogon węża”

void USART1_Init( uint16_t baud ) {
/* Ustawienie prędkości */
UBRR1H = (uint8_t)(baud>>8);
UBRR1L = (uint8_t)baud;
/* Załączenie nadajnika I odbiornika */
UCSR1B |= (1</* Ustawienie format ramki: 8bitów danych, 1 bit stopu */
UCSR1C = (1<

// jeśli nie korzystamy z interefejsu RS485

}

// definiujemy funkcję dodającą jeden bajtdoz bufora cyklicznego
void uart1_putc( char data ) {
uint16_t tmp_head;

tmp_head = (UART_TxHead + 1) & UART1_TX_BUF_MASK;

// pętla oczekuje jeżeli brak miejsca w buforze cyklicznym na kolejne znaki
while( tmp_head == UART_TxTail );

UART1_TxBuf[tmp_head] = data;
UART_TxHead = tmp_head;

// inicjalizujemy przerwanie występujące, gdy bufor jest pusty, dzięki
// czemu w dalszej części wysyłaniem danych zajmie się już procedura
// obsługi przerwania
UCSR1B |= (1<
}

void uart1_puts(char *s)// wysyła łańcuch z pamięci RAM na UART
{
register char c;
while ((c = *s++)) uart1_putc(c);// dopóki nie napotkasz 0 wysyłaj znak
}

void uart1_puts_const(const char *s)// wysyła łańcuch z pamięci RAM na UART
{
register char c;
while ((c = *s++)) uart1_putc(c);// dopóki nie napotkasz 0 wysyłaj znak
}

void uart1_putint(int value, int radix)// wysyła na port szeregowy tekst
{
char string[17];// bufor na wynik funkcji itoa
itoa(value, string, radix);// konwersja value na ASCII
uart1_puts(string);// wyślij string na port szeregowy
}

// definiujemy procedurę obsługi przerwania nadawczego, pobierającą dane z bufora cyklicznego
ISR( USART1_UDRE_vect) {

// sprawdzamy czy indeksy są różne
if ( UART_TxHead != UART_TxTail ) {
// obliczamy i zapamiętujemy nowy indeks ogona węża (może się zrównać z głową)
UART_TxTail = (UART_TxTail + 1) & UART1_TX_BUF_MASK;
// zwracamy bajt pobrany z bufora jako rezultat funkcji
UDR1 = UART1_TxBuf[UART_TxTail];

} else {
// zerujemy flagę przerwania występującego gdy bufor pusty
UCSR1B &= ~(1< }
}

// definiujemy funkcję pobierającą jeden bajt z bufora cyklicznego
char uart1_getc(void) {
// sprawdzamy czy indeksy są równe
if ( UART_RxHead == UART_RxTail ) return 0;

// obliczamy i zapamiętujemy nowy indeks „ogona węża” (może się zrównać z głową)
UART_RxTail = (UART_RxTail + 1) & UART1_RX_BUF_MASK;
// zwracamy bajt pobrany z bufora jako rezultat funkcji
return UART1_RxBuf[UART_RxTail];
}

// definiujemy procedurę obsługi przerwania odbiorczego, zapisującą dane do bufora cyklicznego

ISR (USART1_RX_vect)
{

uint8_t tmp_head;
char data;

data = UDR1; //pobieramy natychmiast bajt danych z bufora sprzętowego

// obliczamy nowy indeks „głowy węża”
tmp_head = ( UART_RxHead + 1) & UART1_RX_BUF_MASK;

// sprawdzamy, czy wąż nie zacznie zjadać własnego ogona
if ( tmp_head == UART_RxTail ) {
// tutaj możemy w jakiś wygodny dla nas sposób obsłużyć błąd spowodowany
// próbą nadpisania danych w buforze, mogłoby dojść do sytuacji gdzie
// nasz wąż zacząłby zjadać własny ogon
} else {
UART_RxHead = tmp_head; // zapamiętujemy nowy indeks
UART1_RxBuf[tmp_head] = data; // wpisujemy odebrany bajt do bufora
}
}[/syntax]

a tak plik mkuart0.c

[syntax=c]/*
/*
* mkuart0.c
*
* Created on: 2010-09-04
* Autor: MirosĹ‚aw KardaĹ›
*/
#include
#include
#include

#include "mkuart0.h"

// definiujemy w końcu nasz bufor UART_RxBuf
volatile char UART_RxBuf[UART0_RX_BUF_SIZE];
// definiujemy indeksy określające ilość danych w buforze
volatile uint8_t UART_RxHead; // indeks oznaczający „głowę węża”
volatile uint8_t UART_RxTail; // indeks oznaczający „ogon węża”

// definiujemy w końcu nasz bufor UART_RxBuf
volatile char UART_TxBuf[UART0_TX_BUF_SIZE];
// definiujemy indeksy określające ilość danych w buforze
volatile uint8_t UART_TxHead; // indeks oznaczający „głowę węża”
volatile uint8_t UART_TxTail; // indeks oznaczający „ogon węża”

void USART0_Init( uint16_t baud ) {
/* Ustawienie prędkości */
UBRR0H = (uint8_t)(baud>>8);
UBRR0L = (uint8_t)baud;
/* Załączenie nadajnika I odbiornika */
UCSR0B |= (1</* Ustawienie format ramki: 8bitów danych, 1 bit stopu */
UCSR0C = (1<}

// procedura obsługi przerwania Tx Complete, gdy zostanie opóżniony UDR
// kompilacja gdy używamy RS485
#ifdef UART_DE_PORT
ISR( USART_TXC_vect ) {
UART_DE_PORT &= ~UART_DE_BIT;// zablokuj nadajnik RS485
}
#endif

// definiujemy funkcję dodającą jeden bajtdoz bufora cyklicznego
void uart0_putc( char data ) {
uint8_t tmp_head;

tmp_head = (UART_TxHead + 1) & UART0_TX_BUF_MASK;

// pętla oczekuje jeżeli brak miejsca w buforze cyklicznym na kolejne znaki
while(tmp_head == UART_TxTail );

UART_TxBuf[tmp_head] = data;
UART_TxHead = tmp_head;

// inicjalizujemy przerwanie występujące, gdy bufor jest pusty, dzięki
// czemu w dalszej części wysyłaniem danych zajmie się już procedura
// obsługi przerwania
UCSR0B |= (1<
}

void uart0_puts(char *s)// wysyła łańcuch z pamięci RAM na UART
{
register char c;
while ((c = *s++)) uart0_putc(c);// dopóki nie napotkasz 0 wysyłaj znak
}

void uart0_puts_const(const char *s)// wysyła łańcuch z pamięci RAM na UART
{
register char c;
while ((c = *s++)) uart0_putc(c);// dopóki nie napotkasz 0 wysyłaj znak
}

void uart0_putint(int value, int radix)// wysyła na port szeregowy tekst
{
char string[17];// bufor na wynik funkcji itoa
itoa(value, string, radix);// konwersja value na ASCII
uart0_puts(string);// wyślij string na port szeregowy
}

// definiujemy procedurę obsługi przerwania nadawczego, pobierającą dane z bufora cyklicznego
ISR( USART0_UDRE_vect) {

// sprawdzamy czy indeksy są różne
if ( UART_TxHead != UART_TxTail ) {
// obliczamy i zapamiętujemy nowy indeks ogona węża (może się zrównać z głową)
UART_TxTail = (UART_TxTail + 1) & UART0_TX_BUF_MASK;
// zwracamy bajt pobrany z bufora jako rezultat funkcji
UDR0 = UART_TxBuf[UART_TxTail];
} else {
// zerujemy flagę przerwania występującego gdy bufor pusty
UCSR0B &= ~(1< }
}

// definiujemy funkcję pobierającą jeden bajt z bufora cyklicznego
char uart0_getc(void) {
// sprawdzamy czy indeksy są równe
if ( UART_RxHead == UART_RxTail ) return 0;

// obliczamy i zapamiętujemy nowy indeks „ogona węża” (może się zrównać z głową)
UART_RxTail = (UART_RxTail + 1) & UART0_RX_BUF_MASK;
// zwracamy bajt pobrany z bufora jako rezultat funkcji

char c=UART_RxBuf[UART_RxTail];

UART_RxBuf[UART_RxTail]=0;
return c;
}

// definiujemy procedurę obsługi przerwania odbiorczego, zapisującą dane do bufora cyklicznego

ISR (USART0_RX_vect)
{

uint8_t tmp_head;
char data;

data = UDR0; //pobieramy natychmiast bajt danych z bufora sprzętowego

// obliczamy nowy indeks „głowy węża”
tmp_head = ( UART_RxHead + 1) & UART0_RX_BUF_MASK;

// sprawdzamy, czy wąż nie zacznie zjadać własnego ogona
if ( tmp_head == UART_RxTail ) {
// tutaj możemy w jakiś wygodny dla nas sposób obsłużyć błąd spowodowany
// próbą nadpisania danych w buforze, mogłoby dojść do sytuacji gdzie
// nasz wąż zacząłby zjadać własny ogon
} else {
UART_RxHead = tmp_head; // zapamiętujemy nowy indeks
UART_RxBuf[tmp_head] = data; // wpisujemy odebrany bajt do bufora
}
}[/syntax]

Bufory i wszystkie inne zmienne są w oddzielnych plikach.

Zauważyłem, e jak zmniejszę czas pomiędzy nadaniami, to "zjada" końcówkę, np. wysyła tylko "hell"

Statystyki: Napisane przez drezzill — 31 sie 2016, o 11:56

Re: Atmega128A i 2 UARTY

2016-08-31T11:45:13+01:00

A przypadkiem nie używasz tych samych buforów / zmiennych do obsługi obu UARTów?

--
Pozdrawiam,
Robert

Statystyki: Napisane przez rskup — 31 sie 2016, o 11:45

Re: Atmega128A i 2 UARTY

2016-08-31T11:31:46+01:00

drezzill napisał(a):

Czy jedynym wyjściem jest wstrzymywanie uarta na jakiś czas po nadaniu?

Gdyby to miało być wyjście to w zasadzie takie rozwiązanie nadawałoby się tylko do kosza to byłaby jakaś tragedia .... nie po to są sprzętowe moduły .... Coś źle przerobiłeś po prostu.

Statystyki: Napisane przez mirekk36 — 31 sie 2016, o 11:31

Atmega128A i 2 UARTY

2016-08-31T11:35:18+01:00

Hej.

Chcę wykorzystać w atmedze128A dwa uarty ale natknąłem się na problem. Jeśli napiszę coś takiego :

[syntax=c]while(1)
{
uart0_puts("hello\r\n");
uart1_puts("hello\r\n");
_delay_ms(1000);
}[/syntax]
to dostaję jakieś śmieci albo ucięte słowa. Jeśli użyję
[syntax=c]while(1)
{
uart0_puts("hello\r\n");
_delay_us(500);
uart1_puts("hello\r\n");
_delay_ms(1000);
}[/syntax]
to wszystko fajnie śmiga. I tu pojawia się pytanie. Czy zawsze trzeba odczekać jakiś czas po nadaniu wiadomości, żeby użyć drugiego uarta, czy to jakiś błąd np. na płytce i zakłócenia?

Używam bibliotek Mirka. Myślałem, że sprawę załatwi dodanie
[syntax=c]UCSR0B &= ~(1<w przerwaniu

[syntax=c]USART1_UDRE_vect[/syntax]

i dodanie
[syntax=c]ISR(USART1_TX_vect)
{
if(UART_TxHead==UART_TxTail)
{
UCSR0B |= (1<}
}[/syntax]
i o czywiście odpowiednio dla drugiego uarta. Ale to niewiele pomogło. Myślałem, że to zablokuje możliwość nadawania uart0 dopóki nie skończy nadawać uart1 i odwrotnie. Czy jedynym wyjściem jest wstrzymywanie uarta na jakiś czas po nadaniu?

Statystyki: Napisane przez drezzill — 31 sie 2016, o 11:26