#define in Main ändern

[sebastian xxlxx (Gast)]

Hallo am Sonntagabend :)

ich habe oben im code :

#define OW_PORT D
#define OW_PIN  7

stehen.

wie kann ich weiter unten im code die Werte D & 7 in B & 0 ändern?

noch ein  #define OW_PORT D im code geht nicht bzw. wird nicht 
umgesetzt.

ein OW_PORT=B; geht auch nicht
ein OW_PORT="B"; geht auch nicht.

im GCC tutorial gibt es aber für mich da keine hilfe.

ich möchte einfach einen Port ändern wenn das programm läuft.

danke für die hilfe

[ogg (Gast)]

http://gcc.gnu.org/onlinedocs/cpp/Undefining-and-Redefining-Macros.html

[Klaus W. (mfgkw)]

Oder in Kurzform:
1. mit #undef ... das alte Makro löschen (kein Problem, falls nicht 
definiert)
2. mit #define... neu definieren
3. Wozu? Wenn man schon generell mit Makros sich eher zurückhalten 
sollte, ist ein Umdefinieren meistens Blödsinn.

[sebastian xxlxx (Gast)]

hmmmm vieleicht bin ich da noch zu viel Anfänger.

mein Code nach eurer info :

#define OW_PORT B
#define OW_PIN  0



// Main

