LED-Matrix Programmieren: Lauftext & Bildsequenz animieren

Eine LED-Matrix muss nicht unbedingt durch Schieberegister betrieben werden. Heute sehen wir uns an, wie eine Laufschrift in C programmiert wird. Dazu dient der letzte Artikel als Grundlage: LED-Matix Programmieren: Binäre Darstellung und Multiplexing

Für einen Lauftext empfehle ich ausdrücklich Schieberegister, da diese das Programmieren um einiges einfacher machen. Sind – so wie bei mir – gerade keine Schieberegister auf Vorrat, spricht aber auch nicht viel gegen die direkte Steuerung über Pins (angeschlossen an Transistoren) des Mikrocontrollers, in diesem Fall ein Arduino Mega R3.

LED Matrix Interfacing

Die LED-Matrix ist an einen Arduino Mega angeschlossen. Im Hintergrund sind die Transistoren und Widerstände erkennbar.

Vorbereitung

Zur Wiederholung: Wir betreiben eine 8×8 LED-Matrix per Multiplexing. Ich habe den Bau der Matrix bereits dokumentiert, ebenfalls wie diese Matrix angeschlossen und programmiert wurde. Wir bauen in diesem Tutorial auf der Code-Basis des letzten Tutorials auf, der Code ist auch auf GitHub verfügbar. Hier ist noch einmal der Komplette Code:

// Offsets for rows/cols
const int start_rows = 38;
const int start_cols = 22;

// Amount of rows/cols
const int num_rows = 8;
const int num_cols = 8;

// 1-Dimensional Array, Bits represent LEDs
const char image[num_rows] ={B11111111,\
							 B10000011,\
							 B10000101,\
							 B10001001,\
							 B10010001,\
							 B10100001,\
							 B11000001,\
							 B11111111};

// Bitmask for logical AND
char bitmask = B00000001;

void setup()
{
	// Set up rows
	for(int i = 0; i < num_rows; i++)
	{
		pinMode(start_rows + (2*i), OUTPUT);
		digitalWrite(start_rows + (2*i), LOW);
	}

	// Set up cols
	for(int i = 0; i < num_cols; i++)
	{
		pinMode(start_cols + (2*i), OUTPUT);
		digitalWrite(start_cols + (2*i), LOW);
	}
}

void loop()
{
	// Repeat displaying a single image
	for(int i = 0; i < 500; i++)
	{
		// Iterate rows
		for(int r = 0; r < num_rows; r++)
		{
			// Switch on a row
			digitalWrite(start_rows + 2*r, HIGH);

			// Iterate Cols
			for(int c = 0; c < num_cols; c++) 			{ 				// Check which cols have to be switched on 				if((image[r]>>c) & bitmask)
					digitalWrite(start_cols + 2*c, HIGH);
				else
					digitalWrite(start_cols + 2*c, LOW);
			}

			// Iterate Cols
			for(int c = 0; c < num_cols; c++)
			{
				// Switch off cols again
				digitalWrite(start_cols + 2*c, LOW);
			}

			// Switch off row again
			digitalWrite(start_rows + 2*r, LOW);
		}
	}
}

Wir werden uns größtenteils auf die loop()-Methode konzentrieren.

Laufschrift – Definition

Die Laufschrift besteht aus mehreren Zeichen (Buchstaben). Es wird eine ganz normaler String (Zeichenkette) auf dem Arduino gespeichert, welche dann auf der LED-Matrix wiedergegeben wird. Da wir Deutsch von Links nach Rechts lesen, wird die angezeigte Zeichenkette nach und nach immer weiter nach Links verschoben. Anstatt dass wir unsere Augen also zum Lesen bewegen, bewegt sich der ganze Text auf dem Display.

