ATNEL tech-forum

Re: Preprocesor

2016-08-01T09:29:33+01:00

I oto gotowy efekt, jakby ktoś chciał, można używać do woli...

[syntax=c]/*
* 01_ARRAY_PINS main.c
*
* Autor: Dąbrowski Tomasz
* Stworzono: 2016-08-01
* Edycja: 08:28:46
*/

#include
#include

// *********************** PRZYGOTOWANIE TABLICOWEGO DOSTĘPU DO PINÓW *********************

//definicje portów umożliwiające działanie w formie numerycznej np.PORT(0)=PORT(PD)=PORTD
#define PORTS 4
#define PA 0
#define PB 1
#define PC 2
#define PD 3

volatile uint8_t *myports[] = { &PORTA, &PORTB, &PORTC, &PORTD };

#define _DDR(x) _SFR_IO8(_SFR_IO_ADDR(*(myports[x]))-1) // adr. r. kier. DDRx
#define _PORT(x) _SFR_IO8(_SFR_IO_ADDR(*(myports[x]))) // adr. r. wyj. PORTx
#define _PIN(x) _SFR_IO8(_SFR_IO_ADDR(*(myports[x]))-2) // adr. r. wej. PINx
#define DDR(p) _DDR(p)
#define PORT(p) _PORT(p)
#define PIN(p) _PIN(p)

//makro zmiany opisu Px,y np PD,5 na BAJT w formacie xxxxxyyy czyli port 0-31, pin 0-7 i vice-versa
#define W2B(port,pin) (((port)<<3)|((pin)&0x07))
#define B2P(bajt) ((bajt)>>3) //bajt to port
#define B2B(bajt) ((bajt)&(0x07)) //bajt to bity

//makra obsługi pinów w formacie LOW_A(W2B(PA,3))
#define OUTPUT_A(pin) (DDR(B2P(pin)) |= (1 << (B2B(pin))))
#define INPUT_A(pin) (DDR(B2P(pin)) &= ~ (1 << (B2B(pin))))
#define HIGH_A(pin) (PORT(B2P(pin)) |= (1 << (B2B(pin))))
#define LOW_A(pin) (PORT(B2P(pin)) &= ~ (1 << (B2B(pin))))
#define TOGGLE_A(pin) (PORT(B2P(pin)) ^= (1 << (B2B(pin))))
#define READ_A(pin) ((PIN(B2P(pin)) >> (B2B(pin))) & 1)

//*************************** MOŻNA WYODRĘBNIĆ DO PLIKU NAGŁÓWKOWEGO ************

//************************** PROGRAM WŁAŚCIWY - WYKORZYSTANIE ******************

//definicja przez tablicę
uint8_t diody[] = { W2B(PA,0), W2B(PA,1), W2B(PA,2), W2B(PA,3), W2B(PA,4), W2B(PA,5), W2B(PA,6), W2B(PA,7),
W2B(PB,0), W2B(PB,1), W2B(PB,2), W2B(PB,3), W2B(PB,4), W2B(PB,5), W2B(PB,6), W2B(PB,7),
W2B(PC,0), W2B(PC,1), W2B(PC,2), W2B(PC,3), W2B(PC,4), W2B(PC,5), W2B(PC,6), W2B(PC,7),
W2B(PD,0), W2B(PD,1), W2B(PD,2), W2B(PD,3), W2B(PD,4), W2B(PD,5), W2B(PD,6), W2B(PD,7)};

uint8_t nrLed;
#define T_LEDON 200
#define T_LEDOFF 5
//zwykła definicja pinu
#define blinkLed W2B(PD,7)

