Mega8 Port.Pin Zustand abfragen wenn gegen GND vs.VCC

[Kostas V. (kostas)]

Hallo Zusammen,

ich habe noch nicht viel Erfahrung mit µC, deshalb möglicherweise
die seltsame Frage:

Wie erkennt der µC den Zustand eines Tasters high oder low:
a)wenn der PortPin im offenen Zustand in der Luft hängt und im
  geschlossen Zustand gegen GND geschaltet ist?
b)wenn der PortPin im offenen Zustand gegen 100R hängt und im
  geschlossen Zustand gegen GND geschaltet ist?
c)wenn der PortPin im offenen Zustand gegen 10K hängt und im
  geschlossen Zustand gegen VCC geschaltet ist?

Ich habe Schaltungen gesehen mit allen drei Varianten und sogar gemischt 
auf ein Board.

Hat des was mit der Initialisierung der Ports zu tun?
Wenn ja, was sind bitte jeweils die unterschiede für Port Maske
und DDR Maske.

Gruß Kostas

[Karl H. (kbuchegg)]

Kostas Victor schrieb:
> Hallo Zusammen,
>
> ich habe noch nicht viel Erfahrung mit µC, deshalb möglicherweise
> die seltsame Frage:

AVR-GCC-Tutorial
AVR-Tutorial: IO-Grundlagen

> Wie erkennt der µC den Zustand eines Tasters high oder low:
> a)wenn der PortPin im offenen Zustand in der Luft hängt und im
>   geschlossen Zustand gegen GND geschaltet ist?

im offenen Zustand: alles ist möglich. Je nachdem welche 
elektromagnetischen Felder so in der gegend rumhängen
geschlossen: 0

> b)wenn der PortPin im offenen Zustand gegen 100R hängt und im
>   geschlossen Zustand gegen GND geschaltet ist?

gegen 100R?
Was soll das sein? Wo führen die 100R hin?

wenn nirgendwohin, dann:
offen: alles ist möglich
geschlossen: 0


> c)wenn der PortPin im offenen Zustand gegen 10K hängt und im
>   geschlossen Zustand gegen VCC geschaltet ist?

wieder: wo führen die 10k hin?
wenn nirgendwohin:
offen: alles ist möglich
geschlossen: 1

> Ich habe Schaltungen gesehen mit allen drei Varianten und sogar gemischt
> auf ein Board.

Ja, durchaus möglich.

> Hat des was mit der Initialisierung der Ports zu tun?

Nö. Hat damit zu tun, was man als Default möchte, wenn der Taster nicht 
geschlossen ist.
Da aber ein Mega8 Pullup-Widerstände eingebaut hat, aktiviert man die 
ganz einfach und lässt den Schalter nach GND schliessen. Dann hat man

nicht geschlossen: 1
geschlossen: 0

> Wenn ja, was sind bitte jeweils die unterschiede für Port Maske
> und DDR Maske.


DDR: Auswahl ob ein Pin Eingang oder Ausgang sein soll.

Wenn Ausgang: Port-Register schaltet den Ausgang auf 0 oder 1

Wenn Eingang:
    Port Register schaltet den Pullup zu oder weg
    Pegel am Eingangspin kann dann über PINx abgefragt werden.


Siehe die Tutorien
AVR-GCC-Tutorial
AVR-Tutorial: IO-Grundlagen

[Kostas V. (kostas)]

Vielen Dank Karl Heinz für deine sehr ausführliche Info.

Das reicht mir schon für die Fehlersuche.

Nur der Vollständigkeitshalber, sorry für die nicht vollständige Infos.
-die 100R sind zwischen PortPin und dem Taster. Der Taster schaltet 
gegen
 GND.
-die 10K die am PortPin hängen sind externe Pullup-Widerstände gegen 
VCC.
 Der Taster ist am PortPin und schaltet gegen GND.


Gruß Kostas

[Karl H. (kbuchegg)]

