ATNEL tech-forum

Re: USART po raz n-ty.

2015-05-10T10:57:37+01:00

Tak, ale tylko do użytku wewnątrz tegoż pliku.

Statystyki: Napisane przez jnk0le — 10 maja 2015, o 10:57

Re: USART po raz n-ty.

2015-05-09T19:02:00+01:00

Dzięki za podpowiedzi. Myślałem o rozwiązaniu z makrami, i może dorobię takie do wykorzystania w bibliotece. Na razie naniosłem kolejne poprawki w kodzie usuwając poważny błąd przy wykrywaniu przepełnienia bufora odbioru (funkcja, która powinna być wywoływana przy przepełnieniu była wywoływana przy każdym odebraniu danych).
A tak z innej beczki czy dopuszczalne jest definiowanie makr w pliku*.c?

Statystyki: Napisane przez ryba84 — 9 maja 2015, o 19:02

Re: USART po raz n-ty.

2017-10-07T20:36:13+01:00

Dosyć ciekawe podejście z callbackami.

Statystyki: Napisane przez jnk0le — 3 maja 2015, o 19:20

Re: USART po raz n-ty.

2015-04-30T21:49:34+01:00

Mam to ustawione i to się odnosi tylko do nieużywanych funkcji. Tutaj problemem jest część kodu znajdująca się w funkcji. Pomijając sprawdzanie czy funkcje zostały zarejestrowane zyskujemy 12 bajtów w tym konkretnym przykładzie (program ma 898bajtów bez sprawdzania i 910 bajtów z, co dla Atmegi2560 akurat ma kolosalne znaczenie ). Brak rejestracji funkcji może wprowadzać w błąd (ciągłe resetowanie się procka) i w konsekwencji szukanie błędu nie tam gdzie trzeba. W pierwszym poście poprawiłem to dla innych. Ja albo sobie dorobię makra do wyłączania zbędnych sekcji, albo może znajdą się flagi wywalające zbędny kod. Tylko to nie takie proste, bo kompilator nie kompiluje od razu całego projektu tylko pliki po kolei, więc kompilując usart.c nie wie jeszcze czy użyszkodnik będzie rejestrował callbacki w głównym programie. Trafiłem kiedyś na flagi możliwe do użycia tylko jak wszystko kompilowało się z jednej linii polecenia, ale nie działają z najnowszym toolchain Atmela (albo ja nie umiem ich użyć).

EDYTA:
Są dwie opcje kompilacji:

