Accessing Individual Bits
The mikroBasic PRO for FT90x allows you to access individual bits of registers, variables or constants. It also supports sbit
and bit
data types.
Lets use the bit 0 from the GPIO_PORT_00_07 as an example. This register is defined in the definition file of the particular MCU as :
dim GPIO_PORT_00_07 as byte absolute 0x0001008; volatile sfr
To access this bit in your code by its name, you can write something like this :
' Clear GPIO_PORT_00_07 Bit 0 GPIO_PORT_00_07 = 0
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
, … , B31
, or 0
, 1
, … 31
, with 31
being the most significant bit :
' predefined GPIO_PORT_00_07 as bit designators ' Clear bit 0 in GPIO_PORT_00_07 register GPIO_PORT_00_07.B0 = 0 ' literal constant as bit designator ' Set bit 5 in GPIO_PORT_00_07 register GPIO_PORT_00_07.5 = 1 ' expression as bit designator ' Set bit 6 in GPIO_PORT_00_07 register i = 5 GPIO_PORT_00_07.(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 FT90x and can be used anywhere in the code. Identifiers B0
–B31
are not case sensitive and have a specific namespace.
You may override them with your own members B0
–B31
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 PIN0 Bit GPIO_PIN0_bit = 1
In this way, if the GPIO_PIN0_bit
changes its register or position in the register, you are sure that the appropriate bit will be affected.
sbit type
The mikroBasic PRO for FT90x 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:
module MyModule dim Abit as sbit sfr external ' Abit is precisely defined in some external file, for example in the main program unit ... implements .... end.
In the main program you have to specify to which register this sbit points to, for example:
program MyProgram ... dim Abit as sbit at GPIO_PORT_00_07.0 ' this is where Abit is fully defined ... main: ... end.
In this way the variable Abit
will actually point to GPIO_PORT_00_07.0. Please note that we used the keyword sfr
for declaration of Abit
, because we are pointing it to GPIO_PORT_00_07 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:
module Mymodule dim AnotherBit as sbit external ' Abit is precisely defined in some external file, for example in the main program unit ... implements ... end.
program MyProgram ... dim MyVar as byte dim Abit as sbit at MyVar.0 ' this is where Abit is fully defined ... main: ... 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 :
module MyModule dim PORTAlias as byte external ' here in the library we can use its symbolic name ... implements ... end.
program MyProgram ... dim PORTAlias as byte at GPIO_PORT_00_07 ' this is where PORTAlias is fully defined ... main: ... end.

at
operator in your code over a variable defined through a external
modifier, appropriate memory specifer must be appended also.
bit type
The mikroBasic PRO for FT90x 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.
dim bf as bit ' bit variable
There are no pointers to bit variables:
dim ptr as ^bit ' invalid
An array of type bit is not valid:
dim arr as array[5] of bit ' invalid

- Bit variables can not be initialized.
- Bit variables can not be members of structures.
- Bit variables do not have addresses, therefore unary operator
@
(address of) is not applicable to these variables.
What do you think about this topic ? Send us feedback!