Eingangspins auslesen

[µC-noob (Gast)]

Hallo,
sorry mir war kein Oberbegriff für meine Frage eingefallen.

--> Atmega 128, gcc compiler <--

Problem:
Ich würde gerne eine Funktion schreiben, die es ermöglicht mehrere 
Eingangspins zu erkennen.

Etwa so

static char inValue = 0x16; //PINE4

unsigned char get_datapins_hardware(void)
{

if (inValue > 2 )
return !( (PINE & inValue) ) ;

}

....

if (get_datapins_hardware) //tu was

Nun möchte ich es aber so gestalten dass man nicht immer nur einen Pin 
auslesen kann sondern mehrere gleichzeitig:

Etwa so

static char inValue = 0x80; //PINE4 + PINE6

unsigned char get_datapins_hardware(void)
{

if (inValue > 2 )
return !( (PINE & inValue) ) ;

}

....

if (get_datapins_hardware) //tu was

Das geht so aber leider nicht.

Gibt es eine möglichkeit Pins so auszulesen, ohne eine for - schleife??

Gruß
Jo

[Patrick (Gast)]

PINE hat doch immer einen bestimmten Wert, je nach dem, welcher Schalter 
betätigt ist.
z.B. bei Pin 0 und 6 auf high und die anderen auf low:
PINE = 0b01000001

Da könntest Du PINE selbst als variable verwenden, die sich je nach 
Port-Zustand verändert.

Andere Frage: Was willst Du damit eigentlich machen? Vielleicht gibt es 
einen anderen Lösungsansatz für Dein Problem.

[Heinrich (Gast)]

Ganzen Port einlesen und dann Bitmanipulation

[Patrick (Gast)]

^^^^ genau das wollte ich damit sagen ;-)

[Compy (Gast)]

Da is noch was:

if (get_datapins_hardware) //tu was

Das is mitunter net ganz ungefährlich. Machnal wird für 
get_datapins_hardware dann nämlich nicht die Routine aufgerufen, und 
dann deren Rückgabewert ausgewertet, sondern einfach die Adresse der 
Routine betrachtet (so als ob get_datapins_hardware eine Variable/ein 
Zeiger wäre).

So ists sicherer:

if (get_datapins_hardware()) //tu was mit Klammern!

[µC-noob (Gast)]

Ich habe ein menü,

in einem Menüpunkt kann der Anwender wählen, welche Pins geprüft werden 
sollen.

In einem anderen menü, wird dann Ausgegeben, ob an den Gewählten Pins 
ein High oder Low - Signal anliegt.

Ich hatte es folgendermaßen geplant:

Globale Variable:

unsigned char inValue;

//Pins übers menü setzen

unsigned char set_getDatapins_input(unsigned char cPinnumber)
{
  // Processorpins PINE7 PINE6 PINE5 PINE4 PIND0 PIND1
  // Boxpins       PIN6  PIN5  PIN4  PIN2  PIN7  PIN8
  // brief:  PIN1 and PIN3 not handled in this function --> only Output

  if (cPinnumber > 1 )//&& cPinnumber != 3)
  {
    if (cPinnumber < 7)
    {
      if (cPinnumber == 2)
        inValue |= ( 1 << (cPinnumber + 2) );
      else
        inValue |= ( 1 << (cPinnumber + 1) );
        
      return inValue;  
    }
    else 
    {
      inValue |= ( 1 << (cPinnumber - 7) );

      return inValue;
    }
  }
  else
  {
    return inValue;    //Previous value to read
  }
}

//Pins übers menü rücksetzen

void reset_getDatapins_input(unsigned char cPinnumber)
{
  // Processorpins PINE7 PINE6 PINE5 PINE4 PIND0 PIND1
  // Boxpins       PIN6  PIN5  PIN4  PIN2  PIN7  PIN8
  // brief:  PIN1 and PIN3 not handled in this function --> only Output

  if (cPinnumber > 1 )//&& cPinnumber != 3)
  {
    if (cPinnumber < 7)
    {
      if (cPinnumber == 2)
        inValue &= ~( 1 << (cPinnumber + 2) );
      else
        inValue &= ~( 1 << (cPinnumber + 1) );
    }
    else 
    {
      inValue &= ~( 1 << (cPinnumber - 7) );
    }
  }
}

