Newsgroup: it.hobby.elettronica.digitale
Titolo: Creare un array di bit in c anziche un array di byte

Ciao a tutti.premetto che programmo un microcontroller 8 bit con un 
compilatore C.
Il mio scopo è occupare meno memoria.
se io faccio static unsigned char arraylcd[2] = {1,0,1}
creo un'array di 3 bytes e poi ci faccio quello che voglio.
ma io voglio creare un'array di 3 bit anzichè 3 bytes.
è possibile ? come si fa' ? grazie.
Spectre

 Spectre


Il C non lo supporto direttamente, ma con qualche macro/funzione si 
riesce a fare.
Da una veloce ricerca su google ho trovato questo:
http://www.cs.umu.se/~isak/snippets/bitarray.c
Ciao

 Ciao

 
dichiara un byte e usa gli operatori bit a bit. 1 byte = 8 variabili da 1 
bit.
-- 
Nuno on zx-6r '04 & CRe 250 '99 working in progress...
La riforma della scuola č pronta
dieci casse Marshall dentro ogni aula

 
Grazie a tutti per le risposte
Spectre


A questo dovrebbe rispondere Spectre.
Secondo me, per 3 bit non conviene usare un bit array: si risparmiano 
2 byte di RAM e si occupa uno sfacelo di ROM in più (in proporzione).
La cosa può avere senso se si devono avere un sacco di flags 
(centinaia/migliaia), in quel caso il risparmio di RAM è consistente.
Sinceramente io non li ho mai usati, non mi è mai capitata la 
necessità di avere così tanti flags, però posso immaginarmi dei casi 
in cui potrebbero essere utili: per esempio per marcare 
regioni/blocchi come usati/non usati in un allocatore di memoria o in 
un file system.
-- 
  _|/ Francesco Sacchi - Develer S.r.l., R&D dept.
   |\ 
http://www.develer.com/
 - 
http://www.bertos.org

Francesco Sacchi ha scritto:

Ciao Francesco,
I tre byte erano per fare un'esempio.
Dovrei realizzare un array di 128 bit (usando 16 bytes di ram) con la 
possibilità di cambiare al volo lo stato dei singoli bit. Forse posso 
farlo con uno struct,però non sono certo se è possibile creare uno 
struct singolo di 128 bit o se devo farne 16 da o bit.
Saluti
Spectre


Puoi farlo con una struct con dentro 128 bitfields, però:
  - Dovrai perdere un po' di tempo a dichiarare singolarmente ogni campo
  - Non potrai accedere ai singoli campi tramite indice, come in un array
Per 128 bit ti consiglio di usare le funzioni indicate nel link, oppure 
se spieghi in dettaglio il problema magari scopriamo che ci sono altri 
sistemi per risolverlo.
Ciao

Gentile Francesco,
Ho verificato e posso creare (come dici anche tu ) il mio array  di 128 
bit con uno struct con uno struct.
Tutto sto' casino è per pilotare un lcd che ha un driver orrendo ma 
quello devo usare.
Ogni bit serve per accendere o spegnere un segmento (sono parecchi segmenti)
Pero':
Ho la necessità di cambiare al volo ogni singolo bit (quindi per questo 
andrebbe bene lo struct)
Una volta settati o resettati i singoli bit del mio bel array di 128 
bit,li devo sparare tutti in sequenza sulla linea di trasmissione verso lcd.
Come buffer di trasmissione ho una variabile da un byte che aggiorno
ogni volta che ho sparato sulla linea di trasmissione gli 8 bit 
contenuti in essa.successivamente aggiorno il buffer con i successivi 8 
bit dell'array fino ad arrivare a 128bit. poi la cosa si ripete 
all'infinito.
La rogna è che ogni 8 bit devo aggiornare il buffer (la variabile da 1 
byte).
Se potessi iterare sui 128 bit(come se fosse un'array normale) e 
spararli sulla linea di trasmissione uno dietro l'altro sarebbe piu' 
comodo,non dovrei aggiornare il buffer ogni 8 bit.
Qui sotto ti incollo la funzione che uso per leggere i singoli bit del 
buffer da 1 byte.
#define ValBit(VAR,Place)         ((u8)(VAR) & (u8)((u8)1<<(u8)(Place)))
if ((ValBit(LcdBitArray,LcdBitCount)) != 0 ) DATA1;
		else DATA0;
LcdBitArray è il buffer da un byte
LcdBitCount è l'indice del buffer da un byte (quindi da 0 a 7)
Quando è un uno setta un'uscita alta e viceversa.
E' scomodo perchè finiti gli 8 bit del buffer devo caricare i successivi 
8 e questo fino ad arrivare a 128 bit
Aspetto il tuo parere.
Spectre
Francesco Sacchi ha scritto:


 comodo,non dovrei aggiornare il buffer ogni 8 bit.
Non capisco perché non puoi usare la soluzione indicata nel link.
Risolve tutti i tuoi problemi. Invece di accedere ad un array, chiami la 
funzione getbit e in base al valore di ritorno setti a 1 o a 0 l'uscita:
/* Lunghezza, in bit, dell'array */
#define BITARRAY_LEN 128
/* Alloca l'array di bit */
uint8_t bit_array[(BITARRAY_LEN + 7) / 8];
/* Se vuoi settare il bit 42 a 1 puoi fare così */
setbit(bit_array, 42, 1);
/* Se vuoi settare il bit 22 a 0 puoi fare così */
setbit(bit_array, 22, 0);
/* Continui a fare tutte le operazioni che vuoi sui bit */
...
/* Infine, per inviare al display */
for (int i = 0; i < BITARRAY_LEN; i++)
{
	if (getbit(bit_array, i)
		DATA1;
	else
		DATA0;
}
Ciao

Gentile Francesco,
ho fatto come hai detto tu (creando un'array di bit con le macro) e 
funziona.
Grazie mille!
Ciao
Spectre
Francesco Sacchi ha scritto:
