Go Down

Topic: Arduino uno 8x8 LED max7219 (Read 4959 times) previous topic - next topic

Kunde

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

agmue

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

#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?
Wahnsinn und Verstand trennt nur eine dünne Wand. (Daniel Düsentrieb)

Kunde

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?

Kunde

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?


agmue

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.

Habe mir mittels arduino einen Simulator für rennspiele gebaut, funktioniert 1a.
... 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:
Code: [Select]
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);
}
Wahnsinn und Verstand trennt nur eine dünne Wand. (Daniel Düsentrieb)

Kunde

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.

Kunde

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

agmue

#7
Nov 14, 2015, 11:17 am Last Edit: Nov 14, 2015, 12:54 pm by agmue
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:
Code: [Select]
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.
Wahnsinn und Verstand trennt nur eine dünne Wand. (Daniel Düsentrieb)

Kunde

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


agmue

#9
Nov 14, 2015, 12:50 pm Last Edit: Nov 14, 2015, 12:56 pm by agmue
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.
Wahnsinn und Verstand trennt nur eine dünne Wand. (Daniel Düsentrieb)

Kunde

kann ich das irgendwie auslesen??
und womit?

agmue

#11
Nov 14, 2015, 02:06 pm Last Edit: Nov 14, 2015, 02:09 pm by agmue
Serial.print() gibt Debugmeldungen aus:
Code: [Select]
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

Wahnsinn und Verstand trennt nur eine dünne Wand. (Daniel Düsentrieb)

Kunde

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

agmue

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!?
Wahnsinn und Verstand trennt nur eine dünne Wand. (Daniel Düsentrieb)

Kunde

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.


Go Up