Lowest 8 bits (byte)of number, bits 7..0.

Function returns the lowest byte of number. Function does not interpret bit patterns of number – it merely returns 8 bits as found in register.

This is an “inline” routine; code is generated in the place of the call, so the call doesn’t count against the nested call limit.

Arguments must be variable of scalar type (i.e. Arithmetic Types and Pointers).

d := 0x12345678; 	
tmp := Lo(d);  // Equals 0x78

Lo(d) := 0xAA; // d equals 0x123456AA

Returns next to the lowest byte of number, bits 8..15.

Function returns next to the lowest byte of number. Function does not interpret bit patterns of number – it merely returns 8 bits as found in register.

This is an “inline” routine; code is generated in the place of the call, so the call doesn’t count against the nested call limit.

Arguments must be variable of scalar type (i.e. Arithmetic Types and Pointers).

d := 0x12345678; 	
tmp := Hi(d);  // Equals 0x56

Hi(d) := 0xAA; // d equals 0x1234AA78

Returns next to the highest byte of number, bits 16..23.

Function returns next to the highest byte of number. Function does not interpret bit patterns of number – it merely returns 8 bits as found in register.

This is an “inline” routine; code is generated in the place of the call, so the call doesn’t count against the nested call limit.

Arguments must be variable of scalar type (i.e. Arithmetic Types and Pointers).

d := 0x12345678; 	
tmp := Higher(d);  // Equals 0x34

Higher(d) := 0xAA; // d equals 0x12AA5678

Returns the highest byte of number, bits 24..31.

Function returns the highest byte of number. Function does not interpret bit patterns of number – it merely returns 8 bits as found in register.

This is an “inline” routine; code is generated in the place of the call, so the call doesn’t count against the nested call limit.

Arguments must be variable of scalar type (i.e. Arithmetic Types and Pointers).

d := 0x12345678; 	
tmp := Highest(d);  // Equals 0x12

Highest(d) := 0xAA; // d equals 0xAA345678

The function returns low word of val. The function does not interpret bit patterns of val – it merely returns 16 bits as found in register.

Parameters :

• val: input value

Low word of val, bits 15..0.

Nothing.

d := 0x12345678; 	
tmp := LoWord(d);  // Equals 0x5678

LoWord(d) := 0xAAAA; // d equals 0x1234AAAA

None.

The function returns high word of val. The function does not interpret bit patterns of val – it merely returns 16 bits as found in register.

Parameters :

• val: input value

High word of val, bits 31..16.

Nothing.

d := 0x12345678; 	
tmp := HiWord(d);  // Equals 0x1234

HiWord(d) := 0xAAAA; // d equals 0xAAAA5678

None.

Nothing.

Increases parameter par by 1.

Nothing.

p := 4;
Inc(p);  // p is now 5

Nothing.

Decreases parameter par by 1.

Nothing.

p := 4;
Dec(p);  // p is now 3

Returns a character associated with the specified character code.

Function returns a character associated with the specified character code. Numbers from 0 to 31 are the standard non-printable ASCII codes.

This is an “inline” routine; the code is generated in the place of the call.

Nothing.

c := Chr(10);  // returns the linefeed character

ASCII code of the character.

Function returns ASCII code of the character.

This is an “inline” routine; the code is generated in the place of the call.

Nothing.

c := Ord('A');  // returns 65

Nothing.

Function sets the bit rbit of register. Parameter rbit needs to be a variable or literal with value 0..7. See Predefined globals and constants for more information on register identifiers.

This is an “inline” routine; code is generated in the place of the call, so the call doesn’t count against the nested call limit.

Nothing.

SetBit(PORTB, 2);  // Set RB2

Nothing.

Function clears the bit rbit of register. Parameter rbit needs to be a variable or literal with value 0..7. See Predefined globals and constants for more information on register identifiers.

This is an “inline” routine; code is generated in the place of the call, so the call doesn’t count against the nested call limit.

Nothing.

ClearBit(PORTC, 7);  // Clear RC7

If the bit is set, returns 1, otherwise returns 0.

Function tests if the bit rbit of register is set. If set, function returns 1, otherwise returns 0. Parameter rbit needs to be a variable or literal with value 0..7. See Predefined globals and constants for more information on register identifiers.

This is an “inline” routine; code is generated in the place of the call, so the call doesn’t count against the nested call limit.

Nothing.

flag := TestBit(PORTE, 2);  // 1 if RE2 is set, otherwise 0

Nothing.

Creates a software delay in duration of time_in_us microseconds (a constant). Range of applicable constants depends on the oscillator frequency.

This is an “inline” routine; code is generated in the place of the call, so the call doesn’t count against the nested call limit.

Nothing.

Delay_us(1000);  // One millisecond pause 

Nothing.

Creates a software delay in duration of time_in_ms milliseconds (a constant). Range of applicable constants depends on the oscillator frequency.

This is an “inline” routine; code is generated in the place of the call, so the call doesn’t count against the nested call limit.

Nothing.

Delay_ms(1000);  // One second pause 

Nothing.