Wir haben bisher mit einem eindimensionalen Array, gefüllt mit Chars, die 8×8 LEDs der Matrix dargestellt. Das behalten wir bei, dabei nutzen wir einen Font, der 8×8 Pixel pro Zeichen verwendet. Jedes Zeichen des Strings, welchen wir anzeigen wollen, belegt also 8×8 Pixel, LEDs oder Bits. Da wir eventuell auch recht lange Strings anzeigen wollen, empfiehlt es sich, ein Zweidimensionales Array zu nutzen: Die erste Dimension beschreibt ein Zeichen, die zweite Dimension die Zeilen eines Zeichens und die Bits als Ersatz für eine dritte Dimension beschreiben die Spalten.

Wie wir bereits im letzten Tutorial gelernt haben, wird die Anzeige durch unseren Code gespiegelt. Es ist sinnvoller die Zeichen, die angezeigt werden sollen, ein mal spiegelverkehrt zu speichern, als die Anzeige bei jedem Durchlauf zu spiegeln. Ich verwende den font8x8 von Daniel Hepper / Marcel Sondaar, dieser umfasst alle Unicode-Zeichen bis U+00FF, außerdem liegen die Daten bereits im korrekten Format (spiegelverkehrt) vor.

Den Pixel-Font nutzen

Sehen wir uns die Headerdatei font8x8_basic.h an, erkennen wir recht schnell:

  • Die Daten sind in einem zweidimensionalen Char-Array gespeichert
  • Die erste Dimension beinhaltet 128 Elemente (Zeichen)
  • Die zweite Dimension beinhaltet 8 Elemente (Chars = Reihen)
  • Die Chars bestehen aus 8 Bit (=Spalten), diese sind spiegelverkehrt und hexadezimal gespeichert

Gespeichert sind also 128 Elemente/Arrays/Zeichen in genau dem Format, welches wir bereits nutzen. Das jeweilige Zeichen ist durch seinen ASCII-Code abrufbar, F wäre also mit dem Index 70 aufrufbar.

Im Programm werden wir einen String definieren. Glücklicherweise ist ein String in C gleichbedeutend mit einem Char-Array, wir können also jeden einzelnen Buchstaben nacheinander abrufen und bekommen dadurch den entsprechenden ASCII-Wert. Wir müssen also zunächst die (zuvor heruntergeladene) Headerdatei in unser Projekt einfügen und einen String definieren, welcher angezeigt werden soll:

#include <font8x8_basic.h>

const char text[] = { "TEST" };

Die Datei font8x8_basic.h muss im libraries-Ordner der Arduino-IDE vorhanden sein! Unter Linux wäre das /usr/share/arduino/libraries.

Laufschrift – Schritt für Schritt

Das einfachste ist es, zuerst einen Buchstaben nach dem anderen Anzeigen zu lassen. Dafür brauchen wir wieder eine Schleife, um jedes Zeichen im String abzurufen:

void loop()
{
    // Char Counter
    for(int s = 0; s < sizeof(text); s++)
    {
        // Repeat displaying a single image
        for(int i = 0; i < 500; i++)
        {
            [...]
        }
    }
}

Hier zeigt sich die zusätzliche For-Schleife, welche die Anzeigedauer einzelner Zeichen festlegt, sehr nützlich. Ohne diese würde einfach ein Zeichen nach dem Anderen angezeigt, so schnell es geht – wir würden nur ein Blinken auf der Matrix erkennen. Die Buchstaben werden jetzt schon nacheinander auf der Matrix wiedergegeben. Allerdings ist die Anzeige der einzelnen Buchstaben nacheinander nicht sehr schön. Durch die Laufschrift erreichen wir, dass die Buchstaben langsam aus oder in das Bild hinein wandern, wir können den Text daher etwas schneller und viel komfortabler anzeigen.

Die Matrix als ganzes

Unser Problem ist, dass wir bisher nur die einzelnen 8×8 Elemente der einzelnen Zeichen betrachtet haben. Anstatt aber jedes Zeichen einzeln abzuarbeiten, müssen wir für den Scrolltext etwas weiter denken. Bisher geben wir ein 8×8 Zeichen auf einer 8×8 Matrix wieder. Angenommen, die Laufschrift hat 5 Zeichen, in diesem Fall wollen wir 40×8 Pixel auf der 8×8 Matrix anzeigen.