Kostas Victor schrieb:
> Vielen Dank Karl Heinz für deine sehr ausführliche Info.
>
> Das reicht mir schon für die Fehlersuche.
>
> Nur der Vollständigkeitshalber, sorry für die nicht vollständige Infos.
> -die 100R sind zwischen PortPin und dem Taster. Der Taster schaltet
> gegen
>  GND.

dann kannst du sie dir auch sparen. Die 100R beeinflussen nichts am 
Pegel. Er macht einen gewissen Schutz am Pin gegen Programmfehler, indem 
er den Strom begrenzt, wenn der Pin irrtümlich auf Ausgang geschaltet 
wird und der Taster gedrückt wird. Das wars dann aber auch schon.

> -die 10K die am PortPin hängen sind externe Pullup-Widerstände gegen
> VCC.
>  Der Taster ist am PortPin und schaltet gegen GND.

Da siehts anders aus. Dieser Pullup sorgst dafür, dass der Eingang bei 
nicht gedrücktem Taster eine 1 sieht, weil es ja eine (wenn auch über 
die 10k) Verbindung zu Vcc gibt.
Aber: Dasselbe erreichst du auch mit dem internen Pullup.

[Kostas V. (kostas)]

!!! Das war jetzt ein sehr interessanter Hinweis mit dem Schutz des 
PortPins!!!

Ich habe aktuell das Problem dass ich den Zustand der Ausgang-Pins 
abfragen
kann, jedoch die Eingänge nicht. Ich bekomme immer 0 zurück, egal wie
der Eingang ist. Möglicherweise sind die Pins am Mega8 defekt.

Das muss ich mit einem anderen Mega8 mal testen.

Herzlichen Dank und eine schöne Zeit.

Gruß Kostas

[Peter R. (pnu)]

Kostas Victor schrieb:
> Möglicherweise sind die Pins am Mega8 defekt.

glaub ich kaum:

Nach meiner Erfahrung ist ein einzelner Pin des atmega8 gegen 0V oder 
+5V kurzschlussfest, nur wenn viele pins gleichzeitig Kurzschluss haben, 
kanns zur Zerstörung des Kontrollers kommen, aber dann geht auch der 
ganze Kontroller nicht mehr.

Beim Basteln geh ich mit den mega8 recht rabiat um. So gelegentlich hab 
ich schon einen ganzen atmega8 gekillt (meist falschrum an 5V-Quelle)- 
aber teilweise, dh.einzelne Pins zu vernichten, hab ich noch nicht 
geschafft.

Dann mach dich mal schlau über den Unterschied zwischen lesen von pin 
und lesen von port (Tutorial, Datenblatt usw.) In falsch gegebenen 
Befehlen dürfte der Fehler liegen, z.B. zwar in ein Register hineinlesen 
aber dann den gelesenen Wert nicht mehr an eine Anzeige ausgeben. Oder 
Reihenfolge: ausgeben-lesen anstatt lesen-ausgeben.

Das mit den Nullen passiert auch, wenn man nach reset ddrn oder portn 
liest, (die werden bei reset auf Null gestellt).

[Karl H. (kbuchegg)]

Beliebter Fehler ist zb, dass man in der Abfrage des Pins das PORTx 
Register benutzt und nicht das PINx Register.

[Kostas V. (kostas)]

Danke sehr für die Hilfestellung.
Ich verwende den AVRCo Compiler von E-Lab, es ist ein Pascal Compiler.
Daran liegt es sicherlich nicht. Es liegt definitiv an mir. Es liegt 
auch nicht am Board. Das Bord wurde bis jetzt betrieben mit dem Mega8 
dessen
Software in Bascom geschrieben war. Die Ports auslesen hat mit Bascom
einwandfrei funktioniert. Unter AVRCo schaffe ich es nur Ausgänge zu 
lesen.
Die Eingänge werden nicht eingelesen. Egal wie sie stehen, bekomme ich 
immer eine 0.
Es gibt kein spezielles Kommando zum Lesen von Eingängen. Deshalb 
wundert mich das so sehr. Vermutlich ist es nur eine Kleinigkeit die ich 
falsch mache. Ich werde schon noch draufkommen.

