STM32: Bitbanding für Arrays?

[Christian J. (Gast)]

Hallo,
kann mir jemand sagen bzw Code zur Vefügung stellen, wie man einen Array 
per Bitbanding anspricht?

Ich habe eine Art FAT in einem EEPROM, lese diese ein in

uint8_t ee_fat[1024];

wobei jedes Bit einen benutzten Sektor abbildet. 8 Bit sind also 8 
"Sektoren". Die Adresse der Daten berechne ich dann aus der Bitposition. 
Wäre nur schön, wenn man den ganzen Array oben als ein Bitfeld hätte. 
Ich habe leider nur Makros, für 32 Bit Variablen und die sind nicht ganz 
so trivial.

Was fehlt wäre sowas wie testbit(ee_fat,1234)

Oder gibt es sowas wie:

struct {
unsigned int data:8760;  // 8760 Bits
}

vermutlich eher weniger, meine Bitfelder sind auf elementare Typen 
begrenzt.


Gruss,
Christian

[Dr. Sommer (Gast)]

Was spricht gegen einfache Bit-Operationen:

#include <limits.h>
#include <stdbool.h>
#include <stddef.h>

bool getBit (size_t index) {
  const size_t entrySize = sizeof(ee_fat[0]) * CHAR_BIT;
  return ee_fat [index / entrySize] & (1 << (index % entrySize));
}
void setBit (size_t index, bool value) {
  const size_t entrySize = sizeof(ee_fat[0]) * CHAR_BIT;
  const size_t bit = index % entrySize;
  ee_fat [index / entrySize] = (ee_fat [index / entrySize] & ~(1 << bit)) | (value << bit);
}

Ist dann sogar portabel und hängt nicht vom Bit-Banding einer 
spezifischen Hardware ab. Wenn du C++ nutzt, kannst du auch einfach 
std::bitset nehmen.

[Christian J. (Gast)]

Spricht nichts gegen..... sieht gut aus, probiere ich mal aus!

ee_fat [index / entrySize] = (ee_fat [index / entrySize] & ~(1 << bit)) 
| (value << bit);

