Function returns the lowest byte of Argument. Function does not interpret bit patterns of Argument – 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.

• Argument: input value. Can be 16-bit or 32-bit value.

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

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

None.

Function returns next to the lowest byte of Argument. Function does not interpret bit patterns of Argument – 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.

• Argument: input value. Can be 16-bit or 32-bit value.

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

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

None.

Function returns next to the highest byte of Argument. Function does not interpret bit patterns of Argument – 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.

• Argument: input value. Can be of dword, longint or real type.

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

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

None.

Function returns the highest byte of Argument. Function does not interpret bit patterns of Argument – 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.

• Argument: input value. Can be of dword, longint or real type.

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

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

None.

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

• Argument: input value. Can be of word..real type.

Low word of Argument, bits 15..0.

Nothing.

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

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

None.

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

• Argument: input value. Can be of dword, longint or real type.

High word of Argument, bits 31..16.

Nothing.

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

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

None.

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

• Argument: input value. Can be of int64, uint64 or extended type.

Higher word of Argument, bits 47..32.

Nothing.

d := 0x1122334455667788;
tmp := HigherWord(d);  // Equals 0x33344

HigherWord(d) := 0xAAAA; // d equals 0x1122AAAA55667788

None.

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

• Argument: input value. Can be of int64, uint64 or extended type.

Highest word of Argument, bits 63..48.

Nothing.

d := 0x1122334455667788;
tmp := HighestWord(d);  // Equals 0x1122

HighestWord(d) := 0xAAAA; // d equals 0xAAAA334455667788

None.

The function returns low dword of Argument. The function does not interpret bit patterns of Argument – it merely returns 32 bits as found in register.

• Argument: input value. Can be of 32-bit or 64-bit type.

Low dword of Argument, bits 31..0.

Nothing.

d := 0x1122334455667788;
tmp := LoDword(d);  // Equals 0x55667788

LoDword(d) := 0xAAAAAAAA; // d equals 0x11223344AAAAAAAA

None.

The function returns high dword of Argument. The function does not interpret bit patterns of Argument – it merely returns 32 bits as found in register.

• Argument: input value. Can be of int64, uint64 or extended type.

High dword of Argument, bits 63..32.

Nothing.

d := 0x1122334455667788;
tmp := HiDword(d);  // Equals 0x11223344

HiDword(d) := 0xAAAAAAAA; // d equals 0xAAAAAAAA55667788

None.

Increases parameter par by 1.

• par: value which will be incremented by 1

Nothing.

Nothing.

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

None.

Decreases parameter par by 1.

• par: value which will be decremented by 1

Nothing.

Nothing.

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

None.

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.

• code_: input character

Returns a character associated with the specified character code_.

Nothing.

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

None.

Function returns ASCII code of the character.

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

• character: input character

ASCII code of the character.

Nothing.

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

None.

Function sets the bit rbit of register_. Parameter rbit needs to be a variable or literal with value 0..15. For more information on register identifiers see Predefined Globals and Constants .

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

• register_: desired register
• rbit: desired bit

Nothing.

Nothing.

SetBit(GPIO_PORT_08_15, 2);  // Set GPIO_PORT_08_15.B2

None.

Function clears the bit rbit of register. Parameter rbit needs to be a variable or literal with value 0..15. 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.

• register_: desired register
• rbit: desired bit

Nothing.

Nothing.

ClearBit(GPIO_PORT_16_23, 7);  // Clear GPIO_PORT_16_23.B7

None.

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..15. 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.

• register_: desired register
• rbit: desired bit

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

Nothing.

flag := TestBit(GPIO_PORT_32_39, 2);  // 1 if GPIO_PORT_32_39.B2 is set, otherwise 0

None.

Creates a software delay in duration of Time_In_us microseconds.

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

• Time_In_us: delay time in microseconds. Valid values: constant values, range of applicable constants depends on the oscillator frequency

