Go Down

Topic: 7-Segment [SA 40-19 RT] - Anschließen - und ansteuern (Read 1 time) previous topic - next topic

HotSystems

Man kann das Bild leider immer erst mit dem Editoren des Beitrages einstellen :-(
Daher dauert das immer einen Kleinen augenblick, da warst du schneller als ich. :-).

Die sind alle klein bei mir :-)

Puhh, da bin ich aber froh, das das mit dem Bild doch noch geklappt hat, ;-) *Spaß*

Ok, 1/4W also 0,25W, somit würden die ausreichen :-) die ich habe für das was ich sie benötige.

DANKE.

Alles klar, ich war wohl zu schnell. ;)  ;)
Kommt aber selten vor.
Gruß Dieter

I2C = weniger ist mehr: weniger Kabel, mehr Probleme. 8)

Muecke

So ich habe die 7 Segmente bekommen und wie auf dem Bild angeschlossen.



Zum testen habe ich mir jetzt den Code mal zusammen gebastelt.

Jetzt möchte ich mir eine Funktion schreiben, mit der ich die Ziffern entsprechende aufrufen kann.
Das Teil sieht echt Cool aus, und ist verdammt groß :-).

Code: [Select]
int a = 7;
  int b = 8;
  int c = 4;
  int d = 3;
  int e = 2;
  int f = 6;
  int g = 5;


void setup() {
 
  pinMode(a, OUTPUT);
  pinMode(b, OUTPUT);
  pinMode(c, OUTPUT);
  pinMode(d, OUTPUT);
  pinMode(e, OUTPUT);
  pinMode(f, OUTPUT);
  pinMode(g, OUTPUT);
  
// Ausgabe 0
  digitalWrite(a, HIGH);
  digitalWrite(b, HIGH);
  digitalWrite(c, HIGH);
  digitalWrite(d, HIGH);
  digitalWrite(e, HIGH);
  digitalWrite(f, HIGH);
  digitalWrite(g, LOW);
delay(1000); // warten für 1 sekunden

// Ausgabe 1
  digitalWrite(a, LOW);
  digitalWrite(b, HIGH);
  digitalWrite(c, HIGH);
  digitalWrite(d, LOW);
  digitalWrite(e, LOW);
  digitalWrite(f, LOW);
  digitalWrite(g, LOW);
delay(1000); // warten für 1 sekunden

// Ausgabe 2
  digitalWrite(a, HIGH);
  digitalWrite(b, HIGH);
  digitalWrite(c, LOW);
  digitalWrite(d, HIGH);
  digitalWrite(e, HIGH);
  digitalWrite(f, LOW);
  digitalWrite(g, HIGH);
delay(1000); // warten für 1 sekunden

// Ausgabe 3
  digitalWrite(a, HIGH);
  digitalWrite(b, HIGH);
  digitalWrite(c, HIGH);
  digitalWrite(d, HIGH);
  digitalWrite(e, LOW);
  digitalWrite(f, LOW);
  digitalWrite(g, HIGH);
delay(1000); // warten für 1 sekunden

// Ausgabe 4
  digitalWrite(a, LOW);
  digitalWrite(b, HIGH);
  digitalWrite(c, HIGH);
  digitalWrite(d, LOW);
  digitalWrite(e, LOW);
  digitalWrite(f, HIGH);
  digitalWrite(g, HIGH);
delay(1000); // warten für 1 sekunden

// Ausgabe 5
  digitalWrite(a, HIGH);
  digitalWrite(b, LOW);
  digitalWrite(c, HIGH);
  digitalWrite(d, HIGH);
  digitalWrite(e, LOW);
  digitalWrite(f, HIGH);
  digitalWrite(g, HIGH);
delay(1000); // warten für 1 sekunden

// Ausgabe 6
  digitalWrite(a, HIGH);
  digitalWrite(b, LOW);
  digitalWrite(c, HIGH);
  digitalWrite(d, HIGH);
  digitalWrite(e, HIGH);
  digitalWrite(f, HIGH);
  digitalWrite(g, HIGH);
delay(1000); // warten für 1 sekunden

// Ausgabe 7
  digitalWrite(a, HIGH);
  digitalWrite(b, HIGH);
  digitalWrite(c, HIGH);
  digitalWrite(d, LOW);
  digitalWrite(e, LOW);
  digitalWrite(f, HIGH);
  digitalWrite(g, LOW);
delay(1000); // warten für 1 sekunden

// Ausgabe 8
  digitalWrite(a, HIGH);
  digitalWrite(b, HIGH);
  digitalWrite(c, HIGH);
  digitalWrite(d, HIGH);
  digitalWrite(e, HIGH);
  digitalWrite(f, HIGH);
  digitalWrite(g, HIGH);
delay(1000); // warten für 1 sekunden

// Ausgabe 9
  digitalWrite(a, HIGH);
  digitalWrite(b, HIGH);
  digitalWrite(c, HIGH);
  digitalWrite(d, HIGH);
  digitalWrite(e, LOW);
  digitalWrite(f, HIGH);
  digitalWrite(g, HIGH);
delay(1000); // warten für 1 sekunden
}

