Befehl: Eingang prüfen (ATtiny13)

[runner02]

Hallo Leute,

Bin jetzt soweit, dass ich Ausgänge am ATtiny beschalte.

Nun würde ich gerne mithilfe von Tastern die Leds blinken lassen...

Jedoch funktioniert noch kein einziger meiner Codes...
Man sieht immer wieder 'PINB (1<<PB7)' und ähnliches, aber es funktioniert einfach nicht...

(Was << hier bedeuten soll findet man auch nirgends klar eklärt...)

Oder kann es an der Schatung liegen?

Ich aktiviere zuerst mittels DDRB=00000011 und nehme dann z.B. port-b3, (wegen 0 ist er ja Eingang)

Dann... Muss ich einen pull-up einschalten?
Das wäre dann PORTB=0000100 (Aber würde ich damit nicht wieder die Ausgänge umschalten -> von High auf Low?)

Und schlussendlich das mit (1<<PB3)

[Hubert.G]

Taster vom Pin nach GND, PullUp aktivieren.
if PINB(!(1<<PB3)){
PORTB|=(1<<PB0)
}
Wenn nicht gedrückt dann wieder ausschalten.
mit PORTB=0000100 schaltest du den PullUp an PB2 ein.

[BurningWave]

DDRX sind Data Direction Register, sie geben an, ob eine Pin als Eingang oder als Ausgang dient. Wenn z.B. mit DDRB = 0x03; (0x03 = 3 = 0b00000011) oder mit DDRB |= (1 << PB0) | (1 << PB1); PB0 und PB1 im Data Direction Register gesetzt hat, gibt man damit an, dass man diese 2 Pins als Ausgang verwenden möchte. (<< und >> sind Schiebeoperatoren, sie schieben ein Bit um x Stellen nach rechts, bzw. nach links).
Möchtest du überprüfen, ob eine als Eingang verwendete Pin HIGH oder LOW ist kannst du das mit z.B. if(PINB & (1 << PB3)) machen.
Wichtig: Wenn du eine Taste an einem Eingang benutzt, brauchst du immer einen PullUp-Widerstand, der die Pin bei nicht gedrückter Taste auf + zieht (ich gehe davon aus, dass deine Taste die Pin auf Masse zieht). Du kannst das entweder mit einem externen Widerstand machen oder intern, indem du das entsprechende Bit für die Pin im Datenausgangsregister PORTX setzt.

mfg

[runner02]

Danke, werde ich gleich mal probieren und bei evt auftretenden Fragen wieder posten...

[runner02]

PORTB|=(1<<PB0)
Was bedeutet das?
Das selbe wie

PORTB=0000100 ?


Es geht noch immer nicht... Leider...




___
Ich glaube hierbei liegt der Fehler

Taster vom Pin nach GND, PullUp aktivieren.
if PINB(!(1<<PB3)){
PORTB|=(1<<PB0)
}
Wenn nicht gedrückt dann wieder ausschalten.
mit PORTB=0000100 schaltest du den PullUp an PB2 ein.

PORTB|=(1<<PB0) habe ich weggelassen, weil ich es nicht verstehe...

[Hubert.G]

PORTB|=(1<<PB0) schaltet PB0 auf high.
PORTB&=~(1<<PB0) schaltet PB0 wieder auf low.
Also kannst du das nicht weglassen.
Wo hast du denn jetzt genau die Tasten und Led angeschalten.

[runner02]

Hier der Code:



