Variable in der Headerdatei

[Sabine F. (Gast)]

Hallo,

#define STX PD1         ... befindet sich in der Header - Datei

Kann ich diese Variable in meinem Hauptprogramm ändern? Würde gerne PD2 
zuweisen.

Danke für eure Hilfe.

MfG Sabine

[Children (Gast)]

das ist keine Variable, sonder nur eine Ersetzung


Welche Sprache soll das sein? Wenn C dann so z.B.


in H-Datei:

extern int globaleVariable;

in C-Datei:

int globaleVariable = 0;


void main(void) {
 globaleVariable = 1;
}

[Udo S. (urschmitt)]

Was willst du erreichen?

[cskulkw (Gast)]

Sabine F. schrieb:
> #define STX PD1         ... befindet sich in der Header - Datei
>
>
>
> Kann ich diese Variable in meinem Hauptprogramm ändern? Würde gerne PD2
>
> zuweisen.

Nein, das geht definitiv nicht...

[Ralf G. (ralg)]

Sabine F. schrieb:
> Kann ich diese Variable in meinem Hauptprogramm ändern?

Das ist keine Variable, das ist eine simple Textersetzung!

Einfach mal nach '#ifdef' googeln ...
'#undef' ist das Zauberwort

[Sabine F. (Gast)]

Danke für deinen Tipp =)

Ja verwende C, kann man auch die 'Ersetzung' ändern?
Kann ich vom Hauptprogramm die Ersetzung in Headerdatei ändern.
Möchte nämlich zu Beginn PD1 verwenden und während des Progammes möchte 
ich sie gerne auf PD2 setzen. Geht das?

[Udo S. (urschmitt)]

Sabine F. schrieb:
> Kann ich vom Hauptprogramm die Ersetzung in Headerdatei ändern.
> Möchte nämlich zu Beginn PD1 verwenden und während des Progammes möchte
> ich sie gerne auf PD2 setzen. Geht das?

Du begreifst es nicht.
ein define ist KEINE Variable, das ist eine Textersetzung, die vor dem 
compilieren durch den Präprozessor erfolgt.
Zur Laufzeit kannst du nur in Variablen etwas ändern
Du brauchst ein C Buch!

[Guest (Gast)]

"Vor" dem kompilieren ist das Stichwort. Ist das Programm erst einmal 
auf dem Controller, lässt sich an einer festen #define Zuweisung nichts 
mehr ändern. (Das # Zeichen bezeichnet Präprozessoranweisungen, die bei 
der Erzeugung des Maschinencodes als erste behandelt werden).

Warum nimmst du nicht einfach eine zweite Zeile á la "#define 
STX_initial PD1" hinzu, verwendest diese Zuweisung eben nur einmal beim 
Start und danach immer STX (dem zu PD2 zugewiesen hast)? Es gibt sicher 
auch noch andere Lösungen, aber deine ursprüngliche Idee ist definitiv 
keine davon.

[Sabine F. (Gast)]

Wie kann man dieses Problem sonst lösen?

#define STX    PD5

Möchte PD5 auf PD4 ändern können, damit ich zweimal das selbe auf zwei 
Software - UARTs senden kann.

Wie könnte dies funktionieren?

#include "main.h"
#include "suart.h"



#define BIT_TIME  (u8)((XTAL / BAUD) / PRESCALE)


volatile u8 stx_count;
u8 stx_data;

volatile u8 srx_done;
u8 srx_data;
u8 srx_mask;
u8 srx_tmp;

void suart_init( void )
{
  SBIT(PORTD,STX) = 1;
  // OCR0A = TCNT0 + 1;    // force first compare
  // TCCR0A = 0;        // Default: Normal port operation
  TCCR0B = 1 << CS01 | 1<<CS00;  // clk/64
  // TIFR0 = 1<<ICF1;      // clear pending interrupt
  TIMSK0 = 1 << OCIE0A;    // enable output compare interrupt

  EICRA = 1 << ISC01;      // falling edge
  EIMSK = 1 << INT0;      // enable edge interrupt

  stx_count = 0;        // nothing to sent
  srx_done = 0;            // nothing received
  STXDDR |= 1 << STX;      // TX output
}


u8 sgetchar (void)      // get byte
{
  while (!srx_done);      // wait until byte received
  srx_done = 0;
  return srx_data;
}