Dankeschön nochmals.

Gruß Kostas

[Spess53 (Gast)]

Hi

>Die Eingänge werden nicht eingelesen. Egal wie sie stehen, bekomme ich
>immer eine 0.

Wie hast du es denn gemacht? Aus dem Bauch heraus:

x: Byte;
...

x := PinX;

MfG spess

[Kostas V. (kostas)]

Hi Spess,

So sind die Pins angelegt.

  //Definition der Port Aliase
  Relais1[@PortD,5] : Bit;
  Relais2[@PortD,6] : Bit;
  Relais3[@PortD,7] : Bit;
  Relais4[@PortB,0] : Bit;

  //ACHTUNG RelaisStatus muß negiert werden
  RelaisStatus1[@PortB,4] : Bit;
  RelaisStatus2[@PortB,3] : Bit;
  RelaisStatus3[@PortB,2] : Bit;
  RelaisStatus4[@PortB,1] : Bit;


So werden die Port.Pins initialisiert.
  PortB:= %00111110; 
//Pullupwiderstände aktivieren/deaktivieren
  DDRB:=  %00000001; 
//Ein-/Ausgänge definieren

  PortC:= %01000000; 
//Pullupwiderstände aktivieren/deaktivieren
  DDRC:=  %00000000; 
//Ein-/Ausgänge definieren

  PortD:= %00001100; 
//Pullupwiderstände aktivieren/deaktivieren
  DDRD:=  %11110010; 
//Ein-/Ausgänge definieren


Die Abfrage ist da so:
IntToStr(Ord(Relais1));
Die Antwort ist dann 0 oder 255
Relais1 bis Relais4 sind die Pins um Relais zu schalten.
Dessen Zustand kann auch ohne Probleme richtig gelesen werden.

Versuche ich jedoch ein Relaisstatus abzufragen, kommt immer als 
Ergebnis 0.
IntToStr(Ord(RelaisStatus1));

Die Relais habe zwei getrennte Schaltkreise.
Der erste Schaltkreis ist der Nutzkreis für die Schaltung
und über den zweiten wird der Zustand des Relais abgefragt.
Port PortB.1 wird als gegen GND geschaltet oder hängt an 100R
im nicht geschalteten Zustand.

Ich kann wenn notwendig auch den kompletten Plan veröffentlichen
und das Programm.

Mit AVRCo wird hier vermutlich sich niemand auskennen.

Gruß Kostas

[Spess53 (Gast)]

Hi

>Ich kann wenn notwendig auch den kompletten Plan veröffentlichen
>und das Programm.

Wäre sinnvoll.

>Mit AVRCo wird hier vermutlich sich niemand auskennen.

AVRCo nicht. Aber etwas Erfahrung mit Turbo Pascal und Delphi.

MfG Spess

[Kostas V. (kostas)]

Anbei der Plan und das Programm.

Es geht hauptsächlich um die Procedure GetPumpStatus;

program Test1;

{ $BOOTRST $00C00}         {Reset Jump to $00C00}
{ $NOSHADOW}
{ $WG}                      {global Warnings on}

Device = mega8, VCC = 5;

Define_Fuses
  Override_Fuses;
  NoteBook   = A;
  Supply     = 4.7, 100;
  LockBits0 = [];  //Nie setzen!
  FuseBits0  = [];
  FuseBits1  = [CKOPT,BOOTSZ0,BOOTSZ1];
  ProgMode   = SPI;

Import SysTick, SerPort, ADCPort, SwitchPort1, SysLEDblink, TickTimer;

From System Import LongWord;