Als kleine Gedankenstütze sollte klargestellt werden: Die innere For-Schleife

// Iterate Cols
for(int c = 0; c < num_cols; c++) { 	// Check which cols have to be switched on 	if((font8x8_basic[ text[s] ][r]>>c) & bitmask)
		digitalWrite(start_cols + 2*c, HIGH);
	else
		digitalWrite(start_cols + 2*c, LOW);
}

Dient weniger dazu, die Elemente des Arrays nacheinander anzusprechen. Der Zähler c dient dazu, nacheinander die Outputs anzusprechen (ab jetzt „Spalten der Matrix“ oder Matrix-Spalte genannt), also die Ausgabe auf der Matrix zu steuern. Diese Schleife regelt, dass immer wieder die „0te bis 7te“ Spalte der Matrix gesteuert werden kann.

Bisher hatten wir es nur mit einem 8×8 Array zu tun, also haben wir den Zähler c auch gleich dazu verwendet, die Spalten des Arrays auszuwählen. Bei der Laufschrift mit 40 Spalten wird das allerdings problematisch, da c nur von 0 bis 7 zählt.

Wir betrachten das, was auf der Matrix angezeigt werden soll, nun als 40×8 Array. Mit der inneren For-Schleife bilden wir immer 8×8 Pixel dieses Arrays ab. Die Aufgabe ist es nun, das 40×8 Array mit dem 8×8 Display von Links nach Rechts abzuarbeiten (abscannen). Dazu brauchen wir einen Zähler, der die Stellen der Verschiebung von 0 bis 32 hochzählt (nach 32 Verschiebungen um 1 Stelle wird das letzte Zeichen komplett angezeigt).

Welche Spalten sollen eingeschaltet werden?

Es fehlt also eine Methode, um zu bestimmen, wann welche Spalte geprüft werden muss, um die entsprechende LED auf der Matrix einzuschalten. Und hierbei liegt die Schwierigkeit…

Es hilft sehr, Schritt für Schritt durchzugehen, was das Programm machen soll. Zur Hilfe habe ich ein Spreadsheet erstellt, welches den Ablauf des Programms darstellen soll. Zusammenfassend lässt sich sagen:

  • In einem Durchlauf der Loop-Funktion soll die Laufschrift 1x über die Matrix laufen
  • Der Lauf-Effekt wird durch stellenweise Verschiebung geschaffen
  • Für jede Verschiebung um 1 Stelle wird das Bild mehrmals aufgebaut
  • Jeder Aufbau des Bildes durchläuft die 7 Zeilen der Matrix
  • In jeder Zeile werden die 7 Spalten der Matrix angesprochen
  • Je nach Verschiebung und Matrix-Spalte, muss das Entsprechende Zeichen gewählt werden
  • Je nach Verschiebung und Matrix-Spalte, muss die Entsprechende Array-Spalte gewählt werden

Dies sind die Aufgaben, die das Programm zu erledigen hat. Bis auf die letzten beiden Aufgaben sind alle in diesem Code implementiert:

void loop()
{
	// Scroll Counter
	for(int s = 0; s < (sizeof(text)-1)*num_cols; s++)
	{
		// Repeat displaying a single image
		for(int i = 0; i < 50; i++)
		{
			// Iterate rows
			for(int r = 0; r < num_rows; r++)
			{
				// Switch on a row
				digitalWrite(start_rows + 2*r, HIGH);

				// Iterate Cols
				for(int c = 0; c < num_cols; c++)
				{
					// Check which cols have to be switched on
				}

				// Iterate Cols
				for(int c = 0; c < num_cols; c++)
				{
					// Switch off cols again
					digitalWrite(start_cols + 2*c, LOW);
				}

				// Switch off row again
				digitalWrite(start_rows + 2*r, LOW);
			}
		}
	}
}

