ATNEL tech-forum

Re: Wskaźnik i funkcja w strukturze

2020-04-03T07:38:04+01:00

Otrzymałem odpowiedź w sprawie hex error, umieszczam ją tu dla porządku.

Środowisko:
MPLAB X ver 5.30, kompilator XC16 ver 1.50

Problem:
MPLAB X ver 5.30 po skopiowaniu projektu może generować błąd niewykonalnego/nieistniejącego hex'a.

Rozwiązanie:
Zmusić MPLAB X do ponownego wygenerowania nbproject/Makefile-default.mk, np. poprzez usunięcie go lub przełączenie kompilatora na inną wersję (można wrócić do najnowszej po przeładowaniu projektu).

Statystyki: Napisane przez abel11 — 3 kwi 2020, o 07:38

Re: Wskaźnik i funkcja w strukturze

2020-03-31T10:23:21+01:00

O coś takiego mi chodziło tyle, że pomimo kompilacji bez błędów na koniec dostaje komunikat jak niżej - dlatego wcześniej odrzuciłem ten pomysł i poszedłem w wskaźniki (na których nie dostaje tego błędu). Może coś jest skopane w ustawieniach projektu, bo nie chce mi się wierzyć, że wpadłeś na identycznie błędny pomysł jak ja.
Sprawdzę ustawienia projektu i zobaczę czy dalej będzie generowało uszkodzonego hex'a.

------------------------ [ Dodano po: 50 minutach ]

Na starszej wersji kompilatora rozwiązanie zaproponowane przez kolegę fofex działa poprawnie, na nowszej ciągle otrzymuje błąd z hex'em - poszedł ticket do MCP.
Dzięki za pomoc.

Statystyki: Napisane przez abel11 — 31 mar 2020, o 10:23

Re: Wskaźnik i funkcja w strukturze

2020-03-31T09:51:05+01:00

[syntax=c]struct Buffer;
typedef struct Buffer{

...

/// Read filtered sample function
bool (*ReadFilteredSample)(signed _Fract* , struct Buffer*);

...
}Buffer;[/syntax]

lub

[syntax=c]typedef struct Buffer Buffer;
struct Buffer{

...

/// Read filtered sample function
bool (*ReadFilteredSample)(signed _Fract* , Buffer*);

...
};[/syntax]

Statystyki: Napisane przez fofex — 31 mar 2020, o 09:51

Re: Wskaźnik i funkcja w strukturze

2020-03-31T09:41:09+01:00

Dzięki za radę.
Niestety tą metodą otrzymam konflikt typów, przez słowo kluczowe typedef ta opcja nie wchodziła w gre wcześniej. Być może coś mi umknęło i da się to obejść w ten sposób tylko jeszcze nie wiem jak.

[syntax=c]typedef struct Buffer_t Buffer_t;
typedef struct{

/// Main buffer ptr (ISR editable)
volatile unsigned _Fract * volatile buffer;

/// Write, sample data pointer (ISR editable)
volatile unsigned _Fract * volatile buffWritePtr;

/// Read, sample data pointer (ISR non editable)
volatile unsigned _Fract * volatile buffReadPtr;

/// Number of filtered samples
uint16_t numberOfFilteredSamples;

/// Sample offset value
unsigned _Fract sampleOffset;

/// Read filtered sample function
bool (*ReadFilteredSample)(signed _Fract* , Buffer_t*);

/// Overflow flag (ISR editable)
volatile bool bufferOverflow;

/// Calculated buffer size
volatile uint16_t buffSize;

}Buffer_t;
extern Buffer_t volatile DataSamplesL1;[/syntax]

[syntax=c]mcc_generated_files/adc1.h:133:2: error: conflicting types for 'Buffer_t'
mcc_generated_files/adc1.h:106:25: note: previous declaration of 'Buffer_t' was here[/syntax]

edit:
Nie dodałem w pierwszym poście informacji o C w wersji C99

Statystyki: Napisane przez abel11 — 31 mar 2020, o 09:41

Re: Wskaźnik i funkcja w strukturze

2020-03-31T09:17:11+01:00

abel11 napisał(a):

czy da się to zrobić nieco prościej bez wskaźnika typu void i rzutowania różnych typów na siebie

Deklarujesz typ przed jego definicją:

