if Abfrage in if Abfrage?

Hallooo :slight_smile:
ich arbeite gerade an einem Projekt…
Ein Matrix 8x8 LED Board zeigt die ganze Zeit den Spielstand (Fußballspiel) an un reagiert auf ein Signal vom Ultraschallsensor losgeschickt wird, wenn dieser den Ball erkennt. Dann erscheinen in einem Textloop die Worte “TOR HAMBURG”…
So jetzt meine Frage… Nach dem ersten Tor soll ja der neue Spielstand angezeigt werden, 1, ist das möglich? Wenn dann das 2. Tor fällt, soll das Board natürlich 2 anzeigen usw. bis 9
Kann mir jemand helfen?
Danke,
Marvin
Code:

int Max7219_pinCLK1 = 11;
int Max7219_pinCS1 = 3;
int Max7219_pinDIN1 = 7;
int pos1 = 0;
int pingPin1 = 4;
int inPin1 = 2;

 unsigned char i;
 unsigned char j; 

#define NUMCHARS 37 // Kleiner Zeichensatz aus 37 Zeichen (0..9, A..Z und Leerzeichen)
const char chars[NUMCHARS+1]="0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ ";
const unsigned char disp1[NUMCHARS][9]={
{0x3C,0x42,0x42,0x42,0x42,0x42,0x42,0x3C},//0
{0x10,0x30,0x50,0x10,0x10,0x10,0x10,0x10},//1
{0x7E,0x2,0x2,0x7E,0x40,0x40,0x40,0x7E},//2
{0x3E,0x2,0x2,0x3E,0x2,0x2,0x3E,0x0},//3
{0x8,0x18,0x28,0x48,0xFE,0x8,0x8,0x8},//4
{0x3C,0x20,0x20,0x3C,0x4,0x4,0x3C,0x0},//5
{0x3C,0x20,0x20,0x3C,0x24,0x24,0x3C,0x0},//6
{0x3E,0x22,0x4,0x8,0x8,0x8,0x8,0x8},//7
{0x0,0x3E,0x22,0x22,0x3E,0x22,0x22,0x3E},//8
{0x3E,0x22,0x22,0x3E,0x2,0x2,0x2,0x3E},//9
  { 
    0b00011000,
    0b00100100,    0b01000010,
    0b01000010,
    0b01111110,
    0b01000010,
    0b01000010,
    0b01000010
  }  ,//A
  { 
    0b01111100,
    0b01000010,
    0b01000010,
    0b01111100,
    0b01000010,
    0b01000010,
    0b01000010,
    0b01111100
  } ,//B
  { 
    0b00111100,
    0b01000010,
    0b01000000,
    0b01000000,
    0b01000000,
    0b01000000,
    0b01000010,
    0b00111100
  } ,//C
  { 
    0b01111100,
    0b01000010,
    0b01000010,
    0b01000010,
    0b01000010,
    0b01000010,
    0b01000010,
    0b01111100
  } ,//D
  { 
    0b01111110,
    0b01000000,
    0b01000000,
    0b01111000,
    0b01000000,
    0b01000000,
    0b01000000,
    0b01111110
  } ,//E
  { 
    0b01111110,
    0b01000000,
    0b01000000,
    0b01111000,
    0b01000000,
    0b01000000,
    0b01000000,
    0b01000000
  } ,//F
  { 
    0b00111100,
    0b01000010,
    0b01000000,
    0b01000000,
    0b01001100,
    0b01000010,
    0b00100010,
    0b00011100
  } ,//G
  { 
    0b01000010,
    0b01000010,
    0b01000010,
    0b01111110,
    0b01000010,
    0b01000010,
    0b01000010,
    0b01000010
  }  ,//H
  { 
    0b00010000,
    0b00010000,
    0b00010000,
    0b00010000,
    0b00010000,
    0b00010000,
    0b00010000,
    0b00010000
  } ,//I
  { 
    0b00000100,
    0b00000100,
    0b00000100,
    0b00000100,
    0b00000100,
    0b00000100,
    0b01000100,
    0b00111000
  } ,//J
  { 
    0b01000010,
    0b01000100,
    0b01001000,
    0b01010000,
    0b01100000,
    0b01010000,
    0b01001000,
    0b01000100
  } ,//K
  { 
    0b01000000,
    0b01000000,
    0b01000000,
    0b01000000,
    0b01000000,
    0b01000000,
    0b01000000,
    0b01111110
  } ,//L
  { 
    0b01000010,
    0b01000010,
    0b01100110,
    0b01011010,
    0b01000010,
    0b01000010,
    0b01000010,
    0b01000010
  },//M
  { 
    0b01100010,
    0b01100010,
    0b01010010,
    0b01010010,
    0b01001010,
    0b01001010,
    0b01000110,
    0b01000110
  } ,//N
  { 
    0b00111100,
    0b01000010,
    0b01000010,
    0b01000010,
    0b01000010,
    0b01000010,
    0b01000010,
    0b00111100
  }  ,//O
  { 
    0b01111100,
    0b01000010,
    0b01000010,
    0b01111100,
    0b01000000,
    0b01000000,
    0b01000000,
    0b01000000
  } ,//P
  { 
    0b00111100,
    0b01000010,
    0b01000010,
    0b01000010,
    0b01000010,
    0b01010010,
    0b01001010,
    0b00111100
  } ,//Q
  { 
    0b01111100,
    0b01000010,
    0b01000010,
    0b01111100,
    0b01010000,
    0b01001000,
    0b01000100,
    0b01000010
  } ,//R
  { 
    0b00111100,
    0b01000010,
    0b01000000,
    0b00111100,
    0b00000010,
    0b00000010,
    0b01000010,
    0b00111100
  } 
,//S
   { 
    0b00111110,
    0b00001000,
    0b00001000,
    0b00001000,
    0b00001000,
    0b00001000,
    0b00001000,
    0b00001000
  } ,//T
  { 
    0b01000010,
    0b01000010,
    0b01000010,
    0b01000010,
    0b01000010,
    0b01000010,
    0b01000010,
    0b00111100
  } ,//U
{0x42,0x42,0x42,0x42,0x42,0x42,0x24,0x18},//V
{0x0,0x49,0x49,0x49,0x49,0x2A,0x1C,0x0},//W
{0x0,0x41,0x22,0x14,0x8,0x14,0x22,0x41},//X
  { 
    0b01000010,
    0b01000010,
    0b00100100,
    0b00011000,
    0b00011000,
    0b00011000,
    0b00011000,
    0b00011000
  } ,//Y
{0x0,0x7F,0x2,0x4,0x8,0x10,0x20,0x7F},//Z
{0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0},// [Space]
};