ISR (INT0_vect)    // rx start
{
  OCR0B = TCNT0 + (u8)((BIT_TIME * 3) / 2);// scan 1.5 bits after start

  srx_tmp = 0;        // clear bit storage
  srx_mask = 1;        // bit mask
  if( !(SRXPIN & 1<<SRX))  {  // still low
    EIMSK &= ~(1 << INT0);      // disable edge interrupt
    TIMSK0 = 1<<OCIE0A^1<<OCIE0B;  // wait for first bit
}
  TIFR0 = 1<<OCF0B;      // clear pending interrupt ? why does that output compare int occur?
EIFR |= (1 << INTF0);    // clear any pending edge interrupt
}


ISR (TIMER0_COMPB_vect)
{
  u8 in = SRXPIN;      // scan rx line
  // PORTB = 0x00;
  if (srx_mask) {
      if (in & 1 << SRX)
      srx_tmp |= srx_mask;
    srx_mask <<= 1;
    OCR0B += BIT_TIME;      // next bit slice
  } else {
    srx_done = 1;      // mark rx data valid
    srx_data = srx_tmp;      // store rx data
    // TIFR0 = 1<<ICF1;      // clear pending interrupt
    TIMSK0 = 1<<OCIE0A;        // enable tx and wait for start
    EIFR |= (1 << INTF0);    // clear any pending edge interrupt: This hinders the in0-vect from beeing triggerd again just now which may occur by falling edges in the serial data bits
    EIMSK = 1 << INT0;  // reenable edge interrupt
  }
    // PORTB = 0x02;
}


void sputchar (u8 val)      // send byte
{
  while (stx_count);      // until last byte finished
  stx_data = ~val;      // invert data for Stop bit generation
  stx_count = 10;      // 10 bits: Start + data + Stop
}


void sputs (u8 *txt)      // send string
{
  while (*txt)
    sputchar (*txt++);
}


ISR (TIMER0_COMPA_vect)    // tx bit
{
  u8 dout;
  u8 count;

  OCR0A += BIT_TIME;      // next bit slice
  count = stx_count;

  if (count) {
    stx_count = --count;    // count down
    // ??? dout = 1<<COM0A1;      // set low on next compare
    dout = 0;
    if (count != 9) {      // no start bit
      if (!(stx_data & 1))    // test inverted data
        //??? dout = 1<<COM0A1^1<<COM0A0;  // set high on next compare
        dout = 1;
          stx_data >>= 1;      // shift zero in from left
    }
    // TCCR0A = dout;
    // STX = (dout == 0) ? 1 : 0;
    SBIT(PORTD,STX) = dout;
  }
}

[Ralf G. (ralg)]

Sabine F. schrieb:
> Möchte PD5 auf PD4 ändern können, damit ich zweimal das selbe auf zwei
> Software - UARTs senden kann.

Dann brauchst du zwei Variablen.

[Karl H. (kbuchegg)]

> Möchte PD5 auf PD4 ändern können, damit ich zweimal das selbe auf
> zwei Software - UARTs senden kann.
>
> Wie könnte dies funktionieren?

Indem du das implementierst, was das logischte ist:
eine 2.te Software UART

HIer ist deine erste

void suart_init_1( void )
{
  SBIT(PORTD,STX_1) = 1;
  // OCR0A = TCNT0 + 1;    // force first compare
  // TCCR0A = 0;        // Default: Normal port operation
  TCCR0B = 1 << CS01 | 1<<CS00;  // clk/64
  // TIFR0 = 1<<ICF1;      // clear pending interrupt
  TIMSK0 = 1 << OCIE0A;    // enable output compare interrupt

  EICRA = 1 << ISC01;      // falling edge
  EIMSK = 1 << INT0;      // enable edge interrupt

  stx_count = 0;        // nothing to sent
  srx_done = 0;            // nothing received
  STXDDR_1 |= 1 << STX_1;      // TX output
}

und sukzessive für alle anderen Funktionen: Allem was UART spezifisch 
ist, verpasst du eine angehängte _1. Aus STX wird STX_1, aus suart_init 
wird suart_init_1, aus sputchar wird sputchar_1, etc. etc.

und dann implementierst du alles nochmal, wobei du anstelle der _1 dann 
eben eine _2 hast.

Voila: 2 Software UART, die sauber in allen Belangen voneinander 
getrennt sind.

Edit: In den höhreren Software Schichten könnte man das auch ein wenig 
eleganter machen, aber im Hinblick auf deine C-Kentnisse nehme ich davon 
mal Abstand. Einfach realisierbar und für dich durchschaubar lautet die 
Devise.

[Jörg W. (dl8dtl) (Moderator)]

