spannung einlesen auf led-reihe ausgeben

Wo hängst? Am ADC? An der Hardware? Am Compiler? An der Ausgabe?

Wo ist das Problem? Du hängst deine Spannungsquelle (solange sie kleiner
als Vref ist) einfach an den ADC-Eingang. Wenn sie grösser ist als Vref
setzt du noch einen Spannungsteiler davor.

Also um rauszubekommen, an welchem Ports ADCs hängen, solltest du
vielleicht mal ins Datenblatt schauen! Würde mich übrigens mal
interessieren, wo du an einem ATMega16 einen PORTF findest.

Keine Ahnung, was für ein Datenblatt du hast, aber bestimmt nicht das
des ATMega16. Der hat nämlich keinen PORTF.

http://www.atmel.com/dyn/resources/prod_documents/2466S.pdf
http://www.atmel.com/dyn/resources/prod_documents/doc2466.pdf

Lustig:
Gerade gestern Abend hab ich genau diese Aufgabenstellung
als Spielerei spät nachts noch ausprobiert.

Anbei das C-Programm für WinAvr.

Ganz ehrlich:
Schnapp die das Datenblatt, da stehen alle Register samt
Bitbelegung drinnen. Dann schaust du nach welche Bits ich
gesetzt habe und vergleichst im Datenblatt was die bewirken.
Genauso funktioniert eine wichtige Übung im Leben eines
Programmierers: Studium von fremden Code.

Der Rest ist ganz einfach die Umrechnung
von 0 .. 1024 (die Werte krieg ich vom ADC)
in den Wertebereich 0 .. 8. 0 bis 8 deswegen
weil ich damit das Leds Array indiziere in dem
das auszugebende Bitmuster drinnensteht.

Ich koennte das ganz einfach machen indem
ich den Wert durch 128 ( = 1024 / 8 ) teile
und in der Urversion war das auch tatsächlich so.
Aber dann hab ich die Arraygröße verändert und war
zu faul immer wieder im Taschenrechner auszurechnen
wodurch ich dividieren muss. Also hab ich das so
umformuliert, dass der Compiler die Berechnung macht.

Hinweis: sizeof liefert die Größe in Bytes des angegebenen
Ausdrucks.
Fuer ein Array
  Datentyp Array[ irgendwas ];

liefert der Ausdruck

  sizeof( Array ) / sizeof( Array[0] )

daher die Anzahl Elemente, irgendwas.

Was ist so toll daran? Wenn ich das Array sowieso
dimensioniere, dann weiss ich doch wie gross es ist.

  #define NR_ENTRIES 8
  unsigned char Leds[ NR_ENTRIES ];

In dem Fall wäre das tatsächlich Overkill. ABer den Fall hab
ich ja nicht. Ich dimensioniere das Array implizit, indem
ich die darin zu speichernden Werte angebe:

  unsigned char Leds[] = { ...... };

Der Compiler zählt die Initialisierungen und macht das Array
genau so gross, dass alles reinpasst. Nur weiss ich halt
nicht wieviele Eintraege das sind. Macht aber nichts, denn
   sizeof( Leds ) / sizeof( Leds[0] )

(Also: Gesammtgröße des Arrays in Bytes durch Größe des ersten
 Eintrags in Bytes)
liefert mir diese Anzahl wieder.

Sinn der Sache: Ich kann die Mustertabelle beliebig erweitern, indem
ich einfach nur neue Werte in die Initialisierungsliste schreibe.
Alles andere passt sich automatisch an.

Verusch zb. mal:

unsigned char Leds[] =
  { 0b11111110,
    0b11111100,
    0b11111000,
    0b11110000,
    0b11100000,
    0b11000000,
    0b10000000,
    0b00000000,
    0b00000001,
    0b00000011,
    0b00000111,
    0b00001111,
    0b00011111,
    0b00111111,
    0b01111111,
    0b11111111,
 };

Hier hat die Tabelle 16 Eintraege. Du brauchst sonst
nichts verändern. Alle notwendigen Konstanten und
Umrechnungen berechnet der Compiler für Dich.

> von 0 .. 1024 (die Werte krieg ich vom ADC)
> in den Wertebereich 0 .. 8.

vom ADC kommt natuerlich nur 0 .. 1023
und die Array Indizierung läuft von 0 bis 7

Sorry. War mit meinen Gedanken bereits dabei, wie
ich dir die sizeof-Geschichte rüberbringe und hab
nicht mehr drauf geachtet.