Hi zusammen,
ich bastle im Moment an einem kleinen Projekt (wie bereits in einem anderen Thread angesprochen) bestehend aus 3 Charlieplex Gruppen zu je 6 LEDs. Das Programm dazu ist fertig und funktioniert. Jetzt möchte ich den Code allerdings noch ein bisschen aufräumen und übersichtlicher gestalten. Das habe ich soweit auch schon hinbekommen, allerdings macht mir ein Abschnitt noch ein bisschen Kopfzerbrechen.
byte Grp1 = 0b00000000;
int NrGrp1[6];
int indexGrp1 = 0;
int LEDout1 = 0;
int bitcount1 = 0;
for (int index = 0; index < 6; index++)
{
if (LED[index + 1] == true) // Check if LED should be driven
{
bitSet(Grp1, indexGrp1); // Write bit in byte
NrGrp1[indexGrp1] = index + 1; // Write LED Nr in int array
bitcount1 ++; // Number of active LEDs
indexGrp1 ++; // indexcounter
}
}
if (indexGrp1 >= 6)
indexGrp1 = 0;
if ((indexOut1 >= bitcount1) || (bitRead(Grp1, indexOut1) == false))
indexOut1 = 0;
// Write LED Nr sequentially in Output Array
if ((bitRead(Grp1, indexOut1) == true) && (indexOut1 < bitcount1))
{
LEDout1 = NrGrp1[indexOut1];
indexOut1 ++;
delay(outputDelay);
}
In meinem Programm werden die LEDs mittels Bool-Array angesteuert. Wenn also zB die LEDs 1, 3 und 6 leuchten sollen, sind LED[1], LED[2] und LED[6] true.
Der gezeigte Code Abschnitt macht jetzt folgendes: Es werden die bits im Array nacheinander auf true verglichen. Wenn das bit true ist, wird das erste Bit im Byte Grp1 gesetzt und die Nr der LED ins int Array NrGrp1 geschrieben.
Somit werden die zu steuernden LEDs nacheinander ins Array geschrieben.
Im unteren Bereich werden dann die LED Nummern nacheinander in den int LEDout1 geschrieben.
Eine weitere Funktion im Programm steuert die LEDs entsprechend der Nr an.
Der Sinn der Übung ist nun der, dass nur die LEDs angesteuert werden die auch benötigt werden. Wenn ich einfach nur das Array auslese und weitergebe werden auch die nicht benötigten LEDs ausgewertet. Duty-Cycle der LEDs sinkt somit.
Ich hoffe ich konnte es einiger Maßen verständlich erklären.
Diesen Abschnitt verwende ich in meinem Programm 4 mal. Nur eben mit abgeänderten Variablen. Also möchte ich diesen Abschnitt in eine Klasse packen und so verwenden. Ich habe jetzt einiges versucht, aber leider wird immer nur die niedrigste LED angesteuert. (Also wenn alle leuchten sollen, leuchtet nur die erste)
So sieht die Klasse aus:
class OutputCalculation {
private:
public:
bool LED[6]; // Bool Array for LEDs to be controled
int offset; // Offset for LED[X], if 0 begin with LED[0]
int outputDelay; // Usually not needed
int calc(bool LED[6], int offset, unsigned int outputDelay)
{
byte Grp = 0b00000000;
int NrGrp[6];
int indexGrp = 0;
unsigned int bitcount = 0;
int indexOut =0;
for (int index = 0; index < 6; index++)
{
if (LED[index + offset] == true) // Check if LED should be driven
{
bitSet(Grp, indexGrp); // Write bit in byte
NrGrp[indexGrp] = index + offset; // Write LED Nr in int array
bitcount ++; // Number of active LEDs
indexGrp ++; // indexcounter
}
}
if (indexGrp >= 6)
indexGrp = 0;
if ((indexOut >= bitcount) || (bitRead(Grp, indexOut) == false))
indexOut = 0;
// Write LED Nr sequentially in Output Array
if ((bitRead(Grp, indexOut) == true) && (indexOut < bitcount))
{
return NrGrp[indexOut];
indexOut ++;
delay(outputDelay);
}
}
};
Deklaration über loop
OutputCalculation outputGrp1;
Aufruf in loop
LEDout1 = outputGrp1.calc(LED, 1, outputDelay);
die drei Variablen in public müssen doch von "außen" zugänglich sein, oder irre ich mich da.
