Arduino uno 8x8 LED max7219

International Deutsch
1

Hallo Gemeinde
Habe mir mittels arduino einen Simulator für rennspiele gebaut, funktioniert 1a.
Nun möchte ich mir eine ganganzeige bauen die den Gang anzeigt und wenn die Drehzahl erreicht wird sollen alle LED s blinken.
Ich tue mich im Moment sehr schwer mit der Sache.
Das 8x8 LED habe ich mit maxmatrix am laufen. Nur da ist die Schrift von rechts nach links am laufen. Kann mir vielleicht jemand beim sketch erstellen helfen?
Bekomme die tage noch ein 8 Bit digital led Display Segment tm1638 von arduino.
Dafür habe ich einen fertigen sketch(im Anhang die rpmgearspeed) , in diesem ist alles drin was ich für die rennspiele brauche. In diesen sketch möchte ich nun das 8x8 max 7219 einbinden. Aber soll die gänge anzeigen und einen schaltblitz erzeugen.
Ich hoffe ihr könnt mir helfen. Bin am verzweifeln

MAX7219_1_LED_DOT_MATRIX229E.ino (9.73 KB)

RpmGearSpeed_ShiftLights___TM1638v3.ino (8.47 KB)

2

Hallo und willkommen im Forum!
Folgender Sketch zeigt abwechselnd "7" und "5" an ohne Bewegung:

#include <MaxMatrix.h>
#include <avr/pgmspace.h>
const byte maxInUse = 1;        // Anzahl der MAX7219-Anzeigen (8x8-Matrix)
const byte DIN = 8;   // verbunden mit DIN
const byte CS  = 9;   // verbunden mit CS,
const byte CLK = 10;  // verbunden mit CLK
MaxMatrix m(DIN, CS, CLK, maxInUse);

