C-Aufgabe: bedingtes Inkrementieren

nga schrieb:
> Es ist nichts schulisches oÄ sondern nur für ein privates Projekt.

Das klänge angesichts dieser exotischen Aufgabe überzeugender, wenn du 
was zum Projekt verrätst.

Kleiner Tip: Wenn ausschliesslich die gezeigten Information vorhanden 
ist, also ein einziger Zahlenwert zwischen 1 und 80, geht es nicht. Du 
kannst dir aber aussuchen, ob die fehlende Information aus Daten 
besteht, oder aus der Position im Verfahren.

Wie wärs mit einer union mit zwei getrennten Zählern?
Könnte gehen, habe aber nicht weiter drüber nachgedacht.

Martin

i = 0;

ISR:
  if (i & 1)
     sensor(1 + (i >> 1) % 16)
  else
     sensor(17 + (i >> 1));
  if (++i == 128)
     i = 0;

Gibt nicht die gleiche Reihenfolge, aber die gleiche Abfragefrequenz.

Keiner sagt das das ganze getimed sein soll. In meinem Verständnis geht 
es rein ums hochzählen.

Martin B. schrieb:
> Keiner sagt das das ganze getimed sein soll.

Doch. Er sagt das.

So kannst Du beliebige Reihenfolgen festlegen:


char aSlaves = { 1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,
                  17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,
                  1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,
                  33,34,.....


char uIndex = 0;

ISR(XXX)
{
        doSomethingWithSlave(uIndex);

        uIndex++;

        if(uIndex >= sizeof(aSlaves))
                uIndex = 0;
}

So kannst Du beliebige Reihenfolgen festlegen: 3. Versuch


char aSlaves = { 1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,
                  17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,
                  1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,
                  33,34,.....};


char uIndex = 0;

ISR(XXX)
{
        doSomethingWithSlave(aSlaves[uIndex]);

        uIndex++;

        if(uIndex >= sizeof(aSlaves))
                uIndex = 0;
}

Ja das ist richtig. Speicherintensiv, aber flexibel.
Und einfach zu verstehen :-)

Gruß

Olaf

A. K. schrieb:
> Martin B. schrieb:
>> Keiner sagt das das ganze getimed sein soll.
>
> Doch. Er sagt das.

OK,

aber man kann doch auch in einem Timer zwei Variablen zählen.

Olaf Dreyer schrieb:
> Speicherintensiv,

Ach wo. ROM pur geht auch:
  const _flash char aSlaves[] = ...
wenn leidlich aktueller avr-gcc.

nga schrieb:
> ich muss den Code nur noch verstehen ;)

Sollte nicht so schwer sein, das einfach mal durchlaufen zu lassen und 
den Index auszugeben. Dann siehst du auch, ob die abweichende 
Reihenfolge den Anforderungen entspricht.

0815 schrieb:
> Offensichtlich möchtest du 4 Abfrageblöcke machen,

Jetzt musst du das nur noch so umstellen, dass eine ISR draus wird. ;-)
Dass es darum geht hatte er erst verspätet verraten.

Ok, ich hab ne Idee. Die ist echt nicht so ganz trivial zu verstehen, 
aber mich hat das Problem gereizt.

Vielleicht hab ich auch was übersehen, dann bitte ich um ne Korrektur.

Zunächst mal braucht man als Ausgangspunkt ja einen Anhaltspunkt, wo man 
gerade in der Sequenz ist. Also zählt man mal statt der gesuchten Folge 
einfach von 0 bis 127 und schaut wie der gesuchte Wert korrespondiert. 
Dabei geh ich jetzt mal davon aus, dass der gesuchte Wert bei 0 beginnt 
und nicht bei 1, weil es das Rechnen erleichtert. Bei Bedarf halt eine 1 
am Ende addieren.

Also 16er Blöcke:

0 - 15 => 0 - 15 = Ausgangswert - 0
16 - 31 => 16 - 31 = Ausgangswert - 0
32 - 47 => 0 - 15 = Ausgangswert - 32
48 - 63 => 32 - 47 = Ausgangswert - 16
64 - 79 => 0 - 15 = Ausgangswert - 64
80 - 95 => 48 - 63 = Ausgangswert - 32
96 - 111 => 0 - 15 = Ausgangswert - 96
112 - 127 => 64 - 79 = Ausgangswert - 48

Wenn ich nun das obere Nibble des Ausgangswert betrachte und das Nibble 
des gesuchten Subtraktors daneben schreibe, komm ich auf:

000 | 000
001 | 000
010 | 010
011 | 001
100 | 100
101 | 010
110 | 110
111 | 011

(Das untere Nibble wird ja eh übernommen, also lass ich das hier weg.)

Ist das niedrigte Bit auf der linken Seite 0, bleibt der Wert 
unverändert. Ist er 1, wird der Wert um 1 nach rechts geschoben.

Der Wert wäre also (ich nehm mal index als 'Ausgangswert'.

index & 16 == 0 ? index & 0xf0 : (index & 0xf0) >> 1;

Also jetzt mal in einer Schleife:

for( int i = 0; i < 127; ++i) {
  int subtract = i & 0xf0;
  if( i & 16) {
    subtract >>= 1;
  }

  int result = i - subtract + 1;  // Add 1 to start the counting at 1.
}

Lieg ich falsch? Hab das jetzt mal nicht gecoded, also praktisch 
getestet, aber ich hoffe mal die Idee kommt rüber.

Ich hab's gerne kurz :-)

1

int i, j, block[] = { 1, 17, 1, 33, 1, 49, 1, 65 };

2

3

for( i=0; i<sizeof(block)/sizeof(*block); ++i )

4

  for( j=0; j<16; ++j ) 

5

    do_somtehing(block[i]+j);

Nicht getestet! Ich hoffe, ich habe nichts übersehen.

Mist! In meiner Lösung ist zumindest noch ein Fehler! Beim Schieben nach 
rechts, wird ja das unterste Bit ins untere Nibble geschoben.

Also hinter

subtract >>= 1;

noch  ein subtract &= 0xf0;

(7f ginge auch, da ja das oberste Bit eh nicht benutzt werden sollte.)

Gerne auch als ISR:

1

ISR()

2

{

3

  static int i=0, j=0, block[] = { 1, 17, 1, 33, 1, 49, 1, 65 };

4

5

  do_something(block[i]+j);

6

  if ( ++j < 16 ) 

7

    return;

8

  j=0;

9

  if ( ++i < sizeof(block)/sizeof(*block) )

10

    return;

11

  i=0;

12

}

Sollte noch kürzer gehen:

1

ISR()

2

{

3

  static int i=0, j=0, block[] = { 1, 17, 1, 33, 1, 49, 1, 65 };

4

5

  do_something(block[i]+j);

6

  ++j < 16 || (j=0, ++i < sizeof(block)/sizeof(*block) || i=0);

7

}

Noch kurz eine Variante ohne if, wenn es etwas kryptischer sein soll ;)

1

int getID(int input) {

2

  return 1 + (input & 0x0f) + (((input & 0x10) >> 4) * (((input & 0xe0) + 0x20) >> 1));

3

}

input = 0 .. 127
output = wie oben

Ähnlich wie Arc Nets Vorschlag (und genauso kryptisch ;-)), aber
zusätzlich ohne die Multiplikation. Außerdem muss die Zählvariable nicht
auf 0..127 begrenzt werden, man kann sie einfach bis zum Wrap-Around
durchlaufen lassen:

1

void isr(void) {

2

  static unsigned char i;

3

  do_something((i&15|~(i&16)+1&(i>>1&48)+16)+1);

4

  i++;

5

}

Leute, Leute, das geht ja schnell hier ;)
Ich werde heute oder in den nächsten Tagen die Lösungen testen, dann 
werde ich berichten.

Nochmal ein großes Dankeschön an alle