void loop() { }



Gruß Mücke



- Anfänger in allen Hinsicht - Bilder sichtbar einstellen
1  Bild Hochladen (Attachements); 2 Beitrag Save; 3 Anhang rechter Mausklick; "Adresse des Links kopieren"; 4 Beitrag „Modify"; 5 img-Tags mit dem kopierten Link einfügen; 6 Beitrag Save
DANKE

agmue

Jetzt möchte ich mir eine Funktion schreiben, mit der ich die Ziffern entsprechende aufrufen kann.
Kleine Anregung von mir. Ob die Bits an der richtigen Stelle sind, kann ich mangels 7-Segmentanzeige nicht testen.

Code: [Select]
//                   a  b  c  d  e  f  g
const byte pins[] = {7, 8, 4, 3, 2, 6, 5};
const byte digits[] = {
  //gfedcba
  0b0111111, // 0
  0b0000110, // 1
  0b1011011, // 2
  0b1001111, // 3
  0b1100110, // 4
  0b1101101, // 5
  0b1111101, // 6
  0b0100111, // 7
  0b1111111, // 8
  0b1101111  // 9
};
void ausgabe(byte zahl)
{
  zahl = zahl % 10; // um die Feldgrenzen nicht zu überschreiten
  byte d = digits[zahl];
  for (byte j = 0; j < sizeof(pins); j++)
  {
    bool hl = d & 1 << j;
    digitalWrite(pins[j], hl);
  }
}

void setup() {
  for (byte j = 0; j < sizeof(pins); j++)
  {
    pinMode(pins[j], OUTPUT);
  }
}

void loop()
{
  for (byte j = 0; j < 10; j++)
  {
    ausgabe(j);
    delay(1000);
  }
}

Muecke

@agmue: Das ist ein sehr Interessantes Programm.
Jedoch muss ich mich da mal mit etwas mehr zeit dran setzen, um das richtig nachvollziehen zu können.

Was ich auf Anhieb verstanden habe ist das du die Pins in ein Array gesteckt hast, das dann wider aufgerufen wird beim Pin Deklarieren als  OUTPUT.

Den Rest muss ich mir genauer anschauen, denn ich möchte das schon verstehen. Was ich da mache.

ich hätte das zwar etwas anders gelöst, bin aber für neue Dinge immer Offen ;-).

Danke dir.

Gruß Mücke
- Anfänger in allen Hinsicht - Bilder sichtbar einstellen
1  Bild Hochladen (Attachements); 2 Beitrag Save; 3 Anhang rechter Mausklick; "Adresse des Links kopieren"; 4 Beitrag „Modify"; 5 img-Tags mit dem kopierten Link einfügen; 6 Beitrag Save
DANKE

agmue


ElEspanol

Studier und versteh den Sketch von agmue, ist gut und effizient gemacht

Muecke

Löse es, wie Du magst :)
Öm, ja, so dass ich den Code auch in ein Paar Wochen noch verstehe zumindest.

Studier und versteh den Sketch von agmue, ist gut und effizient gemacht
Das habe ich vor.

Jedoch zuerst meine Version, wie ich es vorhatte.

Code: [Select]
int a = 7;
  int b = 8;
  int c = 4;
  int d = 3;
  int e = 2;
  int f = 6;
  int g = 5;

void setup()
{
  pinMode(a, OUTPUT);
  pinMode(b, OUTPUT);
  pinMode(c, OUTPUT);
  pinMode(d, OUTPUT);
  pinMode(e, OUTPUT);
  pinMode(f, OUTPUT);
  pinMode(g, OUTPUT);
}

void loop()
{
  for (int j = 0; j < 11; j++)
    {
      Segment(j);
      delay(1000);
    } 
}