int main(void) //rozpoczynamy
{

for(nrLed=0;nrLed{
OUTPUT_A(diody[nrLed]);
}

while(1) //pętla nieskończona
{

for(nrLed=0;nrLed{
HIGH_A(diody[nrLed]);
_delay_ms(T_LEDON);
LOW_A(diody[nrLed]);
_delay_ms(T_LEDOFF);
TOGGLE_A(blinkLed); //migająca podstawa litery L
}

}
}[/syntax]

------------------------ [ Dodano po: 15 minutach ]

Poniższy filmik przedstawia efekt (niestety emulator i kodowanie zrobiły swoje i płynność nie odpowiada rzeczywistemu sprzętowi):

iframe

To tak trochę z nostalgii w oczekiwaniu na YELLOW BOOK'a (kto zgadł nawiązanie zółtymi ledami?) i filmików Pana Mirka, pozdrawiamy i życzymy duuuuuuuuuuuuuuuuuuuuuuużo siły

Statystyki: Napisane przez fizyk_xyz — 1 sie 2016, o 09:29

Re: Preprocesor

2016-07-23T12:49:12+01:00

fizyk_xyz napisał(a):

A i pragnąłbym jeszcze poprosić znawców o nie stosowanie niestosowne krytyki. Bo jeżeli ktoś potrzebuje na forum pomocy to się pomaga. Niestety wielokrotnie zauważam przepychankę o jedynie słuszną rację, ale pomocy z nikąd.ZASADĄ JEST:Umiesz lepiej, pokaż, może inni też chcieliby się nauczyć. To tyczy się też moderatorów szanownego forum...

Myslę że "niestosowną krytykę" zastosował w tym temacie kolega

ale w tym momencie ja piszę w innej sprawie ...
mianowicie jak kolega zakończy wywód ... to proszę mnie poinformować na piśmie (via PW)
nieco uporządkuję by łatwiej kolegom chcącym się nauczyć czegoś nowego się czytało

I niniejszym przepraszam że się wcinam ...

Statystyki: Napisane przez SunRiver — 23 lip 2016, o 12:49

Re: Preprocesor

2016-07-23T06:52:05+01:00

Witam, tak przed śniadaniem dla zaostrzenia apetytu definicje z pkt.2 powinny wyglądać tak:

#define PORT(x) _SFR_IO8(_SFR_IO_ADDR(x))
#define DDR(x) _SFR_IO8(_SFR_IO_ADDR(x)-1)
#define PIN(x) _SFR_IO8(_SFR_IO_ADDR(x)-2)

------------------------ [ Dodano po: 13 minutach ]

Pamiętajcie oczywiście o potrzebie podwójnego definiowanie makr zgodnie z zaleceniami z BB ! Czyli zróbcie sobie np. tak:

#define _PORT(x) ................
#define PORT(x) _PORT(x)

dlaczego? Odsyłam do książki...

Statystyki: Napisane przez fizyk_xyz — 23 lip 2016, o 06:52

Re: Preprocesor

2016-07-22T21:20:21+01:00

4a) Obracamy się w 8bitowcach póki co (ale ten trik można dopasować do 16,32 i 64 bitowej architektury), czyli do zapisu pinów 0-7 wykorzystujemy 3 bity, a pozostałe 5 z oktetu możemy wykorzystać do oznaczenia portu! Nie wiem, czy jakaś AVR'ka ma 32, bo to byłby PORTZF (zapisem EXCEL'a - 26 liter + 6 w kolejnym rzędzie).Zatem przekujmy słowa w czyny i tworzymy odpowiednie...tak makra(ja w ogóle uwielbiam makra bo są lepsze w pewnych warunkach od funkcji, a zawsze oszczędzają RAM i stos kosztem FLASH, którego i tak jest najwięcej.Ale z makrami trzeba uważać BB i GB Mirka Pana. If'ów też unikam na rzecz odpowiednich działań matematycznych, ale to już rozprawka na inny czas.)Ale do rzeczy:
#define PORTPIN2OKTET(port,pin) ((port)<<3)|((pin)&7)
#define OKTET2PORT(oktet) ((oktet)>>3)
#define OKTET2PIN(oktet) ((oktet)&7)

i teraz elegancko:

uint8_t diody {PORTPIN2OKTET(PA,3),PORTPIN2OKTET(PA,3)...}

a wywołujemy:

PORT(OCTET2PORT(diody[idx]))|=(1<
------------------------ [ Dodano po: 8 minutach ]

Ot i cała filozofia. Mi to trochę zajęło: przejrzałem że 3 internety, całą dokumentację avrgcc, obejrzałem wszystkie filmy Mentora, nawet zacząłem czytać BB ze zrozumieniem, i poruszyłem parę szarych komórek , bo tylko tyle mam :{

------------------------ [ Dodano po: 15 minutach ]

5) APPENDIX. Przytoczone linijki kodu nie są dla kompilatora i mogą zawierać błędy syntetyczne! Jest to raczej forma pseudokodu avr gcc pisana z pamięci, aby naprowadzić osoby mające jakieś pojęcie o sztuce programowania uC. Gotowe kody mogę udostępnić nowicjuszem i tym co mają high end skill też oczywiście jak się wykuruję i dotrę do swego workspace w ECLIPSE.O ile będzie zainteresowanie...

------------------------ [ Dodano po: 21 minutach ]

A i pragnąłbym jeszcze poprosić znawców o nie stosowanie niestosowne krytyki. Bo jeżeli ktoś potrzebuje na forum pomocy to się pomaga. Niestety wielokrotnie zauważam przepychankę o jedynie słuszną rację, ale pomocy z nikąd.ZASADĄ JEST:Umiesz lepiej, pokaż, może inni też chcieliby się nauczyć. To tyczy się też moderatorów szanownego forum...

------------------------ [ Dodano po: 24 minutach ]

A JEŻELI JUŻ KRYTYKA, TO TAKA ABY DAĆ KONKRETNĄ I POSZUKIWANĄ ODPOWIEDŹ! Czyli na wysokim poziomie MERYTORYCZNYM. Dobranoc Państwu.

Statystyki: Napisane przez fizyk_xyz — 22 lip 2016, o 21:20

Re: Preprocesor

2016-07-22T20:13:06+01:00

No to lecimy, z tym że będę pisał na raty, bo ciężko u mnie z netem teraz no i maże że smartfona.

1) tworzymy sobie tablicę referencji na porty poprzez ich adresy, coś na kształt:
uint16_t *porty {&PORTA, &PORTB, &PORTC, &PORTD};
#define PA 0
.....
#define PD 3

w programie swoim piny będziemy definiować jako:
#define LED PC,5
(Niestety celowo unikam definicji portów jako pojedyncze nlitery like this:#define C 3, co umożliwiłoby całkowitą zgodność z metodą przedstawioną powyżej, czyli:
#define LED C,2 . Po prostu nie chciałbym "zakręcić preprocesora ani kompilatora", może podołali by albo i nie.

------------------------ [ Dodano po: 20 minutach ]

2) Mając świadomość że rejestry PORT,DDR i PIN występują po sobie z offsetem 1 (przynajmniej większość popularnych-można podejrzeć w plikach ioxxx.h) definiujemy makra dostępu do nich. Obecnie musiałbym jak wy pobuszować po sieci, bo nie pamiętam, podpowiedzią będzie makro avr gcc _SFR_BYTE. Będzie to coś na kształt:
#define PORT(x) _SFR_BYTExxx(x)
#define DDR(x) _SFR_BYTExxx(x+1)
#define PIN(x) _SFR_BYTExxx(x+2)

gdzie x adres wymaganego portu, podawany jako:
DDR(porty(PA))

------------------------ [ Dodano po: 26 minutach ]

3) Tworzymy na podstawie poprzedniego rozwiązania makra dostępu do pinów Atmegi zastępując odwołania DDR,PORT,PIN stworzonymi makrami w punkcie 2.