Define
  ProcClock      = 14745600;       {Hertz}
  SysTick        = 10;             {msec}
  StackSize      = $0064, iData;
  FrameSize      = $0064, iData;
  SerPort        = 57600, Stop1;    {Baud, StopBits|Parity}
  RxBuffer       = 20, iData;   //Es werden maximal 8 Zeichen erwartet.
  TxBuffer       = 20, iData;
  ADCchans       = 6, iData, Int2;
  ADCpresc       = 128;
  SysLedBlink    = 30;              {SysTicks}
  SysLedBlink0   = PortD, 4, high;
  SwitchPort1    = PinD, $0C;  //D2+D3
  PolarityP1     = $00;            // polarity
  TickTimer      = Timer1, pinout;  // use Timer.COMPA and its PortPin


Implementation

{$IDATA}
{--------------------------------------------------------------}
{ Const Declarations }

const
  MaxRXCount     : byte      = 7;
  Enable         : Boolean   = true;
  Dissable       : Boolean   = false;
  
  {Commandos}
  cmdTemperature    :String  = '10';
  cmdPumpStatus     :String  = '11';
  cmdPumpOn         :String  = '12';
  cmdPumpOff        :String  = '13';
  cmdGetADC         :String  = '14';
  cmdTemperatureRef :String  = '15';
  
  Key_Switch        : byte   = $02;         // switchport1    ~ Key_Switch
  Key_Button        : byte   = $03;         // switchport1    ~ Key_Button
  

{ Var Declarations }
var
  RXTelegramArrayLength      : byte;

  //Definition der Port Aliase
  Relais1[@PortD,5] : Bit;
  Relais2[@PortD,6] : Bit;
  Relais3[@PortD,7] : Bit;
  Relais4[@PortB,0] : Bit;

  //ACHTUNG RelaisStatus muß negiert werden
  RelaisStatus1[@PortB,4] : Bit;
  RelaisStatus2[@PortB,3] : Bit;
  RelaisStatus3[@PortB,2] : Bit;
  RelaisStatus4[@PortB,1] : Bit;

  Taster[@PortD,3] : Bit;
  Schalter[@PortD,2] : Bit;
  


{--------------------------------------------------------------}
{ Type Declarations }

type

  TRXTelegramArray = array[0..MaxRXCount-1] of char;

{$IDATA}
{ Var Declarations }
var
 RXTelegramArray : TRXTelegramArray;
 
 //Temporäre Variablen für die abgerufenen ADC Werte der PT100
 ADC1 : integer;
 ADC2 : integer;
 ADC3 : integer;
 ADC4 : integer;
 ADC5 : integer;
 ADC6 : integer;


{ EEPROM Declarations }
{$EEPROM}


{--------------------------------------------------------------}
{ functions }


{------------------------------------------------------------------------------}
procedure onTickTimer(SaveAllRegs);  // optional Callback
{------------------------------------------------------------------------------}
begin
end;


{------------------------------------------------------------------------------}
procedure InitPorts;
{------------------------------------------------------------------------------}
begin
  PortB:= %00111110;                                          //Pullupwiderstände aktivieren/deaktivieren
  DDRB:=  %00000001;                                           //Ein-/Ausgänge definieren

  PortC:= %01000000;                                          //Pullupwiderstände aktivieren/deaktivieren
  DDRC:=  %00000000;                                           //Ein-/Ausgänge definieren

  PortD:= %00001100;                                          //Pullupwiderstände aktivieren/deaktivieren
  DDRD:=  %11110010;                                           //Ein-/Ausgänge definieren

  
end InitPorts;

{------------------------------------------------------------------------------}
procedure InitPins;
{------------------------------------------------------------------------------}
begin

  SetBit(Relais1,false);
  SetBit(Relais2,false);
  SetBit(Relais3,false);
  SetBit(Relais4,false);
  
//  SetBit(RelaisStatus1,false);
//  SetBit(RelaisStatus2,false);
//  SetBit(RelaisStatus3,false);
//  SetBit(RelaisStatus4,false);

  SetBit(Taster,false);
  SetBit(Schalter,false);

end InitPins;


{------------------------------------------------------------------------------}
procedure InitRXTelegramArray;
{------------------------------------------------------------------------------}
var i:byte;
begin
  for i := 0 to MaxRXCount-1 do
    RXTelegramArray[i] := #0;
  endfor;
  RXTelegramArrayLength := 0;