[syntax=c]typedef struct Buffer Buffer;
typedef struct Buffer{

/// Main buffer <>
volatile unsigned _Fract * volatile buffer;

/// Write nacked data pointer <>
volatile unsigned _Fract * volatile buffWritePtr;

/// Read filtered data pointer
volatile unsigned _Fract * volatile buffReadPtr;

/// Number of filtered samples
uint16_t numberOfFilteredSamples;

/// Sample offset value
unsigned _Fract sampleOffset;

/// Read filtered sample function
bool (*ReadFilteredSample)(signed _Fract* , Buffer*);

/// Overflow flag <>
volatile bool bufferOverflow;

/// Calculated buffer size
volatile uint16_t buffSize;

}Buffer;[/syntax]

Statystyki: Napisane przez fofex — 31 mar 2020, o 09:17

Wskaźnik i funkcja w strukturze

2020-03-31T08:59:36+01:00

Hej wszystkim.

Piszę program, w którym te same funkcje wykonują się wiele razy dla innych danych wejściowych, więc chce go nieco uprościć, wstawiając do struktur wskaźniki na funkcje (ala metody) oraz tworząc coś na kształt instancji. Tu pojawił się problem ponieważ z tego co wiem C nie wspiera tego typu operacji i trzeba to robić na piechotę.

To co chce osiągnąć wyglądało by jak kod poniżej, gdyby nie to, że nie mogę wykorzystać typu Buffer_t jako argument wskaźnika na funkcję bool (*ReadFilteredSample)(signed _Fract* , Buffer_t*) w deklaracji struktury ponieważ to definicja Buffer_t więc kompilator nie będzie wiedział co tam wstawić.
[syntax=c]typedef struct{

/// Main buffer <>
volatile unsigned _Fract * volatile buffer;

/// Write nacked data pointer <>
volatile unsigned _Fract * volatile buffWritePtr;

/// Read filtered data pointer
volatile unsigned _Fract * volatile buffReadPtr;

/// Number of filtered samples
uint16_t numberOfFilteredSamples;

/// Sample offset value
unsigned _Fract sampleOffset;

/// Read filtered sample function
bool (*ReadFilteredSample)(signed _Fract* , Buffer_t*);

/// Overflow flag <>
volatile bool bufferOverflow;

/// Calculated buffer size
volatile uint16_t buffSize;

}Buffer_t;
extern Buffer_t volatile DataSamplesL1;[/syntax]

Alternatywą jest przerobienie funkcji bool ReadFilteredSample(signed _Fract* , Buffer_t*) na bool ReadFilteredSample(signed _Fract* , void*) i rzutowanie wewnątrz funkcji wskaźnika void* na wewnętrzną zmienną typu Buffer_t*.
[syntax=c]typedef struct{

/// Main buffer ptr (ISR editable)
volatile unsigned _Fract * volatile buffer;

/// Write, sample data pointer (ISR editable)
volatile unsigned _Fract * volatile buffWritePtr;

/// Read, sample data pointer (ISR non editable)
volatile unsigned _Fract * volatile buffReadPtr;

/// Number of filtered samples
uint16_t numberOfFilteredSamples;

/// Sample offset value
unsigned _Fract sampleOffset;

/// Read filtered sample function
bool (*ReadFilteredSample)(signed _Fract* , void*);

/// Overflow flag (ISR editable)
volatile bool bufferOverflow;

/// Calculated buffer size
volatile uint16_t buffSize;

}Buffer_t;
extern Buffer_t volatile DataSamplesL1;[/syntax]

Funkcja ReadFilteredSample wyglądał by tak:
[syntax=c]bool ReadFilteredSample(signed _Fract* sample, void* buffPtr){

Buffer_t *buffer = buffPtr;

if(buffer->bufferOverflow){
// handle overflow condition
}

if(buffer->numberOfFilteredSamples > 0 && !buffer->bufferOverflow){
// filter sample
return true;
}

return false;
}[/syntax]

Moje pytanie brzmi czy da się to zrobić nieco prościej bez wskaźnika typu void i rzutowania różnych typów na siebie - wydaje mi się że jest to mało bezpieczne rozwiązanie.

Z góry dzięki za wszelkie rady!

Statystyki: Napisane przez abel11 — 31 mar 2020, o 08:59