void Write_Max7219_byte(unsigned char DATA)
{
  unsigned char i;
  digitalWrite(Max7219_pinCS1,LOW);    
  for(i=8;i>=1;i--)
  {     
    digitalWrite(Max7219_pinCLK1,LOW);
    digitalWrite(Max7219_pinDIN1,DATA&0x80);//Obtain the MSB of the data
    DATA = DATA<<1;
    digitalWrite(Max7219_pinCLK1,HIGH);
  }
}


void Write_Max7219(unsigned char address,unsigned char data)
{
  digitalWrite(Max7219_pinCS1,LOW);
  Write_Max7219_byte(address);
  Write_Max7219_byte(data); 
  digitalWrite(Max7219_pinCS1,HIGH);
}

void writeChar2Matrix(byte* databytes)
{
  int i;
  for(i=0;i<8;i++)
  {
    Write_Max7219(i+1,databytes[i]);
  }  
}

void Init_MAX7219(void)
{
Write_Max7219(0x09, 0x00);       //decode: BCD
Write_Max7219(0x0a, 0x03);       //Brightness
Write_Max7219(0x0b, 0x07);       //
Write_Max7219(0x0c, 0x01);       //
Write_Max7219(0x0f, 0x00);       //
}



void setup()
{
  pinMode(Max7219_pinCLK1,OUTPUT);
  pinMode(Max7219_pinCS1,OUTPUT);
  pinMode(Max7219_pinDIN1,OUTPUT);
  delay(50);
  Init_MAX7219();
  Serial.begin(9600);
}



void textloop(char* text)
{ 
  byte i,j,k;
  byte data[8];
  byte thischar, nextchar;
  for(j=0;j<strlen(text);j++)
  {
    thischar=strchr(chars,text[j])-chars; // Index des Buchstaben im disp1 Array
    // Index des nächsten Buchstaben im disp1 Array
    if (j+1<strlen(text)) nextchar=strchr(chars,text[j+1])-chars;
    else nextchar=strchr(chars,' ')-chars;
    
    for (k=0;k<8;k++)
    {
      for (i=0;i<8;i++)
      {
        data[i]=((unsigned int)disp1[thischar][i]<<8 | disp1[nextchar][i]) >>8-k;
      }
      writeChar2Matrix(data);
      delay(100);
    } 
  }     
}