void Segment(int Zahl)
{
  switch (Zahl)
  {
  case 0:
    digitalWrite(a, HIGH);
    digitalWrite(b, HIGH);
    digitalWrite(c, HIGH);
    digitalWrite(d, HIGH);
    digitalWrite(e, HIGH);
    digitalWrite(f, HIGH);
    digitalWrite(g, LOW);
    break;
  case 1:
    digitalWrite(a, LOW);
    digitalWrite(b, HIGH);
    digitalWrite(c, HIGH);
    digitalWrite(d, LOW);
    digitalWrite(e, LOW);
    digitalWrite(f, LOW);
    digitalWrite(g, LOW);
    break;
  case 2:
      digitalWrite(a, HIGH);
      digitalWrite(b, HIGH);
      digitalWrite(c, LOW);
      digitalWrite(d, HIGH);
      digitalWrite(e, HIGH);
      digitalWrite(f, LOW);
      digitalWrite(g, HIGH);
      break;
  case 3:
    digitalWrite(a, HIGH);
    digitalWrite(b, HIGH);
    digitalWrite(c, HIGH);
    digitalWrite(d, HIGH);
    digitalWrite(e, LOW);
    digitalWrite(f, LOW);
    digitalWrite(g, HIGH);
    break;
  case 4:
    digitalWrite(a, LOW);
    digitalWrite(b, HIGH);
    digitalWrite(c, HIGH);
    digitalWrite(d, LOW);
    digitalWrite(e, LOW);
    digitalWrite(f, HIGH);
    digitalWrite(g, HIGH);
    break;
  case 5:
    digitalWrite(a, HIGH);
    digitalWrite(b, LOW);
    digitalWrite(c, HIGH);
    digitalWrite(d, HIGH);
    digitalWrite(e, LOW);
    digitalWrite(f, HIGH);
    digitalWrite(g, HIGH);
    break;
  case 6:
    digitalWrite(a, HIGH);
    digitalWrite(b, LOW);
    digitalWrite(c, HIGH);
    digitalWrite(d, HIGH);
    digitalWrite(e, HIGH);
    digitalWrite(f, HIGH);
    digitalWrite(g, HIGH);
    break;
  case 7:
    digitalWrite(a, HIGH);
    digitalWrite(b, HIGH);
    digitalWrite(c, HIGH);
    digitalWrite(d, LOW);
    digitalWrite(e, LOW);
    digitalWrite(f, HIGH);
    digitalWrite(g, LOW);
    break;
  case 8:
    digitalWrite(a, HIGH);
    digitalWrite(b, HIGH);
    digitalWrite(c, HIGH);
    digitalWrite(d, HIGH);
    digitalWrite(e, HIGH);
    digitalWrite(f, HIGH);
    digitalWrite(g, HIGH);
    break;
  case 9:
    digitalWrite(a, HIGH);
    digitalWrite(b, HIGH);
    digitalWrite(c, HIGH);
    digitalWrite(d, HIGH);
    digitalWrite(e, LOW);
    digitalWrite(f, HIGH);
    digitalWrite(g, HIGH);
    break;
  default:
    digitalWrite(a, LOW);
    digitalWrite(b, LOW);
    digitalWrite(c, LOW);
    digitalWrite(d, LOW);
    digitalWrite(e, LOW);
    digitalWrite(f, LOW);
    digitalWrite(g, LOW); 
  }
}


jetzt muss ich mir, das von agmue genauer anschauen, denn das macht das selbe, nur deutlich schlanker :-)
ein Paar Sachen verstehe ich auf Anhieb, bei einigen Dingen muss ich erst nachschlagen und schauen was das eigendlich ist, und wie das funktioniert.
- Anfänger in allen Hinsicht - Bilder sichtbar einstellen
1  Bild Hochladen (Attachements); 2 Beitrag Save; 3 Anhang rechter Mausklick; "Adresse des Links kopieren"; 4 Beitrag „Modify"; 5 img-Tags mit dem kopierten Link einfügen; 6 Beitrag Save
DANKE

ElEspanol

Du hast z.B. viele Kopien des im Prinzip identischen Codes in der switch/case.
Sowas lagert man in Funktionen (oder Klassen) aus und übergibt nur die entsprechenden Variablen, die jeweils anders sind.
Auch packt man idealerweise gleichartige Variablen in Arrays, da kann man schön drüber iterieren. Sprich for-Schleife und nur 1 x PinMode anstatt 8 Mal pinmode

