Zahl zwischen 0 und 255 finden

[Elzaar (Gast)]

Abend,
Ich bin am verzweifeln ... ich muss einfach einfach nur ein Zahl 
zwischen 0 und 255 also eine 8bit Zahl finden.

Ich kann Fragen ob die "Zufalls Zahl" <= "Such Zahl" ist, der Ansatz ist 
mir klar aber ich habe ein off by 1 Fehler.

ich Gehe so Vor:
1. Such Zahl = 255;
2. Testen (OK es geht weiter), Fail -> Abbruch

Gehen wir davon aus es gibt min. 1 Slave.
3. Such Zahl /= 2 (also 127)
4. Testen OK (wieder halbieren), Fail (Such Adresse +=  Such Adresse/2)

wo ist den da mein Fehler und wie nennt sich so eine Näherungen damit 
ich mal googel befragen kann.

Gruß Elzaar

[Mike (Gast)]

Elzaar schrieb:
> wie nennt sich so eine Näherungen

Binäre Suche oder sukzessive Approximation

[Zweierkomplement (Gast)]

Naja, versuchs doch einfach mal herzuleiten:

Du checkst, ob die Zahl <= "10000000" ist. Wenn ja, dann ziehst Du 128 
ab und addierst 64 dazu (also ziehst du 64 ab). Wenn nein, dass addierst 
Du 64 dazu.
Anmerkung: In einer Loop von 7 downto 0 ist 128=2^7 und 64=2^6, also 
ziehst du 2^6 ab oder addierst es dazu.
Dasselbe mit 6, 5, 4, ... usw
Und schon hast du dein kleines Programm selbst geschrieben.

Abgesehen davon: Wie wird denn die Zahl repräsentiert. Naja letztendlich 
sagt die Zahl ja schon wie sie heißt, also was du findest ist die zahl 
an sich, so wie sie ggf. auch schon dargestellt ist.

Elzaar schrieb:
> ich Gehe so Vor:
> 1. Such Zahl = 255;
> 2. Testen (OK es geht weiter), Fail -> Abbruch
>
> Gehen wir davon aus es gibt min. 1 Slave.
> 3. Such Zahl /= 2 (also 127)
> 4. Testen OK (wieder halbieren), Fail (Such Adresse +=  Such Adresse/2)

Kann ich leider nix min anfangen bzw weiss nicht was du damit meinst.

Elzaar schrieb:
> off by 1 Fehler.

Dito

Bischen mehr info wäre hilfreich ...

[Zweierkomplement (Gast)]

Zweierkomplement schrieb:
> Wie wird denn die Zahl repräsentiert.

Also wenn sich beispielsweise jemand diese Zahl denkt, und dein 
Algorithmus denjenigen dann fragt, dann macht er das mit obiger Methode. 
Sind dann genau 8 Abfragen. (gleichbedeutend mit: Ist bit7=1? Ist 
bit6=1?, ... Ist bit0=1?)

Wenn die Zahl als Parameter übergeben wird, dann liegt sie halt schon 
vor --> Fertig.

Wenn die Zahl als Parameter übergegen wird, und du suchts ne Dezimalzahl 
dazu, gibts auch entsprechende Umwandlungsroutinen ...

[Karl H. (kbuchegg)]

Elzaar schrieb:

> wo ist den da mein Fehler

das weiß keiner, weil niemand dein Programm kennt und aus deiner 
konfusen Beschreibung keiner schlau wird.

Aber: es hilft oft extrem, wenn man als Programmierer sich Papier und 
Bleistift schnappt und sein Programm mal durchspielt. Also keine so 
windige Algorithmenbeschreibung, wie du sie hier abgeliefert hast, 
sondern tatsächlich dein Programm abarbeiten, mit allen Berechnungen 
(und zwar genau so wie sie in deinem Programm stehen). Und das was du 
laut Programm tust, das vergleichst du mit dem wie du dir vorstellst, 
dass die Dinge eigentlich laufen müssten.

> und wie nennt sich so eine Näherungen damit
> ich mal googel befragen kann.

Google kann dir nicht helfen deine Gedanken zu ordnen. Das kannst du nur 
selber.

[Elzaar (Gast)]

Also zur Hardware,

ich habe bis zu 16 Slaves auf einem Bus mit einem Rand Befehl such sich 
jeder Slave eine Adresse zwischen 0- 2^16-1 also eine 16 bit Adresse

zu Vorstellung:

Slave 1: Rand Adresse: 6000
Slave 2: Rand Adresse: 4000
Slave 3: Rand Adresse: 3000
Slave 4: Rand Adresse: 2000
Slave 5: Rand Adresse: 1000
Slave 6: Rand Adresse: 500

ps.: das das glatte Zahlen sind ist Tippfaulheit und nicht relevant.

Der Master Setz nun eine Suchadresse und sende diese an alle Slaves dann 
fragt er ein vergleich an, jeder Slave der eine kleinere oder gleiche 
Rand Adresse hat schreibt auf den Bus und der Master guckt ob auf dem 
Bus irgendwas kommt nur ein Timeout heißt das keine leuchte da ist.

Im Moment mach ich das so:

//ps ist aus einer Statemaschien raus gerissen
Serch_Step = 0x80;
SerchADD_H = 0x80;
SerchADD_L = 0xFF;
SET_Serch_ADD();

case suche_H:
               Serch_Step /= 2;

                if( !(Interface_tmp->flag & RX_TIMEOUT) ){   //OK -> Serch Address / 2
                    SerchADD_H  -= Serch_Step;
                }else{
                    SerchADD_H += Serch_Step;
                }

                if(Serch_Step == 0){ //Suchstep ist 0 und Antwort -> Suche Low Byte
                    if( !(Interface_tmp->flag & RX_TIMEOUT) ){   
                        Interface_tmp->APP_Error = 0;
                        SerchADD_L       = 0xFF;
                        Serch_Step       = 0x80;
                        SET_Serch_ADD();
                    }
                    else{                    //Suchstep ist 0 und keine Antwort -> wieder erhöhen und zurück
                        if(Interface_tmp->APP_Error++ < ERROR_ITER_CNT){
                            Interface_tmp->APP_State -= 2; //Step Back)
                            SerchADD_H++;
                            SET_Serch_ADD();
                        }
                        else{
                            Interface_tmp->APP_State = STATE_Random_Adressing+21; //neustart
                        }
                    }
                }else{
                    SET_Serch_ADD();
                    Interface_tmp->APP_State -= 2;   //und zurück
                }

und irgendwie finde ich das doch sehr umständlich, und dan gehts nicht 
mal richtig ...

[MaWin (Gast)]

> > ich Gehe so Vor:
> > 3. Such Zahl /= 2 (also 127)
> > 4. Testen OK (wieder halbieren), Fail (Such Adresse +=  Such Adresse/2)
> Binäre Suche oder sukzessive Approximation

Im Prinzip versucht er das, aber mit fehlerhaft hingeschriebenem 
Aktionen.

Man würde sowieso mit 128 anfangen.

[Elzaar (Gast)]

Sry mach ich ich ja ich Fange mit 0x80 an.

[Elzaar (Gast)]

Oh je ich muss auch mal meine Sprache sortieren ... xD