------------------------ [ Dodano po: 39 minutach ]

4) "OPTYMALIZATOR RAM". Jak słusznie ktoś już z Was wywnioskował to podejście idealnie nadaje się do operowania w tablicy pinami.Użyteczności wiele:wyświetlacze na magistrali równoległej, multiLCD library, o czym wcześniej wspominałem, czy choćby miganie diodami na wszystkich pinach procka w JEDNEJ pętli like Arduino. Ale tablica:
uint8_t diody{{PA,0},{PA,3}, {PD,7},{PB,2}};
(tu można tak ją definiować bo wszystkie PORTY są liczbami} niepotrzebnie traci RAM.

Statystyki: Napisane przez fizyk_xyz — 22 lip 2016, o 20:13

Re: Preprocesor

2016-07-22T19:37:28+01:00

Każda propozycja będzie ciekawa. Zawsze to krok do przodu, nawet jeżeli nie byłoby to kompletne rozwiązanie.

Statystyki: Napisane przez malavva — 22 lip 2016, o 19:37

Re: Preprocesor

2016-07-22T18:36:56+01:00

kicajek napisał(a):

fizyk_xyz napisał(a):

... A definiowanie połączeń typu w/w to porażka i męczarnia.

Nie za mocne?

Mam lepsze - definicję pinów w tablicach, to dopiero odjazd, potrzebowałem wymyśleć coś do sterowania wieloma Hd44780 na jednym uC. Niestety obecnie nie mam jak wkleić źródeł, bo jestem hospitalizowany i kompakty zostawiłem w domu. Jakby kogoś interesowało to mogę opisać algorytm.