Nothing.

Nothing.

Delay_us(10);  // Ten microseconds pause 

None.

Creates a software delay in duration of Time_In_ms milliseconds.

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

• Time_In_ms: delay time in milliseconds. Valid values: constant values, range of applicable constants depends on the oscillator frequency

Nothing.

Nothing.

Delay_ms(1000);  // One second pause 

For generating delays with variable as input parameter use the Vdelay_ms routine.

Creates a software delay in duration of Time_ms milliseconds. Generated delay is not as precise as the delay created by Delay_ms.

• Time_ms: delay time in milliseconds

Nothing.

Nothing.

var pause : word;
...
VDelay_ms(pause);  // ~ one second pause

None.

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.

• time_ms: delay time in milliseconds
• Current_Fosc_kHz: frequency in kHz

Nothing.

Nothing.

pause := 1000;
fosc := 10000;

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

None.

Creates a delay based on MCU clock.

• cycles_div_by_10: number of cycles divided by 10

Nothing.

Nothing.

Delay_Cyc(10);  // 1 cycles pause

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

Creates a delay based on MCU clock. Delay lasts for CycNo MCU clock cycles.

• CycNo: number of MCU cycles

Nothing.

Nothing.

Delay_Cyc_Long(16384);  // 16384 cycles pause 

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

Returns device clock in kHz, rounded to the nearest integer.

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

None.

Device clock in kHz, rounded to the nearest integer.

Nothing.

clk := Clock_kHz();

None.

Returns device clock in MHz, rounded to the nearest integer.

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

None.

Device clock in MHz, rounded to the nearest integer.

Nothing.

clk := Clock_MHz();

None.

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

None.

Device clock in kHz.

Nothing.

clk := Get_Fosc_kHz();

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

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

None.

Periperal clock in kHz, rounded to the nearest integer.

Nothing.

clk := Get_Peripheral_Clock_kHz();

None.

Function returns device's clock per cycle, rounded to the nearest integer.

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

None.

Device's clock per cycle, rounded to the nearest integer.

Nothing.

var clk_per_cyc : word;
...
clk_per_cyc := Get_Fosc_Per_Cyc();

None.

This function will perform a software reset of the entire device. The processor and all peripherals are reset and all device registers will return to their default values
(with the exception of the reset cause register, which will maintain its current value but have the software reset bit set as well).

None.

Nothing.

Nothing.

SystemReset();

None.

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. This enables the user to manually write code for saving registers upon entrance and to restore them before exit from interrupt.

None.

Nothing.

This routine must be called from main.

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

None.

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.

• FuncName: function name

Nothing.

Nothing.

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

The SetFuncCall directive can help the linker to optimize function frame allocation in the compiled stack.

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

• RoutineName: routine name
• address: starting address

Nothing.

This routine must be called from main.

SetOrg(UART1_Write, 0x1234);

None.

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

None.

String with date and time when this routine is compiled.

Nothing.

str := GetDateTime();

None.

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

None.

String with date and time when this routine is compiled.

Nothing.

str := DoGetDateTime();

None.

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

None.

String with current compiler version.

Nothing.

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

None.

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

None.

String with current compiler version.

Nothing.

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

None.

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).

Function copies nn bytes from the object pointed to by s2 into the object pointed to by s1. If copying takes place between objects that overlap, the behavior is undefined.

The behavior of the MEMCPY instruction is exactly the same as the standard C memcpy() function in ISO/IEC 9899:1990 ("ISO C90").

The function returns address of the object pointed to by s1.

Nothing.

Use this function for all object alignments.

Function copies nn bytes from the object pointed to by s2 into the object pointed to by s1. If copying takes place between objects that overlap, the behavior is undefined.

The behavior of the MEMCPY instruction is exactly the same as the standard C memcpy() function in ISO/IEC 9899:1990 ("ISO C90").

The function returns address of the object pointed to by s1.

