Werte von ADC sortieren und Ausgang schalten

[Ron S. (bast-lwastl)]

Hallo Forum,
ich lasse meinen Atmega 8, über drei ADC_Kanäle, die Werte von drei 
verschidenen analogen Spannungen in den Datentyp uint16_t speichern. Die 
Variablen haben die Namen rot, blau und grün.
Über einen Bubblesort lass ich den Atmega die Werte von klein nach groß 
sortieren. Um dann mit den sortierten Werten einzelne Ausgänge 
anzusteuern.

Nun zu meiner Frage. Kann ich über eine if Kontrollstruktur vergleichen 
welche Farbe die kleinste ist? Bzw. sortiert das Bubblesort mir nur die 
Werte und lässt die Bezeichnung eifach an der Adresse stehen wo ich sie 
hin geschrieben hab?
Ich hoffe ihr versteht die Frage. Vielleicht versteht man es mit dem 
Auszug meines Quelltextes besser.

      rot = ADC_Read(0);    // Messung an Kanal 0 in rot speichern
      blau = ADC_Read(1);    // Messung an Kanal 1 in blau speichern
      gruen = ADC_Read(2);    // Messung an Kanal 2 in gruen speichern


   /* das Array zum Sortieren */

   int sort_array[] = { rot, blau, gruen };
   int N = sizeof(sort_array)/sizeof(int);

   bubble(sort_array, 7);


  if ( sort_array[0] == blau) {
      PORTB = (1<<0) & (0xff);
     }

[Karl H. (kbuchegg)]

if ( rot < blau )
  {
     // blau kann schon mal nicht das kleinste sein, denn rot ist kleiner

     if ( rot < grün )
     {
       // rot ist also kleiner als blau und kleiner als grün
       // da es sonst nichts mehr gibt, muss also rot die kleinste sein
     }

     else
     {
       // da rot kleiner als blau ist, und grün kleiner als rot
       // bleibt nur 1 SChluss: grün muss auch kleiner als blau sein
       // da grün kleiner als rot UND kleiner als blau ist, muss daher
       // grün die kleinste sein
     }
   }

   else
   {
     // blau ist schon mal kleiner oder zumindest gleich wie rot
     // was ist mit grün

     if( blau < grün )
     {
       // wenn blau kleiner als rot ist und auch noch kleiner als
       // grün, dann ist blau die kleinste
     }
     else
     {
       // blau ist nicht kleiner als grün.
       // Also muss grün kleiner als blau sein
       // -> grün ist die kleinste
     }
   }

Bei Gleichstand werden gewisse Farben präferiert. Schliesslich ist ja 
auch nicht definiert, welcher der 5-er in  rot:5, blau:5, grün: 5  der 
kleinere ist :-)

Bei 3 Werten kann man das noch ausprogrammieren. Bei 100 Werten geht das 
nicht mehr. Da benutzt man dann eine andere Technik.

[Ron S. (bast-lwastl)]

Bei drei verschidenen Werten ist das mit if else ja noch möglich. Aber 
ich will das später mit nen anderen µC auf 7 verschidene Werte erhöhen.

Da wird es meiner Meinung relativ viel und unübersichtlich mit if else.

Daher das bubblesort. Nimmt der Sortierbefehl den Namen des uint- Wertes 
beim sortieren mit?

als Beispiel: rot = 2
              blau = 1
              gruen = 3
nach der Sortierung : bau = 1
                      rot = 2
                      gruen =3
oder setht dann da rot = 1
                   blau =2
                   gruen =3
Ich frage das, weil mir jemand sagte, dass der Sortierbefehl nur die 
Zahlen sortieren würde aber nicht den Namen Variable mit nimmt.

[Karl H. (kbuchegg)]

Ron S. schrieb:
> Bei drei verschidenen Werten ist das mit if else ja noch möglich. Aber
> ich will das später mit nen anderen µC auf 7 verschidene Werte erhöhen.
>
> Da wird es meiner Meinung relativ viel und unübersichtlich mit if else.

da hast du nicht unrecht :-)

das macht man dann zb so (es gibt da mehrere Möglichkeiten).

Anstatt der Werte lässt du dir einen 'Index' entsprechend umsortieren.
Du nummerierst einfach die Werte durch.

      Deine Werte    Index

rot      25            1
grün     28            2
blau     17            3


Das Index-Array gibst du zum Sortieren. Aber anstelle dass du in der 
Vergleichsfunktion die beiden int-Zahlen i und j vergleichst, die du 
bekommst, basierst du deinen Vergleich auf Wert[i] und Wert[j].

D.h. die Sortierreihenfolge der 2-ten Spalte basiert auf den Werten der 
ersten Spalte. Als Ergebnis erhältst du

                       3
                       1
                       2

mit der Bedeutung: blau ist am kleinsten, danach kommt rot, gefolgt von 
grün.

[Ron S. (bast-lwastl)]

also ich verusch mich grade daran, das umzusetzen was du geschrieben 
hast.
Ich versteh wie du das meinst. Aber irgendwie komm ich nicht weiter.
Muss ich das array so schr.:

int Farbe [3];

     Farbe [1] = rot;
     Farbe [2] = blau;
     Farbe [3] = gruen;
den Farben hab ich bereits Werte zu gewiesen.

oder muss ich im Array direkt den Wert zu weisen?

Oder ist das ganz und gar der falsche Ansatz?

[Karl H. (kbuchegg)]

Ron S. schrieb:
> also ich verusch mich grade daran, das umzusetzen was du geschrieben
> hast.
> Ich versteh wie du das meinst. Aber irgendwie komm ich nicht weiter.
> Muss ich das array so schr.:
>
> int Farbe [3];
>
      Farbe [0] = 0;
      Farbe [1] = 1;
      Farbe [2] = 2;


Und jetzt sortierst du das Array Farbe, wobei du die kleiner-Beziehnung, 
welche die Sortierung steuern von sort_array abhängig machst

   ....

   // bubble sort
   sorted = false;

   while( ! sorted ) {

      sorted = true;

      for( i = 0; i < N-1; i++ )
      {
        // AChtung jetzt kommts!
        if( sort_array[ Farbe[i] ] < sort_array[ Farbe[i+1] ] )
        {
          tmp = Farbe[i];
          Farbe[i] = Farbe[i+1];
          Farbe[i+1] = tmp;

          sorted = false;
        }
      }
    }

    // In Farbe stehen die Nummern der Farben in der richtigen Reihenfolge
    // 0 = rot, 1 = blau, 2 = grüen
    //
    // dies deshalb, weil du in dieser Reihenfolge dein sort_array
    // int sort_array[] = { rot, blau, gruen };
    // angefüllt hast.
    // ist also Farbe[0] gleich 2, dann ist grün die kleinste