ATNEL tech-forum

Re: Obsługa UARTa - prosta obsługa

2017-11-15T19:45:50+01:00

Daro69 napisał(a):

...

Daro69 napisał(a):

zmienna Licznik_Bufora_RX może przekroczyć dozwolony rozmiar Wielkosc_Bufora , wiadomo czym skutkuje.

heh przekonałem się na własnej skórze jak robiłem sobie bibliotekę do nRF24L01 tyle, że w obsłudze SPI. W czasie testów bufor SPI ustawiłem na 16 bajtów , a jak już wypróbowałem komunikację pomiędzy dwoma nRF24L01 przesyłając sobie kilka bajtów, to zapomniałem, że bufor SPI ma tylko 16 bajtów. I jakie moje zdziwienie było, kiedy wysłałem więcej niż 15 bajtów a na terminalu (bo tak sobie testowałem) pojawiły się tzw. krzaki:)) i szczerze mówiąc to zanim do tego doszedłem to mi trochę zeszło więc.....
Ale LENISTWO czasem bierze górę hihi.
Więc dzięki za motywację.

Pozdrawiam

Statystyki: Napisane przez Artur_26 — 15 lis 2017, o 19:45

Re: Obsługa UARTa - prosta obsługa

2017-11-15T17:52:14+01:00

Witam,

Artur_26 napisał(a):

Tylko muszę się zastanowić jak sobie obsłużyć przekroczenie rozmiaru...

Ja bym poszukal w rozdziale 10_ GB. widzę że masz
Głownie przerwanie ISR( USART_RXC_vect){........ ,
oraz funkcję ....uart_getc(void){.....// (w jakim celu funkcja zwraca typ int ? )
w funkcji uart_get_str(); jest to w jakimś celu sprawdzane.
hmm.. no bo po co nam uszkodzona ramka danych ? pewnie tylko do śmietnika.
a nadpisanie bufora odbiorczego poza jego rozmiarem (gdy np odbiór się chwilowo przerwie bez znaku końca i pojawią następne dane od któregoś tam znaku ),
zmienna Licznik_Bufora_RX może przekroczyć dozwolony rozmiar Wielkosc_Bufora ,
wiadomo czym skutkuje.
pozdrawiam.

Statystyki: Napisane przez Daro69 — 15 lis 2017, o 17:52

Re: Obsługa UARTa - prosta obsługa

2017-11-14T19:54:01+01:00

Witam,

rskup napisał(a):

Nie masz kontroli przepełnienia buforów w czasie ich wypełniania.

Nie zrobiłem, ale w sposób świadomy (trochę lenistwo... ). Choć w zasadzie powinny być więc dorobię.
Tylko muszę się zastanowić jak sobie obsłużyć przekroczenie rozmiaru, tak aby było prosto i mało kodu:).

rskup napisał(a):

po co taka kombinacja z końcem - CR w jedną 0x00 w druga stronę?

Przerobiłem w obu kierunkach na końcu wymagane znak "CR" (0x0D) he he dzieki temu dwie linie kodu mniej:)

[syntax=c]//-----------------------------------------------------------------------------------------------
// Funkcja wysyła DANE z pamięci FLASH
//-----------------------------------------------------------------------------------------------
void USART_WYSLIJ_STRING_P(const char *dane)
{
register char znak;
uint8_t i = 0;

while ((znak = pgm_read_byte(dane++))) // przepisywanie z ROM do BUFORA TX
Uart_Bufor_TX[i++] = znak;

Uart_Bufor_TX[i] = '\r'; // naley wpisa 0x0D na koniec tekstu -- zmiana
USART_WYSLIJ_STRING(Uart_Bufor_TX); // wysłanie buforu TX
}

