rekensom in C

Ik heb geen idee wat je bedoelt. Aan een bit kun je nooit meer zien waar het vandaan kwam uiteraard...

Delen (int) door 8?
12/8=1
18/8=2
25/8=3e byte
Modulo functie weet je welk bit ook nog

Normaal begin je bij byte 0 met tellen

Zonder een hoop achtergrond info zou ik zeggen: niet.
Een bit bevat maar heel weinig informatie. Namelijk of zijn waarde een 1 of een 0 is. Je kan dus onmogelijk weten uit welke van de beschikbare combinaties van 8 bits er eentje uitgeplukt is.
Dat is, tenzij er dus die achtergrond informatie is. Als elke bit bv een treshold van een sensor voorstelt, en die treshold wordt uit de data byte gehaald die die sensor doorstuurt, dan kan je dus aan de hand van de functie van die bit wel uitzoeken van welke sensor en dus van welke byte hij komt. Maar dat is dus niet iets wat een programma kan doen. Dat is iets dat de programmeur moet doen, zodat hij zijn programma kan vertellen naar welke bit ie moet kijken om iets uit te voeren.

je wilt waarschijnlijk weten dat als je de 25e bit telt dat dat bit 0 uit byte 3 is.

even los van of jij begint met tellen bij 0 of 1
deel je je bitnummer door 8 en dan heb je de byte index
doe je een module 8 dan heb je de bit index in die byte

even +1 of niet naar waar je begint met tellen

Jullie praten allemaal nederlands!
TS vraagt een andere taal:

    unsigned long bits = 0b11111111000000001111111100000000;
    cout << "byte\tbit\tvalue" << endl;
    for( int i=0; i<32; i++ ){
        int byte = i / 8;
        int bit  = i % 8;
        int value = bits & (1<<i) ? 1 : 0;
        cout << byte << "\t" << bit << "\t" << value << endl;
    }

resultaat:

byte    bit     value
0       0       0
0       1       0
0       2       0
0       3       0
0       4       0
0       5       0
0       6       0
0       7       0
1       0       1
1       1       1
1       2       1
1       3       1
1       4       1
1       5       1
1       6       1
1       7       1
2       0       0
2       1       0
2       2       0
2       3       0
2       4       0
2       5       0
2       6       0
2       7       0
3       0       1
3       1       1
3       2       1
3       3       1
3       4       1
3       5       1
3       6       1
3       7       1

EDIT:
@Arco, de vraag is niet duidelijk maar toch lees je niet goed. Er wordt niet gevraagd:
"Kun je van een bit zeggen uit welke byte die kwam?"
Maar:
"Kun je van het 12e bit zeggen uit welke byte dat kwam?"

Dan moet de vraag ook duidelijk(er) gesteld worden...
Ik lees nu "Kun je van een bit zeggen uit welke byte die kwam?". Antwoord is nee...

Aha, met die uitdraai van hennep denk ik te begrijpen wat TS bedoelt (als dat is wat ie bedoelt).
Ter bevestiging, maar wel in het nederlands:
TS wilt dus weten in welke "sub-byte" een bit zit van een getal dat groter is dan 1 byte?

Ik begreep de vraag ook niet maar met de voorzetjes van de antwoorden die aan dat van mij vooraf gingen kon ik het "vertalen"
Maar misschien zitten we er allemaal naast en heeft Arco toch gelijk en staat het antwoord op deze corona site: www.magikhethuisverlaten.nl

dan neem je het erg letterlijk
maar als ik het goed begrijp, dan deel je gewoon door 8 en krijg je meteen de byte waar die uit komt, +1 omdat ik met byte 0 begin.
ik dacht dat je dan een getal met een komma zou krijgen dus:

28e bit geeft 28:8 = 3 en niet 3,5

die ,5 is dan de modulo, maar die heb ik niet nodig.

Je moet wel een integer deling doen, anders krijg je inderdaad iets achter de komma...

de 12de bit die komt uit de 2de byte

Klinkt als "het 12de bit van een integer, uit het tweede byte van die integer".

Een byte heeft 8 bits. Meestal genummerd van 0 t/m 7. Dus die heeft nooit een 12de bit.

Een long int heeft wel 32 bits. Dus daar kun je dan wel de gevraagde bits uit halen. Het eerste byte heeft dan bits nr 0 t/m 7, het tweede byte heeft de bits 8 t/m 15 enz.

Als het 12de bit gegeven is dan is de vraag hoe. Kan zijn als getal. Dat kun je dan omrekenen naar een bitpositie door een shift operatie:

   int BitNr = 12;

   long int Bitmap;
   Bitmap |= 1 << (BitNr - 1);

Maar let op, want bits worden genummerd van 0 t/m 31. Het eerste bit is namelijk bit nummer 0, het tweede bit is bit nr 1 enz. Dus je moet wel weten wat die 12 precies betekent. Als je nummert van 1 t/m 32, dan moet je bij het schuiven 1 aftrekken. Als je nummert van 0 t/m 31 dan moet dat niet.

Kan ook zijn dat de bit wordt gegeven als integer waarde.
Die kun je dan terugrekenen door bits te tellen:

   long int BitValue = 1 << (12 - 1);

   for (int BitNr = 0; BitNr <32; BitNr += 1)
   {  if(BitValue & (1 << BitNr) )
      {  printf("Bit nr %d is hoog\n", (BitNr + 1) );
      }
   } 

