ATNEL tech-forum

Re: callbacki... prosze o pomoc.

2018-06-19T11:21:30+01:00

Dziekuje andrews. O to mi chodzilo. Teraz bede w komplecie. Bede dzis testowal. Stawiam piwko

Statystyki: Napisane przez jacabe — 19 cze 2018, o 11:21

Re: callbacki... prosze o pomoc.

2018-06-19T10:13:18+01:00

jacabe napisał(a):

[syntax=c]KEY_SELMUX.keyshort = nastepny_kanal(mux_chnl); //<-tu podstawiam funkcje do wywolania
// z tym parametrem, ktora ma sie wykonac[/syntax]

Pole struktury o nazwie keyshort to wskaźnik na funkcję. Taki wskaźnik to wartość 16-bitowa będąca adresem pierwszej instrukcji funkcji. Nie da się do niego wpisać jeszcze dodatkowo jakiegoś argumentu. Jedyny sposób to:[syntax=c]KEY_SELMUX.keyshort = nastepny_kanal;[/syntax][/syntax]

Jeżeli chcesz zapamiętać argument, z którym funkcja ma się wykonać, możesz np. dodać dodatkowe pole do struktury, które będzie przechowywać wartość tego argumentu:[syntax=c]typedef struct { //struktura tworzaca przycisk
// pomijam nieistotne tutaj pola struktury
void (*keyshort)(int8_t * attr); //<-funkcja do obslugi wcisniecia przycisku
int8_t * keyshort_arg; // argument, z jakim funkcja ma się wykonać
// pomijam nieistotne tutaj pola struktury
} PB;[/syntax]

W strukturze zapisujesz:[syntax=c]// zamiast KEY_SELMUX.keyshort = nastepny_kanal(mux_chnl);
KEY_SELMUX.keyshort = nastepny_kanal;
KEY_SELMUX.keyshort_arg = &mux_chnl; // zmienna mux_chnl musi być zdefiniowana jako int8_t
// a nie jako uint8_t, jak przedstawiłeś w Twoim kodzie[/syntax]

Później wewnątrz funkcji:[syntax=c]// zamiast if (key->keyshort) key->keyshort; //<-tu ma sie wykonac
// funkcja podlaczona przy inicjalizacji
if (key->keyshort) key->keyshort(key->keyshort_arg);[/syntax]

Oczywiście istnieją zapewne inne możliwości osiągnięcia celu, być może lepsze, jednak z Twojego opisu nie potrafię wywnioskować, jaki ten cel dokładnie jest, więc trudno doradzić coś konkretnego.
Nie podałeś jednoznacznie np.:
Czy każdy klawisz ma inną funkcję callback, czy niektóre klawisze korzystają z tych samych funkcji, tylko z innym argumentem?
Czy argumenty to zmienne globalne, czy lokalne? Jeśli do funkcji chcesz przekazywać wskaźniki zmiennych globalnych, to być może wcale nie będziesz potrzebował callbacka z argumentem.

Nie mam w tej chwili czasu na dokładną analizę kodu, ale na pierwszy rzut oka mam wrażenie, że chyba niepotrzebnie przekombinowałeś...

Statystyki: Napisane przez andrews — 19 cze 2018, o 10:13

Re: callbacki... prosze o pomoc.

2018-06-19T07:44:53+01:00

Jeszcze raz ogladalem poradniki. Wszedzie jest rejestracja callbacka bez parametrow a wywolanie z parametrem. Czy da sie zarejestrowac callbacka z parametrem : moje KEY[0].KEYSHORT = wyswietl(mux)? A wywolac if(callback) callback; niech sie wywola zarejestrowana funkcja z parametrem ktory wczesniej dolaczylem?

Statystyki: Napisane przez jacabe — 19 cze 2018, o 07:44

Re: callbacki... prosze o pomoc.

2018-06-19T06:01:00+01:00

No i wlasnie jakos zatrybic nie umiem. Dlatego prosze o pomoc. Ogladam i probuje i mam bledyw kompilacji.

Statystyki: Napisane przez jacabe — 19 cze 2018, o 06:01

Re: callbacki... prosze o pomoc.

