IOs umbenennen

[Mathiable (Gast)]

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

[Karl H. (kbuchegg)]

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.

[Peter D. (peda)]

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

[Peter (Gast)]

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");
  }
}

[Mathiable (Gast)]

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.

[Peter D. (peda)]

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

[Klaus Falser (Gast)]

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.

[Peter (Gast)]

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...

[Peter (Gast)]

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!

[Peter D. (peda)]

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

[Mathiable (Gast)]

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.

[Nils S. (kruemeltee)]

>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.

[Peter D. (peda)]

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

[Mathiable (Gast)]

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.

[Stefan P. (Gast)]

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

[Mathiable (Gast)]

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?

[Karl H. (kbuchegg)]

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.

[Mathiable (Gast)]

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.

[Karl H. (kbuchegg)]

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)

[Mathiable (Gast)]

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.

[Karl H. (kbuchegg)]

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)

[Mathiable (Gast)]

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.

[... (Gast)]

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