//Pins abfragen

unsigned char get_datapins_hardware(void)
{
         if (inValue > 2 )
    return !( (PINE & (inValue) );

  else  
    return !( PIND & inValue );
}

so ist mein Aufruf:
//menü Setze zu Prüfende Pins
  set_getDatapins_input(2);
  set_getDatapins_input(5);

Wenn ich NUR set_getDatapins_input(2); oder NUR 
set_getDatapins_input(5);
schreibe gehts einwandfrei.

//menü Prüfe Pinstatus --> Wird alle 10ms erneut aufgerufen.
  get_datapins_hardware();


Gruß

[Karl H. (kbuchegg)]

Wenn ich das richtig sehe, liegt dein Problem hier
if (inValue > 2 )

inValue ist, sobald du irgendeiner der E-Pins freigeschaltet
ist, immer größer als 2.

Wenn du mehrere Pins, über mehrere Ports verteilt abfragen
willst, dann musst du auf jeden Fall beide PIN Register
auslesen und die Ergebnisse miteinenader verknüpfen.

[µC-noob (Gast)]

Habs geschafft,
danke für die Hinweise

So habs ich Gelöst (ich weiß, nicht die opti-lösung)

unsigned char get_datapins_hardware(void)
{
  static unsigned char pinHigh = 0;
//  Processorpins PINE7 PINE6 PINE5 PINE4 PIND0 PIND1
//  Boxpins       PIN6  PIN5  PIN4  PIN2  PIN7  PIN8
//  Boxpins PIN1 and PIN3 not handled in this function --> only Output


    if( !(PINE & 16) && (inValue & 16) )
      pinHigh |= 16;
    else
      pinHigh &= ~16;


    if( !(PINE & 32) && (inValue & 32))
      pinHigh |= 32;
    else
      pinHigh &= ~32;
    

    if( !(PINE & 64) && (inValue & 64) )
      pinHigh |= 64;
    else
      pinHigh &= ~64;
    

    if( !(PINE & 128) && (inValue & 128))
      pinHigh |= 128;
    else
      pinHigh &= ~128;

    if( !(PIND & 0x01) && (inValue & 1 ) )
      pinHigh |= 1;
    else
      pinHigh &= ~1;

    if( !(PIND & 0x02) && (inValue & 2 ) )
      pinHigh |= 2;
    else
      pinHigh &= ~2;
  //}

  return pinHigh;

}

Gruß

[Karl H. (kbuchegg)]

Bist du an einer 'einfacheren' Lösung interessiert?

unsigned char get_datapins_hardware(void)
{
//  Processorpins PINE7 PINE6 PINE5 PINE4 PIND0 PIND1
//  Boxpins       PIN6  PIN5  PIN4  PIN2  PIN7  PIN8
//  Boxpins PIN1 and PIN3 not handled in this function --> only Output

  unsigned char pinHigh = 0;

  pinHigh = ( PINE & 0xF0 ) | ( PIND & 0x03 );
  return pinHigh & inValue;
}

Ist nicht ganz gleichwertig. Bei dir werden die einzelnen
Pins nacheinander abgefragt, bei mir (zumindest an einem Port)
gleichzeitig. Ich denke mal dass das für den geplanten Anwendungs-
fall aber keine Rolle spielt.

Noch ein kleiner Tipp:
Wenn du mit Bitwerten um dich schmeisst, dann benutze
Hex-Zahlen oder Binärzahlen aber keine Dezimalzahlen.
IN Hex bzw. Binärzahlen kann man direkt das gesetzte
Bit erkennen, bei Dezimalzahlen muss man erst gross
rumrechnen.

[µC-noob (Gast)]

merci!!