Nur so als Anregung zum verstehen von agmues Sketch.

Muecke

Servus miteinander,

ich sitze gerade daran den CODE von agmue #17 nachzuvollziehen.

Dazu würde ich gerne Oben anfangen und ein paar Fragen stellen.


Der Teil:
Code: [Select]
const byte digits[] = {
  //gfedcba
  0b0111111, // 0
  0b0000110, // 1
  0b1011011, // 2
  0b1001111, // 3
  0b1100110, // 4
  0b1101101, // 5
  0b1111101, // 6
  0b0100111, // 7
  0b1111111, // 8
  0b1101111  // 9
};


den Verstehe ich nicht ganz.
Mir isst klar das hier die Pins für die einzelnen Ziffern auf LOW (0) bzw. HIGH (1) gesetzt werden.
Doch ich kapiere es nicht wie.

Kann mir das einer erklären?


so verstehe ich aktuell auch die AUSGABE nicht so richtig :-(
Code: [Select]
void ausgabe(byte zahl)
{
  zahl = zahl % 10; // um die Feldgrenzen nicht zu überschreiten
  byte d = digits[zahl];
  for (byte j = 0; j < sizeof(Segment_1_PIN); j++)
  {
    bool hl = d & 1 << j;
    digitalWrite(Segment_1_PIN[j], hl);
  }
}

ich kann mir ganz grob aus mahlen was da passiert, ich verstehe es aber nicht :-(
ich hoffe das das kommt wenn ich den Obern Teil verstanden habe.


Gruß Mücke
- Anfänger in allen Hinsicht - Bilder sichtbar einstellen
1  Bild Hochladen (Attachements); 2 Beitrag Save; 3 Anhang rechter Mausklick; "Adresse des Links kopieren"; 4 Beitrag „Modify"; 5 img-Tags mit dem kopierten Link einfügen; 6 Beitrag Save
DANKE

agmue

Hallo Crazy Mosquito,

zur ersten Frage nehme ich als Beispiel die Ziffer "2". Das steht "0b1011011", was einer binären Darstellung einer Zahl entspricht. Wenn Du in Windows den Rechner öffnest, auf "Ansicht/Programmierer" wechselst, dann "Bin" und "Byte" wählst, kannst Du "1011011" eingeben. Wähle "Dez" für "91" oder "Hex" für "5B" in der Anzeige. Für den µC ist das immer die selbe Folge von Nullen und Einsen.

Jedem Bit im Byte ist ein Digit zugeordnet, dem Bit 0 ganz rechts das Digit a. Da es nur sieben Digits gibt, habe ich auch nur sieben Bits im Byte angegeben. Also "0b1011011" steht im Byte mit "01011011".


Für die zweite Frage steckt der Kern hier:

Code: [Select]
bool hl = d & 1 << j;

In der Schleife enthält j die Nummer für das zu prüfende Digit, also "0" für "a", "6" für "g". Mit 1 << j wird eine "1" oder 0b00000001 j-mal nach links verschoben. Nullmal verschieben macht nichts, sechsmal ergibt 0b01000000 (oder 0x40 oder 64).

Mittels "&" wird eine bitweise UND-Verknüpfung gemacht.

Beispiel für die Ziffer "2" j=0:
00000001  nullmal verschobene 1
01011011  Ziffer 2
00000001  Ergebnis


Beispiel für die Ziffer "2" j=5:
00100000  fünfmal verschobene 1
01011011  Ziffer 2
00000000  Ergebnis


Beispiel für die Ziffer "2" j=6:
01000000  sechsmal verschobene 1
01011011  Ziffer 2
01000000  Ergebnis


Die Variable hl hat den Tyo bool, speichert also HIGH oder LOW (true oder false). Dabei gelten alle Werte größer Null als HIGH (true) und alle Werte gleich Null als LOW (false).

In den Beispielen mit j=0 und j=6 ist also das Ergebnis HIGH (true), bei j=5 LOW (false).

Mittels digitalWrite(Segment_1_PIN[j], hl); wird das Digit j auf HIGH oder LOW gesetzt.

Muecke

Servus Agmue,

ich glaube ich wies was du meinst.

ich muss das noch mal im Ruhe durch gehen, und nebenher aufschreiben, leider bin ich jetzt wider unterwegs und wies nicht wie schnell ich dazu komme, ich melde mich aber noch mal deshalb!

Gruß Mücke
- Anfänger in allen Hinsicht - Bilder sichtbar einstellen
1  Bild Hochladen (Attachements); 2 Beitrag Save; 3 Anhang rechter Mausklick; "Adresse des Links kopieren"; 4 Beitrag „Modify"; 5 img-Tags mit dem kopierten Link einfügen; 6 Beitrag Save
DANKE

Muecke

Servus Agmue,

jetzt habe ich gedacht das ich dein Beispiel verstanden habe, und schau an, es klappt doch nicht wie ich mir das im Kopf zusammen gereimt habe.

ich habe das ganze um eine Ziffer erweitern wollen.
Ich habe zwei 7-Segemte:

Code: [Select]

Ziffer Eins:
//         a   b   c   d   e   f   g
pins[] = {22, 23, 24, 25, 26, 27, 28}
Ziffer Zwei:
//         a   b   c   d   e   f   g
pins[] = {29, 30, 31, 32, 33, 34, 35}


Jetzt dachte ich eigentlich das ich die Hintereinander schreibe so:
Code: [Select]
//                    Ziffer 1                  / Ziffer 2
//                    a   b   c   d   e   f   g / a   b   c   d   e   f   g   h
const byte pins[] = {22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36};


Dann müsste ich im Code die digits entsprechend anpassen und 7 weitere stellen hinzufügen.

das habe ich dann auch gemacht für die Ziffern 0 bis 9
Schaut dann so aus:
Code: [Select]
const byte digits[] = {
  //Ziffer1 Ziffer2
  //gfedcba gfedcba
  0b00000000111111, // 0
  0b00000000000110, // 1
  0b00000001011011, // 2
  0b00000001001111, // 3
  0b00000001100110, // 4
  0b00000001101101, // 5
  0b00000001111101, // 6
  0b00000000100111, // 7
  0b00000001111111, // 8
  0b00000001101111  // 9
};


jetzt bin ich davon ausgegangen, das auf meiner ersten Ziffer nichts steht und auf der zierten Ziffer dann dann die Zahlen von 0 bis 9 durchgeeilt werden, doch leider Pustekuchen, die Zahlen werde immer noch auf der ersten Ziffer angezeigt. :-(

Was habe ich da Falsch verstanden?

im Array pins definiere ich die Reihenfolge der Digitalen Pins
und im Array  digits kann ich angeben welchen zustand die Pins haben sollen.
Oder doch nicht so richtig?



mein gesamter Code aktuell schaut so aus:
Code: [Select]
//                    Ziffer 1                  / Ziffer 2
//                    a   b   c   d   e   f   g / a   b   c   d   e   f   g   h
const byte pins[] = {22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36};
const byte digits[] = {
  //Ziffer1 Ziffer2
  //gfedcba gfedcba
  0b00000000111111, // 0
  0b00000000000110, // 1
  0b00000001011011, // 2
  0b00000001001111, // 3
  0b00000001100110, // 4
  0b00000001101101, // 5
  0b00000001111101, // 6
  0b00000000100111, // 7
  0b00000001111111, // 8
  0b00000001101111  // 9
};
void ausgabe(byte zahl)
{
 // zahl = zahl % 10;   // um die Feldgrenzen nicht zu überschreiten
  byte d = digits[zahl];
  for (byte j = 0; j < sizeof(pins); j++)
  {
    bool hl = d & 1 << j;
    digitalWrite(pins[j], hl);
  }
}

void setup() {
  for (byte j = 0; j < sizeof(pins); j++)
  {
    pinMode(pins[j], OUTPUT);
  }
}

void loop()
{
  for (byte j = 0; j < 10; j++)
  {
    ausgabe(j);
    delay(1000);
  }
}



Gruß Mücke

- Anfänger in allen Hinsicht - Bilder sichtbar einstellen
1  Bild Hochladen (Attachements); 2 Beitrag Save; 3 Anhang rechter Mausklick; "Adresse des Links kopieren"; 4 Beitrag „Modify"; 5 img-Tags mit dem kopierten Link einfügen; 6 Beitrag Save
DANKE

agmue

Warst ja lange unterwegs :)

Ich habe zwei 7-Segemte:

Code: [Select]

Ziffer Eins:
//         a   b   c   d   e   f   g
pins[] = {22, 23, 24, 25, 26, 27, 28}
Ziffer Zwei:
//         a   b   c   d   e   f   g
pins[] = {29, 30, 31, 32, 33, 34, 35}

Bitte laß uns die Segmente auch so nennen:

Code: [Select]

Segment Eins:
//         a   b   c   d   e   f   g
pins[] = {22, 23, 24, 25, 26, 27, 28}
Segment Zwei:
//         a   b   c   d   e   f   g
pins[] = {29, 30, 31, 32, 33, 34, 35}


Was habe ich da Falsch verstanden?
Das Konzept. So, wie Du das machen möchtest, benötigst Du für die Zahlen 00 bis 99 einhundert Bitdefinitionen (digits[100]), das ist wenig effektiv. Es ist daher besser, jede Ziffer einzeln zur Anzeige zu bringen.

Formal: Du kannst nicht 16 Bits (0b00000000111111) in ein Byte stecken, da passen nur acht rein. Der Compiler meckert nicht, weil er die führenden Nullen wegoptimiert, aber etwas wie 0b01111110111111 dürfte zu einem Fehler führen.

Muecke

:-), ja leider, leider komme ich nicht immer so oft zu meinen Mini Hobby dem Arduino :-(.
Naja, jetzt habe ich wider etwas zeit :-) und arbeite mich wider ein in die Materie.


Da hast du wohl recht das ich das Konzept nicht ganz verstanden hatte.

Ich dachte das ist wie ein Array.
Das erste Array sagt welche Pin Nummer
das Zweite Array sagt ob 0 oder 1 der Pin haben soll.

ich habe das jetzt mit zwei Segmenten ausprobiert , und schau an es Funktioniert :-)


Ich glaube zwar das du das etwas anders gelöst hättest so das man eine zweistellige Zahl schreiben kann, und dann die Zwei Stellige Zahl zerlegt hättest und dann die Segmente entsprechend angesprochen hättest.
Wobei wenn ich das jetzt so schreibe das glaube ich gar keine Doofe Idee ist. muss mal schauen wie man eine Zahl zerlegen kann :-)

naja, das ist mein Aktueller Code:
Code: [Select]

//                              a,  b,  c,  d,  e,  f,  g
const byte pins_Segment_1[] = {22, 23, 24, 25, 26, 27, 28};
const byte pins_Segment_2[] = {29, 30, 31, 32, 33, 34, 35};
const byte digits[] = {
  0b0111111, // 0
  0b0000110, // 1
  0b1011011, // 2
  0b1001111, // 3
  0b1100110, // 4
  0b1101101, // 5
  0b1111101, // 6
  0b0100111, // 7
  0b1111111, // 8
  0b1101111  // 9
};
void ausgabe(byte zahl_1, byte zahl_2)
{
 // zahl_1 = zahl_1 % 10;  // um die Feldgrenzen nicht zu überschreiten
 // zahl_2 = zahl_2 % 10;  // um die Feldgrenzen nicht zu überschreiten

  byte d_1 = digits[zahl_1];
  byte d_2 = digits[zahl_2];
 
  for (byte j = 0; j < sizeof(pins_Segment_1); j++)
  {
    bool hl_1 = d_1 & 1 << j;
    bool hl_2 = d_2 & 1 << j;   
    digitalWrite(pins_Segment_1[j], hl_1);
    digitalWrite(pins_Segment_2[j], hl_2);
  }
}

void setup()
  {
    for (byte j = 0; j < sizeof(pins_Segment_1); j++)
    { pinMode(pins_Segment_1[j], OUTPUT);
      pinMode(pins_Segment_2[j], OUTPUT);
    }
  }

void loop()
{
  for (byte c = 0; c < 10; c++)
  {
    for (byte j = 0; j < 10; j++)
    {
      ausgabe(c, j);
      delay(150);
    }   
  }
}



Gruß Mücke

- Anfänger in allen Hinsicht - Bilder sichtbar einstellen
1  Bild Hochladen (Attachements); 2 Beitrag Save; 3 Anhang rechter Mausklick; "Adresse des Links kopieren"; 4 Beitrag „Modify"; 5 img-Tags mit dem kopierten Link einfügen; 6 Beitrag Save
DANKE

agmue

Ich glaube zwar das du das etwas anders gelöst hättest so das man eine zweistellige Zahl schreiben kann, und dann die Zwei Stellige Zahl zerlegt hättest und dann die Segmente entsprechend angesprochen hättest.
Da glaubst Du richtig: zahl / 10 ergibt die linke Ziffer, zahl % 10 die rechte, wäre doch einfach zu lösen :)

Go Up