main () // Hauptprogramm, startet bei Power ON und Reset
{
DDRB=7;
PORTB=16;
if(PINB & (1<<PINB3))
{

// Schleifenanfang Mainloop
PORTB=17;
waitMs(500);
PORTB=19;
waitMs(250);
PORTB=18;
waitMs(250);
PORTB=17;
waitMs(100);
PORTB=16;
waitMs(1000); // Quellcode
}
while (true); // Schleifenende Mainloop



PORTB|=(1<<PB0) schaltet PB0 auf high.
Diese Schreibweise verstehe ich leider nicht... heißt | nicht eigentlich 'nicht' (so wie '!') ?

Ich rechne mit 2-er Potenzen PORTB(=00000001)=1

[021aet04]

Das | bedeutet log. Funktion OR (Oder)
Das & bedeutet log. Funktion AND (Und)
Das ! bedeutet log. Funktion NOT (Nicht)

http://de.wikipedia.org/wiki/Logischer_Operator

MfG Hannes

[Hubert.G]

Dein Programm wird genau einmal durchlaufen und daher nicht funktionieren.
Es fehlt die Endlosschleife.
Deine Schreibweise ist unübersichtlich, es wird sich niemand die Mühe machen aus den Zahlen zu eruieren welche Pin gemeint sind.
Das | ist ein oder.

[runner02]

Ich sreche immer nur Pin B0 und Pin B1 als Ausgang an.

Dazu kommt Pin B3 MIt dem Wert 2^4=16


@021aet04
Warum hier ein Oder?
Für mich macht das logisch keinen Sinn... Bin aber auch noch Anfänger in dem Gebiet...

[BurningWave]

Generell schreibt man Zuweisungen wie PORTB = 9 so:
PORTB = 0b00001001 (binär wenn man keine Lust hat es in Hex umzurechnen, was aber besser wäre) oder PORTB=0x09 (so ist es am übersichtlichsten, da die erste Stelle das High-Byte und die 2. das Low-Byte angibt (z.B. 0xf0 = 0b11110000) und man sofort sehen kann, was gemeint ist.

[BurningWave]

PORTB |= (1 << PB1) bedeutet PORTB = PORTB | (1 << PB1), PB1 ist als 1 definiert, also wird daraus PORTB = PORTB | (1 << 1), was man zu PORTB = PORTB | 0b10 auflösen kann. Jetzt wird PORTB der Wert von sich selber und 0b10 mit einem Oder-Operator verknüpft, zugewiesen.
Wenn PORTB z.B. 0b11010001 ist, enststeht daraus 0b11010001 | 0b00000010 = 0b11010011 (da 0 | 1 = 1). Also wird das Bit gesetzt.

[runner02]

Sry, aber ich brauch es etwas langsamer...


PORTB |= (1 << PB1)

...ist die Kurzschreibweise für
PORTB = PORTB | (1 << PB1)

soweit richtig?



Wenn ja,

also wird daraus PORTB = PORTB | (1 << 1) im Maschinencode?

Und wieso ist auf einmal beim 2ten einser das PB weg?

[Hubert.G]

Pin B3 hat aber den Wert 8 und nicht 16
Ändert aber nichts an der fehlenden Schleife.

[runner02]

''while (true)''
ist für mich ja schon die Schleife, zumindest mit den Blink-Leds hats funktioniert mit do...while

@_R2D2
Dass das hexa-Darstellung wäre wäre ich nie draufgekommen ....
Für mich war das unverständliches zeugs mit 0x0f ... Jetzt machts Sinn, danke vielmals :idea:



Hey ich glaube ich habs halbwegs verstanden... Das Oder fügt hier das Bit ein, ohne die anderen Bits (Ports) zu verstellen ...?

[BurningWave]

Hey ich glaube ich habs halbwegs verstanden... Das Oder fügt hier das Bit ein, ohne die anderen Bits (Ports) zu verstellen ...?

Genau so ist es, mit einem einfachen = würdest du alles überschreiben und mit | kannst du alle Bits einzeln setzen ohne di anderen zu verändern.

Mit PORTB &= ~(1 << PB1); könntest du dieses Bit wieder löschen.

[runner02]

Mit PORTB &= ~(1 << PB1); könntest du dieses Bit wieder löschen.
Wieso kann ich nicht einfach PORTB=PORTB|(0<<PB) setzen??

Heißt 0 und 1, dass auf jeden Fall eine Eins draus wird??



PORTB &= ~(1 << PB1);
Ist doch wieder so eine Abkürzung, oder?

Wie heißt das für mich Laien? PORTB = PORTB & !(1<<PB1) ??
(Könnte ich um eine deutsche Erläuterung bitten?)


dann noch ne kleine Frage:

in C muss ich auch bei if == setzen (?)

Ergo: if PORTB==PORTB|(1<<PB1) wenn ich das so wörtlich eingebe, müsste es klappen?

[BurningWave]

Wieso kann ich nicht einfach PORTB=PORTB|(0<<PB) setzen??

Das wird nie funktionieren wenn du ein Bit setzen willst, weil 0 ODER 0 nie 1 geben wird.



Wie heißt das für mich Laien? PORTB = PORTB & !(1<<PB1) ??

So ungefähr, nur dass ! ein einzelnes Bit negiert (also aus 0 wird 1 und umgekehrt) und ~ das gleiche aber für ein ganzes Byte macht (das nennt man komplementieren). Also heißt es PORTB = PORTB & ~(1 << PB1);
Man benutzt aber die andere Schreibweise, weil sie eben kürzer ist.



in C muss ich auch bei if == setzen (?)

Ergo: if PORTB==PORTB|(1<<PB1) wenn ich das so wörtlich eingebe, müsste es klappen?

Das müsste gehen, wenn du Klammern darum machst und statt PORTB PINB benutzt (PINB ist für den Eingang). (Ja = ist ein Zuweisungsoperator und == ist der Vergleichsoperator.)

Besser ist aber:
if(PINB & (1 << PB1))

[runner02]

main () // Hauptprogramm, startet bei Power ON und Reset
{
DDRB=3; // 2 Ausgänge definieren
PORTB=0b00001000; // Pull-up Widerstand an PB4 auf ein

if (PINB==PINB|(1<<PB3)) // <- irgendwie agiert die Funktion so, als ob es hieße, if (true)

{
PORTB=PORTB|(1<<PB0);
waitMs(500);
PORTB=16;
waitMs(500);
PORTB=PORTB|(1<<PB0);
waitMs(120);
PORTB=16;
waitMs(120);


} while (true);
}




Aber wieder der gleiche Fehler. Sobald Strom durch den Chip rinnt, läuft das Programm ab.

Der Taster agiert so, als ob er gar nicht da wäre...

[BurningWave]

Du hast Klammern vergessen:
if (PINB==(PINB|(1<<PB3)))
{
...
}

Außerdem bringt die while da unten gar nichts, das Program läuft so nur einmal durch.

Wenn das nicht funktioniert, habe ich einen Denkfehler gemacht, dann musst du doch if(PINB & (1 << PB1)) nehmen.

[runner02]

Außerdem bringt die while da unten gar nichts, das Program läuft so nur einmal durch.
Ich habe ein do...while daraus gemacht, dann ging es in schleife.... Brachte aber nix, weil es mir um den Taster geht


if(PINB & (1 << PB1)) Habe ich jetzt auch probiert, es funktioniert einfach nichts...

Habe es in das oben gepostete Programm eingeschrieben,
nix passiert.... Wie immer...



Also
main () // Hauptprogramm, startet bei Power ON und Reset
{
DDRB=3; // 2 Ausgänge definieren
PORTB=0b00001000; // Pull-up Widerstand an PB4 auf ein

if (PINB&(1<<PB3)) // <- irgendwie agiert die Funktion so, als ob es hieße, if (true)

{
PORTB=PORTB|(1<<PB0);
waitMs(500);
....

[BurningWave]

Zieht dein Taster die Pin auf Masse? Wenn nicht, ist es klar, dass nichts passiert. Überprüfe das mal.

[runner02]

Pin geht auf den Minuspol der Batterie, also Masse (= GND).

[BurningWave]

Also ich mache das in meinen Programmen auch so:

Erst mal Pullup einstellen: z.B. PORTC |= (1 << PC4);
Dann abfragen mit: if(!(PINC & (1 << PC4)))

Mach auch mal ein Ausrufezeichen davor.

[runner02]

Irgendwie geht es trotzdem nicht...

Kann das daran liegen, dass ich nur 3,6 V (eventuell sogar schon deutlich weniger) verwende, und dass diese den Pull-up nicht überwinden können?

[BurningWave]

Kann das daran liegen, dass ich nur 3,6 V (eventuell sogar schon deutlich weniger) verwende, und dass diese den Pull-up nicht überwinden können?

Ich glaube nicht, dass es daran liegt, entweder der µC läuft nicht oder er läuft. Du kannst aber zur Sicherheit mal 4.5V nehmen (also 3 AA-Baterien).

Poste mal den ganzen Quellcode.

[runner02]

main ()

{
DDRB=00000011;
PORTB = PORTB|(1 << PB3);

if(!(PINB & (1 << PB3)))


do
{
PORTB=PORTB|(1<<PB0);
waitMs(500);
PORTB=0b00001000;

}
while (true);


Eine Blockbatterie muss ich mir erst besorgen, könnte vorerst aber auch einfach eine dritte 1,5 Voltbatterie dazuschließen

[BurningWave]

Ein Wunder, dass es sich überhaupt compilieren lässt, was soll denn die if bewirken? Es fehlt doch noch ein {} Block, damit man eine bedingte Anweisung hat. Außerdem, es fehlt eine abschließende } und was gibt main() zurück? Wenn nichts, dann muss man trotzdem void dazu schreiben.

Probiere mal das:

void main ()
{
DDRB=0b00000011; //0b weil es eine Binärzahl ist. besser wäre DDRB = 0x03;
PORTB = 0x08; //Pullup aktivieren (PB3)

while(true)
{
if(!(PINB & (1 << PB3)))
{
PORTB=PORTB|(1<<PB0); //PB0 setzen, besser wäre PORTB |= (1 << PB0);
waitMs(500);
PORTB=0b00001000; //PB0 löschen, besser wäre PORTB &= ~(1 << PB0);
}
}
}

[runner02]

Respekt!!

Ich weiß zwar nicht wie, aber es klappt...


Es fehlt doch noch ein {} Block, damit man eine bedingte Anweisung hat.

Zuerst das while (true) { ...} ?? Kann man damit die Schleife unterbrechen, oder warum gehört das so?

Darin das if?


Warum das Rufzeichen (Negation)? Kann man stattdessen nicht ein Oder nehmen? Werde das gleich mal probieren...



PS: void main ging nicht, er schrieb irgendwas von 'integer benötigt'. Habe das void weggelassen und es ging...
Ach ja, und die 500 ms klommen mir vor wie 2sek, aber das ist erstmal nebensächlich...
Mfg

[BurningWave]

Zuerst das while (true) { ...} ?? Kann man damit die Schleife unterbrechen, oder warum gehört das so?

while(true) {...} ist eine Endlosschleife, alles was im {...}-Block ist, wird endlos wiederholt. Wenn der Ausdruck in den normalen Klammern (Abbruchbedingung) false ist wird die Schleife abgebrochen (was bei true natürlich nie der Fall sein wird).

if(...) {...} funktioniert praktisch genau gleich, wenn der Ausdruck in den normalen Klammern true ergibt, wird alles was zwischen den geschweiften Klammern steht ausgeführt.



Warum das Rufzeichen (Negation)? Kann man stattdessen nicht ein Oder nehmen? Werde das gleich mal probieren...

Wenn du das ! weglässt, ist das mit der Taste genau umgekehrt, alles was im if-Block steht, wird ausgeführt, wenn sie nicht gedrückt ist. Also negiert man den Ausdruck, um den Block nur auszuführen, wen die Taste gedrückt ist. Nein man kann hier kein Oder nehmen...



void main ging nicht, er schrieb irgendwas von 'integer benötigt'. Habe das void weggelassen und es ging...

Was für einen Compiler benutzt du, eigentlich muss void gehen, sonst kannst du int main() schreiben und dann musst du vor die letzte geschweifte Klammer noch return 0; schreiben (dadurch gibt die Funktion eine Integer Null zurück, was soviel bedeutet, wie alles fehlerfrei ausgeführt (obwohl die Stelle durch die Endlosschleife nie erreicht wird). nur main() ist auf jeden Fall ein ganz schlechter Programmierstil (selbst wenn es geht).



Ach ja, und die 500 ms klommen mir vor wie 2sek, aber das ist erstmal nebensächlich...

Das liegt wahrscheinlich daran, dass dein Programm die Frequenz, mit der der µC läuft nicht kennt, binde mal util\delay.h ein (#include <util\delay.h> in die erste Zeile schreiben). In der nächsten Zeile definierst du dann F_CPU mit dem Takt deines µCs (bei 4MHz schreibst du z.B. #define F_CPU 4000000UL).
Jetzt kannst du statt WaitMs() die Funktion _delay_ms(x) benutzen (x steht für dei Anzahl ms, die gewartet werden soll). Das müsste eigentlich funktionieren.

mfg

[021aet04]

Eventuell musst du auch "int main(void)" schreiben.

MfG Hannes

[runner02]

Das liegt wahrscheinlich daran, dass dein Programm die Frequenz, mit der der µC läuft nicht kennt, binde mal util\delay.h ein (#include <util\delay.h> in die erste Zeile schreiben). In der nächsten Zeile definierst du dann F_CPU mit dem Takt deines µCs (bei 4MHz schreibst du z.B. #define F_CPU 4000000UL).
Jetzt kannst du statt WaitMs() die Funktion _delay_ms(x) benutzen (x steht für dei Anzahl ms, die gewartet werden soll). Das müsste eigentlich funktionieren.


Das muss ich mal probieren, aber zuerst versuche ich noch genau zu verstehen, wie die Codes arbeiten....

Z.B. if(!(PINB&(1<<PB3)))
Also hier liest er PB aus. Dann hat er 00000000. Dann rechnet er mit &, das sollte 00001000 ergeben. ! hieße dann, 11110111 ????

[BurningWave]

Also hier liest er PB aus. Dann hat er 00000000. Dann rechnet er mit &, das sollte 00001000 ergeben. ! hieße dann, 11110111

Nehemen wir an PORTB ist 0xff (0b11111111) also wir haben 8 Eingänge (alle Pins dieses Ports werden mit einem Pullup auf High (+ Pol) gezogen, PINB ist deshalb auch 0xff). Die an den Pins angeschlossenen Tasten ziehen die jeweilige Pin auf Masse, das zugehörige Bit in PINB wird dadurch 0. (In diesem Beispiel ist eine Taste an Pin 3 angeschlossen, also ist, wenn sie gedrückt ist, PINB 0b11110111 = 0xf7)
Mit if(!(PINB&(1<<PB3))) fragen wir jetzt nur PB3 in PINB ab und negieren das Ergebnis, da PB3 ja 0 ist, wenn die Taste gedrückt ist und die bedingte Anweisung ja nur ausgeführt wird, wenn der Ausdruck in den Klammern true ist.
if(!(PINB&(1<<PB3))) würde heißen: if(!(0b11110111 & (1 << 3))), also if(!(0b11110111 & 0b00001000)), 0b11110111 & 0b00001000 gibt 0 und !0 gibt 1, so kann man also feststellen, ob die Taste gedrückt ist.

[runner02]

Ich sehe schon, ich muss die Operationen lernen...
| & ~

Hättest du dazu einen verständlichen Link, wo alles langsam erklärt wird??

Die Woche ist gerade ziemlich Stressig im Schulalltag, danach möchte ich mich damit befassen, mit dem pic Ströme zu Messen (für Temperatursensor, etc...)

[BurningWave]

http://www.stud.uni-stuttgart.de/studweb/users/etk/etk39219/avrc/index.htm

http://winavr.scienceprog.com/short-introduction-to-c/c-language-operators-and-expressions.html



mit dem pic Ströme zu Messen

Dachte du benutzt einen AVR µC?

[runner02]

Dachte du benutzt einen AVR µC?
Ja, Attiny 13...

Kann man mit dem keinen Temperatorsensor bauen?

[BurningWave]

Kann man mit dem keinen Temperatorsensor bauen?

Warum nicht? Es geht schon, ein größerer µC wäre aber in vielerlei Hinsicht (z.B. mehr Speicher, mehr Pins, mehr Funktionen,...) besser. Ich würde einen Mega8 nehmen.

[runner02]

Ich würde einen Mega8 nehmen.

Da habe ich gerade keinen zur Hand, und solange es halbwegs geht, möchte ich einen Pic mit wenig Ausgängen nutzen...

Das macht das ganze weniger kompliziert, oder?

Speicher dürfte bei meinen Mikro-Programmen kein Thema sein, denke ich mal (?)


mehr Funktionen
Naja, input output, einfache operationen und spannung auslesen... mehr brauche ich für den Anfang noch nicht.... denke ich zumindest....

Meine Zeit ist momentan relativ begrenzt (Abi), daher möchte ich simpel und effektiv arbeiten O:)

[BurningWave]

möchte ich einen Pic mit wenig Ausgängen nutzen...

Ich glaube du missverstehst das Wort Pic: Mit Pic sind die PIC-Microcontroller von Microchip gemeint. ATMEL AVR Microcontroller kann man einfach AVR nennen.



Das macht das ganze weniger kompliziert, oder?

Nicht unbedint, nicht verwendete Pins benutzt du einfach nicht. Und wenn das Programm dann doch nicht auf den Speicher passt, dann musst du dir doch einen neuen kaufen und alles noch mal bauen.

[runner02]

Achso, eine andere Firma...

Naja... Damit ich mal das Prinzip verstehe:
Wie kann man die Spannung, die an einem PIN anliegt, auslesen?
Gibt es dafür einen Befehl bzw. Gruppe von Befehlen?

[BurningWave]

Wie kann man die Spannung, die an einem PIN anliegt, auslesen?
Gibt es dafür einen Befehl bzw. Gruppe von Befehlen?


Einfach die Spannung, die an einer normalen Pin anliegt auslesen geht nicht. Dazu musst du den Analog/Digital-Wandler benutzen (siehe: http://www.rn-wissen.de/index.php/ADC_(Avr) ). Da die ganz kleinen AVRs nur sehr wenige (wenn überhaupt) Pins haben, die man analog auslesen kann, habe ich dir empfohlen, einen größeren AVR zu nehmen.

[runner02]

Laut Datasheet verfügt er über 4 ADCs... Dürfte also kein Problem sein...

angenommen ich nehme so einen Widerstand, der mit der Temperatur mehr Widerstand hat... Wie beschalte ich ihn, bzw. lese ich ihn dann aus?

[BurningWave]

Dieser Widerstand heißt NTC-Widerstand, einfach das eine Ende an eine ADC-Pin anschließen, das andere an Masse und dann noch AVCC beschalten und wie es angesteuert wird kannst du bei diesem Lnk nachlesen.

[runner02]

Ok, danke

Das Anschließen scheint ja ziemlich einfach...


Aber auf der Seite steht ziemlich viel Quellcode, den ich kaum verstehe...


#include <avr/io.h>
#include <inttypes.h>

uint16_t readADC(uint8_t channel) {
uint8_t i;
uint16_t result = 0;

// Den ADC aktivieren und Teilungsfaktor auf 64 stellen
ADCSRA = (1<<ADEN) | (1<<ADPS2) | (1<<ADPS1);

// Kanal des Multiplexers waehlen
// Interne Referenzspannung verwenden (also 2,56 V)
ADMUX = channel | (1<<REFS1) | (1<<REFS0);

// Den ADC initialisieren und einen sog. Dummyreadout machen
ADCSRA |= (1<<ADSC);
while(ADCSRA & (1<<ADSC));

// Jetzt 3x die analoge Spannung and Kanal channel auslesen
// und dann Durchschnittswert ausrechnen.
for(i=0; i<3; i++) {
// Eine Wandlung
ADCSRA |= (1<<ADSC);
// Auf Ergebnis warten...
while(ADCSRA & (1<<ADSC));

result += ADCW;
}

// ADC wieder deaktivieren
ADCSRA &= ~(1<<ADEN);

result /= 3;

return result;
}

int main(void) {
uint16_t result = readADC(0); //Auslesen der analogen Spannungen an Pin 0,
// also ADC0. In result steht das Ergebnis.
return 0;
}

[BurningWave]

Aber auf der Seite steht ziemlich viel Quellcode, den ich kaum verstehe...

War das eine Frage? Ich würde dir raten, dich erst einmal mit einfacheren Dingen wie den grundlegenden Befehlen und dem Aufbau eines AVRs zu beschäftigen, um den Code zu verstehen. Ansonsten findest du im Internet genug Informationen.

[runner02]

Ok, danke, werde mich mal nach leichteren (grundlegenderen) Programmen umschauen...

Auf jeden Fall danke für die Hilfe bis hierher...

Mfg

[runner02]

Hätte ne Frage:

Wenn ich zwischen Eingangspin und +Pol einen temperaturabhängigen Widerstand hänge, soll der Chip doch die Spannung auslesen, dadurch kann man die Temperatur ermitteln....

Wenn ich das jetzt aber mit dem Ohmschen Gesetz berachte, komme ich zu dem Schluss, dass die Spannung vor und hinter dem Widerstand gleich hoch ist, nur die Stromstärke variiert....

[BurningWave]

Nein die Stromstärke bleibt gleich, am Widerstand fällt jedoch um so mehr Spannung ab, um so größer er ist.

Aber man kann -wie gesagt- diese Spannung nur mit dem A/D-Wandler und einer entsprechenden ADCx-Pin auslesen.

[runner02]

Da dreht sich mein Kopf irgendwie im Kreis....

Angenommen ich habe 5V und 30 Ohm... Dann sollte doch hinter dem Widerstand ein Strom von 0,166 Ampere fließen...

0,166 Ampere mal 30 Ohm ist aber wieder 5 V.... Oder muss ich dann mit den Ohm der Leitung rechnen??

[BurningWave]

Du hast die Formel U=R*I. Wenn du die Spannung, die am Pin anliegt ausrechnen willst, machst du das mit dieser Formel (dazu musst du die Stromstärke messen und NICHT ausrechnen).