const unsigned char CH[] PROGMEM = {
  3, B00000000, B00000000, B00000000, B00000000, B00000000, // space
  1, B01011111, B00000000, B00000000, B00000000, B00000000, // |
  3, B00000011, B00000000, B00000011, B00000000, B00000000, // "
  5, B00010100, B00111110, B00010100, B00111110, B00010100, // #
  4, B00100100, B01101010, B00101011, B00010010, B00000000, // $
  5, B01100011, B00010011, B00001000, B01100100, B01100011, // %
  5, B00110110, B01001001, B01010110, B00100000, B01010000, // &
  1, B00000011, B00000000, B00000000, B00000000, B00000000, // '
  3, B00011100, B00100010, B01000001, B00000000, B00000000, // (
  3, B01000001, B00100010, B00011100, B00000000, B00000000, // )
  5, B00101000, B00011000, B00001110, B00011000, B00101000, // *
  5, B00001000, B00001000, B00111110, B00001000, B00001000, // +
  2, B10110000, B01110000, B00000000, B00000000, B00000000, // ,
  4, B00001000, B00001000, B00001000, B00001000, B00000000, // -
  2, B01100000, B01100000, B00000000, B00000000, B00000000, // .
  4, B01100000, B00011000, B00000110, B00000001, B00000000, // /
  4, B00111110, B01000001, B01000001, B00111110, B00000000, // 0
  3, B01000010, B01111111, B01000000, B00000000, B00000000, // 1
  4, B01100010, B01010001, B01001001, B01000110, B00000000, // 2
  4, B00100010, B01000001, B01001001, B00110110, B00000000, // 3
  4, B00011000, B00010100, B00010010, B01111111, B00000000, // 4
  4, B00100111, B01000101, B01000101, B00111001, B00000000, // 5
  4, B00111110, B01001001, B01001001, B00110000, B00000000, // 6
  4, B01100001, B00010001, B00001001, B00000111, B00000000, // 7
  4, B00110110, B01001001, B01001001, B00110110, B00000000, // 8
  4, B00000110, B01001001, B01001001, B00111110, B00000000, // 9
  2, B01010000, B00000000, B00000000, B00000000, B00000000, // :
  2, B10000000, B01010000, B00000000, B00000000, B00000000, // ;
  3, B00010000, B00101000, B01000100, B00000000, B00000000, // <
  3, B00010100, B00010100, B00010100, B00000000, B00000000, // =
  3, B01000100, B00101000, B00010000, B00000000, B00000000, // >
  4, B00000010, B01011001, B00001001, B00000110, B00000000, // ?
  5, B00111110, B01001001, B01010101, B01011101, B00001110, // @
  4, B01111110, B00010001, B00010001, B01111110, B00000000, // A
  4, B01111111, B01001001, B01001001, B00110110, B00000000, // B
  4, B00111110, B01000001, B01000001, B00100010, B00000000, // C
  4, B01111111, B01000001, B01000001, B00111110, B00000000, // D
  4, B01111111, B01001001, B01001001, B01000001, B00000000, // E
  4, B01111111, B00001001, B00001001, B00000001, B00000000, // F
  4, B00111110, B01000001, B01001001, B01111010, B00000000, // G
  4, B01111111, B00001000, B00001000, B01111111, B00000000, // H
  3, B01000001, B01111111, B01000001, B00000000, B00000000, // I
  4, B00110000, B01000000, B01000001, B00111111, B00000000, // J
  4, B01111111, B00001000, B00010100, B01100011, B00000000, // K
  4, B01111111, B01000000, B01000000, B01000000, B00000000, // L
  5, B01111111, B00000010, B00001100, B00000010, B01111111, // M
  5, B01111111, B00000100, B00001000, B00010000, B01111111, // N
  4, B00111110, B01000001, B01000001, B00111110, B00000000, // O
  4, B01111111, B00001001, B00001001, B00000110, B00000000, // P
  4, B00111110, B01000001, B01000001, B10111110, B00000000, // Q
  4, B01111111, B00001001, B00001001, B01110110, B00000000, // R
  4, B01000110, B01001001, B01001001, B00110010, B00000000, // S
  5, B00000001, B00000001, B01111111, B00000001, B00000001, // T
  4, B00111111, B01000000, B01000000, B00111111, B00000000, // U
  5, B00001111, B00110000, B01000000, B00110000, B00001111, // V
  5, B00111111, B01000000, B00111000, B01000000, B00111111, // W
  5, B01100011, B00010100, B00001000, B00010100, B01100011, // X
  5, B00000111, B00001000, B01110000, B00001000, B00000111, // Y
  4, B01100001, B01010001, B01001001, B01000111, B00000000, // Z
  2, B01111111, B01000001, B00000000, B00000000, B00000000, // [
  4, B00000001, B00000110, B00011000, B01100000, B00000000, // backslash
  2, B01000001, B01111111, B00000000, B00000000, B00000000, // ]
  3, B00000010, B00000001, B00000010, B00000000, B00000000, // ^
  4, B01000000, B01000000, B01000000, B01000000, B00000000, // _
  2, B00000001, B00000010, B00000000, B00000000, B00000000, // `
  4, B00100000, B01010100, B01010100, B01111000, B00000000, // a
  4, B01111111, B01000100, B01000100, B00111000, B00000000, // b
  4, B00111000, B01000100, B01000100, B00101000, B00000000, // c
  4, B00111000, B01000100, B01000100, B01111111, B00000000, // d
  4, B00111000, B01010100, B01010100, B00011000, B00000000, // e
  3, B00000100, B01111110, B00000101, B00000000, B00000000, // f
  4, B10011000, B10100100, B10100100, B01111000, B00000000, // g
  4, B01111111, B00000100, B00000100, B01111000, B00000000, // h
  3, B01000100, B01111101, B01000000, B00000000, B00000000, // i
  4, B01000000, B10000000, B10000100, B01111101, B00000000, // j
  4, B01111111, B00010000, B00101000, B01000100, B00000000, // k
  3, B01000001, B01111111, B01000000, B00000000, B00000000, // l
  5, B01111100, B00000100, B01111100, B00000100, B01111000, // m
  4, B01111100, B00000100, B00000100, B01111000, B00000000, // n
  4, B00111000, B01000100, B01000100, B00111000, B00000000, // o
  4, B11111100, B00100100, B00100100, B00011000, B00000000, // p
  4, B00011000, B00100100, B00100100, B11111100, B00000000, // q
  4, B01111100, B00001000, B00000100, B00000100, B00000000, // r
  4, B01001000, B01010100, B01010100, B00100100, B00000000, // s
  3, B00000100, B00111111, B01000100, B00000000, B00000000, // t
  4, B00111100, B01000000, B01000000, B01111100, B00000000, // u
  5, B00011100, B00100000, B01000000, B00100000, B00011100, // v
  5, B00111100, B01000000, B00111100, B01000000, B00111100, // w
  5, B01000100, B00101000, B00010000, B00101000, B01000100, // x
  4, B10011100, B10100000, B10100000, B01111100, B00000000, // y
  3, B01100100, B01010100, B01001100, B00000000, B00000000, // z
  3, B00001000, B00110110, B01000001, B00000000, B00000000, // {
  1, B01111111, B00000000, B00000000, B00000000, B00000000, // |
  3, B01000001, B00110110, B00001000, B00000000, B00000000, // }
  4, B00001000, B00000100, B00001000, B00000100, B00000000, // ~
};