end InitRXTelegramArray;


{------------------------------------------------------------------------------}
function BitToChar(b:boolean):char;
{------------------------------------------------------------------------------}
begin
 return(char((Byte(b) and 1)+$30));
end BitToChar;

{------------------------------------------------------------------------------}
function CharToByte(c:char):byte;
{------------------------------------------------------------------------------}
begin
 return(Ord(c)-$30);
end CharToByte;

{------------------------------------------------------------------------------}
procedure GetPumpStatus;
{------------------------------------------------------------------------------}
begin
  case RXTelegramArray[2] of
    '1':Write(SerOut, cmdPumpStatus + RXTelegramArray[2] + '-' + IntToStr(Ord(Relais1) ));|   //<<<<<< funktioniert off=0 on=255
    '2':Write(SerOut, cmdPumpStatus + RXTelegramArray[2] + '-' + IntToStr(Ord(RelaisStatus2)) );|  //<<<<<< das funktioniert nicht off=0 on=0
    '3':Write(SerOut, cmdPumpStatus + RXTelegramArray[2] + '-' + BitToChar(RelaisStatus3) );| //<<<<<< funktioniert nicht off=0 on=0
    '4':Write(SerOut, cmdPumpStatus + RXTelegramArray[2] + '-' + BitToChar(RelaisStatus4) );| //<<<<<< funktioniert nicht off=0 on=0
  endcase;

end GetPumpStatus;

{------------------------------------------------------------------------------}
procedure GetTemperature;
{------------------------------------------------------------------------------}
var AdcID:byte;
    AdcValue, temp:word;
    sTemp:String[5];
begin
  AdcID := CharToByte(RXTelegramArray[2]);
  AdcValue := GetAdc(AdcID);
  if (AdcValue > 0)then
    temp := (1000 - AdcValue);
    sTemp := IntToStr(temp DIV 10)+','+IntToStr(temp MOD 10)+'°C';
    Write(SerOut, cmdTemperature + RXTelegramArray[2] + '-' + sTemp);

  else
    Write(SerOut, cmdTemperature + RXTelegramArray[2] + '-' + IntToStr(0));
  endif;
  //....
end GetTemperature;

{------------------------------------------------------------------------------}
procedure SetPump(state:Boolean);
{------------------------------------------------------------------------------}
begin
  case RXTelegramArray[2] of
    '1':SetBit(Relais1,state);|
    '2':SetBit(Relais2,state);|
    '3':SetBit(Relais3,state);|
    '4':SetBit(Relais4,state);|
  endcase;
end SetPump;


{------------------------------------------------------------------------------}
procedure GetADCValue;
{------------------------------------------------------------------------------}
var AdcID:byte;
    s:String[2];
begin
  AdcID := CharToByte(RXTelegramArray[2]);
  Write(SerOut, cmdGetADC + RXTelegramArray[2] + '-' + IntToStr(GetAdc(AdcID)));
end GetADCValue;

procedure SetTemperatureReference;
begin
  //...
end SetTemperatureReference;

{------------------------------------------------------------------------------}
function DoWorkComand:boolean;
{------------------------------------------------------------------------------}
var cmd:string[2];
    bcmd:byte;
begin
  cmd := RXTelegramArray[0] + RXTelegramArray[1];

  bcmd := StrToInt(cmd);
    case bcmd of
      10: GetTemperature;|
      11: GetPumpStatus;|
      12: SetPump(Enable);|
      13: SetPump(Dissable);|
      14: GetADCValue;|
      15: SetTemperatureReference;|
    else
      InitRXTelegramArray;
      Write(SerOut, 'InitRX');
      return(false);
    endcase;
    return(true);
end DoWorkComand;