Function parameters must have alignment 2.

Use this function when function parameters have alignment 2.

Function copies nn bytes from the object pointed to by s2 into the object pointed to by s1. If copying takes place between objects that overlap, the behavior is undefined.

The behavior of the MEMCPY instruction is exactly the same as the standard C memcpy() function in ISO/IEC 9899:1990 ("ISO C90").

The function returns address of the object pointed to by s1.

Function parameters must have alignment 4.

Use this function when function parameters have alignment 4.

Function copies the value of the byte c into each of the first n bytes of the object pointed by s.

The behavior of the MEMSET instruction is exactly the same as the standard C memsety() function in ISO/IEC 9899:1990 ("ISO C90").

The function returns address of the object pointed to by s.

Nothing.

None.

Function copies the value of the byte c into each of the first n bytes of the object pointed by s.

The behavior of the MEMSET instruction is exactly the same as the standard C memset() function in ISO/IEC 9899:1990 ("ISO C90").

The function returns address of the object pointed to by s.

Function parameters must have alignment 2.

Use this function when function parameters have alignment 2.

Function copies the value of the byte c into each of the first n bytes of the object pointed by s.

The behavior of the MEMSET instruction is exactly the same as the standard C memset() function in ISO/IEC 9899:1990 ("ISO C90").

The function returns address of the object pointed to by s.

Function parameters must have alignment 4.

Use this function when function parameters have alignment 4.

Function moves n bytes from an object pointed to by s2 located in I/O, to an object pointed to by s1 located in program memory.

The function returns address of the object pointed to by s1.

Nothing.

None.

Function moves n bytes from an object pointed to by s2 located in I/O, to an object pointed to by s1 located in program memory.

The function returns address of the object pointed to by s1.

Function parameters must have alignment 2.

Use this function when function parameters have alignment 2.

Function moves n bytes from an object pointed to by s2 located in I/O, to an object pointed to by s1 located in program memory.

The function returns address of the object pointed to by s1.

Function parameters must have alignment 4.

Use this function when function parameters have alignment 4.

Function moves n bytes from an object pointed to by s2 located in I/O, to an object pointed to by s1 located in program memory, with incrementing destination program memory address.

The function returns address of the object pointed to by s1.

Nothing.

None.

Function moves n bytes from an object pointed to by s2 located in I/O, to an object pointed to by s1 located in program memory, with incrementing destination program memory address.

The function returns address of the object pointed to by s1.

Function parameters must have alignment 2.

Use this function when function parameters have alignment 2.

Function moves n bytes from an object pointed to by s2 located in I/O, to an object pointed to by s1 located in program memory, with incrementing destination program memory address.

The function returns address of the object pointed to by s1.

Function parameters must have alignment 4.

Use this function when function parameters have alignment 4.

Function moves n bytes from an object pointed to by s2 located in program memory, to an object pointed to by s1 located in I/O.

The function returns address of the object pointed to by s1.

Nothing.

None.

Function moves n bytes from an object pointed to by s2 located in program memory, to an object pointed to by s1 located in I/O.

The function returns address of the object pointed to by s1.

Function parameters must have alignment 2.

Use this function when function parameters have alignment 2.

Function moves n bytes from an object pointed to by s2 located in program memory, to an object pointed to by s1 located in I/O.

The function returns address of the object pointed to by s1.

Function parameters must have alignment 4.

Use this function when function parameters have alignment 4.

Function moves n bytes from an object pointed to by s2 located in program memory, to an object pointed to by s1 located in I/O, with incrementing source program memory address.

The function returns address of the object pointed to by s1.

Nothing.

None.

Function moves n bytes from an object pointed to by s2 located in program memory, to an object pointed to by s1 located in I/O, with incrementing source program memory address.

The function returns address of the object pointed to by s1.

Function parameters must have alignment 2.

Use this function when function parameters have alignment 2.