Wie bereits erwähnt, wird die Array-Spalte abhängig von Verschiebung und Matrix-Spalte errechnet. Da wir die Zeichen weiterhin in „8×8 Arrays“ (genauer: 8 Chars) speichern, darf dieser Index nur von 0 bis 7 Reichen, ein Char hat ja nur 8 Bits. Damit das Zeichen verschoben wird, werden Matrix-Spalte c und Verschiebung s addiert. Da der Index (für die Matrix-Spalte) aber immer nur bis maximal 7 reichen darf, wird der Rest von (c+s) / 8 genommen. Genauer gesagt: (c+s) / num_cols.

Beispiel: Sprechen wir gerade die 6. Spalte der Matrix an, und haben die Zeichen bereits um 4 Stellen nach links verschoben, fragen wir natürlich nicht die 10. Spalte des 0. Zeichens ab, sondern die 3, Spalte des 1. Zeichens. Achtung: da wir mit Array-Indizes arbeiten, beginnt die Nummerierung mit 0! Also: (c+s) % num_cols liefert im Programm den korrekten Index der Array-Spalte (Spalte im Zeichen).

Das jeweilige Zeichen muss aber auch noch gewählt werden. Wieder basierend auf Matrix-Spalte + Verschiebung: c+s/num_cols stellt sicher, dass das richtige Zeichen gewählt wird. Im Programm wird dieser Wert als Integer gespeichert, Nachkommastellen werden also einfach abgeschnitten. Ist die Summe aus Matrix-Spalte und Verschiebung größer oder gleich der Anzahl an Spalten in der Matrix, (c+s) >= num_cols, ergibt sich aus (c+s)/num_cols der nächst größere ganzzahlige Wert. Dies ist der Index für das jeweilige Zeichen. Falls das noch nicht ganz klar ist, seht euch das Spreadsheet mit dem Programmablauf an.

Da hinter steckt ein wenig Mathematik und Logik. Hat man das Prinzip einmal richtig begriffen, ist das ganze „kalter Kaffee“, auch wenn es anfangs etwas dauert, die genauen Terme herzuleiten. Am besten eignen sich dazu – meiner Meinung nach – Papier und Stift. Ich persönlich habe etwa 15 Minuten gebraucht um allgemeingültige Formeln für die Zeichen- und Spaltenauswahl zu erstellen. Mit etwas Konzentration (und Vorwissen, etwa wie man den Modulo anwendet) ist das ganze ein Kinderspiel.

Eingefügt ins Programm ergibt sich folgendes:

// When compiling w/ Arduino IDE, you have to copy this
// header file to your arduino/libraries folder!
#include <font8x8_basic.h>

// Offsets for rows/cols
const int start_rows = 38;
const int start_cols = 22;

// Amount of rows/cols
const int num_rows = 8;
const int num_cols = 8;

// Array of chars to display
const char text[] = { " TacticalCode.de Rocks :D" };

// Bitmask for comparison
const char bitmask = B000001;

void setup()
{
	// Set up rows
	for(int i = 0; i < num_rows; i++)
	{
		pinMode(start_rows + (2*i), OUTPUT);
		digitalWrite(start_rows + (2*i), LOW);
	}

	// Set up cols
	for(int i = 0; i < num_cols; i++)
	{
		pinMode(start_cols + (2*i), OUTPUT);
		digitalWrite(start_cols + (2*i), LOW);
	}
}

