-         

Seite 1 von 3 123 LetzteLetzte
Ergebnis 1 bis 10 von 28

Thema: Winavr - Direktzuweisung ?

  1. #1
    Neuer Benutzer Öfters hier
    Registriert seit
    23.08.2005
    Ort
    95688
    Beiträge
    15

    Winavr - Direktzuweisung ?

    Anzeige

    Hallo,
    bin ziemlich neu bei den avrs und winavr gelandet, hab bis jetzt nur 8051er über wrkit bzw. keil verwendet.
    warum kann ich in dem winavr eigentlich die bits nicht dirket einen wert zuweisen wie es in anderen compilern geht ?
    z.B.: PORTC.2=1;

    genauso meckert der compiler bei anweisung wie: PORTB &= 0x0F;

    mach ich irgendwas falsch oder habe ich nur eine alte version des compilers?

  2. #2
    Erfahrener Benutzer Roboter Genie
    Registriert seit
    22.11.2003
    Beiträge
    991

    Re: Winavr - Direktzuweisung ?

    Zitat Zitat von lundi
    warum kann ich in dem winavr eigentlich die bits nicht dirket einen wert zuweisen wie es in anderen compilern geht ?
    z.B.: PORTC.2=1;
    Weil es das in C nicht gibt. PORTC |= (1<<2); wäre die richtige Schreibweise ...

    Zitat Zitat von lundi
    genauso meckert der compiler bei anweisung wie: PORTB &= 0x0F;
    Da darf der Compiler eigentlich nicht meckern. Hast du am Anfang die avr/io.h eingebunden ??
    Code:
    #include <avr/io.h>
    Ansonsten weiß der Compiler nichts mit den Registerbezeichnungen anzufangen.

    Zitat Zitat von lundi
    (...) oder habe ich nur eine alte version des compilers?
    Das ist schwierig zu sagen ohne zu wissen welche Version du verwendest

    Version 20050214 ist die aktelle ( siehe http://sourceforge.net/projects/winavr/ )

    MfG Kjion

  3. #3
    Neuer Benutzer Öfters hier
    Registriert seit
    23.08.2005
    Ort
    95688
    Beiträge
    15
    Vielen Dank hatte wirklich eine alte Version.
    die avr/io.h habe ich eingebunden aber ihm gefällts trotzdem nicht.

    kijon hat folgendes geschrieben:
    lundi hat folgendes geschrieben::
    warum kann ich in dem winavr eigentlich die bits nicht dirket einen wert zuweisen wie es in anderen compilern geht ?
    z.B.: PORTC.2=1;
    Weil es das in C nicht gibt. PORTC |= (1<<2); wäre die richtige Schreibweise ...
    warum funktioniert die dirktanweisung( PORTC.2=1 ) dann im wrkit bzw. keil das sind doch auch c-compiler?

  4. #4
    Erfahrener Benutzer Roboter Genie Avatar von m.a.r.v.i.n
    Registriert seit
    24.07.2005
    Ort
    Berlin
    Beiträge
    1.247
    Hallo lundi,

    Um die Eigenheiten von winavr besser zu verstehen, empfielt es sich auf alle Fälle mal das AVR-GCC Tutorial durchzuarbeiten:
    http://www.mikrocontroller.net/artic...R-GCC-Tutorial

    Gruß Peter

  5. #5
    Erfahrener Benutzer Roboter Genie
    Registriert seit
    22.11.2003
    Beiträge
    991
    Zitat Zitat von lundi
    warum funktioniert die dirktanweisung( PORTC.2=1 ) dann im wrkit bzw. keil das sind doch auch c-compiler?
    Das sind dann Compilerspezifische Erweiterungen. Im C Standart gibt es diese Operationen nicht.

    MfG Kjion

  6. #6
    Erfahrener Benutzer Robotik Einstein Avatar von SprinterSB
    Registriert seit
    09.06.2005
    Ort
    An der Saar
    Beiträge
    2.801
    Das Problem mit den Ports ist recht nervig. Vor allem dann, wenn man mal einen Port umdefiniert und dann alle Quellen durchsehen muss.
    Ich habe mir mit Macros geholfen und das funktioniert ganz gut, wenn man optimiert (ab -O ).
    Als erstes definiere ich Makros, die eine Konstante 0, 1, ... etc auf einen Port abbilden. Diese Makros sind Target-unabhängig.
    avr-port-macros.h
    Code:
    #ifndef _AVR_PORT_MACROS_H_
    #define _AVR_PORT_MACROS_H_
    
    #ifndef PORT_ID
    #define PORT_ID(n) \
    	(n ## _ID << 3)
    #endif /* PORT_ID */
    
    #ifdef USE_SERPA
    
    extern unsigned char serpa[];
    extern unsigned char serpa_read[];
    extern const unsigned char SERPA_NUM;
    //#define SERPA_NUM 4
    
    //unsigned char serpa[SERPA_NUM];
    
    #define IS_SERPA_PORT(pinid) \
    	((SERPA_ID <= (pinid) >> 3) /* && (SERPA_ID+SERPA_NUM > (pinid) >> 3)*/)
    
    #define N_TO_SERPA(pinid) \
    	serpa[((pinid) >> 3)-SERPA_ID]
    
    #define N_TO_SERPAIN(pinid) \
    	serpa_read[0]
    
    #define IF_SERPA_OP_ELSE(pinid,op) \
    	if (IS_SERPA_PORT (pinid))\
    		N_TO_SERPA(pinid) op ID_TO_BIT(pinid); \
    	else
    
    #else  /* USE_SERPA */
    
    //#define SERPA_NUM 0
    #define IF_SERPA_OP_ELSE(pinid,op)
    #define N_TO_SERPA(pinid) 0
    #define N_TO_SERPAIN(pinid) 0
    
    #endif /* USE_SERPA */
    
    #define IS_HARD_PORT(pinid) \
    	((pinid >> 3) < SERPAIN_ID)
    
    /** Set a PORT bit to 1 */
    #define SET(pinid) \
    	do { \
    		if ((pinid) >> 3 == SERPAIN_ID); else \
    		IF_SERPA_OP_ELSE(pinid, |=) \
    		N_TO_PORT (pinid) |= ID_TO_BIT(pinid); \
    	} while (0)
    
    /** Set a PORT bit to 0 */
    #define CLR(pinid) \
    	do { \
    		if ((pinid) >> 3 == SERPAIN_ID); else \
    		IF_SERPA_OP_ELSE(pinid, &= ~) \
    		N_TO_PORT (pinid) &= ~ID_TO_BIT(pinid); \
    	} while (0)
    
    /** Toggle a PORT bit.
     * Note: The generated code will NOT be atomic!
     */
    #define TOGGLE(pinid) \
    	do { \
    		if ((pinid) >> 3 == SERPAIN_ID); else \
    		IF_SERPA_OP_ELSE(pinid, ^= ) \
    		N_TO_PORT (pinid) ^= ID_TO_BIT(pinid); \
    	} while (0)
    
    /** Set DDR to 1 */
    #define MAKE_OUT(pinid)								\
    	do {											\
    		if (IS_HARD_PORT(pinid)) 					\
    			N_TO_DDR  (pinid) |= ID_TO_BIT(pinid);	\
    	} while (0)
    
    /** Set DDR to 0 */
    #define MAKE_IN(pinid)								\
    	do {											\
    		if (IS_HARD_PORT(pinid)) 					\
    			N_TO_DDR  (pinid) &= ~ID_TO_BIT(pinid);	\
    	} while (0)
    
    /** Is PIN == 1 ? */
    #define IS_SET(pinid) \
    	(IS_HARD_PORT(pinid) \
    		? (N_TO_PIN (pinid) & ID_TO_BIT(pinid)) \
    		: (unsigned char) ((unsigned char) N_TO_SERPAIN(pinid) & (unsigned char) 	ID_TO_BIT(pinid)))
    
    /** Is PIN == 0 ? */
    #define IS_CLEAR(pinid) \
    	(!IS_SET(pinid))
    
    /** Is PORT == 1 ? */
    #define IS_PORT(pinid) 	(N_TO_PORT (pinid) & ID_TO_BIT(pinid))
    
    /*
     * IDs for the various PORTs of our AVRs.
     * If you want to make this work for targets with
     * even more ports (like ATMega128 etc) just add these
     * ports in the following macro definitions.
     * Using #error would require making the macros target dependent.
     */
    enum {
    	PORTA_ID,
    	PORTB_ID,
    	PORTC_ID,
    	PORTD_ID,
    
    	SERPAIN_ID,
    	SERPA_ID
    };
    
    #define pDDRX(pinid)  ({asm volatile (".bad_ddr_id_" # pinid);(unsigned char*) 0;})
    #define pPORTX(pinid) ({asm volatile (".bad_port_id_" # pinid);(unsigned char*) 0;})
    #define pPINX(pinid)  ({asm volatile (".bad_pin_id_" # pinid);(unsigned char*) 0;})
    
    /*
     * #define addresses of PORTs or an assembler error if
     * a non-existing PORT is refered.
     * I found no way to tell this error by the (pre)compiler.
     * Note that #error does not work as expected here.
     */
    #if defined(PORTA)
    #define pPORTA &PORTA
    #else
    #define pPORTA ({asm volatile (".target_has_no_porta");(unsigned char*) 0;})
    #endif
    
    #if defined(PORTB)
    #define pPORTB &PORTB
    #else
    #define pPORTB ({asm volatile (".target_has_no_portb");(unsigned char*) 0;})
    #endif
    
    #if defined(PORTC)
    #define pPORTC &PORTC
    #else
    #define pPORTC ({asm volatile (".target_has_no_portc");(unsigned char*) 0;})
    #endif
    
    #if defined(PORTD)
    #define pPORTD &PORTD
    #else
    #define pPORTD ({asm volatile (".target_has_no_portd");(unsigned char*) 0;})
    #endif
    
    /*
     * #define addresses of DDRs or an assembler error if
     * a non-existing DDR is refered.
     */
    #if defined(DDRA)
    #define pDDRA &DDRA
    #else
    #define pDDRA ({asm volatile (".target_has_no_ddra");(unsigned char*) 0;})
    #endif
    
    #if defined(DDRB)
    #define pDDRB &DDRB
    #else
    #define pDDRB ({asm volatile (".target_has_no_ddrb");(unsigned char*) 0;})
    #endif
    
    #if defined(DDRC)
    #define pDDRC &DDRC
    #else
    #define pDDRC ({asm volatile (".target_has_no_ddrc");(unsigned char*) 0;})
    #endif
    
    #if defined(DDRD)
    #define pDDRD &DDRD
    #else
    #define pDDRD ({asm volatile (".target_has_no_ddrd");(unsigned char*) 0;})
    #endif
    
    /*
     * #define addresses of PINs or an assembler error if
     * a non-existing PIN is refered.
     */
    #if defined(PINA)
    #define pPINA &PINA
    #else
    #define pPINA ({asm volatile (".target_has_no_pina");(unsigned char*) 0;})
    #endif
    
    #if defined(PINB)
    #define pPINB &PINB
    #else
    #define pPINB ({asm volatile (".target_has_no_pinb");(unsigned char*) 0;})
    #endif
    
    #if defined(PINC)
    #define pPINC &PINC
    #else
    #define pPINC ({asm volatile (".target_has_no_pinc");(unsigned char*) 0;})
    #endif
    
    #if defined(PIND)
    #define pPIND &PIND
    #else
    #define pPIND ({asm volatile (".target_has_no_pind");(unsigned char*) 0;})
    #endif
    
    
    #define N_TO_pPORT(pinid)						\
    	(											\
    		(PORTA_ID == (pinid) >> 3) ? pPORTA :	\
    		(PORTB_ID == (pinid) >> 3) ? pPORTB :	\
    		(PORTC_ID == (pinid) >> 3) ? pPORTC :	\
    		(PORTD_ID == (pinid) >> 3) ? pPORTD :	\
    		pPORTX(pinid)							\
    	)
    
    #define N_TO_pDDR(pinid)						\
    	(											\
    		(PORTA_ID == (pinid) >> 3) ? pDDRA :	\
    		(PORTB_ID == (pinid) >> 3) ? pDDRB :	\
    		(PORTC_ID == (pinid) >> 3) ? pDDRC :	\
    		(PORTD_ID == (pinid) >> 3) ? pDDRD :	\
    		pDDRX(pinid)							\
    	)
    
    #define N_TO_pPIN(pinid)						\
    	(											\
    		(PORTA_ID == (pinid) >> 3) ? pPINA :	\
    		(PORTB_ID == (pinid) >> 3) ? pPINB :	\
    		(PORTC_ID == (pinid) >> 3) ? pPINC :	\
    		(PORTD_ID == (pinid) >> 3) ? pPIND :	\
    		pPINX(pinid)							\
    	)
    
    #define N_TO_PORT(pinid) (*(N_TO_pPORT(pinid)))
    #define N_TO_DDR(pinid)  (*(N_TO_pDDR(pinid)))
    #define N_TO_PIN(pinid)  (*(N_TO_pPIN(pinid)))
    
    #define CHECK_PORT_MACRO(port) \
    do { \
    	if (&PORT ## port != N_TO_pPORT (PIN_ID (port,0))) asm volatile (".error_in_N_TO_pPORT_" #port); \
    	if (&DDR  ## port != N_TO_pDDR  (PIN_ID (port,0))) asm volatile (".error_in_N_TO_pDDR_" #port); \
    	if (&PIN  ## port != N_TO_pPIN  (PIN_ID (port,0))) asm volatile (".error_in_N_TO_pPIN_" #port); \
    } while (0)
    
    #endif /* _AVR_PORT_MACROS_H_ */
    Im zweiten File werden je nach verwendetem Target die vorhandenen Ports auf Konstanten abgebildet:
    avr-port-enum.h
    Code:
    #ifndef _AVR_PORT_ENUM_H_
    #define _AVR_PORT_ENUM_H_
    
    /***********************************************************/
     
    #ifndef ID_TO_BIT
    #define ID_TO_BIT(pinid) \
    	(1<<((pinid)&7))
    #endif /* ID_TO_BIT */	
    
    #define PIN_ID(c,n) \
    	((PORT ## c ## _ID << 3) | (n))
    	
    #define ENUM_PIN(letter,pin) \
    	PORT ## letter ## _ ## pin = PIN_ID(letter,pin)
    
    #define ENUM_PORT(p) \
    	ENUM_PIN (p,0), \
    	ENUM_PIN (p,1), \
    	ENUM_PIN (p,2), \
    	ENUM_PIN (p,3), \
    	ENUM_PIN (p,4), \
    	ENUM_PIN (p,5), \
    	ENUM_PIN (p,6), \
    	ENUM_PIN (p,7)
    	
    /*
     * Enumerate all ports of respective MCU,
     * giving us the desired values like PORTD_1 or PORTB_4, e.g.
     */
    
    #if defined(__AVR_AT90S2313__)
    enum {
    	ENUM_PORT (B),
    	
    	ENUM_PIN (D,0),
    	ENUM_PIN (D,1),
    	ENUM_PIN (D,2),
    	ENUM_PIN (D,3),
    	ENUM_PIN (D,4),
    	ENUM_PIN (D,5),
    	ENUM_PIN (D,6),
    	
    	ENUM_PIN_LAST
    };
    #elif defined(__AVR_ATmega8__)
    enum {
    	ENUM_PORT (B),
    	
    	ENUM_PIN (C,0),
    	ENUM_PIN (C,1),
    	ENUM_PIN (C,2),
    	ENUM_PIN (C,3),
    	ENUM_PIN (C,4),
    	ENUM_PIN (C,5),
    	ENUM_PIN (C,6),
    
    	ENUM_PORT (D),
    	
    	ENUM_PIN_LAST
    };
    #elif defined(__AVR_AT90S2333__) || defined(__AVR_AT90S4433__)
    enum {
    	ENUM_PIN (B,0),
    	ENUM_PIN (B,1),
    	ENUM_PIN (B,2),
    	ENUM_PIN (B,3),
    	ENUM_PIN (B,4),
    	ENUM_PIN (B,5),
    	
    	ENUM_PIN (C,0),
    	ENUM_PIN (C,1),
    	ENUM_PIN (C,2),
    	ENUM_PIN (C,3),
    	ENUM_PIN (C,4),
    	ENUM_PIN (C,5),
    
    	ENUM_PORT (D),
    	
    	ENUM_PIN_LAST
    };
    #elif defined(__AVR_AT90S4414__) || defined(__AVR_AT90S8515__) || \
          defined(__AVR_AT90S4434__) || defined(__AVR_AT90S8535__) || \
          defined(__AVR_ATmega163__)
    enum {
    	ENUM_PORT (A),
    	ENUM_PORT (B),
    	ENUM_PORT (C),
    	ENUM_PORT (D),
    	
    	ENUM_PIN_LAST
    };
    #else
    #error Please define available ports for MCU
    #endif
    
    #if 0
    /* Code snippet from avr-gcc source */
    static const struct mcu_type_s avr_mcu_types[] = {
     /* Classic, <= 8K. */
    { "avr2", 2, NULL },
    { "at90s2313", 2, "__AVR_AT90S2313__" },
    { "at90s2323", 2, "__AVR_AT90S2323__" },
    { "at90s2333", 2, "__AVR_AT90S2333__" },
    { "at90s2343", 2, "__AVR_AT90S2343__" },
    { "attiny22", 2, "__AVR_ATtiny22__" },
    { "attiny26", 2, "__AVR_ATtiny26__" },
    { "at90s4414", 2, "__AVR_AT90S4414__" },
    { "at90s4433", 2, "__AVR_AT90S4433__" },
    { "at90s4434", 2, "__AVR_AT90S4434__" },
    { "at90s8515", 2, "__AVR_AT90S8515__" },
    { "at90c8534", 2, "__AVR_AT90C8534__" },
    { "at90s8535", 2, "__AVR_AT90S8535__" },
    { "at86rf401", 2, "__AVR_AT86RF401__" },
    /* Classic, > 8K. */
    { "avr3", 3, NULL },
    { "atmega103", 3, "__AVR_ATmega103__" },
    { "atmega603", 3, "__AVR_ATmega603__" },
    { "at43usb320", 3, "__AVR_AT43USB320__" },
    { "at43usb355", 3, "__AVR_AT43USB355__" },
    { "at76c711", 3, "__AVR_AT76C711__" },
    /* Enhanced, <= 8K. */
    { "avr4", 4, NULL },
    { "atmega8", 4, "__AVR_ATmega8__" },
    { "atmega8515", 4, "__AVR_ATmega8515__" },
    { "atmega8535", 4, "__AVR_ATmega8535__" },
    /* Enhanced, > 8K. */
    { "avr5", 5, NULL },
    { "atmega16", 5, "__AVR_ATmega16__" },
    { "atmega161", 5, "__AVR_ATmega161__" },
    { "atmega162", 5, "__AVR_ATmega162__" },
    { "atmega163", 5, "__AVR_ATmega163__" },
    { "atmega169", 5, "__AVR_ATmega169__" },
    { "atmega32", 5, "__AVR_ATmega32__" },
    { "atmega323", 5, "__AVR_ATmega323__" },
    { "atmega64", 5, "__AVR_ATmega64__" },
    { "atmega128", 5, "__AVR_ATmega128__" },
    { "at94k", 5, "__AVR_AT94K__" },
    /* Assembler only. */
    { "avr1", 1, NULL },
    { "at90s1200", 1, "__AVR_AT90S1200__" },
    { "attiny11", 1, "__AVR_ATtiny11__" },
    { "attiny12", 1, "__AVR_ATtiny12__" },
    { "attiny15", 1, "__AVR_ATtiny15__" },
    { "attiny28", 1, "__AVR_ATtiny28__" },
    { NULL, 0, NULL }
    };
    #endif /* 0 */
    
    #endif /* _AVR_PORT_ENUM_H_ */
    Das sieht alles recht kompliziert aus, aber das kann man wie eine Black Box benutzen und muss es nicht verstehen. Diese beiden Dateien verwende ich in allen Projekten. Sie liegen in einem Verzeichnis ausserhalb der Projekte und den Pfad gebe ich GCC mit dem -I Schalter mit. Etwa:
    avr-gcc ... -Ic:/avr-projekte/include ...
    Die Dateien in jedes Projekt zu kopieren empiehlt sich nicht, weil man dadurch 1000 Kopien der selben Dateien hat.

    Verwendung:
    In jedem Projekt hab ich eine Datei ports.h, die etwa so aussehen könnte
    Code:
    #ifndef _PORTS_H_
    #define _PORTS_H_
    
    #include <avr/io.h>
    // Make sure that GCC can find avr-port-xxx.h
    // Use the -I option to tell GCC where to find these files.
    // avr-gcc ... -Ic:/foo ... (windows)
    // avr-gcc ... -I/usr/local/foo ...(linux)
    #include <avr-port-macros.h>
    #include <avr-port-enum.h>
    
    enum
    {
    	PORT_LED = PORTD_2,
    
    	PORT_SER	= PORTD_4,
    	PORT_SCK	= PORTD_5,
    	PORT_RCK	= PORTD_6,
    
    	PORT_TAST = PORTB_3,
    
    #ifdef USE_DCF	
    	PORT_DCF = PORTD_0,
    #endif /* USE_DCF	*/
    	
    	// sentinel
    	PORT_NIL
    };
    
    #endif /* _PORTS_H_ */
    Hier ein Beispiel zur Verwendung:
    Code:
    #include <avr/io.h>
    #include "ports.h"
    
    void main() // compiled with -ffreestanding
    {
    	// PORT_LED ist Output
    	MAKE_OUT (PORT_LED);
    	// PORT_LED aus
    	CLR (PORT_LED);
    	
    	// PORT_TAST Input mit Pullup
    	MAKE_IN (PORT_TAST);
    	SET (PORT_TAST);
    	
    	if (!IS_SET (PORT_TAST))
    		CLR (PORT_LED);
    		
    	if (IS_CLEAR (PORT_TAST))
    		TOGGLE (PORT_LED);
    		
    	if (!IS_PORT (PORT_LED))
    		SET (PORT_LED);
    }
    Definierte Makros
    • SET(id)
      Setzt PORTx auf 1.
      Beispiel: SET (PORTD_0);
    • CLR(id)
      Setzt PORTx auf 0.
      Beispiel: CLR (PORTD_0);
    • TOGGLE(id)
      Wechselt den Zustand von PORTx.
      Beispiel: TOGGLE (PORTD_0);
      Anmerkung: Hier werden mehrere asm-Instruktionen generiert, der erzeugte Code ist also nicht atomar.
    • MAKE_OUT(id)
      Setzt DDRx auf 1.
      Beispiel: MAKE_OUT (PORTD_0);
    • MAKE_IN(id)
      Setzt DDRx auf 0.
      Beispiel: MAKE_IN (PORTD_0);
    • IS_SET(id)
      Testet PINx auf 1.
      Beispiel: if (IS_SET (PORTD_0)) {...}
      Beispiel: if (!IS_SET (PORTD_0)) {...}
    • IS_CLEAR(id)
      Testet PINx auf 0.
      Beispiel: if (IS_CLEAR (PORTD_0)) {...}
      Beispiel: if (!IS_CLEAR (PORTD_0)) {...}
    • IS_PORT(id)
      Testet PORTx auf 1.
      Beispiel: if (IS_PORT (PORTD_0)) {...}
      Anmerkung: wird man normalerweise nicht brauchen

    Wie man sieht wird mittels PORTD_0 sowohl das passende DDR, PORT und PIN angesprochen! Schreibt man nicht PORTD_0 hin sondern
    #define PORT_LED PORTD_0
    oder
    enum
    {
    ...
    PORT_LED = PORTD_0,
    ...
    };
    dann muss man nur an 1 Stelle im Code anpacken, um alle Zugriffe auf einen anderen Port zu lenken!

    Durch die komplexen Makros wird erst mal recht viel C-Code erzeugt. Da alles Konstanten sind und die Ausdrücke zur Compile-Zeit ausgewertet werden können, kollabieren fast alle zu einer einzigen asm-Instruktion, so daß in *.s alles recht gut aussieht:

    Assembler-Ausgabe des Beispiels
    Code:
     ;  GNU C version 3.4.1 (avr)
     ; 	compiled by GNU C version 3.3.1 (cygming special).
     ;  GGC heuristics: --param ggc-min-expand=38 --param ggc-min-heapsize=16318
     ;  options passed:  -fpreprocessed -mmcu=atmega8 -auxbase -O1 -Wall
     ;  -Winline -ffreestanding -fno-keep-inline-functions -fverbose-asm
     ;  options enabled:  -feliminate-unused-debug-types -fdefer-pop
     ;  -fomit-frame-pointer -fthread-jumps -fpeephole -ffunction-cse
     ;  -fkeep-static-consts -freg-struct-return -fgcse-lm -fgcse-sm -fgcse-las
     ;  -floop-optimize -fif-conversion -fif-conversion2 -fsched-interblock
     ;  -fsched-spec -fsched-stalled-insns -fsched-stalled-insns-dep
     ;  -fbranch-count-reg -fcprop-registers -fcommon -fverbose-asm
     ;  -fargument-alias -fmerge-constants -fzero-initialized-in-bss -fident
     ;  -fguess-branch-probability -fmath-errno -ftrapping-math
     ;  -minit-stack=__stack -mmcu=atmega8
    
    	.text
    .global	main
    	.type	main, @function
    main:
    /* prologue: frame size=0 */
    	ldi r28,lo8(__stack - 0)
    	ldi r29,hi8(__stack - 0)
    	out __SP_H__,r29
    	out __SP_L__,r28
    /* prologue end (size=4) */
    	sbi 49-0x20,2	 ; ,	 ;  15	*sbi	[length = 1]
    	cbi 50-0x20,2	 ; ,	 ;  31	*cbi	[length = 1]
    	cbi 55-0x20,3	 ; ,	 ;  42	*cbi	[length = 1]
    	sbi 56-0x20,3	 ; ,	 ;  58	*sbi	[length = 1]
    	sbis 54-0x20,3	 ; ,	 ;  68	*sbix_branch	[length = 2]
    	cbi 50-0x20,2	 ; ,	 ;  82	*cbi	[length = 1]
    .L12:
    	sbic 54-0x20,3	 ; ,	 ;  93	*sbix_branch	[length = 2]
    	rjmp .L16	 ; 
    	in r24,50-0x20	 ;  tmp74,	 ;  105	*movqi/4	[length = 1]
    	ldi r25,lo8(4)	 ;  tmp75,	 ;  106	*movqi/2	[length = 1]
    	eor r24,r25	 ;  tmp73, tmp75	 ;  107	xorqi3	[length = 1]
    	out 50-0x20,r24	 ; , tmp73	 ;  108	*movqi/3	[length = 1]
    .L16:
    	sbis 50-0x20,2	 ; ,	 ;  119	*sbix_branch	[length = 2]
    	sbi 50-0x20,2	 ; ,	 ;  133	*sbi	[length = 1]
    .L1:
    /* epilogue: frame size=0 */
    	rjmp exit
    /* epilogue end (size=1) */
    Vielleicht findet jemand so ein Paket auch praktisch?
    Würd mich über Rückmeldungen freuen.
    Disclaimer: none. Sue me.

  7. #7
    Erfahrener Benutzer Robotik Einstein Avatar von Felix G
    Registriert seit
    29.06.2004
    Ort
    49°32'N 8°40'E
    Alter
    34
    Beiträge
    1.780
    Zitat Zitat von SprinterSB
    Das Problem mit den Ports ist recht nervig. Vor allem dann, wenn man mal einen Port umdefiniert und dann alle Quellen durchsehen muss.
    Also das musst du aber mal genauer erklären, denn irgendwie sehe ich da kein Problem !?

    Wenn mir bei Port A die Bezeichnung PORTA nicht gefällt,
    und ich der Meinung bin daß EIERSALAT viel besser passen würde,
    dann reicht doch ein einfaches #define EIERSALAT PORTA

    klar, wenn ich schon im ganzen Projekt überall mit PORTA gearbeitet habe ists ein bischen nervig,
    dann muss man halt ein paar Sekunden Zeit investieren und replace drüberjagen.


    Dein Makro-Konstrukt finde ich ehrlichgesagt ein bischen übertrieben...
    das ganze geht nämlich genauso gut auch ohne:
    Code:
    // Bit setzen:
    Variable |= (1 << BitNr);
    
    // Bit löschen:
    Variable &= ~(1 << BitNr);
    
    // Bit togglen:
    Variable ^= (1 << BitNr);
    
    // Bit gesetzt?
    if( Variable & (1 << BitNr) )
    
    // Bit nicht gesetzt?
    if( !(Variable & (1 << BitNr)) )
    kurz, einfach, schnell erlernt

    Ich mache das so, und jeder den ich kenne macht das auch so...
    So viele Treppen und so wenig Zeit!

  8. #8
    Erfahrener Benutzer Roboter Genie
    Registriert seit
    22.11.2003
    Beiträge
    991
    Zitat Zitat von Felix G
    // Bit gesetzt?
    if( Variable & (1 << BitNr) )

    // Bit nicht gesetzt?
    if( !(Variable & (1 << BitNr)) )
    Das geht sogar noch schöner:
    // Bit gesetzt?
    if( bit_is_set(Variable, BitNr) )

    // Bit nicht gesetzt?
    if( bit_is_clear(Variable, BitNr) )
    Ich sehe da jetzt auch eigentlich kein Problem ...

    MfG Kjion

  9. #9
    Erfahrener Benutzer Robotik Einstein Avatar von Felix G
    Registriert seit
    29.06.2004
    Ort
    49°32'N 8°40'E
    Alter
    34
    Beiträge
    1.780
    naja, genau solche Sachen vermeide ich gerne...

    denn die "Variable & (1 << BitNr)"-Variante ist reines Standard-C und funktioniert garantiert mit jedem beliebigen Compiler.

    bit_is_set und bit_is_clear hingegen sind wieder irgendwelche Makros die irgendwo definiert sein müssen.
    So viele Treppen und so wenig Zeit!

  10. #10
    Erfahrener Benutzer Roboter Genie
    Registriert seit
    22.11.2003
    Beiträge
    991
    Zitat Zitat von Felix G
    bit_is_set und bit_is_clear hingegen sind wieder irgendwelche Makros die irgendwo definiert sein müssen.
    Die Makros sind in der avr/sfr_defs.h definiert, werden also auf jeden Fall mit eingebunden wenn du avr/io.h einbindest.

    Und wirklich kompiliziert sind sie auch nicht, ist eben nur ein schönere Beschreibung die man auf den ersten Blick versteht ( jedenfalls geht es mir so ):
    Zitat Zitat von sfr_defs.h
    #define bit_is_set(sfr, bit) (_SFR_BYTE(sfr) & _BV(bit))
    MfG Kjion

Seite 1 von 3 123 LetzteLetzte

Berechtigungen

  • Neue Themen erstellen: Nein
  • Themen beantworten: Nein
  • Anhänge hochladen: Nein
  • Beiträge bearbeiten: Nein
  •