byte sprite[] = {0, 0, 0, 0, 0, 0, 0};
byte helligkeit = 0;    // Helligkeit der Matrix 0 - 15, dunkel - hell
byte anzeigePuffer[] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9'};
void setup() {
  m.init();
  m.setIntensity(helligkeit);
  m.clear();
}

void loop() {
  byte t = displayChar(anzeigePuffer[7], 2);
  delay(2000);
  t = displayChar(anzeigePuffer[5], 2);
  delay(2000);
}
byte displayChar(byte zeichen, byte x) {
  memcpy_P(sprite + 1, CH + (zeichen - 32) * 6, 6);
  sprite[0] = sprite[1];
  sprite[1] = 8;
  m.writeSprite(x, 0, sprite);
  return sprite[0];
}

Wäre das als Einstieg brauchbar?

3

dank dir das ist schon mal sehr fein .
nur wie bekomme ich es hin das es nicht selbständig macht sondern vom pc die daten rein bekommt.
also wenn ich hochschalte der gangwechsel gezeigt wird wie im sketch rpm gear speed .
ich tue mich da so schwer mit.
oder wird es mit dem max7219 nicht funktionieren?
aber dank dir schon einmal für deine arbeit.war für dich bestimmt nicht schwer! oder?

4

hallo

habe mal angefangen ohne genaues wissen ob es geht.
habe direkt mehrere fehler drin und weiss nicht warum.

Anfang1:24: error: 'Serial' does not name a type
Anfang1:26: error: 'module' does not name a type
Anfang1:28: error: 'module' does not name a type
Anfang1:29: error: expected constructor, destructor, or type conversion before '(' token
Anfang1:30: error: 'module' does not name a type
Anfang1:54: error: expected unqualified-id before 'if'
'Serial' does not name a type

wird es überhaupt mit diesem code funtionieren ? und was muss ich ändern das ich es so anwenden kann?

Anfang1.ino (8.31 KB)

5

Kunde:
war für dich bestimmt nicht schwer! oder?

Ich hatte mich schon mal damit beschäftigt, weil ich einen MP3-Player mit Titelanzeige gebaut habe. Als Nebenprodukt dann caution-schnell_ins_Ziel.

Kunde:
Habe mir mittels arduino einen Simulator für rennspiele gebaut, funktioniert 1a.

Kunde:
... sondern vom pc die daten rein bekommt.

Das scheint mir ein Widerspruch zu sein, ich verstehe es zumindest nicht. Kommen die Daten vom Arduino oder PC?

Ein Umschalten mittels Eingabe am seriellen Monitor geht so:

void setup() {
  Serial.begin(9600);
  m.init();
  m.setIntensity(helligkeit);
  m.clear();
  displayChar(anzeigePuffer[0], 2);
  Serial.println("Bitte Gang eingeben!");
}

void loop() {
  if (Serial.available()) {
    byte gang = Serial.read();
    if ((gang > 48) & (gang < 58)) {
      displayChar(anzeigePuffer[gang - 48], 2);
      Serial.print("Gang: "); Serial.println(gang - 48);
    }
  }
}
void displayChar(byte zeichen, byte x) {
  memcpy_P(sprite + 1, CH + (zeichen - 32) * 6, 6);
  sprite[0] = sprite[1];
  sprite[1] = 8;
  m.writeSprite(x, 0, sprite);
}
6