{------------------------------------------------------------------------------}
procedure ReadComPort;
{------------------------------------------------------------------------------}
{"1510235<13>" längster RX String = 7+<#13> Zeichen}
var RXChar : char;

begin
  if SerStat then
    RXChar := SerInp;
    //Write(SerOut, IntToStr(Ord(RXChar)));
    if (RXChar = #10)then
    elsif (RXChar = #13)then
      {Command komplett jetzt verarbeiten}
      DoWorkComand;
      InitRXTelegramArray;
      return;
    elsif (RXTelegramArrayLength <= MaxRXCount)then
      inc(RXTelegramArrayLength);
      RXTelegramArray[RXTelegramArrayLength - 1] := RXChar;
      return;
    endif;
  endif;
end ReadComPort;



{--------------------------------------------------------------}
{ Main Program }
{$IDATA}

      begin
        InitPorts;


        EnableInts;
        InitPins;
        InitRXTelegramArray;
        SWITCHPORT1_CLEAR;
        Write(SerOut, 'Start V3');

        loop


          ReadComPort;

(*          if Inp_Raise1(Key_Button)    Funtioniert auch nicht
          then
            SysLedFlashOn(0);
            Write(SerOut, '-KB');

          endif;

          if INP_RAISE1(Key_Switch)
          then
            Write(SerOut, '-KS');
          endif;
  *)

        endloop;
      end Test1.

[Spess53 (Gast)]

HI

>  RelaisStatus1[@PortB,4] : Bit;

Das Eingangsregister eines Ports heißt PinX und nicht PortX.

MfG Spess

[Kostas V. (kostas)]

Spess, du hast dir einen Orden verdient.
Genau das war der Fehler. Ich wusste es einfach nicht und somit ist mir 
das
auch nicht aufgefallen. In dem Thread wurde das schon mehrfach erwähnt.
Jetzt funktionieren plötzlich auch die Tasten, so was aber auch.

Tausend Dank für die großartige Hilfe.
Gruß Kostas

[Spess53 (Gast)]

Hi

>Ich wusste es einfach nicht und somit ist mir das auch nicht aufgefallen.

Auch Hochsprachen entbinden dich nicht vom Lesen des Datenblatts.

MfG Spess

[Kostas V. (kostas)]

Du hast vollkommen Recht.
Wahrscheinlich hätte ich das nicht herausgelesen da ich nicht damit 
gerechnet habe dass die Zugriffsmethode von einem Port.Pin sich 
unterscheidet in Abhängigkeit ob es als Eingang oder Ausgang 
initialisiert wurde. Sachlich sehe ich immer noch den gleichen Pin. 
Eigentlich wäre das
die Aufgabe der Hochsprache das zu portieren.
Sicherlich hat das irgendwelche Hintergründe warum das nicht gemacht 
wurde.
Es ist schon völlig in Ordnung so wie es ist. Ich verbuche das sehr 
gerne auf "Nach drei Tagen grübeln, doch noch etwas dazugelernt ;-)"

Dir noch eine schöne Zeit.

Gruß Kostas

[Spess53 (Gast)]

Hi

>Eigentlich wäre das die Aufgabe der Hochsprache das zu portieren.

Wie sollte das machbar sein? Wenn du das Port-Register liest kann für 
einen Pin eine 1 bedeuten das das Pin H ist wenn der Pin Ausgang ist, 
oder das der interne Pull-Up-Widerstand eingeschaltet ist, wenn der Pin 
Ausgang ist.

Ich kenne keine Hochsprache, in der eine Glaskugel integriert ist.

MfG Spess

[Kostas V. (kostas)]

Wir haben uns Missverstanden.
Ich meinte das lesen und schreibe sollte über die gleiche Methode gehen
z.B.: A.1 soll ein Zeiger auf den Pin selbst sein. Je nach dem wie der
Port.Pin initialisiert ist sollte die Hochsprache das trennen:

Ich schreibe also:
LED[@A,1] : Bit;
Taster[@A,2] : Bit;

Die Hochsprache macht intern:
LED[@PortA,1] : Bit;
Taster[@PinA,2] : Bit;

Dafür muss er nur vorher überprüfen ob der Port.Pin als Eingang oder 
Ausgang definiert wurde.

Gruß Kostas

[Spess53 (Gast)]

Hi

>Dafür muss er nur vorher überprüfen ob der Port.Pin als Eingang oder
>Ausgang definiert wurde.

So etwas kostet aber Code und Zeit. Und beides kann auf µCs knapp sein. 
Das sind keine PCs.

MfG Spess

[ich (Gast)]

Vielleicht liegt hier ein kleines Mißverständnis vor.
PORT und PIN sind im Prozessor selbst zwei verschiedene Register, die 
auch zwei verschiedene Aufgaben haben. Es ist zwar das gleiche Beinchen, 
was aus dem Prozessor rauskommt, aber intern ist für die Ausgabe das 
PORT-Register verdrahtet und für das Einlesen das PIN-Register.
Du kannst das PORT-Register auch auslesen, aber da erfährst du nur, ob 
die letzte Schreib-Operation auf das PORT-Register eine 1 oder 0 war. Du 
erfährst nicht, wenn das ein Eingang ist, ob dort von außen 1 oder 0 
anliegt.

[Kostas V. (kostas)]

Nein der Compiler sollte das machen und den passenden Assembler code
erstellen. Auf µC Ebene darf das natürlich nicht passieren.

Aber wie gesagt, ich bin völlig einverstanden damit so wie es ist.
Ich kann damit Super umgehen. Das werde ich sicherlich nie wieder 
vergessen. :-)

[Kostas V. (kostas)]

Hallo Gast,

wie gesagt, es gibt sicherlich Gründe warum das so ist. So wie du es
beschreibst ist das sicherlich ein triftiger Grund und somit ist
das völlig in Ordnung. Ich kritisiere das auch in keinster Weise.
Es war für mich massiv Lehrreich die Unterhaltung. Und mein Projekt
funktioniert in diesem Bereich jetzt einwandfrei. Nun kann ich mich
an den Rest ran machen. Bis ich wieder auf das nächste Problem stoße.
Aber in diesem Bereich ist ja ein Ende faktisch nie erreicht. Das macht
es ja so unglaublich interessant.

Gruß Kostas

[Amateur (Gast)]

>Nein der Compiler sollte das machen und den passenden Assembler code

Das dürfte wohl nicht möglich sein. Während des Codens und Hackens 
gibt’s den Prozessor bzw. Port gar nicht. Und während der Laufzeit - ich 
wäre echt sauer, wenn der Compiler von sich aus Testcode einfügen würde 
um festzustellen, ob dass, was ich mache auch OK ist.
Sollte - warum und wann auch immer - der Anschluss seine Richtung ändern 
stürzt der Rechner ab ;-)

Da machen sich die Jungens von Atmel 'nen Haufen Arbeit mit Ihren 
Manuals, incl. der Beispiele, und keiner liest sie.

[Kostas V. (kostas)]

Sorry, so ist es nun wirklich nicht, dass niemand die Manuals liest.
Wenn ich dir eine Doku gebe von irgendein Bauteil mit mehreren Duzend
Seiten, wirst du sicherlich auch nicht alles verstehen, selbst wenn du 
das
Manual zehn Mal durchliest, und schon gar nicht wenn du instinktiv eine
andere Erwartungshaltung hast. Das ist doch völlig normal. Für jemand
der das permanent macht ist das sicherlich selbstverständlich. Wenn dass
alles auch für mich so selbstverständlich wäre wie für Euch, dann 
müsstet
ihr lauter Deppen sein. Ich beschäftige mich beruflich mit Entwicklung
von Bausoftware. In diesem Bereich bin ich wahrscheinlich der Experte. 
Da gibt es Begriffe die du auch sicherlich nie gehört hast.

Sorry nochmals für meine Unwissenheit. Der einzige Trost für mich ist
mein Sprichwort: "Völlig Egal wie viel jemand an Wissen sich angeeignet 
hat, es gibt immer jemand der mehr Wissen hat, ebenso jemand mit weniger 
Wissen."

Dir noch eine schöne Zeit.
Gruß Kostas