Creates a software delay in duration of time_in_ms milliseconds (a variable). Generated delay is not as precise as the delay created by Delay_ms.

Note that Vdelay_ms is library function rather than a built-in routine; it is presented in this topic for the sake of convenience.

Nothing.

pause := 1000;
Vdelay_ms(pause);  // ~ one second pause

Nothing.

Creates a software delay in duration of time_in_ms milliseconds (a variable), for a given oscillator frequency. Generated delay is not as precise as the delay created by Delay_ms.

Note that Vdelay_ms is library function rather than a built-in routine; it is presented in this topic for the sake of convenience.

Nothing.

pause := 1000;
fosc := 10000;

VDelay_Advanced_ms(pause, fosc);  // Generates approximately one second pause, for a oscillator frequency of 10 MHz

Nothing.

Creates a delay based on MCU clock. Delay lasts for 10 times the input parameter in MCU cycles.

Note that Delay_Cyc is library function rather than a built-in routine; it is presented in this topic for the sake of convenience. There are limitations for Cycles_div_by_10 value. Value Cycles_div_by_10 must be between 2 and 257.

Nothing.

Delay_Cyc(10);  // Hundred MCU cycles pause

Device clock in kHz, rounded to the nearest integer.

Function returns device clock in KHz, rounded to the nearest integer.

This is an “inline” routine; code is generated in the place of the call, so the call doesn’t count against the nested call limit.

Nothing.

clk := Clock_kHz();

Device clock in MHz, rounded to the nearest integer.

Function returns device clock in MHz, rounded to the nearest integer.

This is an “inline” routine; code is generated in the place of the call, so the call doesn’t count against the nested call limit.

Nothing.

clk := Clock_MHz();

Device clock in kHz.

Function returns device clock in kHz, rounded to the nearest integer.

Get_Fosc_kHz is a library function rather than a built-in routine; it is presented in this topic for the sake of convenience.

Nothing.

clk := Get_Fosc_kHz();

Returns byte consisting of swapped nibbles.

Swaps higher nibble (bits 7..4) and lower nibble (bits 3..0) of byte-size parameter arg.

Nothing.

PORTB := 0xF0;
PORTA := Swap(PORTB);  // PORTA = PORTB = 0x0F

Nothing.

This procedure is equal to assembler instruction reset. This procedure works only for P18.

Nothing.

Reset(); // Resets the MCU

Nothing.

This procedure is equal to assembler instruction clrwdt.

Nothing.

ClrWdt(); // Clears WDT

Nothing.

Use the DisableContextSaving to instruct the compiler not to automatically perform context-switching.
This means that no register will be saved/restored by the compiler on entrance/exit from interrupt service routine, except STATUS, WREG and BSR registers in high priority interrupt ('Fast Register Stack').

This exception can be overridden by placing an asm RETFIE, 0 instruction at the end of the high priority interrupt routine (with redirecting all routine exits to this instruction).
Thus, DisableContextSaving directive enables the user to manually write code for saving registers upon entrance and to restore them before exit from interrupt.

This routine must be called from main.

DisableContextSaving(); // instruct the compiler not to automatically perform context-switching

Nothing.

If the linker encounters an indirect function call (by a pointer to function), it assumes that any routine whose address was taken anywhere in the program can be called at that point if it's prototype matches the pointer declaration.

Use the SetFuncCall directive within routine body to instruct the linker which routines can be called indirectly from that routine :
SetFunCCall (called_func[, ,...])

Routines specified in the SetFunCCall argument list will be linked if the routine containing SetFunCCall directive is called in the code no matter whether any of them was explicitly called or not.

Thus, placing SetFuncCall directive in main will make compiler link specified routines always.

Nothing.

procedure first(p, q: byte);
begin
...
  SetFuncCall(second); // let linker know that we will call the routine 'second'
...
end

Nothing.

Use the SetOrg() routine to specify the starting address of a routine in ROM.

This routine must be called from main.

SetOrg(UART1_Write, 0x1234);

String with date and time when this routine is compiled.

Use the GetDateTime() to get date and time of compilation as string in your code.

Nothing.

str := GetDateTime();

String with date and time when this routine is compiled.

Use the DoGetDateTime() to get date and time of compilation as string in your code.

Nothing.

str := DoGetDateTime();

String with current compiler version.

Use the GetVersion() to get the current version of compiler.

Nothing.

str := GetVersion(); // for example, str will take the value of '8.2.1.6'

String with current compiler version.

Use the DoGetVersion() to get the current version of compiler.

Nothing.

str := DoGetVersion(); // for example, str will take the value of '8.2.1.6'

Allocates a block of memory from the memory Heap, taking care of the alignment. It is recommended to use this routine instead of GetMem.

• Ptr: variable of any pointer type, pointing to an object which is to be allocated.

Returns a pointer to the memory block allocated by the function; Otherwise 0 (no free blocks of memory are large enough).

Nothing.

None.

Disposes a block of memory from the memory Heap, referenced by Ptr and returns its memory to the Heap.

• Ptr: variable of any pointer type previously assigned by the New procedure.

Nothing.

After calling this routine, the value of Ptr is nil (0) (not assigned pointer).