die daten kommen vom pc mittels simtools etc..
beim simulator gab es diverse anleitungen mit fertigen skatch.
der skatch aus dem ersten post ist ein skatch der vom pc gefüttert wird.
nur wie bekomme ich es hin das nicht das 7 segment display sondern das 8x8 display gefüttert wird?
habe nun schon etliche skatchs geladen aber es ist keins dabei wo es die daten vom pc nimmt.
kannst du dir bitte mal den skatch aus dem ersten post anschauen und mir sagen was ich davon brauche um das 8x8 display zu füttern.

und danke das du dich um mich kümmerst.

7

arduino bekommt die befehle vom pc wann das display was machen soll. so ist es richtig

8

Kunde:
die daten kommen vom pc mittels simtools etc..

"simtools" kenne ich nicht und weiß auch nicht, was da für Daten kommen. Wenn ich das Programm richtig verstehe, müßte 000000G50000 übertragen werden. Dann tut es dieser Sketch:

byte sprite[] = {0, 0, 0, 0, 0, 0, 0};
byte helligkeit = 0;    // Helligkeit der Matrix 0 - 15, dunkel - hell
byte anzeigePuffer[] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9'};

int Speed;
int Gear;
int Rpm;
int RpmLeds;
int RpmMax = 8000;
int ShiftPoint = 4000;
int LimitRange = 0;
int UnderShiftPoint;
int OverShiftPoint;
int OverShift;
int UnderShift;
int buttonCheck = 1;
int bufferArray[12];

void setup() {
  Serial.begin(9600);
  m.init();
  m.setIntensity(helligkeit);
  m.clear();
  displayChar(anzeigePuffer[0], 2);
  Serial.println("Bitte Wert 012345678901 eingeben!");
  Serial.println("           000000G50000");
}

void loop() {
  if (Serial.available() == 12)  {    // wenn 12 Byte im seriellen Puffer sind
    int i;
    for (i = 0; i < 12; i = i + 1) { // read and label each byte.
      bufferArray[i] = Serial.read();
    }
    if (bufferArray[6] == 'G') {
      unsigned int gearSmTools = ((bufferArray[7] - 48) * 1);
      Gear = gearSmTools;
      Serial.print("You have set the Gear to a Value of: ");
      Serial.println(gearSmTools);
      if ((Gear > 0) && (Gear < 10)) {
        displayChar(anzeigePuffer[Gear], 2);
      }
    }
  }
}

void displayChar(byte zeichen, byte x) {
  memcpy_P(sprite + 1, CH + (zeichen - 32) * 6, 6);
  sprite[0] = sprite[1];
  sprite[1] = 8;
  m.writeSprite(x, 0, sprite);
}

PS.: Du kannst einen Post auch verändern, wenn Du Dich verschrieben hast oder etwas ändern möchtest. Du kannst ihn auch löschen.

9

danke für deine Arbeit. habe nun deinen Code genommen und bei den rest dabei gemacht.
habe beim starten jetzt schon einmal eine 0 zu sehen.

anbei habe ich dir schon einmal den skratch bei gefügt .
das problem ist das es im spiel noch nicht funktioniert.
habe im x-sim forum mal angefragt woran es kliegen kann.
werde mich sobald ich neues erfahre wieder hier melden .
vielen dank noch einmal für deine schnelle hilfe.
du bist ein tier!!!!!

dankee

Fertig_Game_Dash.ino (7.68 KB)

10

Die Null kommt von der Initialisierung: displayChar(anzeigePuffer[0], 2);

Ich gebe im seriellen Monitor 000000G50000 ohne Zeilenvorschub ein und sehe dann auf meiner Matrix eine 5.

Sonst wäre halt interessant, was in bufferArray[] steht.

11

kann ich das irgendwie auslesen??
und womit?

12

Serial.print() gibt Debugmeldungen aus:

void loop() {
  if (Serial.available() == 12)  {    //if 24 bits available in the Serial buffer...
    int i;
    Serial.println("00 01 02 03 04 05 06 07 08 09 10 11");
    for (i = 0; i < 12; i = i + 1) { // read and label each byte.
      bufferArray[i] = Serial.read();
      Serial.print(bufferArray[i], HEX);
      Serial.print(" ");
    }
    Serial.println("");
    if (bufferArray[6] == 'G') {
      unsigned int gearSmTools = ((bufferArray[7] - 48) * 1);
      Gear = gearSmTools;
      Serial.print("You have set the Gear to a Value of: ");
      Serial.println(gearSmTools);
      if ((Gear > 0) && (Gear < 10)) {
        displayChar(anzeigePuffer[Gear], 2);
      }
    }
  }
}

Sieht dann bei mir so auf dem seriellen Monitor aus:

Bitte Wert 012345678901 eingeben!
           000000G50000
00 01 02 03 04 05 06 07 08 09 10 11
30 30 30 30 30 30 47 35 30 30 30 30 
You have set the Gear to a Value of: 5
00 01 02 03 04 05 06 07 08 09 10 11
30 30 30 30 30 30 47 37 30 30 30 30 
You have set the Gear to a Value of: 7
13

das blöde ist das sich auf dem display nichts verändert, egal was ich eingebe.
es bleibt immer die null stehen!

14

Ich mache das mit dem seriellen Monitor der IDE (ich habe 1.6.5). Baudrate wie im Sketch angegeben einstellen und kein Zeilenvorschub. Siehst Du dann den Text Bitte Wert 012345678901 eingeben!?

15

ja den text sehe ich. am arduino wird auch ein wert eingespielt. das grüne lämpchen blinkt kurz.
auch wenn ich das spiel starte ist das lämpchen dauerhaft an.
aber auf der matrix bleibt die 0 stehen.
im sim tool wird auch angezeigt der der gang wechselt.

16

Wenn man das Gesamtproblem nicht lösen kann, hilft das Zerlegen in Teilprobleme. Darum mein Vorschlag: Simtool stoppen. Ich kann mir nicht vorstellen, daß IDE und Somtool sich vertragen, benutzen ja dieselbe USB-Schnittstelle. Mir geht es darum, Deinen und meinen Aufbau synchron zu bekommen. Also IDE alleine:

Kunde:
ja den text sehe ich.

Dann gib 000000G50000 ein. Dann sollte der Text aus #11 erscheinen. Tut er das?

17

Ich werde es gleich morgen früh testen. Dir noch nen schönen abend.
Ich dank dir.

18

ich habe alle zusatz usb kabel abgeklemmt die ganze sim sachen ausgeschaltet.
nun gebe ich im monitor 000000G50000
ein es kommt auch ein signal im arduino an. aber es ändert nichts.

im monitor wird nach der eingabe folgendes gezeigt:

Bitte Wert 012345678901 eingeben!
000000G50000
00 01 02 03 04 05 06 07 08 09 10 11
42 69 74 74 65 20 57 65 72 74 20 30
00 01 02 03 04 05 06 07 08 09 10 11
31 32 33 34 35 36 37 38 39 30 31 20

aber keine änderung.

19

so habe nun am seriellen monitor

000000G50000
eingegeben und der gang geht auf gang 5

000000G40000
eingegeben und der gang geht aufgang 4

danach möchte ich noch einen gang eingeben dann geht aber nichts mehr.
arduino reset dann geht es wieder 2 mal.
das ist komisch das es immer nur 2 mal geht

Bitte Wert 012345678901 eingeben!
000000G50000
00 01 02 03 04 05 06 07 08 09 10 11
30 30 30 30 30 30 47 35 30 30 30 30
You have set the Gear to a Value of: 5
00 01 02 03 04 05 06 07 08 09 10 11
30 30 30 30 30 30 47 34 30 30 30 30
You have set the Gear to a Value of: 4
00 01 02 03 04 05 06 07 08 09 10 11
20 30 30 30 30 30 30 47 33 30 30 30

20

habe die leerzeichen im code entfernt und dann gehen auch mehr als 2 einträge.

Serial.println("000000G50000");

aber wenn ich das spiel starte verändert sich nichts .es bleibt bei 0 stehen. aber das arduino bekommt befehle rein. das grüne lämpchen ist dauerhaft an.