How to reference a bit in an int16 array?

[jani20]

Hello!

Pls help me to reference a bit in an int16 array.
Like in PIC Basic.

http://www.picbasic.co.uk/forum/showthread.php?t=544

How can I do that in CCS?

[Ttelmah]

There is not real advantage to using words, rather than bytes (remember the RAM is always byte orientated), but if you just want to treat the word array as if it was an array of bits, something like:
#define read_bitn(x,y) bit_test(*((int*)x+(y>>3)),y&7)
#define set_bitn(x,y) bit_set(*((int*)x+(y>>3)),y&7)
#define clear_bitn(x,y) bit_clear((*((int*)x+(y>>3)),y&7)

accessed with:

int16 Myarray[5];

set_bitn(MyArray,43);

Which will set the 43rd bit in the array.
The other functions will clear/read the bits respectively.

Best Wishes

[jani20]

Thanks!

But isnt that simplier when I make a bit array?
like this:

[jani20]

I tried to dived the 10bit to an 8bit pointer, and 2 one bit pointer.
But its says that pointing to a bit is not permitted:(

Your first code is a bit comlicated to me.
And the speed is also important.

I have 4 10bits in the array, when I save it out I think it would take a lot of time because this long define line.

in Basic I did it like this:

[Ttelmah]

[jani20]

Is there anyway to freely align an 8bit size pointer?
(bit aligned instead of byte?) (maybe in assembly?)
If this is possible some how than I could copy the 10bits
with 2 8bit pointer (overlaped each other in 6 bits).
Is it possible?

OR

I wrote this in PicBasic:

[Ttemah]

The output code you post, is not the assembler. Most of the commands, are _macros_, which will expand to extra code, in the actual assembler.
There is no way to directly access a bit array in the PIC processor. The basic, has a set of assembler macros, which do this, and are being used in the code you show. Guess what, they produce very similar code to the C macros I posted...

Best Wishes

[jani20]

Ok. Can you give some advice about how can I find more info about your C macro? Im just interested in the bit read line.
Is there any similar code explained in some documents, or online?
I searched google but nothing but nothing useable results.

Thank you.

[Mark]

if you are just trying to extract the 10bit values out of the array of bytes, then take a look at the rotate_left() or rotate_right() functions. You can rotate the value right by the correct number of bits so that the result is right justified. Then just take the first 2 bytes of the array and treat it as an int16. And this with 0x3FF to get the 10 bit result.

[Ttelmah]

The macros are just simple arithmetic. You can access an area of memory, as if it is an array of bytes, using C pointers. So if you have the address of an array (the name of an array, is it's address), and this is treated as an 'int' pointer, then:

*(name)

accesses the byte at this address. While:

*(name+1)

accesses the next byte.

Now because the array used, can be int8, or int16 or int32 values, to ensure that the compiler accesses it a byte at a time, a 'cast' is used:

*((int *)name)

ensures that all the pointer arithmetic is dealing with int8 values (CCS defaults to doing this, but the cast _makes sure_).

Now if you have a 'bit address', you need to access the byte corresponding to this address/8. Division is slow, but binary division (/2, /4 etc.), can be done by simply rotating the value, and is quick. So, given a bit number, the required byte, is accessed with:

*((int*)name+(bit_no>>3))

This takes the bit number/8, and adds it to the address, to find the required byte.

Now you have to access the bit in the byte.
CCS provides a set of functions (bit_set etc.), which access a specified bit in a byte. The bit to be accessed, is the remainder after the division by 8. This is also the low three bits of the original value. This is obtained using:

bit_no&7

Replace 'bit_no', and 'address', with x & y in the macro definitions, and you are there.

Best Wishes

[jani20]

Thats is, the bit_test function!!!!
I miss that out in the manual:(
But now I can do everything with this function and a pointer :D
Thank you very much!