void loop(){
long duration, inches, cm;
pinMode (pingPin1, OUTPUT);
digitalWrite(pingPin1, LOW);
delayMicroseconds(2);
digitalWrite(pingPin1, HIGH);
delayMicroseconds(10);
digitalWrite(pingPin1, LOW);
pinMode(inPin1, INPUT);
duration = pulseIn(inPin1, HIGH);
cm = microsecondsToCentimeters(duration);
for(i=1;i<9;i++)
    Write_Max7219(i,disp1[j][i-1]);
if(cm < 4){
 textloop(" TOR HAMBURG ");
}


Serial.println(cm, DEC);

delay(10);
}

long microsecondsToCentimeters(long microseconds)
{
return microseconds / 29 / 2;
}

Ich nehme mal an, deine Prozedur textloop() funktioniert, und dauert lang genug, dass danach der Ball längst wieder weg ist. ( Und dass während sie läuft, kein neues Tor gezählt werden muss. )

Brauchst du halt einen Spielstand-Zähler der um eins erhöht wird, wenn textloop() aufgerufen wird, und eine Funktion, die immer dann, wenn nicht deine textloop() läuft, diesen Stand anzeigt.

byte Spielstand;  

void loop() {
...
   if(cm < 4){
      textloop(" TOR HAMBURG ");
      if (Spielstand < 9) Spielstand++;
   }
   else
     AnzeigeZiffer( Spielstand ); // gibt fest 0 .. 9 aus

   Serial.println(cm, DEC);
   delay(10);
}

void AnzeigeZiffer( byte ziffer) {
  // keine Ahnung ob dies so stimmt
  byte* datap = disp1[ziffer];
  writeChar2Matrix(datap);
}

[Nachtrag:]
Die Funktion AnzeigeZiffer() habe ich mal aufs geratewohl geschätzt. (Ohne so eine Matrix zu haben) Das solltest du evtl. separat testen …

michael_x:
Ich nehme mal an, deine Prozedur textloop() funktioniert, und dauert lang genug, dass danach der Ball längst wieder weg ist. ( Und dass während sie läuft, kein neues Tor gezählt werden muss. )

Brauchst du halt einen Spielstand-Zähler der um eins erhöht wird, wenn textloop() aufgerufen wird, und eine Funktion, die immer dann, wenn nicht deine textloop() läuft, diesen Stand anzeigt.

byte Spielstand;  

void loop() {

  if(cm < 4){
      textloop(" TOR HAMBURG ");
      if (Spielstand < 9) Spielstand++;
  }
  else
    AnzeigeZiffer( Spielstand ); // gibt fest 0 … 9 aus

Serial.println(cm, DEC);
  delay(10);
}

void AnzeigeZiffer( byte ziffer) {
  // keine Ahnung ob dies so stimmt
  byte* datap = disp1[ziffer];
  writeChar2Matrix(datap);
}




[Nachtrag:]
Die Funktion AnzeigeZiffer() habe ich mal aufs geratewohl geschätzt. (Ohne so eine Matrix zu haben) Das solltest du evtl. separat testen ...

Hei, erst mal danke für die Antwort…
In der Zeile byte datap… wird nen fehler erkannt… Die Meldung : Build-Optionen wurden verändert, alles wird neu gebaut
Neuster_Stand.ino: In function ‘void AnzeigeZiffer(byte)’:
Neuster_Stand:379: error: invalid conversion from ‘const unsigned char*’ to ‘byte {aka unsigned char}’ [-fpermissive]
Neuster_Stand:380: error: invalid conversion from ‘byte {aka unsigned char}’ to ‘byte* {aka unsigned char*}’ [-fpermissive]
Neuster_Stand:289: error: initializing argument 1 of ‘void writeChar2Matrix(byte*)’ [-fpermissive]
invalid conversion from ‘const unsigned char*’ to ‘byte {aka unsigned char}’ [-fpermissive]

Sorry für die späte Antwort: Der Compiler hat natürlich recht, es muss

[b]const[/b] byte * datap = disp1[ziffer];

heissen

Und die Funktion WriteChar2Matrix sollte besser als

void writeChar2Matrix([b]const[/b] byte* databytes)
{
...
}

definiert werden