void loop()
{
	// Scroll Counter
	for(int s = 0; s < sizeof(text)*num_cols; s++)
	{
		// Repeat displaying a single image
		for(int i = 0; i < 50; i++)
		{
			// Iterate rows
			for(int r = 0; r < num_rows; r++)
			{
				// Switch on a row
				digitalWrite(start_rows + 2*r, HIGH);

				// Iterate Cols
				for(int c = 0; c < num_cols; c++) 				{ 					// Check which cols have to be switched on 					if((font8x8_basic[ text[(c+s)/num_cols ]][r] >> (c+s)%num_cols) & bitmask)
						digitalWrite(start_cols + (2*c), HIGH);
					else
						digitalWrite(start_cols + (2*c), LOW);
				}

				// Iterate Cols
				for(int c = 0; c < num_cols; c++)
				{
					// Switch off cols again
					digitalWrite(start_cols + 2*c, LOW);
				}

				// Switch off row again
				digitalWrite(start_rows + 2*r, LOW);
			}
		}
	}
}

Und das ist der fertige Programmcode für eine LED-Matrix Laufschrift, die direkt vom Mikrocontroller gesteuert wird. Ich empfehle euch einmal den Quellcode auf GitHub anzusehen, dort sind noch ein paar Verbesserungen enthalten.

Das ganze Hin und Her mit Verschiebung im Programmcode ist aber natürlich noch etwas unkomfortabel, außerdem wird es je nach Mikrocontroller schwierig, mit den vorhandenen Pins große Matritzen anzusprechen. Daher werden wir uns im nächsten Tutorial zur Serie ansehen, was das ganze auch recht einfach mit Schieberegistern gelöst werden kann. Ich hätte auch gerne direkt Schieberegister eingesetzt, aber leider habe ich gerade keine hier. Sobald ich ein paar 74HC595 zwischen die Finger bekomme, werde ich mich dran setzen, das neue Tutorial zu schreiben. Ich könnte zwar alles theoretisch schreiben, aber ich lege Wert darauf alles wirklich getestet zu haben und auf mögliche Schwierigkeiten hinzuweisen.

Wie immer: Falls euch der Artikel gefallen hat, oder auch nicht, hinterlasst bitte einen Kommentar, teilt den Artikel, schreibt mit eine Mail… Lasst es mich wissen ;)

MfG
Damon Dransfeld

Dieser Eintrag wurde veröffentlicht in Arduino
Bookmarken: Permanent-Link Schreibe einen Kommentar oder hinterlasse einen Trackback: Trackback-URL.

