Zahl zwischen 0 und 255 finden

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

Binäre Suche oder sukzessive Approximation

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 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 ...

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:

1

//ps ist aus einer Statemaschien raus gerissen

2

Serch_Step = 0x80;

3

SerchADD_H = 0x80;

4

SerchADD_L = 0xFF;

5

SET_Serch_ADD();

6

7

case suche_H:

8

               Serch_Step /= 2;

9

10

                if( !(Interface_tmp->flag & RX_TIMEOUT) ){   //OK -> Serch Address / 2

11

                    SerchADD_H  -= Serch_Step;

12

                }else{

13

                    SerchADD_H += Serch_Step;

14

                }

15

16

                if(Serch_Step == 0){ //Suchstep ist 0 und Antwort -> Suche Low Byte

17

                    if( !(Interface_tmp->flag & RX_TIMEOUT) ){   

18

                        Interface_tmp->APP_Error = 0;

19

                        SerchADD_L       = 0xFF;

20

                        Serch_Step       = 0x80;

21

                        SET_Serch_ADD();

22

                    }

23

                    else{                    //Suchstep ist 0 und keine Antwort -> wieder erhöhen und zurück

24

                        if(Interface_tmp->APP_Error++ < ERROR_ITER_CNT){

25

                            Interface_tmp->APP_State -= 2; //Step Back)

26

                            SerchADD_H++;

27

                            SET_Serch_ADD();

28

                        }

29

                        else{

30

                            Interface_tmp->APP_State = STATE_Random_Adressing+21; //neustart

31

                        }

32

                    }

33

                }else{

34

                    SET_Serch_ADD();

35

                    Interface_tmp->APP_State -= 2;   //und zurück

36

                }

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

> > 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.

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

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