Function moves n bytes from an object pointed to by s2 located in program memory, to an object pointed to by s1 located in I/O, with incrementing source program memory address.

The function returns address of the object pointed to by s1.

Function parameters must have alignment 4.

Use this function when function parameters have alignment 4.

Function compares strings s1 and s2 and returns zero if the strings are equal, or returns a difference between the first differing characters (in a left-to-right evaluation).
Accordingly, the result is greater than zero if s1 is greater than s2 and vice versa.

The behavior of the STRCMP_B instruction is exactly the same as the standard C strcmp() function in ISO/IEC 9899:1990 ("ISO C90").

The function returns zero if the strings are equal, or returns a difference between the first differing characters (in a left-to-right evaluation).

Nothing.

None.

Function compares strings s1 and s2 and returns zero if the strings are equal, or returns a difference between the first differing characters (in a left-to-right evaluation).
Accordingly, the result is greater than zero if s1 is greater than s2 and vice versa.

The behavior of the STRCMP_B instruction is exactly the same as the standard C strcmp() function in ISO/IEC 9899:1990 ("ISO C90").

The function returns zero if the strings are equal, or returns a difference between the first differing characters (in a left-to-right evaluation).

Function parameters must have alignment 2.

Use this function when function parameters have alignment 2.

Function compares strings s1 and s2 and returns zero if the strings are equal, or returns a difference between the first differing characters (in a left-to-right evaluation).
Accordingly, the result is greater than zero if s1 is greater than s2 and vice versa.

The behavior of the STRCMP_B instruction is exactly the same as the standard C strcmp() function in ISO/IEC 9899:1990 ("ISO C90").

The function returns zero if the strings are equal, or returns a difference between the first differing characters (in a left-to-right evaluation).

Function parameters must have alignment 4.

Use this function when function parameters have alignment 4.

Function copies the string s2 into the string s1. If copying is successful, the function returns pointer to s1. If copying takes place between objects that overlap, the behavior is undefined.

The behavior of the STPCPY_B instruction is exactly the same as the standard C stpcpy() function in ISO/IEC 9899:1990 ("ISO C90").

The function returns address of the object pointed to by s1.

Nothing.

None.

Function copies the string s2 into the string s1. If copying is successful, the function returns pointer to s1. If copying takes place between objects that overlap, the behavior is undefined.

The behavior of the STPCPY_B instruction is exactly the same as the standard C stpcpy() function in ISO/IEC 9899:1990 ("ISO C90").

The function returns address of the object pointed to by s1.

Function parameters must have alignment 2.

Use this function when function parameters have alignment 2.

Function copies the string s2 into the string s1. If copying is successful, the function returns pointer to s1. If copying takes place between objects that overlap, the behavior is undefined.

The behavior of the STPCPY_L instruction is exactly the same as the standard C stpcpy() function in ISO/IEC 9899:1990 ("ISO C90").

The function returns address of the object pointed to by s1.

Function parameters must have alignment 4.

Use this function when function parameters have alignment 4.

Function returns the length of the string s (the terminating null character does not count against string’s length).

The behavior of the STRLEN_B instruction is exactly the same as the standard C strlen() function in ISO/IEC 9899:1990 ("ISO C90").

Function returns the length of the string.

Nothing.

None.

Function returns the length of the string s (the terminating null character does not count against string’s length).

The behavior of the STRLEN_S instruction is exactly the same as the standard C strlen() function in ISO/IEC 9899:1990 ("ISO C90").

Function returns the length of the string.

Function parameters must have alignment 2.

Use this function when function parameters have alignment 2.

Function returns the length of the string s (the terminating null character does not count against string’s length).

The behavior of the STRLEN_L instruction is exactly the same as the standard C strlen() function in ISO/IEC 9899:1990 ("ISO C90").

Function returns the length of the string.

Function parameters must have alignment 4.

Use this function when function parameters have alignment 4.