74HC595 Ansteuerroutine als eigene void auslagern?

Hallo,

ich stehe gerade bei einem simplen Problem auf dem Schlauch :blush:
Das hier funktioniert:

int takt = 9; // SH_CP
int speicher = 8; // ST_CP
int daten = 10; // DS
int dimPin = 6; 
byte a[]={
  0b00000001,
  0b00000010,
  0b00000100,
  0b00001000,
  0b00010000,
  0b00100000,
  0b01000000,
  0b10000000,
  0b01000000,
  0b00100000,
  0b00010000,
  0b00001000,
  0b00000100,
  0b00000010
};

int i;
void setup(){
pinMode(takt, OUTPUT);
pinMode(speicher, OUTPUT);
pinMode(daten, OUTPUT);
pinMode(dimPin, OUTPUT);
analogWrite(dimPin, 0);
}

void loop(){
for(i=0;i<14;i++){
digitalWrite(speicher, LOW);
shiftOut(daten, takt, MSBFIRST, a[i]);
digitalWrite(speicher, HIGH);
delay(200);
}
}

Ich will aber das hier als eigene Funktion, z.b. void shift595 in die void setup auslagern, so das ich dann shift595 i direkt übergeben kann. So würde ich diese 3 Zeilen Code nur 1x als Funktion definieren.
Sinn des Ganzen ist, das ich noch ein paar Muster mehr ins Arry packe und die dann über shift595 direkt anspringe. Wie muß ich vorgehen? Ich kriege ums Verrecken nicht i (wofür ich dann ganze Zahlen nehme) übergeben :stuck_out_tongue_closed_eyes:
An analogWrite(dimPin, 0); stört euch mal nicht, das geht auf den Output Enable des 595. Später gehört dann optional noch ein analoger Eingang mit Fototransistor dazu. Das funktioniert in einem anderen Projekt so und ich habe den Code nur als Option gelassen und hart verdahtet, für volle Helligkeit.
Genau deswegen nutze ich nicht die I/O’s des Arduino, sondern nehme den 595, da ich dann alle Ausgänge auf eine gemeinsame Helligkeit dimmen kann. Der 328 hat keine 8 dimmbaren Ausgänge :wink:

Gruß Gerald

hi,

ich verstehe zwar nicht, warum Du i nicht übergeben kannst (dann halt nicht als globale variable definieren), aber besser und flxibler ist es sowieso, Du übergibst nur das array und nimmst in der funktion dann die größe des arrays ( i = sizeof(a) ).

gruß stefan

Sowas wie “eine void” gibt es nicht. void ist der Rückgabe-Wert der Funktion! In diesem Fall nichts. Die Dinger heißen einfach Funktionen und werden nur über ihren Namen identifiziert (und eventuell die Parameter, wenn sie überladen sind)

Meinst du einfach das?

void shift595(int index)
{
   digitalWrite(speicher, LOW);
   shiftOut(daten, takt, MSBFIRST, a[index]);
   digitalWrite(speicher, HIGH);
}

Oder wie vorgeschlagen du übergibst die Array Variable selbst:

void shift595(byte* a, int size)
{
      for(int i=0; i < size; i++)
      {
          digitalWrite(speicher, LOW);
          shiftOut(daten, takt, MSBFIRST, a[i]);
          digitalWrite(speicher, HIGH);
      }
}

Aufruf so:

shift595(a, sizeof(a));

Ich war so nahe dran :blush:
Ich habe es irgendwie nicht gebacken gekriegt, in der Funktionsdefinition mit int index noch eine weitere Zwischenvariable zu definieren. a Steckte in der Funktion, das nahm er nicht als Argument.
Ich habe jetzt gleich noch als 2. Argument die Zeit mit übergeben.

int takt = 9; // SH_CP
int speicher = 8; // ST_CP
int daten = 10; // DS
int dimPin = 6; 
byte a[]={
  0b00000000,
  0b00000001,
  0b00000010,
  0b00000100,
  0b00001000,
  0b00010000,
  0b00100000,
  0b01000000,
  0b10000000,
  0b11000000,
  0b11100000,
  0b11110000,
  0b11111000,
  0b11111100,
  0b11111110,
  0b11111111
};

void setup(){
pinMode(takt, OUTPUT);
pinMode(speicher, OUTPUT);
pinMode(daten, OUTPUT);
pinMode(dimPin, OUTPUT);
analogWrite(dimPin, 0);
}
void shift595(int index, int t)
{
   digitalWrite(speicher, LOW);
   shiftOut(daten, takt, MSBFIRST, a[index]);
   digitalWrite(speicher, HIGH);
   delay(t);
}

void loop(){
shift595 (1, 100);
shift595 (2, 100);
shift595 (3, 100);
shift595 (4, 100);
shift595 (5, 100);
shift595 (6, 100);
shift595 (7, 100);
shift595 (8, 100);
shift595 (9, 100);
shift595 (10, 100);
shift595 (11, 100);
shift595 (12, 100);
shift595 (13, 100);
shift595 (14, 100);
shift595 (15, 100);
shift595 (0, 250);
shift595 (15, 100);
shift595 (0, 250);
shift595 (15, 100);
shift595 (0, 250);
}

so geht's vermutlich am einfachsten. Kann dann bei Blitzsequenzen, wie unten, oder Mustern, die mehrmals laufen sollen, ja dann noch mit Schleifen arbeiten. Jedenfalls funzt es mit minimalem Tippaufwand. Copy & paste und nur noch Position im Arry und Zeit übergeben und fertig :smiley:
Danke nochmal, fürs auf die Sprünge helfen. Manchmal sieht man den Wald vor lauter Bäumen nicht.

Gruß Gerald

nix_mehr_frei:
Ich habe es irgendwie nicht gebacken gekriegt, in der Funktionsdefinition mit int index noch eine weitere Zwischenvariable zu definieren.

Die Variablen die man übergibt heißen Parameter oder Argumente. Wobei ersteres genau genommen die Variablen in der Funktionsdefinition selbst sind (also die Variablen die die übergebenen Werte aufnehmen), und letzteres die Variablen die man beim Aufruf übergibt.

a Steckte in der Funktion, das nahm er nicht als Argument.

Array Variablen sind Zeiger auf das erste Element. Um Arrays an eine Funktion zu übergeben, macht man also einfach einen Zeiger als Parameter:

void func(int* array, int size)
{
}

Alternativ geht auch das, aber das sieht man eher selten in professionellerem Code:

void func(int array[], int size)
{
}

Dabei wird aber auch nur ein Zeiger übergeben! Nicht das ganze Array

Siehe hier:

Da wird die Notation verwendet