2018-06-19T00:02:19+01:00

jacabe napisał(a):

Chodzi mi o wywolywanie podstawionej funkcji z parametrem. A nie wywolanie funkcji ze stalym paramertem. Da sie tak?

Da się
Oglądałeś poradniki Mirka o callbackach? Wspomina tam o tym ...

--
Pozdrawiam,
Robert

Statystyki: Napisane przez rskup — 19 cze 2018, o 00:02

Re: callbacki... prosze o pomoc.

2018-06-18T23:28:20+01:00

Jak zrobic zebym przypisal do wskaznika funkcj np KEY[0].WYSWIETL(INTFCE);
KEY[1].WYSWIETL(MUX);
a wywolanie funkcji : if(key->keyshort)key->keyshort;
Chodzi mi o wywolywanie podstawionej funkcji z parametrem. A nie wywolanie funkcji ze stalym paramertem. Da sie tak?

Statystyki: Napisane przez jacabe — 18 cze 2018, o 23:28

Re: callbacki... prosze o pomoc.

2018-06-18T10:00:11+01:00

Tak, tak powinno byc. Tylko wtedy musi byc z tym parametrem. Ja bym chcial zmieniac parametr. Czt tak sie wogole da?

Statystyki: Napisane przez jacabe — 18 cze 2018, o 10:00

callbacki... prosze o pomoc.

2018-06-17T16:50:44+01:00

Cześć. Próbuje napisać program do obsługi 9 klawiszy (takie superdebounce) wykorzystujac zreszta ta funkcje. Problem mam z callbackami, niestety. Mianowicie potrzebuje aby kazdy klawisz obslugiwal callbacka z argumentem. to zrobilem i dziala. ale kazdy klawisz ma miec inny callback i inny argument wywolywany z tej samej funkcji...
[syntax=c]//--------------definicje wejsc/wyjsc--------------

#define SEL(1<#define IFC(1<#define SYM(1<#define SWP(1<#define SWM(1<#define OWP(1<#define OWM(1<#define ACC(1<#define TAC(1<
//-------------------------------------------------

enum { KEYSEL = 1, KEYIFC = 2, KEYSYM = 4, KEYSWP = 8, KEYSWM = 16,
KEYOWP = 32, KEYOWM = 64, KEYACC = 128, KEYTAC = 256 };

typedef struct { //struktura tworzaca przycisk
volatile uint8_t *PIN;
uint8_t key;
volatile uint8_t key_long;
volatile uint8_t key_lockD;
volatile uint8_t key_lockU;
uint8_t key_powt_flag;
uint8_t key_d10ms;
void (*keyshort)(int8_t * attr); //<-funkcja do obslugi wcisniecia przycisku
void (*keyspull)(int8_t);
void (*keylong)(uint8_t);
void (*keypull)(void);
} PB;

PB KEY[9];

#define KEY_SELMUXKEY[0]
#define KEY_INFCEKEY[1]
#define KEY_SYMKEY[2]
#define KEY_SNDAPKEY[3]//klawisz SONDA +
#define KEY_SNDAMKEY[4]//klawisz SONDA -
#define KEY_OBRPKEY[5]
#define KEY_OBRMKEY[6]
#define KEY_ACCKEY[7]
#define KEY_TACHOKEY[8]

uint8_t disp_flag;//flaga zezwolenia na wyswietlenie informacji
#define DFTOGdisp_flag ^= 1

uint8_t mux_chnl;//licznik kanalow muxa
uint8_t mux_intfce;//zmienna interfejsu muxa

volatile uint8_t d10ms;//zmienna zmieniajaca stan co 10ms
volatile uint16_t key_reg;//rejestr flag przyciskow
uint16_t key_p;//pomocniczy rejestr przyciskow

snd *chanel;//wskaznik na kanal muxa

void disp_EVENT(void);
void key_EVENT(void);
void key_spr(PB * key, uint8_t powt);
void nastepny_kanal(int8_t kanal);
void zmiana_interfejsu(int8_t intfce);
void RX0_EVENT(void);

