[c]Bepalen hoogste input waarde op een microcontroller

[Verwijderd]

Goedenavond allen, ik zit met het volgende probleem.

Er zijn 5 IR sensoren. Deze zijn op zo'n manier geschakeld aan de microcontroller dat elke sensor met elkaar vergeleken wordt en deze vergelijking als signaal binnenkomt. Een voorbeeld:

Sensor1 COMPARE Sensor2 (in de schakeling)
De microcontroller ontvangt een hoog signaal op de input wanneer 1 > 2, anders is het een laag signaal.

Simpel gezegd om de sensor met de hoogste input te bepalen zitten deze vergelijkingen elk op een input:

a. S1 > S2
b. S1 > S3
c. S1 > S4
d. S1 > S5

e. S2 > S3
f. S2 > S4
g. S2 > S5

h. S3 > S4
i. S3 > S5

j. S4 > S5

Dit worden echter een bult IF statements om te bepalen welke S het hoogste signaal heeft, waar ik eigenlijk een mooi algoritme voor probeer te vinden. Helaas laat mijn inzicht hier mij op het moment in de steek. Ik hooop dat mijn uitleg duidelijk is en mensen mij een zetje in de goede richting kunnen geven?

--------
edit:

hmm ik zie net in:

C:

if (a and b and c and d)
  highest = S1;
elseif (e and f and g)
  highest = S2;
elseif (h and i)
  highest = S3;
elseif (j)
  highest = S4;
else 
  highest = S5;

Mocht het makkelijker kunnen of maak ik hier een fout dan hoor ik het graag

[ Voor 22% gewijzigd door Verwijderd op 01-12-2004 01:05 ]

[DaCoTa]

Kun je een sensor nummer opslaan in een ander register? Dan kan je met een dummy register erlangs lopen. Dus zoiets als:

code:

reg higest = s1;
if(s2 > highest) highest = s2;
if(s3 > highest) highest = s3;
if(s4 > highest) highest = s4;
if(s5 > highest) highest = s5;

[Verwijderd]

Een optie is een switch

code:

switch {
 case a: 
 case b:
 case c:
 case d: { Als A of B of C of D dan S1
    break;
 }
 case e:
 case f:
 case g: {
    break;
 }

Je kan namelijk a t/m j apart testen en hebt dus geen ANDs nodig.

[NMe]

Ehm, waar switch je dan op?

[Virgil]

Een switch is lastig om het hoogste signaal te bepalen.
Wat dacota zegt, is imho de beste methode om te bepalen welk signaal het hoogst is.

[Haploid]

Verwijderd schreef op woensdag 01 december 2004 @ 00:33:
Mocht het makkelijker kunnen of maak ik hier een fout dan hoor ik het graag

Makkelijker denk ik niet, maar het kan wel met minder vergelijkingen, nl.:

C:

if (a) {
    if (b) {
        if (c) {
            highest=d?S1:S5;
        } else {
            highest=j?S4:S5;
        }
    } else {
        if (h) {
            highest=i?S3:S5;
        } else {
            highest=j?S4:S5;
        }
    }
} else {
    if (e) {
        if (f) {
            highest=g?S2:S5;
        } else {
            highest=j?S4:S5;
        }
    } else {
        if (h) {
            highest=i?S3:S5;
        } else {
            highest=j?S4:S5;
        }
    }
}

Zo krijg je minimaal en maximaal 4 vergelijkingen, onafhankelijk van welke het nou wordt, terwijl je in jouw oplossing maar liefst 10 vergelijkingen moet doen als het S5 blijkt te zijn. Zal verder niet zoveel uitmaken, maar goed.

edit:
Oh ja, maar DaCoTa's oplossing geniet uiteindelijk natuurlijk de voorkeur.

[ Voor 6% gewijzigd door Haploid op 01-12-2004 14:38 ]

[Elijan9]

Ik weet niet of die inputs voor het grootste deel op dezelfde poort zijn aangesloten, maar gesteld dat input a t/m j op dezelfde poort zijn aangesloten van bit 0 t/m bit 10, of in een unsigned short geplaatst kunnen worden op die volgorde, dan kun je doen:

C:

unsigned short readings = port_1;

if ((readings & 0x0f) == 0x0f)
{
    highest = s1;
}
else if ((readings & 0x71) == 0x70)
{
    highest = s2;
}
else if ((readings & 0x183) == 0x180)
{
    highest = s3;
}
else if ((readings & 0x207) == 0x200)
{
    highest = s4;
}
else
    highest = s5;

Buiten dit is de oplossing van Haploid het snelst en je eigen oplossing kwa codesize het kleinst.

En DaCoTa snapt de vraagstelling volgens mij niet helemaal

[ Voor 7% gewijzigd door Elijan9 op 01-12-2004 17:01 . Reden: port_1 kun je beter maar 1 keer inlezen... ]

[Verwijderd]

Wat je kunt doen is: je maakt een var aan die de hoogste waarde op t=t0 heeft (eerste inlees actie). Bij het inlezen van de volgende controleer je of de huidige ingelezen waarde hoger is dan de waarde in het geheugen zo ja - overschrijven, en helemaal netjes is om het via irq's te doen maar dat is afhankelijk van hoeveel irq pins je hebt, en natuurlijk van welke mcu je hebt etc..etc

Dit heeft 2 voordelen omdat je ze toch naar alle waarschijnlijkheid niet tegelijk inleest (dat kan niet eens)

Overigens, neem dat het voor de hobby is maar een comperator zou niet verkeerd zijn want je mcu zal nu constant bezig zijn met inlezen vergelijken etc..

Maar goed my 2 cents suc6