hallo allemaal,

ik zat wat te proberen met pointers, maar liep vast, is het mogelijk om rechtstreeks naar een geheugenplaats te schrijven zonder het address in een variable op te slaan net als hier:

char *p = 0x28;
*p &= 0xfd;

alvast bedankt!

Je kan een register als variabele gebruiken zoals hier beschreven staat. Is dat wat je wil?

nee ik wil gewoon in het vorige voorbeeld de variable p weghalen en rechtstreeks het adres opschrijven, ik kan het niet echt anders uitleggen:P

[Bericht gewijzigd door Jeffreynlnl op (17%)]

Kijk eens in de AVR libc-FAQ. Misschien vindt je daar wat je zoekt.

Ik begrijp niet wat je precies bedoelt.
Ik neem aan dat met de AVR ook gewoon indirecte adressering mogelijk is?

Bedoel je dit:


*(char*)0x28 = 0xfd;

(Noot: Bovenstaand fragment is welliswaar valide, maar eigenlijk alleen geschikt als voorbeeld hoe het niet moet!)

Bovenstaand fragment kan, en zonder optimalisatie levert het snellere code op met avr-gcc. Maar zodra je optimalisatie aanzet geeft jou (veel leesbaardere!) code dezelfde assembly als mijn regeltje:


        ldi r24,lo8(-3)
        out 40-32,r24

[Bericht gewijzigd door blurp op (15%)]

Ik dacht meer aan zo op de nette manier: (-Os)


char * const pointer = (char *)0x28;

int main(int argc, char *arcgv[]) {


    *pointer = 0xfd;

    return(0);

}

De pointer is nu readonly, de inhoud waar die naartoe wijst niet.
Dan komt er dit uit:


4:        int main(int argc, char *arcgv[]) {
+0000003B:   EF8D        LDI       R24,0xFD       Load immediate
+0000003C:   BB80        OUT       0x08,R24       Out to I/O location
11:       }
+0000003D:   E080        LDI       R24,0x00       Load immediate
+0000003E:   E090        LDI       R25,0x00       Load immediate
+0000003F:   9508        RET                      Subroutine return
11:       }

Waar die 0x08 nu vandaan komt weet ik niet, hij loopt wel netjes op als je de pointer (compiletime) hoger maakt. Ik denk dat de linker de zaak relocate.

Zonder optimalisatie:


4:        int main(int argc, char *arcgv[]) {
+0000003B:   93DF        PUSH      R29            Push register on stack
+0000003C:   93CF        PUSH      R28            Push register on stack
+0000003D:   D000        RCALL     PC+0x0001      Relative call subroutine
+0000003E:   D000        RCALL     PC+0x0001      Relative call subroutine
+0000003F:   B7CD        IN        R28,0x3D       In from I/O location
+00000040:   B7DE        IN        R29,0x3E       In from I/O location
+00000041:   839A        STD       Y+2,R25        Store indirect with displacement
+00000042:   8389        STD       Y+1,R24        Store indirect with displacement
+00000043:   837C        STD       Y+4,R23        Store indirect with displacement
+00000044:   836B        STD       Y+3,R22        Store indirect with displacement
7:            *pointer = 0xfd;
+00000045:   91E00060    LDS       R30,0x0060     Load direct from data space
+00000047:   91F00061    LDS       R31,0x0061     Load direct from data space
+00000049:   EF8D        LDI       R24,0xFD       Load immediate
+0000004A:   8380        STD       Z+0,R24        Store indirect with displacement
9:            return(0);
+0000004B:   E080        LDI       R24,0x00       Load immediate
+0000004C:   E090        LDI       R25,0x00       Load immediate
11:       }

Maar wil je echt de regiters aanspreken moet je ze zo addresseren:
#define REGISTER (*((volatile uint8_t*)0x28))
En dan deze define gebruiken.

Als ik de TS goed begrijp, wil hij rechtstreeks een geheugenplaats (RAM, dus) benaderen in C, zonder daar een variabele bij te betrekken.
Het nut ontgaat me volledig - snelheidswinst valt er IMHO niet te halen...

Op 27 oktober 2011 19:47:06 schreef henri62:


4:        int main(int argc, char *arcgv[]) {
+0000003B:   EF8D        LDI       R24,0xFD       Load immediate
+0000003C:   BB80        OUT       0x08,R24       Out to I/O location
11:       }

Waar die 0x08 nu vandaan komt weet ik niet, hij loopt wel netjes op als je de pointer (compiletime) hoger maakt. Ik denk dat de linker de zaak relocate.

De architectuur van AVR's is zo dat adressen 0-31 altijd de registers zijn. De meest(gebruikt)e IO registers zitten tussen de 32 en 96, en zijn direct te benaderen met de OUT en IN instructies. Echter, in AVR assembly moet je dan 32 van het adres aftrekken. 0x28 = 40; 40-32 is 8.

Het heeft dus niets met de linker te maken.

Overigens is 0x28 het adres in de meeste AVRs PORTC of ACSR. Maar wellicht koos TS dit adres willekeurig.