-fwhole-program - tego nie umiem w ogóle zmusić do działania - trzeba przekazywać wszystkie pliki źródłowe na raz do kompilatora
-flto - pod Eclipse tworzy większy kod (1416 bajtów), ale z linii komend daje 894 bajty (system linux):
Code:
avr-gcc -Wall -I"/home/ryba/Programowanie/avr/usart_lib" -Os -fpack-struct -fshort-enums -ffunction-sections -fdata-sections -ffreestanding -fno-tree-scev-cprop -mcall-prologues -flto -std=gnu99 -funsigned-char -funsigned-bitfields -mmcu=atmega2560 -DF_CPU=16000000UL -MD -MP -MT -MF"usart_lib.d" "../usart.c" "../main.c" -mmcu=atmega2560 -Wl,--relax -Wl,--gc-sections -Wl,-Map=usart_lib.map -o usart_lib.elf
żeby nie było tak różowo to i w Eclipse i z linii komend wali warningiem:
Code:
In function '__vector_25':
../main.c:74:1: warning: '_vector_25' appears to be a misspelled signal handler [enabled by default]
ISR(USART0_RX_vect) {
^
In function '__vector_27':
../main.c:78:1: warning: '_vector_27' appears to be a misspelled signal handler [enabled by default]
ISR(USART0_TX_vect) {
co nie zmienia faktu, że program działa.

Pierwsza opcja może być wydajniejsza gdyż wszystkie funkcje w plikach traktuje jako statyczne pozwalając na bardziej agresywną optymalizację, ale ja nie umiem jej zmusić do działania.

EDYTA2:
Działa też -fwhole-program nawet w Eclipse. Tylko żeby działało musiałem dać na górze main.c[syntax=c]#include "usart.c"[/syntax]co nie jest zbyt ładną praktyką. Daje to kod wielkości 816 bajtów (ok. 10% mniejszy)!!! Według dokumentacji GCC nie wolno łączyć obu optymalizacji.

Statystyki: Napisane przez ryba84 — 30 kwi 2015, o 21:49

Re: USART po raz n-ty.

2015-04-30T21:20:09+01:00

jeśli chodzi o flagi to
W konfiguracji projektu C/C++ Build -> Settings -> AVR Compiler -> Optimization zaznaczone opcje -ffunction-sections oraz -fdata-sections
ewentualnie w starszej wersji avr plugin dopisać w Other Optimization Flags

Code:

-ffunction-sections -fdata-sections

następnie w AVR C Linker -> General -> Other Arguments dopisać

Code:

-Wl,--gc-sections

i jeśli dobrze pamiętam to Eclipse Gadget ma tez opcję z dodaniem tych parametrów do projektu

Statystyki: Napisane przez lemurek — 30 kwi 2015, o 21:20

Re: USART po raz n-ty.

2015-04-30T21:12:34+01:00

To by było ciekawe czy działa pod PIC. Jak jest możliwość pomijania zbędnego kodu w GCC to z chęcią z niej skorzystam. Albo może jakiś warning/błąd podczas kompilacji, że nie zarejestrowałem funkcji. Ja dopiero raczkuję w C i tylko w wolnym czasie, więc jak są jakieś sugestie to z chęcią ich posłucham(przeczytam ).

Statystyki: Napisane przez ryba84 — 30 kwi 2015, o 21:12

Re: USART po raz n-ty.

2015-04-30T21:14:05+01:00

Nie tak ostro bo w piórka obrosnę . Masz rację powinienem sprawdzać czy mam podpięty callback bo program pójdzie w maliny, ale chciałem kilkadziesiąt bajtów zaoszczędzić (chyba, że masz pomysł jakich flag optymalizacji użyć aby GCC samo usuwało zbędny kod). Z drugiej strony jeśli użytkownik nie zarejestruje funkcji to i tak mu nie będzie działać to co chce. Sprawdzam tylko czy ktoś chce obsługiwać przepełnienie bufora. Reszta ma być bo inaczej nie działa . Tak trzeba się wysilić aby użyć tej biblioteki (inicjalizacja), ale dzięki takiemu podejściu jak się przesiądę na jakiś inny procek (ARM?PIC?) to nadal można korzystać z tego kodu (chyba ). Za to dorobienie do tego obsługi RS485 w trybie half duplex jest banalnie proste, bo wystarczy wachlować dodatkowym pinem podczas uruchamiania i wyłączania trybu nadawania. Kombinowałem z napisaniem jakiejś prostej funkcji inicjalizacji pod AVR z callbackiem pod rejestry użyszkodnika, ale to moim zdaniem strata czasu. Równie dobrze może być tak jak jest, a po niewielkich przeróbkach (które za jakiś czas wrzucę) możemy korzystać z kilku USART-ów na raz z oddzielnymi buforami dla każdego z nich.

Statystyki: Napisane przez ryba84 — 30 kwi 2015, o 20:51

USART po raz n-ty.

2015-05-09T18:47:30+01:00

Witam.

Chciałbym się podzielić z Wami biblioteką mojego autorstwa służącą do obsługi USART w AVR. Celem było napisanie jak najbardziej uniwersalnej oraz nieblokującej obsługi USART.
Funkcjonalność biblioteki:

Pełna niezależność od rejestrów procesora(naoglądałem się Mirka poradników o callbackach ) - ta przyjemność pozostaje po stronie użytkownika.
Obsługa buforów cyklicznych z obsługą przepełnienia - po jednym dla nadawania i odbierania danych.
Nieblokujące funkcje wysyłania i odbierania - transmisja z i do bufora odbywa się w przerwaniach.

Poniżej kod biblioteki:
usart.h
[syntax=c]/*
* usart.h
*
* Created on: 27 kwi 2015
* Author: Piotr Rudzki ryba.lodz@gmail.com
*Version: 1.0
*Changelog:
*1.0 - added macro definitions to use when more compact code is needed.
*- removed bug in usartRxIsrRoutine - bad detecting buffer overflow.
*0.9 - added missing tests when calling callback functions.
*- added _rxDataReady callback.
*- moved buffers definitions.
*- added txStarted flag.
*0.8 - initial release.
*/

#ifndef USART_H_
#define USART_H_

#include
#include

// Pojemność buforów danych. W celu szybszej obsługi wielkość buforów powinna być potęgą 2.
// Maksymalna pojemność bufora 256.
#define BUFFER_LENGHT 16
#define USART_TX_ENABLE // Włączenie kodu nadawania. Dodaje do kodu tylko flagę nadawania do zmiennych globalnych.

// Dodatkowe definicje jeśli nie chcemy korzystać z mechanizmów callback,
// np. w celu optymalizacji kodu (oszczędność ~150bajtów).
// Definicja funkcji rozpoczynającej odbiór danych.
/*#define USART_RX_START(UCSR0B |= (1 << RXEN0))
// Definicja wywoływana podczas przepełnienia bufora odbioru.
#define USART_RX_BUFFER_FULLextern void rxBufferFull(void);\
rxBufferFull()
// Definicja funkcji wywoływanej po odebraniu pierwszych danych.
#define USART_RX_DATA_READYextern void rxDataReady(void);\
rxDataReady()
// Definicja funkcji rozpoczęcia nadawania.
#define USART_TX_START(UCSR0B |= (1 << TXEN0))
// Definicja funkcji końca nadawania.
#define USART_TX_STOP(UCSR0B &= ~(1 << TXEN0))
*/

// Struktura opisująca kolejkę FIFO.
typedef struct {
uint8_t tail; // wskaźnik na początek bufora
uint8_t head; // wskaźnik na koniec bufora
uint8_t buff[BUFFER_LENGHT]; // bufor z danymi
} fifo_t;

// Definicje funkcji biblioteki. Część można zastąpić makrami definiowanymi powyżej.
// Odbieranie danych.
void regRxStart(void (*callback)(void)); // Rejestracja funkcji wywoływanej podczas startu odbierania.
void regRxBufferFull(void (*callback)(void)); // Rejestracja funkcji wywoływanej podczas przepełnienia bufora odbioru.
void regRxDataReady(void (*callback)(void)); // Rejestracja funkcji wywoływanej po odebraniu bajtu danych.
void usartRxStart(); // Start odbioru danych.
int16_t usartReadRxBuffer(volatile fifo_t *rxBuffer); // Odczyt danych z bufora odbioru.
void usartRxIsrRoutine(volatile uint8_t *usartDataReg, volatile fifo_t *rxBuffer); // Funkcja wywoływana w przerwaniu.

// Nadawanie danych.
void regTxStart(void (*callback)(void)); // Rejestracja funkcji wywoływanej podczas startu wysyłania.
void regTxStop(void (*callback)(void)); // Rejestracja funkcji wywoływanej podczas końca wysyłania.
void usartTxStart(volatile uint8_t *usartDataReg, volatile fifo_t *txBuffer); // Start nadawania danych.
int8_t usartWriteTxBuffer(uint8_t data, volatile fifo_t *txBuffer); // Zapis znaku do bufora nadawania.
void usartTxIsrRoutine(volatile uint8_t *usartDataReg, volatile fifo_t *txBuffer); // Funkcja wywoływana w przerwaniu.
#endif /* USART_H_ */[/syntax]
usart.c
[syntax=c]/*
* usart.c
*
* Created on: 27 kwi 2015
* Author: Piotr Rudzki ryba.lodz@gmail.com
*Version: 1.0
*Changelog:
*1.0 - added macro definitions to use for more compact code.
*- removed bug in usartRxIsrRoutine - bad detecting buffer overflow.
*- small code optimizations.
*0.9 - added missing tests when calling callback functions.
*- added _rxDataReady callback
*- moved buffers definitions
*- added txStarted flag
*0.8 - initial release
*/

#include "usart.h"

#ifdef USART_TX_ENABLE
volatile uint8_t txStarted; // Flaga nadawania. Jeśli nadawanie trwa przyjmuje wartość 1.
#endif

/*
* Funkcje wewnętrzne biblioteki.
*/
// Odczyt bajtu z bufora danych. Zwraca bajt z bufora lub -1 w przypadku pustego bufora.
static int16_t usartReadCharBuff(volatile fifo_t *buffer) {
if (buffer->tail != buffer->head) { // Jeśli bufor nie jest pusty.
uint8_t tmp = buffer->buff[buffer->tail]; // Odczyt kolejnego bajtu z bufora.
buffer->tail = (buffer->tail + 1) % BUFFER_LENGHT; // Przesuń początek bufora na następną pozycję.
return tmp;
}
return -1;
}
// Zapis bajtu do bufora danych. Zwraca -1 w przypadku przepełnionego bufora.
static int8_t usartWriteCharBuff(volatile fifo_t *buffer, uint8_t data) {
uint8_t next = (buffer->head + 1) % BUFFER_LENGHT; // Ustalamy numer kolejnego bajtu w buforze.
// Sprawdzamy czy jest miejsce w buforze.
if (next != buffer->tail) {
buffer->buff[buffer->head] = data; // Zapisz kolejny bajt w buforze.
buffer->head = next;
return 0;
}
return -1;
}

/*
* Odbiór danych.
*/
#ifndef USART_RX_START
// Callback wywoływany podczas uruchamiania nasłuchu.
void (*_usartRxStart)(void);
// Rejestracja powyższej funkcji.
void regRxStart(void (*callback)(void)) {
_usartRxStart = callback;
}
#endif
#ifndef USART_RX_BUFFER_FULL
// Callback wywoływany w przypadku zapełnienia bufora odbierania.
void (*_rxBufferFull)(void);
// Rejestracja powyższej funkcji.
void regRxBufferFull(void (*callback)(void)) {
_rxBufferFull = callback;
}
#endif
#ifndef USART_RX_DATA_READY
// Callback wywoływany w przypadku odebrania danych.
void (*_rxDataReady)(void);
// Rejestracja powyższej funkcji.
void regRxDataReady(void (*callback)(void)) {
_rxDataReady = callback;
}
#endif
#ifndef USART_RX_START
// Start odbioru danych.
void usartRxStart() {
if (_usartRxStart) {
(*_usartRxStart)();
}
}
#endif
// Odczyt danych z bufora odbioru. Zwraca -1 w przypadku pustego bufora.
int16_t usartReadRxBuffer(volatile fifo_t *rxBuffer) {
return usartReadCharBuff(rxBuffer);
}
// Wypełnianie bufora w przerwaniu. Jako argument przyjmuje rejestr bufora danych USART.
void usartRxIsrRoutine(volatile uint8_t *usartDataReg,
volatile fifo_t *rxBuffer) {
uint8_t tmp = *usartDataReg;
if (usartWriteCharBuff(rxBuffer, tmp) > -1) { // Sprawdzamy czy bufor nie został przepełniony.
#ifndef USART_RX_DATA_READY
if (_rxDataReady) {
(*_rxDataReady)(); // Odebrano dane.
}
#else
USART_RX_DATA_READY;
#endif
} else {
#ifndef USART_RX_BUFFER_FULL
if (_rxBufferFull) {
(*_rxBufferFull)(); // Przepełnienie bufora odbioru.
}
#else
USART_RX_BUFFER_FULL;
#endif
}
}

/*
* Wysyłanie danych
*/
#ifndef USART_TX_START
// Callback wywoływany podczas uruchamiania nadawania.
void (*_usartTxStart)(void);
// Rejestracja powyższej funkcji.
void regTxStart(void (*callback)(void)) {
_usartTxStart = callback;
}
#endif
#ifndef USART_TX_STOP
// Callback wywoływany podczas wyłączania nadawania.
void (*_usartTxStop)(void);
// Rejestracja powyższej funkcji.
void regTxStop(void (*callback)(void)) {
_usartTxStop = callback;
}
#endif
// Start nadawania. Jeśli wywołamy przy pustym buforze to nie uruchomi nadawania.
void usartTxStart(volatile uint8_t *usartDataReg, volatile fifo_t *txBuffer) {
if (txStarted == 0) {
int16_t tmp = usartReadCharBuff(txBuffer);
if (tmp > -1) { // Sprawdzamy czy było coś w buforze.
txStarted = 1;
#ifndef USART_TX_START
if (_usartTxStart) {
(*_usartTxStart)(); // Uruchamiamy nadawanie.
}
#else
USART_TX_START;
#endif
*usartDataReg = tmp; // Wysyłamy pierwszy znak - reszta z bufora pójdzie w przerwaniu.
}
}
}
// Zapis znaku do bufora. Zwraca -1 w przypadku przepełnienia bufora.
int8_t usartWriteTxBuffer(uint8_t data, volatile fifo_t *txBuffer) {
return usartWriteCharBuff(txBuffer, data);
}
// Wysyłanie danych w przerwaniu. Jako argument przyjmuje rejestr bufora danych USART.
void usartTxIsrRoutine(volatile uint8_t *usartDataReg,
volatile fifo_t *txBuffer) {
int8_t tmp = usartReadCharBuff(txBuffer);
if (tmp > -1) { // Sprawdzamy czy jest coś w buforze nadawania.
*usartDataReg = tmp; // Wysyłamy kolejny bajt z bufora.
} else {
txStarted = 0;
#ifndef USART_TX_STOP
if (_usartTxStop) {
(*_usartTxStop)(); // Wyłączamy nadawanie danych.
}
#else
USART_TX_STOP;
#endif
}
}[/syntax]
I oczywiście przykładowe wykorzystanie biblioteki. Tutaj proste echo odebranych danych wersja dla Atmegi2560:
main.h
[syntax=c]/*
* main.h
*
* Created on: 27 kwi 2015
* Author: Piotr Rudzki ryba.lodz@gmail.com
*/

#ifndef MAIN_H_
#define MAIN_H_

#include
#include
#include

#include "usart.h"

#endif /* MAIN_H_ */[/syntax]
main.c
[syntax=c]/*
* main.c
*
* Created on: 27 kwi 2015
* Author: Piotr Rudzki ryba.lodz@gmail.com
*/

// Poniżej definiujemy prędkość USART.
#define BAUD 38400

#include "main.h"

volatile fifo_t rxBuffer;// Bufor odbioru danych.
volatile fifo_t txBuffer;// Bufor nadawania danych.

// Inicjalizacja USART0 w Mega2560.
static inline void usartInit() {
// Prędkość transmisji (definiowana w BAUD powyżej).
UBRR0H = UBRRH_VALUE;
UBRR0L = UBRRL_VALUE;
UCSR0A = (USE_2X << U2X0);
// Przerwania po odebraniu i wysłaniu danych.
UCSR0B = (1 << RXCIE0) | (1 << TXCIE0);
// Format 8N1 (8 bitów, bez parzystości, jeden bit stopu).
UCSR0C = (1 << UCSZ00) | (1 << UCSZ01);
// Start przerwań.
sei();
}
// Start odbierania danych - wywoływany jako callback przez bibliotekę.
void rxStart() {
UCSR0B |= (1 << RXEN0); // Włączenie odbiornika.
}
// Start nadawania danych - wywoływany jako callback przez bibliotekę.
void txStart() {
UCSR0B |= (1 << TXEN0); // Włączenie nadajnika.
}
// Koniec nadawania danych - wywoływany jako callback przez bibliotekę.
void txStop() {
UCSR0B &= ~(1 << TXEN0); // Wyłączenie nadajnika.
}
// Przepełnienie bufora odbioru - wywoływany jako callback przez bibliotekę.
void bufferFull() {
// Tutaj funkcja opróżniająca bufor odbioru w razie przepełnienia.
}
void rxDataReady() {
// Tutaj funkcja wywoływana po pojawieniu się danych w buforze odbioru.
}

int main(void) {
int16_t tmp; // Zmienna przechowująca odczytany bajt z bufora odbioru.
int8_t txBufferFlag; // Flaga zajętości bufora nadawania.

regRxStart(rxStart); // Rejestracja funkcji uruchomiającej odbiór danych.
regTxStart(txStart); // Rejestracja funkcji uruchamiającej nadawanie danych.
regTxStop(txStop); // Rejestracja funkcji wyłączającej nadawanie danych.
regRxBufferFull(bufferFull); // Rejestracja funkcji wywoływanej przy przepełnieniu bufora odbioru.
usartInit(); // Inicjalizacja USART.

usartRxStart(); // Start odbioru danych.
// Pętla programu
while (1) {
// Poniżej prosta funkcja odsyłająca odebrane dane.
tmp = usartReadRxBuffer(&rxBuffer);
if (tmp > -1) { // Jeśli odczytano znak z bufora.
txBufferFlag = usartWriteTxBuffer(tmp, &txBuffer);
if (txBufferFlag == 0) { // Sprawdzamy czy wpisywany znak znalazł miejsce w buforze.
usartTxStart(&UDR0, &txBuffer); // Start nadawania danych.
}
}
// Tutaj możemy robić coś więcej bez czekania na USART.
}
}
// Przerwanie końca odbioru.
ISR(USART0_RX_vect) {
usartRxIsrRoutine(&UDR0, &rxBuffer);
}
// Przerwanie końca nadawania.
ISR(USART0_TX_vect) {
usartTxIsrRoutine(&UDR0, &txBuffer);
}[/syntax]
Proszę o niekopiowanie kodu w innych miejscach bez mojej zgody. Kod udostępniam do użytku niekomercyjnego.
Myślę, że komentarze w plikach wystarczą za wyjaśnienie sposobu użytkowania tej biblioteki. Wszelka konstruktywna krytyka mile widziana.
EDYTA1:
Zmiany w bibliotece:

Bufory definiowane przez użytkownika, wskaźniki na nie należy przekazywać do funkcji biblioteki. Dzięki temu można zunifikować bufor jeśli transmitujemy w trybie half duplex.
Dodano callback do funkcji odbierania wywoływany po pierwszym pojawieniu się danych w buforze.
Dodano flagę wysyłania tak by nie było możliwe kilkukrotne uruchamianie wysyłania.

EDYTA2:
Kolejne zmiany i poprawki.

Dodano możliwość skorzystania z makr zamiast systemu callback-ów co zmniejsza kod wynikowy.
Usunąłem błąd w procedurze odbierania danych polegający na błędnym wykrywaniu przepełnienia bufora. Chyba nikt nie przejrzał kodu bo aż raziło

Statystyki: Napisane przez ryba84 — 30 kwi 2015, o 20:25