Nicht ganz einfach zu verstehen... erst Bit löschen mit & ~(.. , dann 
das neue mit ODER danach einmaskieren?

Geht das hier auch noch eleganter?

     /* Bit setzen */
        LED_BitStream |= (uint64_t)(1ull << pos );
        /* 1 Bit evtl. blinken lassen */
        if (blink)
            /* Setze korrespondierende Position im Blink Stream */
            LED_BitStatus |= (uint64_t)(1ull << pos );
        else
            LED_BitStatus &= ~(uint64_t)(1ull << pos );

[Dr. Sommer (Gast)]

Christian J. schrieb:
> Nicht ganz einfach zu verstehen... erst Bit löschen mit & ~(.. , dann
> das neue mit ODER danach einmaskieren?
Ja genau.
> Geht das hier auch noch eleganter?
Geht auch, aber je nach Hardware kann es sein dass if-else-Konstrukte 
langsamer sind (wg. Pipeline & Branch-Prediction) als eine scheinbar 
kompliziertere Arithmetik. Kannst du ja einfach ausprobieren.

[Ruediger A. (Firma: keine) (rac)]

Christian J. schrieb:
> Spricht nichts gegen..... sieht gut aus, probiere ich mal aus!
>
> ee_fat [index / entrySize] = (ee_fat [index / entrySize] & ~(1 << bit))
> | (value << bit);
>
> Nicht ganz einfach zu verstehen... erst Bit löschen mit & ~(.. , dann
> das neue mit ODER danach einmaskieren?

Naja, der grosse Vorteil vom Bit Banding IST ja eben, dass die Operation 
auf dem Bit "atomisch" ist, d.h. wenn Du ein Bit über seinen Alias 
manipulierst, bleiben die anderen Bits im selben 32 Bit Wert unberührt. 
Du musst Dich also nicht mit Maskenoperationen herumschlagen.

Allerdings kannst Du durch funktionale Abstraktion die Maskenoperationen 
in den "traditionellen" Implementationen von Bitfeldern so einkapseln, 
dass Du sie genau an einer Stelle machen musst. Dann sind die Bitfelder 
so ziemlich gleichwertig... ausser... es gibt nebenläufigen Zugriff auf 
die Bitfelder (in dem Fall hilft Dir die Ununterbrechbarkeit der 
Operation beim Bit Banding, Nebenläufigkeitsprobleme zu umschiffen).

[(prx) A. K. (prx)]

Obacht: Bei Bitbanding sollte "ee_fat" als "volatile" deklariert werden, 
da der Compiler nicht weiss, dass die Bitbanding-Operationen darauf 
Einfluss haben.

Sollte ungefähr so mit Bitbanding funktionieren, ungetestet.

#define RAM_BASE_BYTES 0x12345678 // Basisadresse bitadressierbares RAM
#define RAM_BASE_BITS  0x87654321 // Spiegeladresse für Bitadressierung

#define bb_ram            ((volatile uint32_t *)RAM_BASE_BITS)
#define bb_offs(array)    ((unsigned)(array) - RAM_BASE_BYTES)
#define bb_bit(array,bit) bb_ram[bb_offs(array) * 8 + (bit)]

  bb_bit(ee_fat,123) = ...
  if (bb_bit(ee_fat,123)) ...

[Christian J. (Gast)]

Jo, danke!

Ich probiers heute abend dann mal aus am uC. Geht auch mehr um den Spass 
an der Sache als einen echten Nutzwert da stündliche Wettermessdaten 
abzuspeichern. Kann man auch aus Datenbanken abfragen wie die Werte wann 
wo waren.

[temp (Gast)]

ist es so was was du meinst?

#define BitBandMemAddr(addr, bitnum) ((volatile uint32_t*)(0x22000000 + (((uint32_t)(addr) & 0xFFFFF) << 5) + ((bitnum) << 2)))

volatile uint8_t   bitarray[10];

int main(void)
{
  volatile uint32_t *ba=BitBandMemAddr(&bitarray,0);
  ba[0]=1;
  ba[1]=1;
  ba[2]=1;
  ba[3]=1;
  ba[4]=1;
  ba[5]=1;
  ....

  ba[79]=1;

  if (ba[12])
    {

  ...
  ...

[Markus M. (Firma: EleLa - www.elela.de) (mmvisual)]

temp schrieb:
> ist es so was was du meinst?

Genau so geht das beim STM32, der hat extra Bitbanding Adressen um auf 
dem RAM einzelne Bits lesen/schreiben zu können.
Da braucht man nichts ausmaskieren/rechnen/zuweisen, das geht direkt.

[Christian J. (Gast)]

Markus M. schrieb:

> Genau so geht das beim STM32, der hat extra Bitbanding Adressen um auf
> dem RAM einzelne Bits lesen/schreiben zu können.

Das weiss ich :-) Es geht ja auch granuliert manuell aber damit geht es 
eben programmiertechnisch einfacher.

Diesen Trümmer habe ich gesucht:

#define BitBandMemAddr(addr, bitnum) ((volatile uint32_t*)(0x22000000 + 
(((uint32_t)(addr) & 0xFFFFF) << 5) + ((bitnum) << 2)))

[(prx) A. K. (prx)]

Markus M. schrieb:
> Da braucht man nichts ausmaskieren/rechnen/zuweisen, das geht direkt.

Umrechnen muss der Prozessor schon, nämlich die normale Byteadresse des 
Arrays in die Bitadresse des Spiegeladressraums. Aber man kann sich 
aussuchen wann man das tut. So sieht es jedenfalls eleganter aus:

#define RAM_BASE_BYTES 0x12345678 // Basisadresse bitadressierbares RAM
#define RAM_BASE_BITS  0x87654321 // Spiegeladresse für Bitadressierung

#define bb_ram            ((volatile uint32_t *)RAM_BASE_BITS)
#define bb_array(array)   (bb_ram + ((unsigned)(array) - RAM_BASE_BYTES) * 8)

  volatile uint32_t *ee_fat_bb = bb_array(ee_fat);

  ee_fat_bb[1234] = ...
  if (ee_fat_bb[1234]) ...

[Christian J. (Gast)]

temp schrieb:
> ist es so was was du meinst?
> #define BitBandMemAddr(addr, bitnum) ((volatile uint32_t*)(0x22000000 +
> (((uint32_t)(addr) & 0xFFFFF) << 5) + ((bitnum) << 2)))
>
> volatile uint8_t   bitarray[10];

Selbst ohne Optimierung ist das extrem schmal aber leider nicht debugbar
Und leider funktioniert es auch nicht.

    ba[0] = 1;
    ba[1] = 1;
    ba[2] = 0;
    ba[3] = 1;

    v1 = ba[0];
    v2 = ba[1];
    v3 = ba[2];
    v4 = ba[3];

v1 = 1;
V2 bis v4 = 0;



0x22003080 <error: Cannot access memory at address 0x22003080>