void main(void) {

lcd_init();
while (1)
{

#undef OW_PORT
#undef OW-PIN
#define OW_PORT D
#define OW_PIN  7

     set_cursor(0,1);
     Read_Temperature(); // messen + Ausgabe

#undef OW_PORT
#undef OW-PIN
#define OW_PORT B
#define OW_PIN  0


     set_cursor(0,2);
     Read_Temperature(); // messen + Ausgabe

}

das geht aber nicht so recht ...

[Johann L. (gjlayde)]

Erstens heisst es OW_PIN und nicht OW-PIN.

Zweitens werden die Macros überhaupt nicht verwendet, wozu also ändern?

Makros machen nur Textersatz mehr nicht.

[Klaus W. (mfgkw)]

@ sebastian:
Falls du glaubst, daß sich das Definieren von OW_... in main() auf 
set_cursor() oder Read_Temperature() auswirken würde:
Nein.

Für so etwas müsstest du stattdessen entweder die Werte als Parameter 
übergeben (und in den Funktionen auch entsprechend verwenden), oder 
globale Variablen nehmen (ziemlich sicher kein schöner Weg).

[sebastian xxlxx (Gast)]

hallo

ich bin lernfähig und lese mich ein aber es will nicht klappen.
das macros nur da sind um im compiler text durch text zu ersetzen habe 
ich verstanden.

jetzt nöchte ich aber globale variablen definieren.

#define OW_PORT D
#define OW_PIN  7

#define concat(a, b) a##b
#define indir(a, b) concat(a, b)
#define ow_port indir(PORT, OW_PORT)
#define ow_pin  indir(PIN, OW_PORT)
#define ow_ddr  indir(DDR, OW_PORT)

so sah das bisher aus und möchte es jetzt so setzen

char ow_pin=PIND;     //könnte Hex C0 sein
char ow_port=PORTD;   //könnte Hex 00 sein
char ow_ddr=DDRD;     //könnte Hex 3F sein
char OW_PIN=7;

mit OW_PIN=7; geht das auch. aber PIND geht nicht da kein char denke ich 
mal.  Wie kann ich PIND,PORTD,DDRD in eine Variable übergeben?
da meckert der compiler :(
gibt es dafür adressen (hexwerte)?

danke
Sebastian

[Michael (Gast)]

PIND, PORTD und DDRD sind Pointer auf 8bit Register im Speicher:

volatile char* ow_pin = PIND;
volatile char* ow_port = PORTD;
volatile char* ow_ddr = DDRD;
char OW_PIN = 7;

Viele Grüße!
Michael

[Michael (Gast)]

Ach ich erzähle Schwachsinn!

volatile char* ow_pin = &PIND;
volatile char* ow_port = &PORTD;
volatile char* ow_ddr = &DDRD;
char OW_PIN = 7;

Zum setzen des Pins könnte man dann soetwas tun:

*ow_port |= (1 << OW_PIN);

Viele Grüße!
Michael

[sebastian xxlxx (Gast)]

Hallo

danke für die schnelle hilfe.
aber so einfach wie ich dachte ist das nicht :(
ich dachte ich ersetze die #define durch variablen.
jetzt kommen aber noch mehr fehler.

schade das der 1Wire code so viel define nutzt.

gibt es eine einfach art so eine Funktion

static inline void clear_dq(void)
        {
          ow_port &= ~(1 << OW_PIN);
          ow_ddr  |= (1 << OW_PIN);
        }

wo OW_PIN, ow_port , ow_ddr  steht die parameter zu übergeben ?

der ganze code ist voll davon und das define setzt dort werte beim 
comperlieren ein. ich möchte aber diese ports in der laufzeit ändern.
wo muss ich bei dieser funktion ansetzen ?

[sebastian xxlxx (Gast)]

ich poste mal den code komplett

#include <avr/io.h>
#include <avr/interrupt.h>
#include "delay.h"
#include <util/delay.h>
#include <string.h>
#include <stdlib.h>
#include <util/crc16.h>
#include <stdio.h>


#ifndef F_CPU
#define F_CPU 8000000
#endif


//1wire port
//#define OW_PORT D
//#define OW_PIN  7

extern bool ow_reset(void);
#define concat(a, b) a##b
#define indir(a, b) concat(a, b)
//#define ow_port indir(PORT, OW_PORT)
//#define ow_pin  indir(PIN, OW_PORT)
//#define ow_ddr  indir(DDR, OW_PORT)
#define uchar unsigned char
 
//char ow_pin=PIND;
//char ow_port=PORTD;
//char ow_ddr=DDRD;
char OW_PIN=7;

volatile char* ow_pin = &PIND;
volatile char* ow_port = &PORTD;
volatile char* ow_ddr = &DDRD;



static void hw_init(void) 
        {
          //DDRB = 0x2F;
          //PORTB = 0xFE;
          //DDRD = 0x12;  // Input-Port, außer TxD
          //PORTD = 0xEF;  // Pull-Ups aktivieren

          //TIMSK1 = 2;
        }


static inline void clear_dq(void)
        {
          ow_port &= ~(1 << OW_PIN);
          ow_ddr  |= (1 << OW_PIN);
        }


static inline void set_dq(void)
        {
          ow_port &= ~(1 << OW_PIN);
          ow_ddr  &= ~(1 << OW_PIN);
        }


static inline uint8_t get_dq(void)
        {
          return (ow_pin & (1 << OW_PIN)) == 0;
        }


bool ow_reset(void)
        {
          bool presence;

          cli();
          clear_dq();
          _delay_ms(0.48);
          set_dq();
          _delay_ms(0.07);
          presence = get_dq();
          sei();
          _delay_ms(0.24);

          return presence;
        }

static uint8_t ow_read_bit(void)
        {
          bool res;

          cli();
          clear_dq();
          set_dq();
          _delay_us(15);

          res = get_dq();
          sei();
          _delay_us(60);

          return res? 0: 1;
        }


static void ow_write_bit(bool bit)
        {
          cli();
          clear_dq();
          if (bit)
            set_dq();
          _delay_ms(0.1);
          set_dq();
          sei();
        }


uint8_t ow_read_byte(void)
        {
          uint8_t i;
          uint8_t val = 0, mask;

          for (i = 0, mask = 1; i < 8; i++, mask <<= 1)
            {
              if (ow_read_bit())
                val |= mask;
              _delay_ms(0.1);
            }

          return val;
        }


void ow_write_byte(uint8_t val)
        {
          uint8_t i;
          uint8_t mask;

          for (i = 0, mask = 1; i < 8; i++, mask <<= 1)
            {
              ow_write_bit(val & mask);
            }
          _delay_ms(0.1);
        }


uint8_t ow_checkcrc(uint8_t *data, uint8_t nbytes)
        {
          uint8_t crc = 0, i;

          for (i = 0; i < nbytes; i++)
            crc = _crc_ibutton_update(crc, data[i]);

          return crc; // must be 0
        }



static void Read_Temperature(void)
        {
          uint8_t get[9];
          uint8_t k;
          uchar s[30];
      



          ow_reset();
          ow_write_byte(0xCC); //Skip ROM
          ow_write_byte(0x44); // Start Conversion
           //for (i = 0; i < 750; i++)
          //  _delay_ms(1);
          _delay_ms(1000);
          ow_reset();
          ow_write_byte(0xCC); // Skip ROM
          ow_write_byte(0xBE); // Read Scratch Pad
  
          for (k = 0; k < 9; k++){
            get[k] = ow_read_byte();
          //lcd_data(get[k]);

          }
          k = ow_checkcrc(get, 9);

  

      
          
        

          if (get[1] == 0x00)   // + vorzeichen
              {lcd_string("+");} 

            if (get[1] == 0xFF)    // - vorzeichen 
            {lcd_string("-");
            get[0]=255-get[0];    // minuswerte invertieren 
            }
     
          get[0]=get[0]/2;
          
          //sprintf( (char*)s, "%04Xh", get[0] );  // hex value
          sprintf( (char*)s, "%3d Grad", get[0]  ); // 1 Grad Dez
         
                    lcd_string( (char*)s );
 
        }



// Main


void main(void) {
    
  uchar s[30];

  hw_init();
  lcd_init();

while (1)
{

 
    set_cursor(0,1);
     Read_Temperature(); // messen + Ausgabe

}
  
}

[Michael (Gast)]

Halbwegs elegant könntest du dir ein Port struct definieren:

struct port
{
  volatile char*  port;
  volatile char*  pin;
  volatile char*  ddr;
  uint8_t  bit;
};

Deine Funktionen abändern, dass sie so ein Port struct annehmen, z.B.:

static inline void clear_dq(const struct port* port)
{
    *port->port &= ~(1 << port->bit);
    *port->ddr  |= (1 << port->bit);
}

Und dann diese Funktion mit einer Instanz des Port structs aufrufen:

static const struct port toller_port = { &PORTD, &PIND, &DDRD, PD6 };

clear_dq(&toller_port);

[Klaus W. (mfgkw)]

Nicht vielleicht besser uint8_t statt char?

[sebastian xxlxx (Gast)]

hallo

danke - wusste gar nicht das es sowas gibt... werde ich heute nacht 
testen ...

[sebastian xxlxx (Gast)]

Klaus Wachtler schrieb:
> Nicht vielleicht besser uint8_t statt char?


hat er recht ?

[Karl H. (kbuchegg)]

sebastian xxlxx schrieb:
> Klaus Wachtler schrieb:
>> Nicht vielleicht besser uint8_t statt char?
>
>
> hat er recht ?

hat er.