int main(void){

PORTD |= ROZ | SZA;//wejscia mux podciagniete do VCC
PORTA |= SEL | IFC | SYM | SWP | SWM | OWP | OWM | ACC ;
PORTB |= TAC ;

GICR |= (1 << PCIE0); //odblokowanie przerwania PCINT8-14
PCMSK0 |= (1 << PCINT7)|(1 << PCINT6)|(1 << PCINT5)|(1 << PCINT4)|(1 << PCINT3)|(1 << PCINT2)
|(1 << PCINT1)|(1 << PCINT0); //przerwanie od PCINT9
//PCIFR |= (1 << PCIF1); //kazda zmiana stanu

/*
* --------------------------timer2---------------------
*/

TCCR2 |= (1<TCCR2 |=(1<OCR2 = 72;//czas 10ms
TIMSK |=(1</*
* -----------------------------------------------------
*/

//----------------przypisanie poszczegolnym klawiszom reakcji na wcisniecie krotkie, dlugie
//----------------lub zwolnienie-----------------------------------------------------------

KEY_SELMUX.PIN = &PINC;
KEY_SELMUX.key = KEYSEL;
KEY_SELMUX.key_long = 200; //dlugie wcisniecie co najmniej 2s(200*10ms)
KEY_SELMUX.keyshort = nastepny_kanal(mux_chnl); //<-tu podstawiam funkcje do wywolania z tym parametrem, ktora ma sie
wykonac
//KEY_SELMUX.keyspull = nastepny_kanal;
//KEY_SELMUX.keylong = dlugie;
//KEY_SELMUX .keypull = zwolniony;

KEY_INFCE.PIN = &PINC;
KEY_INFCE.key = KEYSEL;
KEY_INFCE.key_long = 200; //dlugie wcisniecie co najmniej 2s(200*10ms)
KEY_INFCE.keyshort = zmiana_interfejsu(mux_chnl); //<-inna funkcja dla roznych klawiszy i inne parametry
//KEY[0].keyspull = nastepny_kanal;
//KEY[0].keylong = dlugie;
//KEY[0].keypull = zwolniony;

USART0_Init(UBRRC0);

// licz_petli = 150;
// uint8_t zaptime = 5;//200ms*5 = 1s
//co sekunde zapyta sonde o wartosc

wdt_disable();

_delay_ms(1000);

sei();

while (1) {

key_EVENT();

if (disp_flag){
DFTOG;

disp_EVENT();

}

RX0_EVENT();

}
}

ISR ( PCINT0_vect ) {

if (!(*KEY[0].PIN & KEY[0].key) && !KEY[0].key_lockD) KEY[0].key_lockD = 1;
else if ((*KEY[0].PIN & KEY[0].key) && (KEY[0].key_lockD > 1) && !KEY[0].key_lockU) KEY[0].key_lockU = 1;

// else if((PINA & SEL) && ksel_lock > 0 && ksel_lock < 3){
// ksel_lock++;
// }

if (!(PINA & IFC) && !KEY[1].key_lockD) {
KEY[1].key_lockD = 1;
key_reg |= KEYIFC;
}

else if((PINA & IFC) && KEY[1].key_lockU){
key_reg &= ~KEYIFC;
KEY[0].key_lockU = 0;
}
}

ISR(TIMER2_OVF_vect){

if(!(PINB & TAC) && !KEY[8].key_lockD){
KEY[8].key_lockD = 1;
key_reg |= KEYTAC;
}
else if((PINB & TAC) && KEY[8].key_lockU){
key_reg &= ~KEYTAC;
KEY[8].key_lockU = 0;
}
//else if((PINB & TAC) && ktac_lock > 0 && ktac_lock < 3){
//ktac_lock++;
//}

d10ms ^= 1;
uint16_t n = delaytime1;//realizacja delay min 10ms
if(n)delaytime1 = --n;

}

void disp_EVENT(void){

}

void key_EVENT(void){

key_spr(&KEY_SELMUX, 0);
key_spr(&KEY_INFCE, 0);

}

void key_spr(PB * key, uint8_t powt) {

if (!(*key->PIN & key->key) && key->key_lockD == 1) { //akcja zaraz po wcisnieciu przycisku
key->key_lockD++;
key->key_lockU = 0;
if (key->keyshort) key->keyshort; //<-tu ma sie wykonac funkcja podlaczona przy inicjalizacji
}

if (!(*key->PIN & key->key) && key->key_lockD && (!(key->key_d10ms == d10ms))) {
key->key_d10ms = d10ms;
if (key->key_lockD < 255) key->key_lockD++;

}

if ((!(*key->PIN & key->key)) && (key->key_lockD == key->key_long)) { //akcja po dlugim naciskaniu przycisku

if (powt && key->key_powt_flag) key->key_powt_flag = 0; //jezeli akcja ma byc powtarzana co zadany czas

if (!key->key_powt_flag) {
if (key->keylong) key->keylong(key->key_lockD);
key->key_powt_flag = 1;
key->key_lockD = 2;
}
}

if ((*key->PIN & key->key) && key->key_lockD > 1 && key->key_lockU == 1 ) { //akcja po puszczeniu przycisku
if (key->keyspull) key->keyspull(-1);
if (key->keypull) key->keypull();
key->key_lockD = 0;
key->key_lockU++;
}

if ((*key->PIN & key->key) && (!(key->key_d10ms == d10ms)) && key->key_lockU) {
key->key_d10ms = d10ms;
key->key_lockU++;
}

if ((*key->PIN & key->key) && key->key_lockD > 1 && key->key_lockU > 1) { //akcja po
//puszczeniu przycisku
key->key_lockD = 0;
key->key_lockD = 0;
key->key_powt_flag = 0;
}

}

void nastepny_kanal(int8_t kanal){

kanal++;
if (kanal == 4) kanal = 0;
mux_chnl = kanal;
//complus(kanal);
disp_flag = 1;

}

void zmiana_interfejsu(int8_t kanal){

*chanel = complus(kanal);
uint8_t ifc = chanel->interfejs & 63;
uint8_t pom = 0;
ifc = ifc<<1;//przejscie na kolejna pozycje interfejsu
if (ifc > 0 && ifc < 32) pom = ifc;
if(pom == 32) pom = 1;//pozycji jest piec potem pozycja 1
else if (pom == 128) pom |= 64;//jezeli wlaczona symulacja kanalu mux ustaw pozycje 6
else if (!pom) pom &= ~63;//jezeli wylaczona symulacja to zeruj pozycje 6

chanel->interfejs = pom;
disp_flag = 1;// flaga zezwolenia na wyswietlenie

}[/syntax]

Niestety kompilator sypie bledami:
[syntax=c]17:28:06 **** Incremental Build of configuration Release for project 000_krzysiek_tester ****
make all
'Building file: ../main.c'
'Invoking: AVR Compiler'
avr-gcc -Wall -Os -fpack-struct -fshort-enums -ffunction-sections -fdata-sections -std=gnu99 -funsigned-char -funsigned-bitfields -mmcu=atmega162 -DF_CPU=7372800UL -MMD -MP -MF"main.d" -MT"main.o" -c -o "main.o" "../main.c"
../main.c: In function 'main':
../main.c:131:22: error: void value not ignored as it ought to be
KEY_SELMUX.keyshort = nastepny_kanal(mux_chnl);
^
../main.c:140:21: warning: assignment from incompatible pointer type [enabled by default]
KEY_INFCE.keyshort = zmiana_interfejsu;
^
../main.c: In function 'key_spr':
../main.c:328:5: warning: passing argument 1 of 'key->keyshort' makes pointer from integer without a cast [enabled by default]
if (key->keyshort) key->keyshort(mux_chnl);
^
../main.c:328:5: note: expected 'int8_t *' but argument is of type 'uint8_t'
make: *** [main.o] Błąd 1

17:28:07 Build Finished (took 1s.339ms)[/syntax]
Pytanie moje jest takie: Czy da się tak jak ja chce i jak to wykonać? Proszę o pomoc. Mirek tak fajnie to tłumaczył, ze podstawowe działanie rozumiem, niestety chciałbym moc podać rożne funkcje i parametry do wykonania przy rożnych klawiszach. Z góry dziękuję za wytłumaczenie.

Statystyki: Napisane przez jacabe — 17 cze 2018, o 16:50