7 Kommentare

  1. Rakuzo
    Erstellt am 28. Oktober 2013 um 01:02 | Permalink zum Kommentar

    Hi,
    Ich habe versucht deinen Code individuell an meine 7×7 LED Matrix anzupassen.
    Jedoch bekomme ich beim Compilen mit der Arduino Software folgende Fehlermeldung:

    „sketch_oct28a.ino: In function ‚void loop()‘:
    sketch_oct28a:57: error: ‚font8x8_basic‘ was not declared in this scope“

    Ich habe die font8x8_basic.h jedoch in den libraries Ordner gepackt, so wie es sich gehört.
    Ich wäre dankbar wenn mir jemand helfen könnte :)

  2. Rakuzo
    Erstellt am 28. Oktober 2013 um 01:04 | Permalink zum Kommentar

    Achja, hier mein Quellcode:
    // When compiling w/ Arduino IDE, you have to copy this
    // header file to your arduino/libraries folder!
    #include

    // Offsets for rows/cols
    const int start_rows = 9;
    const int start_cols = 2;

    // Amount of rows/cols
    const int num_rows = 7;
    const int num_cols = 7;

    // Array of chars to display
    const char text[] = { “ Hallo “ };

    // Bitmask for comparison
    const char bitmask = B000001;

    void setup()
    {
    // Set up rows
    for(int i = 0; i < num_rows; i++)
    {
    pinMode(start_rows + i, OUTPUT);
    digitalWrite(start_rows + i, LOW);
    }

    // Set up cols
    for(int i = 0; i < num_cols; i++)
    {
    pinMode(start_cols + i, OUTPUT);
    digitalWrite(start_cols + i, LOW);
    }
    }

    void loop()
    {
    // Scroll Counter
    for(int s = 0; s < sizeof(text)*num_cols; s++)
    {
    // Repeat displaying a single image
    for(int i = 0; i < 50; i++)
    {
    // Iterate rows
    for(int r = 0; r < num_rows; r++)
    {
    // Switch on a row
    digitalWrite(start_rows + r, HIGH);

    // Iterate Cols
    for(int c = 0; c < num_cols; c++)
    {
    // c+s must be within the amount of total cols in text[]
    if(c+s > (c+s)%num_cols) & bitmask)
    digitalWrite(start_cols + c, HIGH);
    else
    digitalWrite(start_cols + c, LOW);
    }
    // but we want a blank display at the end, looks smooth
    else
    {
    // switch off all cols until we have a blank display
    digitalWrite(start_cols + c, LOW);
    }
    }

    // Iterate Cols
    for(int c = 0; c < num_cols; c++)
    {
    // Switch off cols again
    digitalWrite(start_cols + c, LOW);
    }

    // Switch off row again
    digitalWrite(start_rows + r, LOW);
    }
    }
    }
    }

    • Erstellt am 28. Oktober 2013 um 17:46 | Permalink zum Kommentar

      Hey,
      Den Fehler wirft der Compiler aus, da das include-statement leer ist („#include“). Da sollte natürlich „#include “ stehen. Oder wurde dieser Teil aus dem Kommentar entfernt, weil das nach HTML aussieht?

      Mir ist auch aufgefallen, im loop-Block einiges durcheinander ist. (Kann sein dass das auch mein Blog gefressen hat…), Kopier am besten nochmal die loop-funktion und ersetze einfach das 2*r, 2*i, 2*c durch r, i und c.

      MfG
      Damon

  3. Andy
    Erstellt am 23. Dezember 2013 um 23:42 | Permalink zum Kommentar

    Hey mal ne frage und zwar würde der Code auch auf einer matrix mit 30 spalten und 7 Zeilen funktionieren ??? Was müsste ich dort ändern und was ist bei der Hardware zu beachten? Mit Freundlichen Grūßen und Frohe weihnachten Andy

    • Erstellt am 24. Dezember 2013 um 00:13 | Permalink zum Kommentar

      Hi Andy,
      Beim erstellen des Codes habe ich darauf geachtet, dass möglichst einfach auch andere Matrix-Dimensionen eingestellt werden können.
      Für eine 30×7 Matrix müsste folgendes Angepasst werden:
      num_rows = 7
      num_cols = 30

      Außerdem sollte start_rows und start_cols angepasst werden, je nachdem an welche Pins die Reihen/Spalten angeschlossen werden. In meinem Beispiel ist die erste Spalte an Pin 22 angeschlossen, die anderen an 24, 26, 28 usw. Da nur jeder zweite Pin genutzt wird, steht in den Schleifen „2*c“ und „2*r“. Wären alle pins hintereinander genutzt (22,23,24,25…), muss einfach nur das „2*“ entfernt werden.

      Bei der Hardware/Komponenten ändert sich nicht viel. Es können beliebig viele Spalten angehangen werden, solange Transistoren genutzt werden um die LEDs über eine externe Stromquelle zu betreiben. Der Arduino selbst kann die LEDs nicht direkt treiben, das würde zu viel Strom ziehen, der Mikrocontroller könnte in Rauch aufgehen.

      Und natürlich sollte noch ein Font benutzt werden, der 7 Reihen hoch ist. Man könnte natürlich auch den 8×8 Font benutzen, allerdings würde die letzte Zeile komplett ignoriert werden.

      MfG und frohe Festtage,
      Damon

  4. joni
    Erstellt am 12. April 2015 um 21:42 | Permalink zum Kommentar

    ich weiß ist schon ein jahr her, aber trorzdem:-) deine anleitungen sind top, endlich mal schön ausführlich. noch hab ich mein projekt nicht gestartet, dennoch hab ich noch eine frage: bei einer matrix mit 5 zeilen ist doch jede led nur ein fünftel der gesamtzeit an. ist dann nicht das helligkeitsempfinden jeder led nur ein fünftel der gesamtzeit an. also nur noch ein fünftel der „normalen“ helligkeit der led. wie kann man diesea helligkeitsdefizit kompensieren? oder habe ich irgendwas falsch verstanden?
    hoffe ich hab das verständlich erklärt.
    lg joni

  5. SkyRanger
    Erstellt am 3. Oktober 2015 um 02:18 | Permalink zum Kommentar

    Ich hab den Code probiert und bei mir angepasst.
    Das vorige Tutorial mit der Matrix an sich funktioniert einwandfrei mit dem Testbild.

    Aber dieses hier spuckt mit Fehlern um sich.

    Arduino: 1.6.5 (Windows 7), Platine: „Arduino/Genuino Mega or Mega 2560, ATmega2560 (Mega 2560)“

    Build-Optionen wurden verändert, alles wird neu gebaut

    In file included from LED_matrix_scrolltext2.ino:13:0:
    D:\Programme\arduino-1.6.5-r5\libraries\Font/font8x8_basic.h:152:1: warning: narrowing conversion of ‚255‘ from ‚int‘ to ‚char‘ inside { } is ill-formed in C++11 [-Wnarrowing]
    };
    ^
    D:\Programme\arduino-1.6.5-r5\libraries\Font/font8x8_basic.h:152:1: warning: narrowing conversion of ‚255‘ from ‚int‘ to ‚char‘ inside { } is ill-formed in C++11 [-Wnarrowing]
    LED_matrix_scrolltext2.ino: In function ‚void loop()‘:
    LED_matrix_scrolltext2.ino:52:34: warning: comparison between signed and unsigned integer expressions [-Wsign-compare]
    LED_matrix_scrolltext2.ino:65:28: warning: comparison between signed and unsigned integer expressions [-Wsign-compare]
    LED_matrix_scrolltext2.ino:68:45: warning: array subscript has type ‚char‘ [-Wchar-subscripts]
    D:\Programme\arduino-1.6.5-r5\libraries\Font\render.c: In function ‚render‘:
    D:\Programme\arduino-1.6.5-r5\libraries\Font\render.c:13:9: warning: unused variable ‚mask‘ [-Wunused-variable]
    int mask;
    ^
    D:\Programme\arduino-1.6.5-r5\libraries\Font\render.c: In function ‚main‘:
    D:\Programme\arduino-1.6.5-r5\libraries\Font\render.c:29:5: warning: implicit declaration of function ‚atoi‘ [-Wimplicit-function-declaration]
    ord = atoi(argv[1]);
    ^
    Font\render.c.o:(.data.font8x8_basic+0x0): multiple definition of `font8x8_basic‘
    LED_matrix_scrolltext2.cpp.o:(.data.font8x8_basic+0x0): first defined here
    d:/programme/arduino-1.6.5-r5/hardware/tools/avr/bin/../lib/gcc/avr/4.8.1/../../../../avr/bin/ld.exe: Disabling relaxation: it will not work with multiple definitions
    collect2.exe: error: ld returned 1 exit status
    Fehler beim Kompilieren.

    Vielleicht kann ja jemand helfen.

Achtung: Wordpress interpretiert bestimmte Zeichenfolgen als Markup und verändert diese. Nutzt für Programmcode lieber Gist oder PasteBin-Services und verlinkt die Code-Schnipsel.

Post a Comment

Ihre E-Mail wird niemals veröffentlicht oder verteilt. Benötigte Felder sind mit * markiert

*
*

Du kannst diese HTML Tags und Attribute verwenden: <a href="" title=""> <abbr title=""> <acronym title=""> <b> <blockquote cite=""> <cite> <code> <del datetime=""> <em> <i> <q cite=""> <s> <strike> <strong>