Accessing Individual Bits

The mikroPascal PRO for ARM allows you to access individual bits of 16-bit variables. It also supports sbit and bit data types.

Lets use the GPIO_PORTA bit 0 as an example. This bit is defined in the definition file of the particular MCU as :

const GPIO_PORTA_DATA0 = 0; register;
var   GPIO_PORTA_DATA0_bit : sbit at GPIO_PORTA_DATA.B0;

To access this bit in your code by its name, you can write something like this:

// Clear GPIO_PORTA.0 Bit
GPIO_PORTA_DATA.GPIO_PORTA_DATA0 := 0;

In this way, if GPIO_PORTA.0 bit changes its position in the register, you are sure that the appropriate bit will be affected.
But, if Sleep bit is not located in the designated register, you may get errors.

Another way of accesing bits is by using the direct member selector (.) with a variable, followed by a primary expression. Primary expression can be variable, constant, function call or an expression enclosed by parentheses. For individual bit access there are predefined global constants B0, B1, … , B15, or 0, 1, … 15, with 15 being the most significant bit :

// predefined globals as bit designators
// Clear bit 0 in GPIO_PORTA_DATA register 
GPIO_PORTA_DATA.B0 := 0;

// literal constant as bit designator
// Set bit 5 in GPIO_PORTA_DATA register 
GPIO_PORTA_DATA.5 := 1;

// expression as bit designator
// Set bit 6 in GPIO_PORTA_DATA register 
i := 5;
GPIO_PORTA_DATA.(i+1) := 1;

In this way, if the target bit changes its position in the register, you cannot be sure that you are invoking the appropriate bit.

This kind of selective access is an intrinsic feature of mikroPascal PRO for ARM and can be used anywhere in the code. Identifiers B0–B15 are not case sensitive and have a specific namespace.

You may override them with your own members B0–B15 within any given structure.

When using literal constants as bit designators instead of predefined ones, make sure not to exceed the appropriate type size.

Also, you can access the desired bit by using its alias name :

// Set GPIO_PORTA.0 Bit 
GPIO_PORTA_DATA0_bit := 1;

In this way, if the Sleep bit changes its register or position in the register, you are sure that the appropriate bit will be affected.

See Predefined Globals and Constants for more information on register/bit names.

sbit type

The mikroPascal PRO for ARM compiler has sbit data type which provides access to registers, SFRs, variables, etc.
You can declare a sbit variable in a unit in such way that it points to a specific bit in SFR register:

unit MyUnit;
   
var Abit: sbit; sfr; external; // Abit is precisely defined in some external file, for example in the main program unit
...
implementation
....
end.

In the main program you have to specify to which register this sbit points to, for example:

program MyProgram;
...
var Abit: sbit at GPIO_PORTA_DATA.0; // this is where Abit is fully defined
...
begin
...
end.

In this way the variable Abit will actually point to GPIO_PORTA_DATA.0. Please note that we used the keyword sfr for declaration of Abit, because we are pointing it to GPIO_PORTB which is defined as a sfr variable.

In case we want to declare a bit over a variable which is not defined as sfr, then the keyword sfr is not necessary, for example:

unit MyUnit;
   
var AnotherBit: sbit; external; // Abit is precisely defined in some external file, for example in the main program unit
...
implementation
...
end.

program MyProgram;
...
var MyVar: byte;
var Abit: sbit at MyVar.0; // this is where Abit is fully defined
...
begin
...
end.

at keyword

You can use the keyword "at" to make an alias to a variable, for example, you can write a library without using register names, and later in the main program to define those registers, for example:

unit MyUnit;
   
var PORTAlias: byte; external; // here in the library we can use its symbolic name
...
implementation
...
end.

program MyProgram;
...
var PORTAlias: byte at GPIO_PORTA_DATA; // this is where PORTAlias is fully defined
...
begin
...
end.

bit type

The mikroPascal PRO for ARM compiler provides a bit data type that may be used for variable declarations. It can not be used for argument lists, and function-return values.

var bf : bit;    // bit variable

There are no pointers to bit variables:

var ptr : ^bit;    // invalid

An array of type bit is not valid:

var arr[5] : bit;     // invalid 

Related topics: Predefined globals and constants, External modifier