Statystyki: Napisane przez fizyk_xyz — 22 lip 2016, o 18:36

Re: Preprocesor

2016-07-22T18:09:14+01:00

fizyk_xyz napisał(a):

... A definiowanie połączeń typu w/w to porażka i męczarnia.

Nie za mocne?

Statystyki: Napisane przez kicajek — 22 lip 2016, o 18:09

Re: Preprocesor

2016-07-22T17:36:28+01:00

Panowie zapraszam na www.starlino.com/port_macro.html i w sekcji AVR macie porządne makra obsługi pinów.Osobiście używam i sprawdzają się rewelacyjnie. A definiowanie połączeń typu w/w to porażka i męczarnia.

Statystyki: Napisane przez fizyk_xyz — 22 lip 2016, o 17:36

Re: Preprocesor

2016-07-21T18:29:50+01:00

Kolego Alef, czy udało Ci się rozwiązać ten problem? Stanąłem w tym samym miejscu i nijak nie mogę ruszyć dalej.

Statystyki: Napisane przez malavva — 21 lip 2016, o 18:29

Re: Preprocesor

2014-07-13T09:13:54+01:00

xbary napisał(a):

Ja dla procesorów STM sprawę rozciągłem w ten sposób

Analogicznie działa to dla Microchip'a, ale Microchip wspiera operacje na bitach, a AVR nie.
Poza tym to dział "Język C dla AVR".

atmel napisał(a):

Wydaje mi się, że prostszym rozwiązaniem jest po prostu posłużenie się wskaźnikami:

To nie rozwiązanie problemu tylko jego obejście. Chociaż pomysł niezły i będę musiał go popróbować.

Mi chodziło o to jak "wyłuskać" A z PA1 i dokleić potem do PORT. Jak dokleić to wiem - wykorzystując "stringifikację", czyli przekazanie napisu a nie wartości w poleceniu #define. Ale jak wyłuskać, tego nie wiem i tego pragnę się dowiedzieć.

Nadal nie wiem jak podejrzeć plik po preprocesorze, a byłoby to bardzo użyteczne przy testowaniu makr preprocesora.

Statystyki: Napisane przez alef — 13 lip 2014, o 09:13

Re: Preprocesor

2014-07-13T07:28:35+01:00

Witam

Spójrz tutaj:
http://mirekk36.blogspot.com/2011/12/jezyk-c-makra-upraszczajace-dostep-do.html

Pozdrawiam

Statystyki: Napisane przez JanuszT — 13 lip 2014, o 07:28

Re: Preprocesor

2014-07-12T19:50:45+01:00

Wydaje mi się, że prostszym rozwiązaniem jest po prostu posłużenie się wskaźnikami:

[syntax=cpp]#define LED_PORT PORTA
#define LED_PIN 1
#define LED_DDR *(&LED_PORT - 1)
...
LED_DDR |= 1<LED_PORT |= 1<LED_PORT &= ~(1<
...

#define BUTTON_PORT PORTA
#define BUTTON_PIN 2
#define BUTTON_DDR *(&BUTTON_PORT - 1)
#define BUTTON__PIN *(&BUTTON_PORT - 2)
...
BUTTON_DDR &= ~(1<bool In = BUTTON__PIN & 1<Wystarczy zmienić jedynie wartość PORT lub PIN w define. Oczywiście PA1 == 1, dlatego ten zapis można uprościć jedynie do numeru pinu.

Statystyki: Napisane przez atmel — 12 lip 2014, o 19:50

Re: Preprocesor

2014-07-12T19:32:13+01:00

Ja dla procesorów STM sprawę rozciągłem w ten sposób

Tak wyglądaja definicje pinów od LEDów np

[syntax=c]#define LED1_ANODEPC9
#define LED2_ANODEPC8

#define LED1_PORT GPIO(LED1_ANODE)
#define LED1_PIN PIN(LED1_ANODE)
#define LED1_ON() LED1_PORT->BSRR = LED1_PIN
#define LED1_OFF() LED1_PORT->BRR = LED1_PIN
#define LED1_TOGGLE() LED1_PORT->ODR ^= LED1_PIN

#define LED2_PORT GPIO(LED2_ANODE)
#define LED2_PIN PIN(LED2_ANODE)
#define LED2_ON() LED2_PORT->BSRR = LED2_PIN
#define LED2_OFF() LED2_PORT->BRR = LED2_PIN
#define LED2_TOGGLE() LED2_PORT->ODR ^= LED2_PIN[/syntax]

a wcześniej w inkludzie sobie rozpisałem tak

[syntax=c]#define PC00x20
#define PC10x21
#define PC20x22
#define PC30x23
#define PC40x24
#define PC50x25
#define PC60x26
#define PC70x27
#define PC80x28
#define PC90x29
#define PC100x2a
#define PC110x2b
#define PC120x2c
#define PC130x2d
#define PC140x2e
#define PC150x2f

...................

#define GPIO(P) ( \
P==PA0?GPIOA:P==PA1?GPIOA:P==PA2?GPIOA :P==PA3?GPIOA :P==PA4?GPIOA :P==PA5?GPIOA :P==PA6?GPIOA :P==PA7?GPIOA: \
P==PA8?GPIOA:P==PA9?GPIOA:P==PA10?GPIOA:P==PA11?GPIOA:P==PA12?GPIOA:P==PA13?GPIOA:P==PA14?GPIOA:P==PA15?GPIOA: \
P==PB0?GPIOB:P==PB1?GPIOB:P==PB2?GPIOB :P==PB3?GPIOB :P==PB4?GPIOB :P==PB5?GPIOB :P==PB6?GPIOB :P==PB7?GPIOB: \
P==PB8?GPIOB:P==PB9?GPIOB:P==PB10?GPIOB:P==PB11?GPIOB:P==PB12?GPIOB:P==PB13?GPIOB:P==PB14?GPIOB:P==PB15?GPIOB: \
P==PC0?GPIOC:P==PC1?GPIOC:P==PC2?GPIOC :P==PC3?GPIOC :P==PC4?GPIOC :P==PC5?GPIOC :P==PC6?GPIOC :P==PC7?GPIOC: \
P==PC8?GPIOC:P==PC9?GPIOC:P==PC10?GPIOC:P==PC11?GPIOC:P==PC12?GPIOC:P==PC13?GPIOC:P==PC14?GPIOC:P==PC15?GPIOC: \
P==PD0?GPIOD:P==PD1?GPIOD:P==PD2?GPIOD :P==PD3?GPIOD :P==PD4?GPIOD :P==PD5?GPIOD :P==PD6?GPIOD :P==PD7?GPIOD: \
P==PD8?GPIOD:P==PD9?GPIOD:P==PD10?GPIOD:P==PD11?GPIOD:P==PD12?GPIOD:P==PD13?GPIOD:P==PD14?GPIOD:P==PD15?GPIOD: \
P==PE0?GPIOE:P==PE1?GPIOE:P==PE2?GPIOE :P==PE3?GPIOE :P==PE4?GPIOE :P==PE5?GPIOE :P==PE6?GPIOE :P==PE7?GPIOE: \
P==PE8?GPIOE:P==PE9?GPIOE:P==PE10?GPIOE:P==PE11?GPIOE:P==PE12?GPIOE:P==PE13?GPIOE:P==PE14?GPIOE:P==PE15?GPIOE: \
P==PF0?GPIOF:P==PF1?GPIOF:P==PF2?GPIOF :P==PF3?GPIOF :P==PF4?GPIOF :P==PF5?GPIOF :P==PF6?GPIOF :P==PF7?GPIOF: \
P==PF8?GPIOF:P==PF9?GPIOF:P==PF10?GPIOF:P==PF11?GPIOF:P==PF12?GPIOF:P==PF13?GPIOF:P==PF14?GPIOF:P==PF15?GPIOF: \
P==PX0?GPIOX:P==PX1?GPIOX:P==PX2?GPIOX :P==PX3?GPIOX :P==PX4?GPIOX :P==PX5?GPIOX :P==PX6?GPIOX :P==PX7?GPIOX: \
P==PX8?GPIOX:P==PX9?GPIOX:P==PX10?GPIOX:P==PX11?GPIOX:P==PX12?GPIOX:P==PX13?GPIOX:P==PX14?GPIOX:P==PX15?GPIOX: \
P==PY0?GPIOY:P==PY1?GPIOY:P==PY2?GPIOY :P==PY3?GPIOY :P==PY4?GPIOY :P==PY5?GPIOY :P==PY6?GPIOY :P==PY7?GPIOY: \
P==PY8?GPIOY:P==PY9?GPIOY:P==PY10?GPIOY:P==PY11?GPIOY:P==PY12?GPIOY:P==PY13?GPIOY:P==PY14?GPIOY:P==PY15?GPIOY:GPIOY \
)

#define PIN(P) ( \
P==PA0?GPIO_Pin_0 :P==PA1?GPIO_Pin_1 :P==PA2?GPIO_Pin_2 :P==PA3?GPIO_Pin_3 :P==PA4?GPIO_Pin_4 :P==PA5?GPIO_Pin_5 :P==PA6?GPIO_Pin_6 :P==PA7?GPIO_Pin_7: \
P==PA8?GPIO_Pin_8 :P==PA9?GPIO_Pin_9 :P==PA10?GPIO_Pin_10:P==PA11?GPIO_Pin_11:P==PA12?GPIO_Pin_12:P==PA13?GPIO_Pin_13:P==PA14?GPIO_Pin_14:P==PA15?GPIO_Pin_15: \
P==PB0?GPIO_Pin_0 :P==PB1?GPIO_Pin_1 :P==PB2?GPIO_Pin_2 :P==PB3?GPIO_Pin_3 :P==PB4?GPIO_Pin_4 :P==PB5?GPIO_Pin_5 :P==PB6?GPIO_Pin_6 :P==PB7?GPIO_Pin_7: \
P==PB8?GPIO_Pin_8 :P==PB9?GPIO_Pin_9 :P==PB10?GPIO_Pin_10:P==PB11?GPIO_Pin_11:P==PB12?GPIO_Pin_12:P==PB13?GPIO_Pin_13:P==PB14?GPIO_Pin_14:P==PB15?GPIO_Pin_15: \
P==PC0?GPIO_Pin_0 :P==PC1?GPIO_Pin_1 :P==PC2?GPIO_Pin_2 :P==PC3?GPIO_Pin_3 :P==PC4?GPIO_Pin_4 :P==PC5?GPIO_Pin_5 :P==PC6?GPIO_Pin_6 :P==PC7?GPIO_Pin_7: \
P==PC8?GPIO_Pin_8 :P==PC9?GPIO_Pin_9 :P==PC10?GPIO_Pin_10:P==PC11?GPIO_Pin_11:P==PC12?GPIO_Pin_12:P==PC13?GPIO_Pin_13:P==PC14?GPIO_Pin_14:P==PC15?GPIO_Pin_15: \
P==PD0?GPIO_Pin_0 :P==PD1?GPIO_Pin_1 :P==PD2?GPIO_Pin_2 :P==PD3?GPIO_Pin_3 :P==PD4?GPIO_Pin_4 :P==PD5?GPIO_Pin_5 :P==PD6?GPIO_Pin_6 :P==PD7?GPIO_Pin_7: \
P==PD8?GPIO_Pin_8 :P==PD9?GPIO_Pin_9 :P==PD10?GPIO_Pin_10:P==PD11?GPIO_Pin_11:P==PD12?GPIO_Pin_12:P==PD13?GPIO_Pin_13:P==PD14?GPIO_Pin_14:P==PD15?GPIO_Pin_15: \
P==PE0?GPIO_Pin_0 :P==PE1?GPIO_Pin_1 :P==PE2?GPIO_Pin_2 :P==PE3?GPIO_Pin_3 :P==PE4?GPIO_Pin_4 :P==PE5?GPIO_Pin_5 :P==PE6?GPIO_Pin_6 :P==PE7?GPIO_Pin_7: \
P==PE8?GPIO_Pin_8 :P==PE9?GPIO_Pin_9 :P==PE10?GPIO_Pin_10:P==PE11?GPIO_Pin_11:P==PE12?GPIO_Pin_12:P==PE13?GPIO_Pin_13:P==PE14?GPIO_Pin_14:P==PE15?GPIO_Pin_15: \
P==PF0?GPIO_Pin_0 :P==PF1?GPIO_Pin_1 :P==PF2?GPIO_Pin_2 :P==PF3?GPIO_Pin_3 :P==PF4?GPIO_Pin_4 :P==PF5?GPIO_Pin_5 :P==PF6?GPIO_Pin_6 :P==PF7?GPIO_Pin_7: \
P==PF8?GPIO_Pin_8 :P==PF9?GPIO_Pin_9 :P==PF10?GPIO_Pin_10:P==PF11?GPIO_Pin_11:P==PF12?GPIO_Pin_12:P==PF13?GPIO_Pin_13:P==PF14?GPIO_Pin_14:P==PF15?GPIO_Pin_15: \
P==PX0?GPIO_Pin_0 :P==PX1?GPIO_Pin_1 :P==PX2?GPIO_Pin_2 :P==PX3?GPIO_Pin_3 :P==PX4?GPIO_Pin_4 :P==PX5?GPIO_Pin_5 :P==PX6?GPIO_Pin_6 :P==PX7?GPIO_Pin_7: \
P==PX8?GPIO_Pin_8 :P==PX9?GPIO_Pin_9 :P==PX10?GPIO_Pin_10:P==PX11?GPIO_Pin_11:P==PX12?GPIO_Pin_12:P==PX13?GPIO_Pin_13:P==PX14?GPIO_Pin_14:P==PX15?GPIO_Pin_15: \
P==PY0?GPIO_Pin_0 :P==PY1?GPIO_Pin_1 :P==PY2?GPIO_Pin_2 :P==PY3?GPIO_Pin_3 :P==PY4?GPIO_Pin_4 :P==PY5?GPIO_Pin_5 :P==PY6?GPIO_Pin_6 :P==PY7?GPIO_Pin_7: \
P==PY8?GPIO_Pin_8 :P==PY9?GPIO_Pin_9 :P==PY10?GPIO_Pin_10:P==PY11?GPIO_Pin_11:P==PY12?GPIO_Pin_12:P==PY13?GPIO_Pin_13:P==PY14?GPIO_Pin_14:P==PY15?GPIO_Pin_15:GPIO_Pin_15 \
)

