www.mikrocontroller.net

Forum: Compiler & IDEs IOs umbenennen


Autor: Mathiable (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Guten Tag

Ich arbeite momentan mit WinAVR und einem ATXMEGA128A1, der ja 
bekanntlich 78 IOs hat. Das Programm wird aber auch von Personen 
bearbeitet, die zwar C programmieren können aber noch nie mit Atmel MyCs 
gearbeitet haben, so dass ich mich wegen der Übersichtlichkeit frage ob 
es eine Möglichkeit gibt Outputs quasi wie eine Variable anzusteuern, so 
dass bsp. PINA1 mit "LED=1" angesteuert werden könnte. Die Input abfrage 
lässt sich ja mit Define so abändern.

#define BIT_VALUE( PORT, BIT )    (( (PORT) & (1<<(BIT))) != 0 ) //macht aus dem Byte einzelne Bit

#define Taste (BIT_VALUE( PINA, PINA0 ))

void main(void)
{
    if(Taste==1){
     
    ...

    }
}


Hoffe ihr könnt mir helfen

Freundliche Grüsse

Mathiable

Autor: Karl Heinz (kbuchegg) (Moderator)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Mathiable schrieb:
> Guten Tag
>
> Ich arbeite momentan mit WinAVR und einem ATXMEGA128A1, der ja
> bekanntlich 78 IOs hat. Das Programm wird aber auch von Personen
> bearbeitet, die zwar C programmieren können aber noch nie mit Atmel MyCs
> gearbeitet haben, so dass ich mich wegen der Übersichtlichkeit frage ob
> es eine Möglichkeit gibt Outputs quasi wie eine Variable anzusteuern, so
> dass bsp. PINA1 mit "LED=1" angesteuert werden könnte.

Die Möglichkeit gibt es schon. Man kann sich natürlich eine struct 
machen, in der mittels Bitfelder ein uint8_t auf 8 Bits aufgedröselt 
wird und dann dem Compiler die ganze Maskierung überlassen.

Aber wenn deine Programmierer sowieso nicht so fit sind, ist es 
fraglich, ob du dadurch nicht mehr Konfusion erzeugst als es gut ist.

Ich würde die PortPins, ähnlich wie du es bei der Abfrage gemacht hast, 
in ein paar Makros verpacken, jeweils mit einem Set und Clear Makro.

Autor: Peter Dannegger (peda)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Ja das geht sogar sehr gut.

Man braucht dazu ein Macro. Dann kann man die Portpins wie Bitvariablen 
ansprechen, also auf 0 oder 1 testen oder setzen.
Hier eine Beispiel:

http://www.mikrocontroller.net/attachment/30300/lcd_drv.zip


Peter

Autor: Peter (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Eine elegante Möglichkeit: Nicht super effizient, aber auch nicht so 
schlimm wie es zunächst aussieht...
//==============================================================
// Definition for I/O-Pin control
//--------------------------------------------------------------
#define PIN_0       0x01  // IO-Pin(0)
#define PIN_1       0x02  // IO-Pin(1)
#define PIN_2       0x04  // IO-Pin(2)
#define PIN_3       0x08  // IO-Pin(3)
#define PIN_4       0x10  // IO-Pin(4)
#define PIN_5       0x20  // IO-Pin(5)
#define PIN_6       0x40  // IO-Pin(6)
#define PIN_7       0x80  // IO-Pin(7)

#define PORT_A      &PORTA, &DDRA, &PINA
#define PORT_B      &PORTB, &DDRB, &PINB
#define PORT_C      &PORTC, &DDRC, &PINC
#define PORT_D      &PORTD, &DDRD, &PIND

#define L           0    // Output Low-Level
#define H           1    // Output High-Level
#define T           2    // Output Toggle-Level
#define Z           3    // Input with High-Impedance
#define P           4    // Input with Pullup

//---------------------------------------
// Beispiel Definitionen für alle IOs
//---------------------------------------
#define IOUT_1        PORT_A, PIN_0
#define UOUT_1        PORT_A, PIN_1
#define SD_1A         PORT_A, PIN_2
#define SD_2A         PORT_A, PIN_3
#define IOUT_2        PORT_A, PIN_4
#define UOUT_2        PORT_A, PIN_5
#define SD_1B         PORT_A, PIN_6
#define SD_2B         PORT_A, PIN_7

#define I_UF_1        PORT_B, PIN_0
#define SELECT_2A     PORT_B, PIN_1
#define I_UF_2        PORT_B, PIN_2
#define SELECT_2B     PORT_B, PIN_3
#define LED_1A_N      PORT_B, PIN_4
#define LED_2A_N      PORT_B, PIN_5
#define LED_1B_N      PORT_B, PIN_6
#define LED_2B_N      PORT_B, PIN_7

#define SCL           PORT_C, PIN_0
#define SDA           PORT_C, PIN_1
#define TCK           PORT_C, PIN_2
#define TMS           PORT_C, PIN_3
#define STATE_GREEN   PORT_C, PIN_4
#define TDI           PORT_C, PIN_5
#define RELAIS_LOOP   PORT_C, PIN_6
#define STATE_RED     PORT_C, PIN_7

#define RXD           PORT_D, PIN_0
#define TXD           PORT_D, PIN_1
#define I_OF_1        PORT_D, PIN_2
#define I_OF_2        PORT_D, PIN_3
#define P5V_ON_1      PORT_D, PIN_4
#define AC230_ON_1    PORT_D, PIN_5
#define P5V_ON_2      PORT_D, PIN_6
#define AC230_ON_2    PORT_D, PIN_7
//---------------------------------------------------------
// Set IO-Pin as Output(L,H,T) or as Input(Z,P)
//-----------------------------------------------------------
void set(volatile u08 *PORT, volatile u08 *DDR, volatile u08 *PIN, u08 msk, u08 status)
{
  if (status == H)
  {
    *PORT |=  msk;           // Set IO-pin High
    *DDR  |=  msk;           // Set IO-pin as output
  }
  else if (status == L)
  {
    *PORT &= ~msk;           // Set IO-pin Low
    *DDR  |=  msk;           // Set IO-pin as output
  }
  else if (status == T)
  {
    *PORT ^=  msk;           // Toggle IO-pin level
    *DDR  |=  msk;           // Set IO-pin as output
  }
  else if (status == Z)
  {
    *DDR  &= ~msk;           // Set IO-pin as input
    *PORT &= ~msk;           // Disable Pullup
  }
  else if (status == P)
  {
    *DDR  &= ~msk;           // Set IO-pin as input
    *PORT |=  msk;           // Enable Pullup
  }
}

//---------------------------------------------------------
// Get IO-Pin Level (returns 0 or 1)
//---------------------------------------------------------
u08 get(volatile u08 *PORT, volatile u08 *DDR, volatile u08 *PIN, u08 msk)
{
  if((*PIN & msk) != 0)
  {
    return H;
  }
  return L;
}
//--------------------------------------
// Anwendungs-Beispiel
//--------------------------------------
if (get(AC230_ON_2) == L)
{
  set(AC230_ON_2,L);    // drive output low
  set(AC230_ON_2,H);    // rising edge
  set(AC230_ON_2,Z);    // set as input High-Z
  _delay_us(100);
  if (get(AC230_ON_2) == H)   // check again
  {
    printf("State2: CONNECT => POWERED");
  }
}

Autor: Mathiable (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Peter Dannegger schrieb:
> Ja das geht sogar sehr gut.
>
> Man braucht dazu ein Macro. Dann kann man die Portpins wie Bitvariablen
> ansprechen, also auf 0 oder 1 testen oder setzen.
> Hier eine Beispiel:
>
> http://www.mikrocontroller.net/attachment/30300/lcd_drv.zip
>
>
> Peter

Sieht schon mal vielversprechend aus. Ich werde das mal genauer 
studieren. Vielen Dank.

Autor: Peter Dannegger (peda)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Peter schrieb:
> Nicht super effizient, aber auch nicht so
> schlimm wie es zunächst aussieht...

Ich habs mal compiliert.
Es ist wirklich doch so schlimm, wie es aussieht.

Das sind riesige Unterfunktionen und elend lange Listen von Argumenten 
pro Aufruf:
  set(AC230_ON_2,L);    // drive output low
  f2:   82 e3           ldi     r24, 0x32       ; 50
  f4:   90 e0           ldi     r25, 0x00       ; 0
  f6:   61 e3           ldi     r22, 0x31       ; 49
  f8:   70 e0           ldi     r23, 0x00       ; 0
  fa:   40 e3           ldi     r20, 0x30       ; 48
  fc:   50 e0           ldi     r21, 0x00       ; 0
  fe:   20 e8           ldi     r18, 0x80       ; 128
 100:   00 e0           ldi     r16, 0x00       ; 0
 102:   0e 94 36 00     call    0x6c    ; 0x6c <set>

Ich schätze mal, es ereicht die gleiche Langsamkeit bei 8MHz, wie die 
Verwendung von Bitmacros bei 32kHz.


Peter

Autor: Klaus Falser (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Peter Dannegger schrieb:
> Ich habs mal compiliert.
> Es ist wirklich doch so schlimm, wie es aussieht.

Möglicherweise würde es helfen, die Funktion als inline zu definieren.
Dann könnte der Optimizer das ganze überflüssige Zeug wegschmeissen.

Autor: Peter (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Naja, Du übertreibst da etwas: 8 MHz / 32 kHz = 250000  ;o)

Und Flashspeicher ist bei einem ATXMEGA128A1 auch reichlich vorhanden! 
Mir ist ein pflegeleichter und übersichtlicher Code lieber, auch wenn er 
schlussendlich 20% grösser wird...

Autor: Peter (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Man könnte das folgende auch in einem globalen Strukt defninieren, dann 
müsste man der set/get Funktion nur noch einen Pointer übergeben

#define PORT_A      &PORTA, &DDRA, &PINA
#define PORT_B      &PORTB, &DDRB, &PINB
#define PORT_C      &PORTC, &DDRC, &PINC
#define PORT_D      &PORTD, &DDRD, &PIND

Habe hier zugegebenrmassen nicht gross Kopfzerbrechen bereitet!

Autor: Peter Dannegger (peda)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Peter schrieb:
> Naja, Du übertreibst da etwas: 8 MHz / 32 kHz = 250000  ;o)

8 MHz / 32 kHz = 250

> Mir ist ein pflegeleichter und übersichtlicher Code lieber

Ist wohl Geschmackssache.
Ich finde Variablenzugriffe deutlich besser lesbar als Funktionsaufrufe:
if( KEY0 == KEY_PRESS )
  LED0 = LED_ON;

> auch wenn er
> schlussendlich 20% grösser wird...

Der Aufruf kostet 10 Words, das ist das 10-fache eines SBI-Befehls, also 
900% mehr.
Nur 20% mehr für das gesamte Programm dürfte daher kaum hinkommen.


Peter

Autor: Mathiable (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Vielen Dank für die Antworten. Ich habe nun wie bei Peter Danneggers 
Beispiel eine h File geschrieben mit diversen defines und kann nun 
"LED=1;" schreiben und es fehlerfrei kompilieren. Ich habe die Hardware 
noch nicht fertig, aber wenn noch Fehler auftreten werde ich mich wider 
melden.

Autor: Nils S. (kruemeltee) Benutzerseite
Datum:

Bewertung
0 lesenswert
nicht lesenswert
>eine h File geschrieben mit diversen defines und kann nun
>"LED=1;" schreiben und es fehlerfrei kompilieren. Ich habe die Hardware
>noch nicht fertig, aber wenn noch Fehler auftreten werde ich mich wider
>melden.
Wäre schön wenn du mal ein Beispiel zeigen würdest.

Autor: Peter Dannegger (peda)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Klaus Falser schrieb:
> Möglicherweise würde es helfen, die Funktion als inline zu definieren.
> Dann könnte der Optimizer das ganze überflüssige Zeug wegschmeissen.

Ja, mit "__attribute__ ((always_inline))" kommt sogar was brauchbares 
raus.

Wie gesagt, es ist Geschmackssache, ob man diese Schreibweise mag.


Peter

Autor: Mathiable (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Ich habe eigentlich nur Copy Paste gemacht, aber in der h File steht 
jetzt folgendes:
typedef unsigned char  u8;

#define vu8(x)  (*(volatile u8*)&(x))


struct bits {
  u8 b0:1;
  u8 b1:1;
  u8 b2:1;
  u8 b3:1;
  u8 b4:1;
  u8 b5:1;
  u8 b6:1;
  u8 b7:1;
} __attribute__((__packed__));

#define SBIT(port,pin) ((*(volatile struct bits*)&port).b##pin)


#define  LED    SBIT( PORTA, 0 )

Kompilieren kann er es aber getestet habe ich es noch nicht.

Autor: Stefan P. (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hi,
ich hab mir diesbezüglich auch mal was geschrieben. Wie das als ASM 
ausschaut hab ich noch gar nie nachgeschaut. Ist aber eigentlich nur 
Bitmanipulation. OK so super ist der Code noch nicht... muss da mal noch 
etwas handanlegen und bitte nicht auf das miese Englisch achten. Sollte 
wohl doch besser in deutsch Kommentieren ;-)
#ifndef IO_CONTROL_H_
#define IO_CONTROL_H_


/* ------------------------------------------------------------------------- */
/* -------------------------- IO descriptoion ------------------------------ */
/* ------------------------------------------------------------------------- */
/*
 * DDRx : Datenrichtungsregister
 * if ddr is set (1)     --> OUTPUT
 * if ddr is not set (0) --> INPUT
 *
 * PINx : Eingangsadresse
 * Read the temporary status of the bit, !!if Port is INPUT (DDRx = 1)
 * if pin is set (1)     --> level is high (VCC)
 * if pin is not set (0) --> level is low (GND)
 *
 * PORTx : Datenregister
 * If Port is set as OUTPUT, you can set the bit level
 *   if port is set (1)     --> level is hight (VCC)
 *   if port is not set (0) --> level is low (GND)
 *
 * If Port is set as INPUT, you can enabel or disable the internal Pull-up Resistor
 *   if port is set (1)     --> pull-up is active
 *   if port is not set (0) --> pull-up is not active
 */

/* ------------------------------------------------------------------------- */
/* -------------------------- Global definitions --------------------------- */
/* ------------------------------------------------------------------------- */
/*
 * Define for example:
 * -> "IO_PORT_PIN(D)" and it returns an simular action like writing "PIND".
 * The "name" in "IO_PORT_PIN(name)" is for this example "D".
 * 
 * With the IO_DDR_INPUT/OUTPUT(type, name) functions you can set the Data
 * Direction Register as inpot or output.
 *
 * Declarations:
 * a ## b  --> combinates the two strings a=AAA, b=BBB to AAABBB
 *     a=DDR, b=B  -> result = DDRB
 */

#define IO_PORT_ARG(a, b)      a
#define IO_BIT_ARG(a, b)      b

#define IO_PORT_NAME(a, b)      IO_PORT_ARG(a, b)
#define IO_BIT_NUM(name)      IO_BIT_ARG(name)

#define IO_PORT_MERGE_TMP(a, b)    a ## b
#define IO_PORT_MERGE(a, b)      IO_PORT_MERGE_TMP(a, b)


#define IO_PORT_DDR(name)      IO_PORT_MERGE(DDR, IO_PORT_NAME(name) )
#define IO_PORT_PORT(name)      IO_PORT_MERGE(PORT, IO_PORT_NAME(name) )
#define IO_PORT_PIN(name)      IO_PORT_MERGE(PIN, IO_PORT_NAME(name) )

#define IO_DDR(type, name)      IO_PORT_DDR(type##__##name)
#define IO_PORT(type, name)      IO_PORT_PORT(type##__##name)
#define IO_PIN(type, name)      IO_PORT_PIN(type##__##name)
#define IO_BIT(type, name)      IO_BIT_NUM(type##__##name)


/* ------------------------------------------------------------------------- */
/* -------------------------- Global IO definitions ------------------------ */
/* ------------------------------------------------------------------------- */

#define IO_SET_INPUT(type, name)  IO_DDR(type, name) &= ~(1<<IO_BIT(type, name) )    // set Port as input
#define IO_SET_OUTPUT(type, name)  IO_DDR(type, name) |= (1<<IO_BIT(type, name) )    // set Port as output

//#define IO_IS_HIGH(type, name)    IO_DDR(type, name) |= (1<<IO_BIT(type, name) )    // ask if IO is high/VCC
//#define IO_IS_LOW(type, name)    IO_DDR(type, name) |= (1<<IO_BIT(type, name) )    // ask if IO is low/GND

/* ------------------------------------------------------------------------- */
/* -------------------------- Definitons for LED's ------------------------- */
/* ------------------------------------------------------------------------- */
/*
 * Functions tor switch ON / OFF or Toggle an device.
 * The "type" oft the device can be every kind of string.
 * For example LED, SWITCH,..
 * The "name" oft the device can be every kind of string. 
 * For example 1,2,3,blue,red,green,yellow,...
 *
 * Attention! On and off are defined for the follwoing wiring.
 * DDRx must defined as output. Use for this the IO_DDR_OUTPUT(type, name) fuction.
 * 
 *  VCC
 *   |
 *   |
 *   X LED
 *   |                 VCC
 *   -                  |
 *  | | Resistor     -------
 *   -              |       |
 *   |              |uC     |
 *   |______________|Pin ?? |
 *                  |       |
 *                   -------
 *                      |
 *                     GND
 *
 * To use these functions you have to define:
 * "type"_"name"_PORTNAME and "type"_"name"_BIT
 * "type" and "name" must be the same string.
 *
 * Example:
 * #define LED_red_PORTNAME    D
 * #define LED_red_BIT      2
 *
 * The Data Direction Register DDRx must defined as an output!
 * Use the IO_DDR_OUTPUT(LED, red) function to do this.
 *
 * In programm code you can use the ON/OFF/TOGGLE("type", "name") function like this:
 * IO_ON(LED, red);      //red LED on Pin-D2 ON
 * IO_OFF(LED, red);    //red LED on Pin-D2 OFF
 * IO_TOGGLE(LED, red);    //red LED on Pin-D2 TOGGLE
 *
 * type##_##name##_PORTNAME  --> fils the "type" and "name" into the string
 *     type = LED  ->  result = LED_"name"_PORTNAME
 *    name = red  ->  result = "type"_red_PORTNAME
 *    ---> LED_red_PORTNAME
 */

#define IO_OFF(type, name)        IO_PORT(type, name) |= (1<<IO_BIT(type, name) )    // OFF, active low
#define IO_ON(type, name)        IO_PORT(type, name) &= ~(1<<IO_BIT(type, name) )  // ON, active low
#define IO_TOGGLE(type, name)      IO_PORT(type, name) ^= (1<<IO_BIT(type, name) )    // Toggle


/* ------------------------------------------------------------------------- */
/*
 * Designed for switching an pin by using Port and Bit {_PB}
 */
#define IO_OFF_PB(port, bit)      port |= (1<<bit )    // OFF, active low
#define IO_ON_PB(port, bit)        port &= ~(1<<bit )    // ON, active low
#define IO_TOGGLE_PB(port, bit)      port ^= (1<<bit )    // Toggle

#define IO_SET_INPUT_DB(ddr, bit)    ddr &= ~(1<<bit )    // set Port as input
#define IO_SET_OUTPUT_DB(ddr, bit)    ddr |= (1<<bit )    // set Port as output


/* ------------------------------------------------------------------------- */
/* -------------------------- Definitons for LED's ------------------------- */
/* ------------------------------------------------------------------------- */
/*
 * Functions tor switch ON / OFF or Toggle an device.
 * The "type" oft the device can be every kind of string.
 * For example LED, SWITCH,..
 * The "name" oft the device can be every kind of string. 
 * For example 1,2,3,blue,red,green,yellow,...
 *
 * Attention! On and off are defined for the follwoing wiring.
 * DDRx must defined as output. Use for this the IO_DDR_OUTPUT(type, name) fuction.
 *
 *                     VCC
 *                      |
 *                   -------
 *    ______________|       |
 *   |              |uC     |
 *   |              |Pin ?? |
 *   X Device       |       |
 *   |               -------
 *   |                   |
 *  GND                 GND
 *
 *
 * The function works same as the one above. But inverse.
 * The index AH in the function means Active Hight.
 * To switch devices with litte more current (A) use the wiring above.
 */
 
 
#define IO_ON_AH(type, name)      IO_PORT(type, name) |= (1<<IO_BIT(type, name) )    // ON, active hight
#define IO_OFF_AH(type, name)      IO_PORT(type, name) &= ~(1<<IO_BIT(type, name) )  // OFF, active hight

#endif /* IO_CONTROL_H_ */

und in der config.h steht dann
#define LED__Control              D, 7

#define LED__Alarm        B, 0

#define RELAYS__00        B, 1

#define RELAYS__01        B, 2

Angesprochen wird das dann z. B. so...
IO_OFF(LED, Alarm);
Möglicherweise hab ich mich an manchen Stellen etwas verkünstelt aber 
ich kann noch nicht alle Kniffe beim Makros schreiben. Vielleicht habt 
ihr mir da ja mal nen guten Link mit einer Übersicht.
Gruß
Stefan

Autor: Mathiable (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Also, die Hardware ist nun erstellt und so wie ich es oben geschrieben 
habe, funktioniert es nicht. Kenne mich auch überhaupt nicht mit Makros 
aus. Was habe ich falsch gemacht?

Autor: Karl Heinz (kbuchegg) (Moderator)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Mathiable schrieb:
> Also, die Hardware ist nun erstellt und so wie ich es oben geschrieben
> habe, funktioniert es nicht. Kenne mich auch überhaupt nicht mit Makros
> aus. Was habe ich falsch gemacht?

Frische Hardware?
Dann würde ich vorschlagen du benutzt erst mal die klassische, 
konventionelle Methode, um zu sehen ob die Hardware korrekt 
funktioniert, ehe du da anfängst zu künsteln.

Autor: Mathiable (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Karl heinz Buchegger schrieb:
> Frische Hardware?
> Dann würde ich vorschlagen du benutzt erst mal die klassische,
> konventionelle Methode, um zu sehen ob die Hardware korrekt
> funktioniert, ehe du da anfängst zu künsteln.

War natürlich das erste was ich gemacht habe. Ohne einen vollständigen 
Funktions- check, beginne ich erst gar nicht zu Programmieren.

Autor: Karl Heinz (kbuchegg) (Moderator)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Gut.

Bei Makros ist ein sinnvolles Vorgehen bei der expandierten Fassung 
anzufangen.

Dein Programm sehe so aus
int main()
{
  DDRA = 0xFF;

  PORTA = ( 1 << PA0 );

  while( 1 )
    ;
}

Jetzt möchtest du den Port erst mal in die Struktur verpacken, so dass 
du auf die Bits zugreifen kannst. Dazu musst du die Adresse von PORTA 
auf einen entsprechenden Pointer auf die Struktur umcasten um dann über 
diesen Pointer auf das entsprechende Member zuzugreifen.
typedef unsigned char  u8;

struct bits {
  u8 b0:1;
  u8 b1:1;
  u8 b2:1;
  u8 b3:1;
  u8 b4:1;
  u8 b5:1;
  u8 b6:1;
  u8 b7:1;
} __attribute__((__packed__));

int main()
{
  DDRA = 0xFF;

  ((volatile struct bits*)&PORTA)->b0 = 1;

  while( 1 )
    ;
}

klappt das? (testen)

Autor: Mathiable (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Karl heinz Buchegger schrieb:
> klappt das? (testen)
>

Nein hat leider nicht geklappt. Kann es etwas damit zu tun haben, dass 
es sich um einen XMEGA handelt? Der hat ja teilweise andere Syntax, z.B. 
bei der IO Definierung.

Autor: Karl Heinz (kbuchegg) (Moderator)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Mathiable schrieb:
> Karl heinz Buchegger schrieb:
>> klappt das? (testen)
>>
>
> Nein hat leider nicht geklappt. Kann es etwas damit zu tun haben, dass
> es sich um einen XMEGA handelt?

Das kann durchaus sein.
Da müsste man jetzt mal nachgehen, wie PORTA definiert ist. Das wird ja 
auch nur ein Makro sein, welches irgendwo in den Header Files residiert.

Nur der Vollständigkeit halber

  (*(volatile struct bits*)&PORTA).b0 = 1;

wird auch nicht gehen, oder? (Ist aus C Sicht identisch zur -> 
Schreibweise)

Autor: Mathiable (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Karl heinz Buchegger schrieb:
> Nur der Vollständigkeit halber
>
>   (*(volatile struct bits*)&PORTA).b0 = 1;
>
> wird auch nicht gehen, oder? (Ist aus C Sicht identisch zur ->
> Schreibweise)

Ok, hab’s rausgefunden. Anstelle von PORTA muss PORTA.OUT stehen, das 
währe der XMEGA Syntax für die Port Ansteuerung. Funktioniert jetzt 
einwandfrei. Vielen Dank.

Autor: ... (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Alternativ dazu auch 'PORTA_OUT' statt 'PORTA.OUT'.
Wobei eigentlich die die OUTSET, OUTCLR und OUTTGL Varianten noch 
interessanter sind.

Antwort schreiben

Die Angabe einer E-Mail-Adresse ist freiwillig. Wenn Sie automatisch per E-Mail über Antworten auf Ihren Beitrag informiert werden möchten, melden Sie sich bitte an.

Wichtige Regeln - erst lesen, dann posten!

  • Groß- und Kleinschreibung verwenden
  • Längeren Sourcecode nicht im Text einfügen, sondern als Dateianhang

Formatierung (mehr Informationen...)

  • [c]C-Code[/c]
  • [avrasm]AVR-Assembler-Code[/avrasm]
  • [code]Code in anderen Sprachen, ASCII-Zeichnungen[/code]
  • [math]Formel in LaTeX-Syntax[/math]
  • [[Titel]] - Link zu Artikel
  • Verweis auf anderen Beitrag einfügen: Rechtsklick auf Beitragstitel,
    "Adresse kopieren", und in den Text einfügen




Bild automatisch verkleinern, falls nötig
Bitte das JPG-Format nur für Fotos und Scans verwenden!
Zeichnungen und Screenshots im PNG- oder
GIF-Format hochladen. Siehe Bildformate.
Hinweis: der ursprüngliche Beitrag ist mehr als 6 Monate alt.
Bitte hier nur auf die ursprüngliche Frage antworten,
für neue Fragen einen neuen Beitrag erstellen.

Mit dem Abschicken bestätigst du, die Nutzungsbedingungen anzuerkennen.