Sabine F. schrieb:
> Möchte PD5 auf PD4 ändern können, damit ich zweimal das selbe auf zwei
> Software - UARTs senden kann.

Dann schmeiß STX und SRX komplett aus der Headerdatei raus um
sicherzustellen, dass sie tatsächlich auch sonst niemand benutzt.

In der Implementierungsdatei schreibst du dann:

#define STX PD5
#define SRX PD6

// Implementierung der 1. Software-UART

#undef STX
#undef SRX

#define STX PD4
#define SRX PD3

// Implementierung der 2. Software-UART

#undef STX
#undef SRX

Edit: unterscheidet sich von Karl-Heinz' Vorschlag nur geringfügig
in der Form, die Grundzüge der Implementierung bleiben zwischen
uns beiden gleich.

[Sabine F. (Gast)]

Vielen Dank, werde es versuchen.

[Karl H. (kbuchegg)]

Wobei:

Mit dieser Interrupt getriebenen SW-UART

  TCCR0B = 1 << CS01 | 1<<CS00;  // clk/64
  // TIFR0 = 1<<ICF1;      // clear pending interrupt
  TIMSK0 = 1 << OCIE0A;    // enable output compare interrupt

  EICRA = 1 << ISC01;      // falling edge
  EIMSK = 1 << INT0;      // enable edge interrupt

könnte es interessant werden, eine 2. SW-UART aufzusetzen, die 
Timer-Interrupt getrieben das richtige tut und man keinen funktional 
gleichwertigen Timer mehr übrig hat.

Insofern nehm ich meine implizite Aussage von weiter oben, das das mit 
kleinen Modifikationen geht, wieder zurück. Da hab ich mir das alles 
nicht besonders gut angesehen.

[Sabine F. (Gast)]

Ich will nicht zwei Uarts gleichzeitig benützen, es reicht mir auch, 
wenn sie hintereinander etwas senden können, sprich daten auf PD4 und 
dann PD5. Ist es nicht möglich PD4 mit einer Anweisung auf PD5 
umschalten zu können?

[Sascha W. (sascha-w)]

Sabine F. schrieb:
> Ich will nicht zwei Uarts gleichzeitig benützen, es reicht mir auch,
> wenn sie hintereinander etwas senden können, sprich daten auf PD4 und
> dann PD5. Ist es nicht möglich PD4 mit einer Anweisung auf PD5
> umschalten zu können?
nein, dann must du UART-Routinen so umschreiben, das an allen Stellen, 
an denen die define's verwendet werden entweder direkt mit Variablen 
gearbeitet wird. Oder noch mal eine Fallunterscheidung durchgeführt 
wird.

z.B.

uint8 SRX;

...

//UART A
SRX=1<<PD4;

if( !(SRXPIN & SRX))  //PD4 abfragen

//umschalten auf UART B
SRX=1<<PD6;

if( !(SRXPIN & SRX))  //PD6 abfragen


Sascha

[Sabine F. (Gast)]

Habe jetzt die Software - Uart in eine neue Klasse geschrieben und eine 
zusätzliche Headerdatei geschrieben. Jedoch bekomme ich beim Ausführen 
einen Error.

make: *** [SoftwareUART.elf] Fehler 1

[Sabine F. (Gast)]

Die erste Header - Datei:

#define SRX    PD6
#define SRXPIN  PIND

#define STX    PD5    //Pinbelegung Datasheet (OC1A) #define STX    PD4
#define STXDDR  DDRD

extern volatile u8 srx_done;

#define kbhit()  (srx_done)  // true if byte received

void suart_init( void );
void sputchar( u8 val );
u8 sgetchar( void );
void sputs( u8 *txt );

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  SBIT(x,y)  SBIT_(x,y)

Die zweite Header - Datei:

#define SRX1 PD6
#define SRXPIN1  PIND

#define STX1 PD4    //Pinbelegung Datasheet (OC1A) #define STX    PD4
#define STXDDR1  DDRD

extern volatile u8 srx_done1;

#define kbhit()  (srx_done1)  // true if byte received

void suart_init1( void );
void sputchar1( u8 val );
u8 sgetchar1( void );
void sputs1( u8 *txt );

struct bits1 {
  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_1(port,pin) ((*(volatile struct bits1*)&port).b##pin)
#define  SBIT1(x,y)  SBIT_1(x,y)

Darf ich das so machen?

[Sabine F. (Gast)]

Die Software - UART habe ich einfach nochmal kopiert, nun zwei getrennte 
Klassen. Wie könnte es sonst gehn?