volatile uint8_t *ba = (uint8_t*)BitBandMemAddr(&ee_fat,0);
0800266A  ldr  r3, [pc, #376]  ; (0x80027e4 <main+476>)
0800266C  lsls  r3, r3, #5
0800266E  bic.w  r3, r3, #4261412864  ; 0xfe000000
08002672  bic.w  r3, r3, #31
08002676  add.w  r3, r3, #570425344  ; 0x22000000
0800267A  str  r3, [r7, #20]
(115)      ba[0] = 1;
0800267C  ldr  r3, [r7, #20]
0800267E  movs  r2, #1
08002680  strb  r2, [r3, #0]
(116)      ba[1] = 1;
08002682  ldr  r3, [r7, #20]
08002684  adds  r3, #1
08002686  movs  r2, #1
08002688  strb  r2, [r3, #0]

[Christian J. (Gast)]

Dr. Sommer schrieb:

> bool getBit (size_t index) {
>   const size_t entrySize = sizeof(ee_fat[0]) * CHAR_BIT;
>   return ee_fat [index / entrySize] & (1 << (index % entrySize));
> }
> void setBit (size_t index, bool value) {
>   const size_t entrySize = sizeof(ee_fat[0]) * CHAR_BIT;
>   const size_t bit = index % entrySize;
>   ee_fat [index / entrySize] = (ee_fat [index / entrySize] & ~(1 <<
> bit)) | (value << bit);
> }

Ich hoffe mal, dass ich das richtig umgeschrieben habe, da ich mit 
Zeigern und castings  auf Kriegsfuss stehe. Brauchte das Feld nämliuch 
als Parameter, ist ne lokale Variable.

bool getBit (uint8_t* p, size_t index) {
  const size_t entrySize = sizeof(p[0]) * CHAR_BIT;
  return p[index / entrySize] & (1 << (index % entrySize));
}
void setBit (uint8_t* p, size_t index, bool value) {
  const size_t entrySize = sizeof(p[0]) * CHAR_BIT;
  const size_t bit = index % entrySize;
  p[index / entrySize] = (p[index / entrySize] & ~(1 << bit)) | (value << bit);
}

[Dr. Sommer (Gast)]

Ja sieht doch gut aus. Funktioniert's nicht?

[Christian J. (Gast)]

Dr. Sommer schrieb:
> Ja sieht doch gut aus. Funktioniert's nicht?

In 5 MInuten kann ich  Dir das sagen.....

[Christian J. (Gast)]

Korrigiere mich, es funktioniert! War nur etwas dumm dargestellt im 
Watch. Nach umschalten auf Binärdarstellung ist die 1 da wo sie 
hingehört.

[Dr. Sommer (Gast)]

Also da funktioniert's:
https://ideone.com/7aKmc9

[Christian J. (Gast)]

Bei mir ja auch :-) Nur schade,  dass das mit dem Bitbanding nicht 
klappte.

Ist ganz schön viel:

12  ldr  r3, [r7, #8]
08000314  ldr  r2, [r7, #20]
08000316  udiv  r2, r3, r2
0800031A  ldr  r1, [r7, #20]
0800031C  mul.w  r2, r1, r2
08000320  subs  r3, r3, r2
08000322  str  r3, [r7, #16]
(77)    p[index / entrySize] = (p[index / entrySize] & ~(1 << bit)) | (value << bit);
08000324  ldr  r2, [r7, #8]
08000326  ldr  r3, [r7, #20]
08000328  udiv  r3, r2, r3
0800032C  ldr  r2, [r7, #12]
0800032E  add  r3, r2
08000330  ldr  r1, [r7, #8]
08000332  ldr  r2, [r7, #20]
08000334  udiv  r2, r1, r2
08000338  ldr  r1, [r7, #12]
0800033A  add  r2, r1
0800033C  ldrb  r2, [r2, #0]
0800033E  sxtb  r1, r2
08000340  movs  r0, #1
08000342  ldr  r2, [r7, #16]
08000344  lsl.w  r2, r0, r2
08000348  sxtb  r2, r2
0800034A  mvns  r2, r2
0800034C  sxtb  r2, r2
0800034E  ands  r2, r1
08000350  sxtb  r1, r2
08000352  ldrb  r0, [r7, #7]
08000354  ldr  r2, [r7, #16]
08000356  lsl.w  r2, r0, r2
0800035A  sxtb  r2, r2
0800035C  orrs  r2, r1
0800035E  sxtb  r2, r2
08000360  uxtb  r2, r2
08000362  strb  r2, [r3, #0]
(78)  }

[Dr. Sommer (Gast)]

Optimierungen eingeschaltet?! Die Division sollte eigentlich 
wegoptimiert werden.

[Christian J. (Gast)]

Dr. Sommer schrieb:
> Optimierungen eingeschaltet?! Die Division sollte eigentlich
> wegoptimiert werden.

Dann kann ich nicht mehr debuggen, weil der Source Code nicht mit dem 
Bin File übereinstimmt. Man kann keine BPs mehr setzen und der Codefluss 
ist chaotisch.

[(prx) A. K. (prx)]

Christian J. schrieb:
> volatile uint8_t *ba = (uint8_t*)BitBandMemAddr(&ee_fat,0);

Mach
  volatile uint32_t *ba = (uint32_t*)BitBandMemAddr(&ee_fat,0);
draus und die Sache wird besser aussehen. Der Bitbanding-Bereich bildet 
Bits auf Worte ab, nicht auf Bytes. Weshalb zwar

> (115)      ba[0] = 1;
> 0800267C  ldr  r3, [r7, #20]
> 0800267E  movs  r2, #1
> 08002680  strb  r2, [r3, #0]

noch funktioniert, nicht aber

> (116)      ba[1] = 1;
> 08002682  ldr  r3, [r7, #20]
> 08002684  adds  r3, #1
> 08002686  movs  r2, #1
> 08002688  strb  r2, [r3, #0]

[Christian J. (Gast)]

Der A.K. .... wenn wir ihn nicht hätten :-)

[temp (Gast)]

Christian J. schrieb:
> Selbst ohne Optimierung ist das extrem schmal aber leider nicht debugbar
> Und leider funktioniert es auch nicht.

Mein Code bezieht sich auf einen STM32F103C8 und da funtioniert das. Hab 
das eben nochmal in Debugger betrachtet. Leider hast du uns nicht 
verraten was du für einen Chip hast. Ob der Bitbang Bereich bei deiner 
CPU auch an 0x22000000 losgeht kann ich nicht in der Glaskugel lesen. 
Das der Code kurz wird ist ja genau das was damit erreicht werden soll. 
Aber die Doku dazu sollte man sich schon reinziehen.

[Christian J. (Gast)]

Genau den gleiche Schips.... Blaue Pille Board.
Wenn Du es im Debugger hast, dann schieb es doch mal rüber...

[temp (Gast)]

Nochmal gegoogelt. Alle M3 und M4 sollten das auf dieser Adress haben. 
M0 hat es überhaupt nicht.

[Christian J. (Gast)]

A. K. schrieb:
> Mach
>   volatile uint32_t *ba = (uint32_t*)BitBandMemAddr(&ee_fat,0);
> draus

Passt! Stimmt! Läuft! :-) Kotmäßig erheblich kürzer als das maskieren, 
nur 4 Befehle pro Bitsetzen, ohne Optimierung.

[Christian J. (Gast)]

temp schrieb:
> Nochmal gegoogelt. Alle M3 und M4 sollten das auf dieser Adress haben.
> M0 hat es überhaupt nicht.

Klappt auch ja jetzt, hatte falsch gecastet.

Jungs, ihr seit spitze! :-)

[Dr. Sommer (Gast)]

Christian J. schrieb:
> Dann kann ich nicht mehr debuggen, weil der Source Code nicht mit dem
> Bin File übereinstimmt. Man kann keine BPs mehr setzen und der Codefluss
> ist chaotisch.
Geht schon, ist etwas fummeliger. Wenn du die Optimierungen nicht nutzt, 
beschwer dich nicht dass der Code ineffizient ist. Aus der Division 
sollte ein Bitshift werden, aus dem Modulo ein "and". Wenn das 
unoptimierte Programm nicht in den Flash passt, nimmt man einen größeren 
Chip für das Debuggen und einen kleineren (in den das optimierte 
Programm passt) für die Serie. Falls man keine Serie produziert, braucht 
man auch nicht am Flash zu sparen.

[temp (Gast)]

Christian J. schrieb:
> Der A.K. .... wenn wir ihn nicht hätten :-)

Dass du sogar Fehler beim Kopieren machst habe ich auch nicht gleich 
gesehen...

[Christian J. (Gast)]

Dr. Sommer schrieb:
> Geht schon, ist etwas fummeliger. Wenn du die Optimierungen nicht nutzt,
> beschwer dich nicht dass der Code ineffizient ist.

In der Release Version ist natürliuch alles eingeschaltet, die ist auch 
20kb kürzer als die Debug Version. Nein, man kann nicht debuggen, Embitz 
schmiert sogar komplett ab, wenn man es versucht. Wenn der Code nicht 
zeile für zeile dem Kompilat entspricht ist Ende. Und ist ja nur Hobby, 
habe ja jetzt 128kb mit dem OCD Debugger und dem patch aus dem C103RB 
heraus geholt. Die haben ja alle 128kb statt 64. Schalte ich LTO ab und 
noch so eine Option bläst der Code auf 110kb auf und der geht noch rein.

[Dr. Sommer (Gast)]

Christian J. schrieb:
> Nein, man kann nicht debuggen, Embitz
> schmiert sogar komplett ab, wenn man es versucht. Wenn der Code nicht
> zeile für zeile dem Kompilat entspricht ist Ende.
Oy. Eclipse und GDB können das. Versuch mal -Og, das ist ein Kompromiss 
zwischen Debugbarkeit und Optimierung. Für Hobby kann man auch einfach 
einen F4 nehmen, die haben z.B. 1 MB, da braucht man sich gar keine 
Sorgen um Programmspeicher machen. Kostet ein paar Euro mehr und spart 
ein paar graue Haare.

[Christian J. (Gast)]

Ja, hat der Master auch, den 429er aber bei dem hier muss ich etwas 
knausern mit dem Platz.... packe das aber jetzt auch wieder weg und 
widme mich er Reparatur echter Hardware zum Anfassen, die auch glimmt 
und glüht und vor allem sehr schwer ist :-)

-Og klappt echt gut und ist sogar nur 4 kb größer als das Minimum.

Code ist echt atomar:

(87)      static storage_t DataToSafe[24];       /* Datenspeicher für 24h Stunden */
(88)  
(89)      volatile uint32_t *ba = (uint32_t*)BitBandMemAddr(&ee_fat,0);
08003086  lsls  r3, r4, #5
08003088  bic.w  r3, r3, #4261412864  ; 0xfe000000
0800308C  bic.w  r3, r3, #255  ; 0xff
08003090  add.w  r3, r3, #570425344  ; 0x22000000
(90)  
(91)      ba[0] = 1;
08003094  movs  r2, #1
08003096  str  r2, [r3, #0]
(92)      ba[1] = 0;
08003098  movs  r1, #0
0800309A  str  r1, [r3, #4]
(93)      ba[2] = 1;
0800309C  str  r2, [r3, #8]
(94)      ba[3] = 1;
0800309E  str  r2, [r3, #12]
(95)  
(96)      v1 = ba[0];
080030A0  ldr  r2, [r3, #0]
(97)      v2 = ba[1];
080030A2  ldr  r2, [r3, #4]
(98)      v3 = ba[2];
080030A4  ldr  r2, [r3, #8]
(99)      v4 = ba[3];
080030A6  ldr  r3, [r3, #12]

[Markus (Gast)]

Platz?
Diese F407 Board hier könnte noch auf Deine Platine passen:
http://www.ebay.de/itm/STM32F407VET6-ARM-Mini-Version-Core-Board-Cortex-M4-STM32-Minimum-System-Board-/122444767496?hash=item1c8246e108

[Christian J. (Gast)]

Dr. Sommer schrieb:
> Oy. Eclipse und GDB können das. Versuch mal -Og,

Könntest Du mir mal zeigen wie -Og definiert ist? In der offiziellen GNU 
Doku finde ich das nicht.

[Christian J. (Gast)]

Markus schrieb:
> Platz?
> Diese F407 Board hier könnte noch auf Deine Platine passen:
> Ebay-Artikel Nr. 122444767496

Kenne ich. Ich habe die Masterplatine mit dem 407 gemacht, einfach ein 
Disko Board drauf gesteckt, wo ich diverses vorher abgelötet habe, da 
ich es nicht brauche. Und etliches an Peripherie dran gebaut. Das wuchs 
immer mehr. Da nutze ich einiges mehr an SPIs und I2Cs, bzw auch die 180 
kb Ram. Aber für die kleinen Dinge reichen die 103 aus. Schnell muss 
nichts sein und Platz genug ist auch da. Habe 4 Timer im Einsatz, 2 als 
PWM, beide SPIs, eine I2C und noch die CRC Einheit, sowie die RTC und 
die Backup Register.

[Dr. Sommer (Gast)]

Christian J. schrieb:
> Könntest Du mir mal zeigen wie -Og definiert ist? In der offiziellen GNU
> Doku finde ich das nicht.

Ich schon:
https://gcc.gnu.org/onlinedocs/gcc/Optimize-Options.html

-Og
Optimize debugging experience. -Og enables optimizations that do not 
interfere with debugging. It should be the optimization level of choice 
for the standard edit-compile-debug cycle, offering a reasonable level 
of optimization while maintaining fast compilation and a good debugging 
experience.