Ook hier weer (12 - 1) en (BitNr + 1) omdat Bit 0 het eerste bit is.

Op 29 januari 2021 12:35:55 schreef Arco:
...een integer deling...

Dat is een lastige voor een beginnend C-programmeur
Of het een "integer deling" is is niet afhankelijk van het quotient (variabele f in dit geval) maar van het deeltal (28 in dit geval).

int i = 28 / 8;
cout << i << endl;
resultaat: 3

float f = 28 / 8;
cout << f << endl;
resultaat: 3

f = 28.0 / 8;
cout << f << endl;
resultaat: 3.5

f = (float)28 / 8;
cout << f << endl;
resultaat: 3.5

Ik heb ooit een C compiler gehad waarbij het resultaat afhankelijk was van het eerste getal achter het '=' teken (mogelijk een oudere versie van de Microsoft compiler, pre visual studio). Maar ik zie net dat GCC ook 28 / 8.0 als een floating point deling ziet.

hoe een simpele vraag toch moeilijk word, dat komt omdat ik voor de vraag enkel en alleen het noodzakelijke heb gegeven.dus iets uitgebreider voor de duidelijkheid.

die 12e bit komt uit een matrix van 300x300 (X,Y). in die matrix zit een 4-kant, met daarin weer een 4-kant (als een donut), waarvan ik de hoeken moet vinden (8 stuks dus).
de buitenste hoeken zijn ondertussen gevonden, ik ben nu bezig met de binnenste. hiervoor "scan" ik alleen het gebied binnen de 4 buitenste hoeken (= minder scannen = sneller).
dus stel de bovenste buitenste hor. lijn = 28 (had ik al gevonden), daar begin ik dus met scannen. alleen die staat in de externe ram in byte no: 4000.
dus ik moet een berekening doen om van die 28 naar het juist byte no: in de ext. RAM te komen.

Jij vindt het misschien een simpele vraag maar ik denk dat de meesten van ons vinden dat die moeilijk is gesteld
Hopelijk is de vraag beantwoord want ik heb geen idee wat je aan het doen bent. Je beschrijving maakt het niet duidelijker.
Succes met het zoeken van bits in bytes!

zal straks wel een plaatje posten, dan word het duidelijker. heb ik dacht ik al eens ergens gedaan.

[Bericht gewijzigd door trix op vrijdag 29 januari 2021 13:14:11 (39%)

Hier kan ik geen chocola van maken. Dit is alleen een algemene beschrijving, en in software gaat het juist om de details.

hier een link van een eerder topic over deze materie:

https://www.circuitsonline.net/forum/view/149958

Toen ik (slordige 50 jaar geleden) een beetje wiskunde leerde, kwamen de opgaven neer op
"Gegeven: xxx Gevraagd: yyy Oplossing: zzz"
"Gegeven: xxx Te bewijzen: yyy Bewijs: zzz"

Een duidelijke volledige ondubbelzinnige invulling van "gegeven" en "gevraagd" zou erg helpen om u te kunnen helpen.

Nogal tegenstrijdig daar ook.
Je begint op ram positie 1000. Terwijl de horizontale schaal genummerd is vanaf 1. Dus de eerste byte staat op 1001? En is dat decimaal of hex?

En dan heb je het over een matrix van 300x300, dus dan zou ik de tweede scanlijn verwachten op positie 1300 in de Ram, maar die staat op 2000?

Zolang het niet duidelijk is wat de spelregels precies zijn kun je daar nooit een programma voor schrijven.

spelregels zijn wel duidelijk, alleen moeilijk uit te leggen.

En dan heb je het over een matrix van 300x300, dus dan zou ik de tweede scanlijn verwachten op positie 1300 in de Ram, maar die staat op 2000?

nu zijn het er 300, maar dat kunnen er later meer worden. vandaar dat ik daar 1000 plekken voor reserveer.

En is dat decimaal of hex?

dat is decimaal.

maar dat kunnen er later meer worden. vandaar dat ik daar 1000 plekken voor reserveer.

Maak dan van dat aantal een variabele - of (in sommige talen, C bv.) een constante. Dan wordt de code leesbaarder voor anderen, wie weet zelfs ook voor uzelf.

ja wellicht,...houd ik in gedachten voor als ik er niet uitkom.
bedankt.

O. Dus zolang het enigszins kan gaat de voorkeur naar een rommeltje? Opkuis/verbetering enkel als het echt niet meer anders kan? Veel sukses gewenst, dan.

ik zie niet 1 2 3 hoe ik dat kan toepassen.
stel ik heb die 300 pos.op de X-as (in het plaatje zijn het er 75).
dan moet die 2e rij niet bij 2000 beginnen maar bij 1301 (zoals je al zei).
nu is dat niet zo heel moeilijk om dat te doen, dan moet ik bij het wegschrijven v/d data in de ext. RAM gewoon door nummeren i.p.v. lege plekken te reserveren voor toekomstige uitbreidingen.

alleen hoe dat de boel (veel) simpeler maakt zie ik niet.
probleem blijft een beetje dat ik een complete byte uit de ext. RAM haal, die ik moet "ontleden" om per bit te kunnen bekijken.