Geheugen probleem

International Nederlands
1

Hallo,

Ik ben bezig om date te versturen tussen twee MEGA's.

Ik loop alleen tegen een geheugenprobleem op. Na onderzoek heb ik best wel veel bool variabele die ik overstuur. Ik las op internet dat een bool en een byte even groot zijn. Ik wilde het zo maken dat 4 bool's in een byte gestopt worden.

Als je een byte binair weergeef zou er "0000" staan als de byte "leeg" is. Als de eerste bool hoog is, zou het "1000" zijn. De tweede bool hoog, "1100". De derde bool, "1110". En de vierde bool, "1111". En alle variaties daar op. Corrigeer me als ik heb niet helemaal goed heb.

Ik wilde een byte maken per 4 bools. Dus aan de ene zijde van de te versturen date wil ik 4 bools in een byte stoppen en aan de andere zijde wil ik 4 bool uit een byte halen. Dan zou ik met geheugen m.b.t. bools kunnen optimalieren met 75%.

De status van de bool zitten als het varen in het programma verwerkt en deze wordt automatische omgezet naar een byte.

boolA \                                                                   / boolA
boolB  \_byteABCD ---> DataStrucOut   {RS232}  DataStrucIn ---> byteABCD_/  boolB
boolC  /                                                                 \  boolC
boolD /                                                                   \ boolD

Ik zie veel voorbeelde met boolean arrays en for lussen, maar ik heb allemaal lossen bool variabele. Ik wil graag me functionele benamingen behouden in het programma.

Kan iemand mij helpen?

MvG,
Edwin

2

Kijk eens naar de boolean acties |, &, << en >>
het ene is boolean or het ander boolean en en de laatste 2 zijn bitshift left en right
Meer info in de reference

Voor het coderen iets in de zin van

byteABCD = boolA <<3 | boolB <<2 | boolC <<1 | boolD;

voor het decoderen iets als

boolA = 8 & byteABCD ==8;
boolB = 4 & byteABCD ==4;
3

Hoi rainman.

Het woord Byte is een fonetische samentrekking van de woorden "bit" en "eight".
Byte heeft dus 8 bits dus acht enen of nullen.

Daarmee is een wat jij noemt 'lege' byte 00000000.

Om het gecompliceerder te maken, is er wel iets dat uit 4 bits bestaat.
Dat heet een 'nibble', en een byte bestaat uit een lage en een hoge nibble.
De 4 linkse bits in een byte vormen de hoge nibble. en de rechtse de lage.
Leuk om te weten, maar wel historie.
Want er word in de praktijk nooit meer mee gewerkt.

Dit is geen muggenzifterij van mij, want het is belangrijk dat je weet waar je over praat als je een byte gaat declareren en er mee gaat werken.
Anders gooi je nog steeds de helft van de opslagruimte onnodig weg.

Verder moet je dan ook meteen weten wat dan de 1e en de laatste bit zijn, want uit je vraag blijkt dat je dat nog niet had opgepikt.
Wanneer je hier mee werkt, dan is het eerste getal niet 1 maar nul.
Een byte heeft dus 8 bits die oplopen van bit 0 naar bit 7, en dat gaat van rechts naar links.
Dat is exact hetzelfde als onze andere getallenstelsels (nou ja, degenen die ik ken).
Wanneer het getal hoger wordt, komt er aan de linkerkant een cijfer bij (van 9 naar 10 bijvoorbeeld).
Dus als je spreekt van het eerste bit, dan heb je het niet over 1000 in jouw voorbeeld, maar over 0001 (en dat is wel het eerste bit, maar bit nummer nul).
Dit is van belang tijdens het coderen en decoderen, dus vandaar dat ik dat vermeld.

4

Ik vraag me af wat voor geheugen problemen je hebt. Je moet nogal veel bools hebben voordat je die 8k geheugen vol hebt. Ik vermoed dat er een ander probleem is maar aangezien Sinterklaas dit jaar geen nieuwe kristallen bol heeft gebracht blijft dat bij een vermoeden. Misschien kun je je code met de geheugen problemen hier neerzetten.

Maar OK, misschien is een struct van bit fields een optie om bools efficienter te gebruiken.

struct myBooleans
{
  byte mijnEersteBool: 1;
  byte mijntweedeBool: 1;
  ...
  ...
  byte mijnTweeEnDertigsteBool: 1;
  byte mijnDrieEnDertigsteBool: 1;
  ...
  ...
};

myBooleans theBools;

Je kunt de booleans in de struct op de volgende manier gebruiken

theBools.mijnEersteBool = false;
if(theBools.mijnDrienEnDertigsteBool == true)
{
  ...
  ...
};

Om deze over te sturen via Serial1

Serial1.write((byte*)&theBools, sizeof(theBools));

Het eerste argument is het adres van theBools, 'omgezet' naar een pointer naar een byte. Het tweede element is het aantal bytes dat theBools in beslag neemt in het geheugen.

En een simpele methode om te ontvangen op Serial1

Serial1.readBytes((byte*)&theBools, sizeof(theBools));

Note:
niet getest

5

aanzetten doe je door een bit te zetten door byte | bitnummer
uitzetten met &
aan de andere kant kun je dus vragen byte &bitnummer.
kijk inderdaad naar de struct