//-----------------------------------------------------------------------------------------------
// Obsługa przerwania PUSTY BUFOR
//-----------------------------------------------------------------------------------------------
ISR(USART_UDRE_vect)
{

UDR = *wskaznik_TX; // wpisanie znaku z adresu we wskaźniku do nadajnika UART
if (*wskaznik_TX++ == '\r') // sprawdzenie czy znak równy 0x0D
UCSRB &=~(1<
}

//-----------------------------------------------------------------------------------------------
// Obsługa przerwania OTRZYMANO ZNAK
// Potwierdzenie odebrania całej ramki odbywa się po odebraniu znaku "CR" (0x0D)
//-----------------------------------------------------------------------------------------------
ISR(USART_RXC_vect)
{
static uint8_t Licznik_Bufora_Rx = 0; // licznik odebranych bajtów

Uart_Bufor_RX[Licznik_Bufora_Rx] = UDR; // odczytanie odebranego bajtu z odbiornika

if (Uart_Bufor_RX[Licznik_Bufora_Rx++] == '\r') // jeśli odebrany znak = "CR" to:
{
Licznik_Bufora_Rx = 0; // kasowanie liniczka odebranych bajtów
Jest_dana_z_RX = 1; // ustawienie flagi Jest_dana_z_RX, że zostały odebrane dane
}
}[/syntax]

Dzięki za uwagi

Statystyki: Napisane przez Artur_26 — 14 lis 2017, o 19:54

Re: Obsługa UARTa - prosta obsługa

2017-11-14T10:38:14+01:00

Tak na szybko:
- Nie masz kontroli przepełnienia buforów w czasie ich wypełniania.
- po co taka kombinacja z końcem - CR w jedną 0x00 w druga stronę?

--
Pozdrawiam,
Robert

Statystyki: Napisane przez rskup — 14 lis 2017, o 10:38

Re: Obsługa UARTa - prosta obsługa

2017-11-14T08:29:21+01:00

A przepraszam!
Chyba jeszcze spałem jak to pisałem.
Jeszcze raz przepraszam

Statystyki: Napisane przez MirkoT — 14 lis 2017, o 08:29

Re: Obsługa UARTa - prosta obsługa

2017-11-14T07:38:34+01:00

MirkoT napisał(a):

A co to ma wspólnego z DIY?
Może jednak warto się zastanowić gdzie się umieszcza
swoje pytania?

A to, kolego , że jest to projekt programistyczny. Nazwy działów czytamy że zrozumieniem.
Pozdrawiam

Wysłane z mojego HTC One_M8 przy użyciu Tapatalka

Statystyki: Napisane przez adamBo — 14 lis 2017, o 07:38

Re: Obsługa UARTa - prosta obsługa

2017-11-14T07:30:14+01:00

A co to ma wspólnego z DIY?
Może jednak warto się zastanowić gdzie się umieszcza
swoje pytania?

Statystyki: Napisane przez MirkoT — 14 lis 2017, o 07:30

Obsługa UARTa - prosta obsługa

2017-11-13T21:43:28+01:00

Witam, chciałbym się z wami podzielić moją malutką biblioteką do obsługi UART.

Jest to pierwsze moje wystąpienie z kodem C na tym forum!

Założenia:
1. Praca oparta o przerwania nadajnika i odbiornika.
1. Ilość przesyłanych danych mała do kilkudziesięciu bajtów.
2. Praca na dwóch buforach Tx i Rx.
3. Transmisja oparta o znaki ASCII

W moim przykładzie obsługa sprowadza się do wykorzystania:

1. USART_UDRE_vect - przerwanie od pustego buforu nadajnika
2. USART_RXC_vect - przerwanie od odebranej danej przez UART.
3. Bufor Tx - bufor danych wysyłanych, wielkość buforu ustalana na stałe
4. Bufor Rx - bufor danych odbieranych, wielkość buforu ustalana na stałe
5. Flaga "Jest_dana_z_RX" - flaga ustawiana kiedy zostanie odebrana cała ramka, czyli jeśli zostanie odebrany znak "CR" (0x0D)

Dane wysyłane do uC muszą być zakończone znakiem "CR" (0x0D)

Dane wysyłane z uC muszą być zakończone zerem (0x00). - zero oznacza, że uC ma przestać wysyłać dane.

Flaga "Jest_dana_z_RX" wykorzystywana do obsługi odebranych danych, patrz przykład kod poniżej.

Napisałem 4 funkcje obsługujące UART:
1. Inicjalizacja Uarta
2. Wysłanie pojedynczego znaku
3. Wysłanie danych z RAM
4. Wysłanie danych z ROM

Poniżej przedstawiam kod:

UART_ATMega.h

[syntax=c]/*
* UART_ATMega.h
*
* Created on: 2017-11-03
* Author: Artur
*/

// !!!!!!!! Obsługa UARTA oparta na przerwaniach !!!!!!!!

#ifndef UART_ATMEGA_H_
#define UART_ATMEGA_H_

#define UART_BAUD 38400 // tu definiujemy interesującą nas prędkość

#define _UBRR ((F_CPU) / (16UL*UART_BAUD)-1) // obliczamy UBRR dla U2X=0

#define _UCSRC ((1<
#define _UCSRB ((1<
// bity RXC UDRE FE DOR PE są tylko do odczytu
#define _UCSRA ((0<

#define WIELKOSC_BUFOR_TX 32

#define WIELKOSC_BUFOR_RX 32

extern volatile char Uart_Bufor_TX[WIELKOSC_BUFOR_TX];

extern volatile char Uart_Bufor_RX[WIELKOSC_BUFOR_RX];

extern volatile uint8_t Jest_dana_z_RX; // flaga potwierdzająca odebranie danych, koniec danych (ramki) określa znka "CR",
// i po odebraniu tego znaku flaga ta jest ustawiana
// 0 - nie odebrane 1 - odebrane

void USART_INI(uint8_t baud); // inicjalizacja portu RS232
void USART_WYSLIJ_ZNAK(uint8_t dana); // funkcja wysyła pojedynczy znak
void USART_WYSLIJ_STRING(volatile void *dane); // funkcja wysyła string z RAM
void USART_WYSLIJ_STRING_P(const char *dane); // funkcja wysyła string z FLASH

#endif /* UART_ATMEGA_H_ */[/syntax]

UART_ATMega.c

[syntax=c]/*
* UART_ATMega.c
*
* Created on: 2017-11-03
* Author: Artur
*/

#include
#include
#include

#include "UART_ATMega.h"

volatile char Uart_Bufor_TX[WIELKOSC_BUFOR_TX];
volatile char Uart_Bufor_RX[WIELKOSC_BUFOR_RX];

volatile uint8_t Jest_dana_z_RX;

volatile uint8_t *wskaznik_TX; // wskaźnik do wysyłanych danych

//-----------------------------------------------------------------------------------------------
// Funkcja Inicjalizująca USART
// NIE MA POTRZEBY USTAWIAĆ LINI PORTU WE/WY, PO WŁĄCZENIU NADAJNIKA I ODBIORNIKA
// USART PRZEJMUJE KONTORLĘ NAD PINAMI uC
//-----------------------------------------------------------------------------------------------
void USART_INI(uint8_t baud)
{
UBRRH = (uint8_t)(baud>>8); // Ustawienie prędkości
UBRRL = (uint8_t) baud;

UCSRC = _UCSRC; //aby zapisać do UCSRC to należy ustawić bit 7 (URSEL)
UCSRB = _UCSRB;
}

//-----------------------------------------------------------------------------------------------
// Funkcja wysyła pojedynczy znak
//-----------------------------------------------------------------------------------------------
void USART_WYSLIJ_ZNAK(uint8_t dana)
{
UDR = dana;
}

//-----------------------------------------------------------------------------------------------
// Funkcja wysyła DANE z dowolnego obszaru pamięci RAM wskazanego poprzez wskaźnik
// Tu podajemy tylko wskaźnik do pierwszej komórki pamięci, od której mają być wysyłane dane
// i włączamy przerwanie od pustego bufora nadajnika.
// Dalsze wysyłanie danych przejmuje przerwanie od pustego bufora nadajnika
//-----------------------------------------------------------------------------------------------
void USART_WYSLIJ_STRING(volatile void *dane)
{
wskaznik_TX = dane; // przepisanie wskaźnika, wskaźnik_TX używany w przerwaniu od pustego bufora
UCSRB |= (1<}

//-----------------------------------------------------------------------------------------------
// Funkcja wysyła DANE z pamięci FLASH
//-----------------------------------------------------------------------------------------------
void USART_WYSLIJ_STRING_P(const char *dane)
{
register char znak;
uint8_t i = 0;

while ((znak = pgm_read_byte(dane++))) // przepisywanie z ROM do BUFORA TX
Uart_Bufor_TX[i++] = znak;

Uart_Bufor_TX[i] = 0; // należy wpisać 0 na koniec tekstu
USART_WYSLIJ_STRING(Uart_Bufor_TX); // wysłanie buforu TX
}

//-----------------------------------------------------------------------------------------------
// Obsługa przerwania PUSTY BUFOR
//-----------------------------------------------------------------------------------------------
ISR(USART_UDRE_vect)
{
if (*wskaznik_TX) // jeżeli wartość w buforze większa od zera
UDR = *wskaznik_TX++; // wpisanie znaku z adresu we wskaźniku do nadajnika UART
else // jeżeli wartość w buforze równa 0 to:
UCSRB &=~(1<}

//-----------------------------------------------------------------------------------------------
// Obsługa przerwania OTRZYMANO ZNAK
// Potwierdzenie odebrania całej ramki odbywa się po odebraniu znaku "CR" (0x0D)
//-----------------------------------------------------------------------------------------------
ISR(USART_RXC_vect)
{
static uint8_t Licznik_Bufora_Rx = 0; // licznik odebranych bajtów

Uart_Bufor_RX[Licznik_Bufora_Rx] = UDR; // odczytanie odebranego bajtu z odbiornika

if (Uart_Bufor_RX[Licznik_Bufora_Rx++] == '\r') // jeśli odebrany znak = "CR" to:
{
Uart_Bufor_RX[--Licznik_Bufora_Rx] = 0; // podmiana na 0 ostatnio odebranego znaku czyli entera
Licznik_Bufora_Rx = 0; // kasowanie licznika odebranych bajtów
Jest_dana_z_RX = 1; // ustawienie flagi Jest_dana_z_RX, że zostały odebrane dane
}
}[/syntax]

main.c

[syntax=c]/*
* main.c ATmega16 F_CPU = 16000000 Hz
*
* Created on: 2017-11-03
* Author: Artur
*/
// dołączanie systemowych plików nagłówkowych
#include
#include
#include
#include

// miejsce na dołączanie własnych plików
#include "UART_ATMega/UART_ATMega.h"

const char Tekst[] PROGMEM = "NAPIS Z PAMIECI FLASH";

// główna funkcja programu - main()
int main( void )
{
// sekcja inicjalizacji peryferiów
USART_INI(_UBRR);
sei();

// główna pętla programu
while(1)
{
//przykład tstowy
if (Jest_dana_z_RX) // sprawdzenie czy zostały odebrane dane przez UART
{
Jest_dana_z_RX = 0;
if (Uart_Bufor_RX[0] == 'A') // sprawdzenie czy w pierwszy bajt w buforze RX to "A"
{
USART_WYSLIJ_STRING(Uart_Bufor_RX); // jeśli tak to odsyła dane wcześniej odebrane
}

}

}

}[/syntax]

Poniżej obrazek z terminala dla tego testowego programu.

Proszę o opinie, może jakieś ciekawe podpowiedzi ? utrzymując założenie, że obsługa ma być stosunkowo prosta i na przerwaniach .

Pozdrawiam

Statystyki: Napisane przez Artur_26 — 13 lis 2017, o 21:43