#define _RCC(P) ( \
P==PA0?RCC_AHB1Periph_GPIOA:P==PA1?RCC_AHB1Periph_GPIOA:P==PA2?RCC_AHB1Periph_GPIOA :P==PA3?RCC_AHB1Periph_GPIOA :P==PA4?RCC_AHB1Periph_GPIOA :P==PA5?RCC_AHB1Periph_GPIOA :P==PA6?RCC_AHB1Periph_GPIOA :P==PA7?RCC_AHB1Periph_GPIOA: \
P==PA8?RCC_AHB1Periph_GPIOA:P==PA9?RCC_AHB1Periph_GPIOA:P==PA10?RCC_AHB1Periph_GPIOA:P==PA11?RCC_AHB1Periph_GPIOA:P==PA12?RCC_AHB1Periph_GPIOA:P==PA13?RCC_AHB1Periph_GPIOA:P==PA14?RCC_AHB1Periph_GPIOA:P==PA15?RCC_AHB1Periph_GPIOA: \
P==PB0?RCC_AHB1Periph_GPIOB:P==PB1?RCC_AHB1Periph_GPIOB:P==PB2?RCC_AHB1Periph_GPIOB :P==PB3?RCC_AHB1Periph_GPIOB :P==PB4?RCC_AHB1Periph_GPIOB :P==PB5?RCC_AHB1Periph_GPIOB :P==PB6?RCC_AHB1Periph_GPIOB :P==PB7?RCC_AHB1Periph_GPIOB: \
P==PB8?RCC_AHB1Periph_GPIOB:P==PB9?RCC_AHB1Periph_GPIOB:P==PB10?RCC_AHB1Periph_GPIOB:P==PB11?RCC_AHB1Periph_GPIOB:P==PB12?RCC_AHB1Periph_GPIOB:P==PB13?RCC_AHB1Periph_GPIOB:P==PB14?RCC_AHB1Periph_GPIOB:P==PB15?RCC_AHB1Periph_GPIOB: \
P==PC0?RCC_AHB1Periph_GPIOC:P==PC1?RCC_AHB1Periph_GPIOC:P==PC2?RCC_AHB1Periph_GPIOC :P==PC3?RCC_AHB1Periph_GPIOC :P==PC4?RCC_AHB1Periph_GPIOC :P==PC5?RCC_AHB1Periph_GPIOC :P==PC6?RCC_AHB1Periph_GPIOC :P==PC7?RCC_AHB1Periph_GPIOC: \
P==PC8?RCC_AHB1Periph_GPIOC:P==PC9?RCC_AHB1Periph_GPIOC:P==PC10?RCC_AHB1Periph_GPIOC:P==PC11?RCC_AHB1Periph_GPIOC:P==PC12?RCC_AHB1Periph_GPIOC:P==PC13?RCC_AHB1Periph_GPIOC:P==PC14?RCC_AHB1Periph_GPIOC:P==PC15?RCC_AHB1Periph_GPIOC: \
P==PD0?RCC_AHB1Periph_GPIOD:P==PD1?RCC_AHB1Periph_GPIOD:P==PD2?RCC_AHB1Periph_GPIOD :P==PD3?RCC_AHB1Periph_GPIOD :P==PD4?RCC_AHB1Periph_GPIOD :P==PD5?RCC_AHB1Periph_GPIOD :P==PD6?RCC_AHB1Periph_GPIOD :P==PD7?RCC_AHB1Periph_GPIOD: \
P==PD8?RCC_AHB1Periph_GPIOD:P==PD9?RCC_AHB1Periph_GPIOD:P==PD10?RCC_AHB1Periph_GPIOD:P==PD11?RCC_AHB1Periph_GPIOD:P==PD12?RCC_AHB1Periph_GPIOD:P==PD13?RCC_AHB1Periph_GPIOD:P==PD14?RCC_AHB1Periph_GPIOD:P==PD15?RCC_AHB1Periph_GPIOD: \
P==PE0?RCC_AHB1Periph_GPIOE:P==PE1?RCC_AHB1Periph_GPIOE:P==PE2?RCC_AHB1Periph_GPIOE :P==PE3?RCC_AHB1Periph_GPIOE :P==PE4?RCC_AHB1Periph_GPIOE :P==PE5?RCC_AHB1Periph_GPIOE :P==PE6?RCC_AHB1Periph_GPIOE :P==PE7?RCC_AHB1Periph_GPIOE: \
P==PE8?RCC_AHB1Periph_GPIOE:P==PE9?RCC_AHB1Periph_GPIOE:P==PE10?RCC_AHB1Periph_GPIOE:P==PE11?RCC_AHB1Periph_GPIOE:P==PE12?RCC_AHB1Periph_GPIOE:P==PE13?RCC_AHB1Periph_GPIOE:P==PE14?RCC_AHB1Periph_GPIOE:P==PE15?RCC_AHB1Periph_GPIOE: \
P==PF0?RCC_AHB1Periph_GPIOF:P==PF1?RCC_AHB1Periph_GPIOF:P==PF2?RCC_AHB1Periph_GPIOF :P==PF3?RCC_AHB1Periph_GPIOF :P==PF4?RCC_AHB1Periph_GPIOF :P==PF5?RCC_AHB1Periph_GPIOF :P==PF6?RCC_AHB1Periph_GPIOF :P==PF7?RCC_AHB1Periph_GPIOF: \
P==PF8?RCC_AHB1Periph_GPIOF:P==PF9?RCC_AHB1Periph_GPIOF:P==PF10?RCC_AHB1Periph_GPIOF:P==PF11?RCC_AHB1Periph_GPIOF:P==PF12?RCC_AHB1Periph_GPIOF:P==PF13?RCC_AHB1Periph_GPIOF:P==PF14?RCC_AHB1Periph_GPIOF:P==PF15?RCC_AHB1Periph_GPIOF:RCC_AHB1Periph_GPIOF \
)[/syntax]

Trochę kaszanka, ale wystarczy przy pierwszych definicjach wskazać pin gdzie LEDa ma się podłączonego iii resztę preprocesor sobie poustawia.

Statystyki: Napisane przez xbary — 12 lip 2014, o 19:32

Preprocesor

2014-07-12T19:17:27+01:00

Witam,
przy okazji zabawy z 1wire napisałem takie deklaracje
[syntax=c]#define PIN_1wire PA1
#define DDR_1wire DDRA
#define PORT_1wire PORTA
#define I N_1wire PINA[/syntax]
i teraz pytanie, jak zrobić by przy zmianie portu nie musieć zmieniać jego nazwy w 4 miejscach, tylko zmieniając nazwę pinu (tu PA1) uzyskać automatyczna zmianę w POTRA, DDA i PINA.
Może nie jest to szczególnie istotne, ale dla mnie jest to mocno irytujące.
I przy okazji w jaki sposób można podejrzeć plik po preprocesorze?

Statystyki: Napisane przez alef — 12 lip 2014, o 19:17