AVR Embedded Tutorial - Int to digits/de

│ Deutsch (de) │ English (en) │

Ausgabe auf Digits (7 Segmentanzeige)

Will man einen Integer auf eine 7-Segmentanzeige ausgeben, macht man das am besten mit der Procedure welche weiter unten beschrieben ist. Dies sieht aufwändiger aus, als mit div und mode, ist aber viel schneller, da die AVR keine Hardware-Division können. Die AVR müssen dies sehr aufwändig mit machen und dies braucht sehr viel Zeit.

4-Stellige Ausgabe auf eine 7-Segmentanzeige

Deklaration der Variablen

var
  Digit  : array[0..3] of byte; // Werte der einzelnen Digits
  MyValue: Integer;             // Einen Integer der Ausgegeben werden soll.

Auf dem PC

Auf dem PC würde man die einzelnen Digits so berechnen. Bei einen ATtiny wird dies nicht einmal kompiliert, da er keine Division kann. Mann könnte dies Softwaremässig machen, aber dies braucht seht viel Zeit.

Digit[0] := MyValue div 1000;
Digit[1] := MyValue div 100 mod 10;
Digit[2] := MyValue div 10 mod 10;
Digit[3] := MyValue mod 10;

Auf dem AVR

Da aber der ATmega keine Division kann und der ATtiny nicht mal Multiplikationen kennt, muss man dies folgendermassen berechnen.

  procedure IntToDigit(val: UInt16);
  var
    achr: byte;
    leer: boolean;
  begin

    // Tausender
    achr := 0;
    leer := True;
    while (val >= 1000) do begin
      Dec(val, 1000);
      Inc(achr);
      leer := False;
    end;
    if leer then begin
      achr := 16;
    end;
    Digit[0] := achr;

    // Hunderter
    achr := 0;
    while (val >= 100) do begin
      Dec(val, 100);
      Inc(achr);
      leer := False;
    end;
    if leer then begin
      achr := 16;
    end;
    Digit[1] := achr;

    // Zehner
    achr := 0;
    while (val >= 10) do begin
      Dec(val, 10);
      Inc(achr);
      leer := False;
    end;
    if leer then begin
      achr := 16;
    end;
    Digit[2] := achr;

    // Einer
    achr := 0;
    while (val >= 1) do begin
      Dec(val);
      Inc(achr);
    end;
    Digit[3] := achr;
  end;

Hexadezimale Ausgabe

Will man eine Hexadezimale Ausgabe, kann man die so machen, da nur Shift und And Operationen gebraucht werden, in dies kann der AVR sehr schnell bewerkstelligen.

Digit[0] := MyValue shr 12;
Digit[1] := MyValue shr 8 and %1111;
Digit[2] := MyValue shr 4 and %1111;
Digit[3] := MyValue and %1111;

Aufruf

Mit IntToDigit wird an Digit[] Werte zugeordnet, welche dann zB. auf eine 7-Segmentanzeige ausgegeben werden können.

MyValue := 1234;      // Ein Wert zuweisen.
IntToDigit(MyValue);  // Die Digits-Array bekommt Werte.

Ausgabe

Zur Ausgabe an eine 7-Segmentanzeige, eignet sich folgendes, da man keine 32 Pins des AVR opfern will, wen überhaupt vorhanden.

• Über 4 Schieberegister
• Multiplex, dafür werden 12 Pins gebaucht, wen man den Dezimalpunkt auch anschliesst.
• Schieberegister und Multiplex.

Siehe auch:

• Multiplex - Multiplex anhand einer 4-fach Siebensegmentanzeige.
• Schieberegister - Wie steuere ich Schieberegister an.

Siehe auch

• Übersichtseite AVR Embedded Tutorial

Autor: Mathias