Syntax:
VAR name1, name2, name3
VAR Name = Value
VAR array[size]
VAR array[size] = {value1, value2, ...}
VAR array[size] = {index: value1, value2, ...} Filling from a position
VAR matrix[rows, columns]
VAR matrix[rows, columns] = {{value1, value2}, {value3, value4}, ...}
VAR matrix[rows, columns] = {row: {value1, value2}, ...} From line N
VAR matrix[rows, columns] = {{column: value1, ...}, ...} With column N in each line
VAR matrix[rows, columns] = {row: {column: value1, ...}, ...} Combined option
Description:
Declaration of scalar variables, one-dimensional and two-dimensional arrays. Supports comma-separated multiple declarations.
All arrays (1D and 2D) are allocated from a total memory pool of 32KB (8192 float elements).
Examples:
Simple Announcement
VAR A, B, C, DD, D2S
With Initialization
VAR A=1, B=2, C=3
Mixed
VAR A=5, B, C=10
One-dimensional arrays
VAR A[10], B, C[5]
One-dimensional arrays with initialization
VAR A[3]={1,2,3}, B=5, C
Two-dimensional arrays
VAR MATRIX[3, 4] // Matrix 3x4 (3 rows, 4 columns)
VAR GRID[5, 5] // 5x5 grid
Two-dimensional arrays with initialization
VAR MAT[2, 3] = {{1, 2, 3}, {4, 5, 6}}
VAR IDENT[3, 3] = {{1, 0, 0}, {0, 1, 0}, {0, 0, 1}}
Mixed ad
VAR A[5], MATRIX[3, 3], B = 10
One-dimensional arrays initialized from an arbitrary position
VAR A[10] = {5: 1,2,3,4,5} // A[0..4]=0, A[5..9]={1,2,3,4,5}
VAR B[20] = {10: 100,200,300} // B[0..9]=0, B[10..12]={100,200,300}, B[13..19]=0
VAR C[15] = {12: 99,88,77} // C[0..11]=0, C[12..14]={99,88,77}
Two-dimensional arrays initialized from line N
VAR M[5,5] = {2: {1,2,3}, {4,5,6}} // Start from the 2nd line
M[0..1,*]=0, M[2,0..2]={1,2,3}, M[3,0..2]={4,5,6}, remainder=0
Two-dimensional arrays initialized with column N on each line
VAR M[5,5] = {{2: 1,2,3}, {1: 4,5,6}} // 0th row from column 2, 1st from column 1
// M[0,0..1]=0, M[0,2..4]={1,2,3}
// M[1,0]=0, M[1,1..3]={4,5,6}, M[1,4]=0
Two-dimensional arrays: combination (start with line N and column M on each line)
VAR M[5,5] = {2: {1:10,20}, {0:30,40,50}} // From the 2nd line, each from its own column
// M[0..1,*]=0
// M[2,0]=0, M[2,1..2]={10,20}, M[2,3..4]=0
// M[3,0..2]={30,40,50}, M[3,3..4]=0
// M[4,*]=0
Working with two-dimensional arrays:
Announcement
VAR MATRIX[3, 4]
Recording an Item
MATRIX[0, 0] = 10
MATRIX[1, 2] = 25.5
MATRIX[2, 3] = 100
Read an item
VAR X = MATRIX[1, 2]
Output of the entire matrix (by rows)
PRINT MATRIX
Single Line Output
PRINT MATRIX[1]
Single Item Output
PRINT MATRIX[1, 2]
Use in Expressions
VAR SUM = MATRIX[0, 0] + MATRIX[1, 1] + MATRIX[2, 2]
Full example: Working with a temperature matrix
Declaring a 4x4 Temperature Storage Matrix
VAR TEMP[4, 4]
Matrix Filling
VAR ROW = 0
WHILE ROW < 4
VAR COL = 0
WHILE COL < 4
TEMP[ROW, COL] = 20 + RND(0, 10) // Temperatures from 20 to 30
COL = COL + 1
WEND
ROW = ROW + 1
WEND
Output of the entire matrix
PRINT "Temperature matrix:"
PRINT TEMP
Find the maximum temperature
VAR MAX_TEMP = TEMP[0, 0]
VAR MAX_ROW = 0
VAR MAX_COL = 0
ROW = 0
WHILE ROW < 4
VAR COL = 0
WHILE COL < 4
IF TEMP[ROW, COL] > MAX_TEMP THEN
MAX_TEMP = TEMP[ROW, COL]
MAX_ROW = ROW
MAX_COL = COL
ENDIF
COL = COL + 1
WEND
ROW = ROW + 1
WEND
PRINT "Max. Temperature:", MAX_TEMP.1, "°C"
PRINT "Position: [", MAX_ROW, ",", MAX_COL, "]"
Output diagonal
PRINT "Diagonal:"
VAR I = 0
WHILE I < 4
PRINT TEMP[I, I].1
I = I + 1
WEND
Important Notes:
Syntax:
COPY(src, src_pos, dst, dst_pos, count)
Options:
Description:
Copies a specified number of elements from one array to another. It works with both one-dimensional and two-dimensional arrays (the elements of 2D arrays are referenced linearly).
All parameters can be expressions (including variables).
Examples:
One-dimensional arrays
VAR A[10] = {1,2,3,4,5,6,7,8,9,10}
VAR B[10]
Copying 3 items from A[5] to B[0]
COPY(A, 5, B, 0, 3)
Result: B[0..2] = {6,7,8}, B[3..9] = 0
Copying using variables
VAR SRC_POS = 2
VAR DST_POS = 5
VAR CNT = 4
COPY(A, SRC_POS, B, DST_POS, CNT)
Result: B[5..8] = {3,4,5,6}
Copying a Part of an Array to Itself
VAR DATA[20] = {0: 10,20,30,40,50}
COPY(DATA, 0, DATA, 5, 5)
Result: DATA[0..4] and DATA[5..9] contain {10,20,30,40,50}
Two-dimensional arrays (linear inversion)
VAR M1[3, 4] = {{1,2,3,4}, {5,6,7,8}, {9,10,11,12}}
VAR M2[3, 4]
Copy the second line M1 (items 4-7) to the first line M2 (items 0-3)
COPY(M1, 4, M2, 0, 4)
Result: M2[0,*] = {5,6,7,8}
Copy the entire matrix
COPY(M1, 0, M2, 0, 12) // 3×4 = 12 elements
Important Notes:
There are two ways to populate ranges: a single value and a list of values.
Syntax:
Single Value Filling
array[start-end] = value // 1D array
array[row, column_start-column_end] = value // 2D: single row, range of columns
array[row_start-row_end, column] = value // 2D: range of rows, single column
array[row_start-row_end, column_start-column_end] = value // 2D: rectangular area
Populating with a list of values
array[start-end] = {value1, value2, ...} 1D Array
array[row, column_start-column_end] = {value1, value2, ...} 2D: Column Range
array[row_start-row_end, column] = {value1, value2, ...} 2D: Range of Rows
array[row_start-row_end, column_start-column_end] = {value1, value2, ...} 2D: Rectangular area
Description:
Fills the specified range of array elements. When filling in the list of values, the values are assigned sequentially from left to right, from top to bottom (for 2D arrays).
One-dimensional arrays
VAR A[100]
A[0-99] = 0 // Fill the entire array with zeros
A[10-19] = 100 // Fill A[10..19] with 100
A[5-14] = 42 // Fill A[5..14] with 42
With variables
VAR START = 10
VAR END = 20
A[START-END] = 255
Two-dimensional arrays
VAR M[5, 10]
M[0-4, 0-9] = 0 // Fill the entire matrix with zeros
M[1-3, 2-7] = 10 // Fill the 3x6 rectangle with the value 10
M[2, 0-9] = 5 // Fill in the third line in its entirety
M[0-4, 5] = 7 // Fill the sixth column in its entirety
Creating a Frame Around the Matrix
VAR GRID[10, 10]
GRID[0-9, 0-9] = 0 // Clear the entire grid
GRID[0, 0-9] = 1 // Upper bound
GRID[9, 0-9] = 1 // Lower bound
GRID[0-9, 0] = 1 // Left border
GRID[0-9, 9] = 1 // Right border (turns out to be a frame)
One-dimensional arrays
VAR MAS[20]
Fill the range with a list of values
MAS[5-10] = {4, 6, 8, 0, 1, 2}
Result: MAS[5]=4, MAS[6]=6, MAS[7]=8, MAS[8]=0, MAS[9]=1, MAS[10]=2
Range with expressions in the list
VAR BASE = 100
MAS[0-4] = {BASE, BASE+10, BASE+20, BASE+30, BASE+40}
Result: MAS[0..4] = {100, 110, 120, 130, 140}
Two-dimensional arrays
VAR M[10, 10]
Fill a range of columns in a single row
M[1, 5-7] = {2, 5, 6}
Result: M[1,5]=2, M[1,6]=5, M[1,7]=6
Populate a range of rows in a single column
M[0-2, 3] = {10, 20, 30}
Result: M[0,3]=10, M[1,3]=20, M[2,3]=30
Fill rectangular area (3 rows × 3 columns = 9 items)
M[1-3, 1-3] = {1, 2, 3, 4, 5, 6, 7, 8, 9}
Result:
// M[1,1]=1 M[1,2]=2 M[1,3]=3
// M[2,1]=4 M[2,2]=5 M[2,3]=6
// M[3,1]=7 M[3,2]=8 M[3,3]=9
Creating a Chessboard (Part)
VAR BOARD[8, 8]
BOARD[0, 0-7] = {1, 0, 1, 0, 1, 0, 1, 0} // First line
BOARD[1, 0-7] = {0, 1, 0, 1, 0, 1, 0, 1} // Second line
Initializing a lookup table
VAR LUT[16]
LUT[0-15] = {0, 15, 31, 47, 63, 79, 95, 111, 127, 143, 159, 175, 191, 207, 223, 255}
Filling the buffer with a template
VAR BUFFER[100]
BUFFER[0-9] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 0}
BUFFER[10-19] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 0}
Creating a Gradient on the Screen (Luminance Matrix)
VAR BRIGHTNESS[5, 10]
BRIGHTNESS[0, 0-9] = {0, 28, 56, 84, 112, 140, 168, 196, 224, 255}
BRIGHTNESS[1, 0-9] = {0, 28, 56, 84, 112, 140, 168, 196, 224, 255}
BRIGHTNESS[2, 0-9] = {0, 28, 56, 84, 112, 140, 168, 196, 224, 255}
Important Notes:
The interpreter supports working with numbers in various number systems: decimal, hexadecimal, and binary.
Syntax:
Decimal numbers (regular)
VAR A = 255
VAR B = 100
Hexadecimal numbers (prefix 0x or 0X)
VAR C = 0xFF // 255 in decimal
VAR D = 0x10 // 16 in decimal
VAR E = 0xABCD // 43981 in decimal
Binary numbers (prefix 0b or 0B)
VAR F = 0b1111 // 15 in decimal
VAR G = 0b1010 // 10 in decimal
VAR H = 0b111111111 // 255 in decimal
Description:
Literals allow you to write numbers in a convenient number system directly in the code:
All numbers are internally stored in decimal form, but you can choose a convenient format for writing.
Examples of use:**
Working with colors (hexadecimal format is more convenient)
VAR RED = 0xF800 // RGB565: red
VAR GREEN = 0x07E0 // RGB565: green
VAR BLUE = 0x001F // RGB565: Blue
DISPLAY_FILL_RECT(0, 0, 100, 100, 0xF800)
Working with bitmasks
VAR MASK1 = 0b00001111 // Low 4 bits
VAR MASK2 = 0b11110000 // Low 4 bits
VAR FLAGS = 0b10100101 // Flag Set
Mixed use
VAR DEC = 100 // Decimal
VAR HEX = 0x64 // Same number in hex (100)
VAR BIN = 0b1100100 // Same number in binary (100)
IF DEC == HEX THEN
PRINT "Equal!" It will bring out "Equals!"
ENDIF
Syntax:
PRINT variable // Decimal format (default)
PRINT variable.h // Hexadecimal format (0xXXXX)
PRINT variable.b // Binary format (0bXXXXXXXX)
Examples:
VAR NUM = 255
Output in different formats
PRINT NUM // Outputs: 255
PRINT NUM.h // Outputs: 0xFF
PRINT NUM.b // Outputs: 0b11111111
Combined Output
PRINT "Dec:", NUM, "Hex:", NUM.h, "Bin:", NUM.b
Output: Dec: 255 Hex: 0xFF Bin: 0b111111111
Working with Variables
VAR COLOR = 0xF800
PRINT "Color value:", COLOR // 63488
PRINT "Color hex:", COLOR.h // 0xF800
Arrays
VAR DATA[3] = {10, 255, 0b1010}
PRINT "Array[0]:", DATA[0].h // 0xA
PRINT "Array[1]:", DATA[1].b // 0b11111111
PRINT "Array[2]:", DATA[2] // 10
Formatting features:
VAR V1 = ADC_IN1
PRINT "ADC Channel 1:"
PRINT " Decimal: ", V1
PRINT " Hex: ", V1.h
PRINT " Binary: ", V1.b
On display
DISPLAY_TEXT(0, 0, "ADC1: ", V1.2, " V", Font_7x10, 1, 0xFFFF)
DISPLAY_TEXT(0, 20, "Raw: ", V1.h, Font_7x10, 1, 0xFFFF)
Creating Color
VAR R=255, G=128, B=64
VAR COLOR = RGB565(R, G, B)
Color Information Output
PRINT "RGB:", R, G, B
PRINT "RGB565:", COLOR.h // Hex is convenient for colors
PRINT "RGB565 bits:", COLOR.b // Show bit structure
Display
DISPLAY_FILL_RECT(10, 10, 100, 50, COLOR)
DISPLAY_TEXT(10, 70, "Color: ", COLOR.h, Font_7x10, 1, 0xFFFF)
Defining Bit Flags
VAR FLAG_ENABLE = 0b00000001
VAR FLAG_READY = 0b00000010
VAR FLAG_ERROR = 0b00000100
VAR FLAG_DONE = 0b00001000
VAR STATUS = 0b00000101 // ENABLE + ERROR
PRINT "Status register:"
PRINT " Binary: ", STATUS.b
PRINT " Hex: ", STATUS.h
Checking Flags (Simple Comparison)
IF STATUS == FLAG_ENABLE THEN
PRINT "Device enabled"
ENDIF
VAR INPUT = 42
DISPLAY_CLEAR()
DISPLAY_TEXT(10, 10, "Number converter", Font_11x18, 1, RGB565(255, 255, 0))
DISPLAY_TEXT(10, 50, "Input: ", INPUT, Font_7x10, 1, 0xFFFF)
DISPLAY_TEXT(10, 70, "Decimal: ", INPUT, Font_7x10, 1, RGB565(255, 255, 255))
DISPLAY_TEXT(10, 90, "Hex: ", INPUT.h, Font_7x10, 1, RGB565(0, 255, 0))
DISPLAY_TEXT(10, 110, "Binary: ", INPUT.b, Font_7x10, 1, RGB565(0, 255, 255))
You can also use literals to validate
VAR TEST1 = 0x2A // 42 in hex
VAR TEST2 = 0b101010 // 42 in binary
IF INPUT == TEST1 AND INPUT == TEST2 THEN
DISPLAY_TEXT(10, 140, "All equal!", Font_7x10, 1, RGB565(0, 255, 0))
ENDIF
DISPLAY_CLEAR()
DISPLAY_TEXT(10, 0, "DEC HEX BINARY", Font_7x10, 1, RGB565(255, 255, 0))
FOR I = 0 TO 15
VAR Y = 20 + I * 15
DISPLAY_TEXT(10, Y, I, Font_7x10, 1, 0xFFFF)
DISPLAY_TEXT(50, Y, I.h, Font_7x10, 1, 0xFFFF)
DISPLAY_TEXT(100, Y, I.b, Font_7x10, 1, 0xFFFF)
NEXT
Displays a table:
// 0 0x0 0b0
// 1 0x1 0b1
// 2 0x2 0b10
// ...
// 15 0xF 0b1111
The interpreter supports three color formats for different types of devices:
| Function | Bits | Format | Application |
|---|---|---|---|
| RGB565() | 16-bit | R5G6B5 | ILI9341, ILI9488, ST7789, ST7735 Displays |
| RGB666() | 18-bit | R6G6B6 | ST7796 Display |
| RGB888() | 24-bit | R8G8B8 | WS2812 LED, matrices |
Syntax:
RGB565(red, green, blue)
Description:
Converts RGB888 (0-255) to RGB565 (16-bit) for ILI9341/ILI9488/ST7789/ST7735 displays.
Options:
Format:
RGB565 uses 16 bits to store color:
Examples:
Primary colors
VAR RED = RGB565(255, 0, 0)
VAR GREEN = RGB565(0, 255, 0)
VAR BLUE = RGB565(0, 0, 255)
VAR WHITE = RGB565(255, 255, 255)
Use with 16-bit displays
DISPLAY_INIT(SPI, ILI9341, 320, 240)
DISPLAY_FILL_RECT(0, 0, 100, 100, RGB565(255, 128, 64))
With variables
VAR R=255, G=128, B=64
VAR COLOR = RGB565(R, G, B)
DISPLAY_FILL_CIRCLE(160, 120, 50, COLOR)
With arrays
VAR COLORS[3] = {255, 128, 64}
VAR C = RGB565(COLORS[0], COLORS[1], COLORS[2])
Note:
Syntax:
RGB888(red, green, blue)
Description:
Converts RGB components to RGB888 (24-bit): 0xRRGGBB
Options:
Format:
RGB888 uses the full 8 bits per color channel:
Application:
Examples:
Primary colors
VAR RED = RGB888(255, 0, 0)
VAR GREEN = RGB888(0, 255, 0)
VAR BLUE = RGB888(0, 0, 255)
For WS2812 LED Strip
VAR LEDS[10]
FOR I = 0 TO 9
LEDS[I] = RGB888(255, I*25, 0)
NEXT
WS2812_SEND LEDS[]
For LED matrix
MATRIX_INIT(16, 16)
VAR COLOR = RGB888(100, 50, 200)
MATRIX_SET(8, 8, COLOR)
MATRIX_UPDATE()
With expressions
VAR BRIGHTNESS = 128
VAR WARM_WHITE = RGB888(BRIGHTNESS, BRIGHTNESS*0.9, BRIGHTNESS*0.7)
Note:
Syntax:
RGB666(red, green, blue)
Description:
Converts RGB888 (0-255) to RGB666 (18-bit) for the ST7796 display.
Options:
Format:
RGB666 uses 6 bits per color channel:
Examples:
Primary colors
VAR RED = RGB666(255, 0, 0)
VAR GREEN = RGB666(0, 255, 0)
VAR BLUE = RGB666(0, 0, 255)
VAR WHITE = RGB666(255, 255, 255)
Use with ST7796 Display
DISPLAY_INIT(SPI, ST7796, 480, 320)
DISPLAY_FILL_RECT(0, 0, 100, 100, RGB666(255, 128, 64))
With variables
VAR R=200, G=100, B=50
VAR COLOR = RGB666(R, G, B)
DISPLAY_FILL_CIRCLE(240, 160, 80, COLOR)
With arrays
VAR PALETTE[3] = {255, 128, 64}
VAR C = RGB666(PALETTE[0], PALETTE[1], PALETTE[2])
Note:
Syntax:
IF condition THEN
Command
ENDIF
IF condition THEN
Command
ELSE
Command
ENDIF
IF condition1 THEN
Teams1
ELSE IF condition2 THEN
Teams2
ELSE
Teams3
ENDIF
Description:
The IF construct allows commands to be executed depending on the condition. The condition is evaluated as true (not 0) or false (0).
Branching:
Comparison operators:
Boolean operators:**
Features of the conditions:
Examples:
' Simple Condition
IF A > 10 THEN
PRINT "A is greater than 10"
ENDIF
' IF-ELSE IF-ELSE (Multiple Choice)
' Conditions are checked from top to bottom
Once one condition is true, the others are not checked
IF A > 100 THEN
PRINT "High"
ELSE IF A > 50 THEN
PRINT "Medium"
ELSE
PRINT "Low"
ENDIF
' Multiple ELSE IFs in a row
IF TEMP < 10 THEN
PRINT "Cold"
ELSE IF TEMP < 20 THEN
PRINT "Cool"
ELSE IF TEMP < 30 THEN
PRINT "Comfortable"
ELSE IF TEMP < 40 THEN
PRINT "Teplo"
ELSE
PRINT "Zharko"
ENDIF
' ELSE IF with Boolean Operators
IF VOLTAGE > 12.6 THEN
PRINT "Battery fully charged"
ELSE IF VOLTAGE > 12.0 AND VOLTAGE <= 12.6 THEN
PRINT "Battery partially charged"
ELSE IF VOLTAGE > 11.5 THEN
PRINT "Battery is low"
ELSE
PRINT "Charging Required!"
ENDIF
' ELSE IF to define a range of values
VAR ADC_VAL = ADC_IN1
IF ADC_VAL < 0.5 THEN
PRINT "Range 1"
OUT(1, 1)
ELSE IF ADC_VAL < 1.0 THEN
PRINT "Range 2"
OUT(2, 1)
ELSE IF ADC_VAL < 1.5 THEN
PRINT "Range 3"
OUT(3, 1)
ELSE IF ADC_VAL < 2.0 THEN
PRINT "Range 4"
OUT(4, 1)
ELSE
PRINT "Range 5"
OUT(5, 1)
ENDIF
' Operator is not equal to
IF A <> 0 THEN
PRINT "A is not equal to zero"
ENDIF
› Boolean operators
IF A > 10 AND B < 20 THEN
PRINT "A in the range of 10-20"
ENDIF
IF X < 0 OR X > 100 THEN
PRINT "X out of the 0-100 range"
ENDIF
› Difficult conditions with brackets
IF (A > 5 AND B > 5) OR (A < -5 AND B < -5) THEN
PRINT "Both are greater than 5 or both are less than -5"
ENDIF
' Expression Conditions
IF (A + B) / 2 > 50 THEN
PRINT "Average is greater than 50"
ENDIF
› Terms with features
IF ABS(TEMP - 25) < 5 THEN
PRINT "The temperature is close to 25 degrees"
ENDIF
› ADC Terms
IF ADC_IN1 > 2.5 AND ADC_IN2 < 1.0 THEN
PRINT "Voltage on IN1 > 2.5V, on IN2 < 1.0V"
ENDIF
› Conditions with arrays
IF DATA[I] > THRESHOLD THEN
PRINT "Value", I, "Exceeded Threshold"
ENDIF
' Nested IF
IF A > 0 THEN
IF B > 0 THEN
PRINT "Both positive"
ELSE
PRINT "A positive, B negative"
ENDIF
ELSE
PRINT "A negative"
ENDIF
Syntax:
FOR variable = start TO end
Command
NEXT
FOR variable = start TO end STEP step
Command
NEXT
Description:
A FOR loop executes commands a specified number of times by changing the loop variable from start to end in specified increments.
Options:
Features:
Examples:
' Simple cycle from 1 to 10
FOR I = 1 TO 10
PRINT I
NEXT
' Increment Cycle
FOR I = 0 TO 100 STEP 10
PRINT I
NEXT
› Cycle in reverse
FOR I = 10 TO 1 STEP -1
PRINT I
NEXT
' Fractional Step Cycle
FOR X = 0 TO 1 STEP 0.1
PRINT X
NEXT
' Loop with variables in parameters
VAR N = 10
FOR I = 1 TO N
PRINT I
NEXT
' Loop with expressions in all parameters
VAR START = 5
VAR END = 20
VAR STEP_SIZE = 3
FOR I = START TO END STEP STEP_SIZE
PRINT I
NEXT
' Expressions are evaluated once when entering a loop
VAR N = 10
FOR I = 1 TO N * 2 STEP 2
PRINT I
N = N + 1 // A change in N does not affect the end of the cycle
NEXT
' Using Functions in Settings
VAR MAX_VAL = ABS(-100)
FOR I = 0 TO MAX_VAL STEP 10
PRINT I
NEXT
Using ADC for a Dynamic Number of Iterations
VAR ITERATIONS = ADC_IN1 * 100 // 0-330 iterations depending on voltage
FOR I = 1 TO ITERATIONS
PRINT I
NEXT
' Calculating a Range Based on an Array
VAR DATA[10] = {5, 8, 12, 3, 15, 9, 20, 6, 11, 7}
VAR MIN_VAL = 0
VAR MAX_VAL = 0
› Find the minimum and maximum
FOR I = 0 TO 9
IF DATA[I] < MIN_VAL OR I = 0 THEN
MIN_VAL = DATA[I]
ENDIF
IF DATA[I] > MAX_VAL THEN
MAX_VAL = DATA[I]
ENDIF
NEXT
' Use the found values in a new loop
FOR VAL = MIN_VAL TO MAX_VAL
PRINT VAL
NEXT
' Using a loop variable in expressions
FOR ANGLE = 0 TO 360 STEP 30
VAR RAD = ANGLE * 3.14159 / 180
VAR X = 160 + COS(RAD) * 100
VAR Y = 120 + SIN(RAD) * 100
DISPLAY_CIRCLE(X, Y, 5, RGB565(255, 0, 0))
NEXT
' Nested loops (multiplication table)
FOR I = 1 TO 10
FOR J = 1 TO 10
PRINT I * J, " "
NEXT
PRINT // Line feed
NEXT
' Loop over an array
VAR DATA[10]
FOR I = 0 TO 9
DATA[I] = I * I
NEXT
' A Condition Loop Inside
FOR I = 1 TO 100
IF I % 2 = 0 THEN
PRINT I, " - even"
ENDIF
NEXT
' Cycle to fill a 2D array
VAR MATRIX[5, 5]
FOR ROW = 0 TO 4
FOR COL = 0 TO 4
MATRIX[ROW, COL] = ROW * 10 + COL
NEXT
NEXT
Syntax:
WHILE (condition)
Command
WEND
Description:
The WHILE loop executes commands as long as the condition is true. The condition is checked before each iteration.
Features:
Examples:
' Simple Loop with Counter
VAR I = 0
WHILE (I < 10)
PRINT I
I = I + 1
WEND
' Conditional Loop
VAR SUM = 0
VAR N = 1
WHILE (SUM < 100)
SUM = SUM + N
N = N + 1
WEND
PRINT "Sum:", SUM
' Loop with Boolean Operators
VAR X = 0
VAR Y = 0
WHILE (X < 10 AND Y < 10)
X = X + 1
Y = Y + 2
PRINT X, Y
WEND
' Loop with expressions in the condition
VAR A = 5
VAR B = 10
WHILE ((A + B) / 2 < 20)
A = A + 1
B = B + 2
PRINT "Average:", (A + B) / 2
WEND
' Loop with function in condition
VAR ANGLE = 0
WHILE (ABS(SIN(ANGLE)) < 0.9)
ANGLE = ANGLE + 0.1
PRINT ANGLE, SIN(ANGLE)
WEND
› Cycle with ADC (Threshold Exceeding Wait)
WHILE (ADC_IN1 < 2.5)
PRINT "Waiting for a signal..."
PAUSE 100
WEND
PRINT "Signal detected!"
' Multi-sensor condition
WHILE (ADC_IN1 > 1.0 AND ADC_IN2 < 2.0)
PRINT "ADC1:", ADC_IN1, "ADC2:", ADC_IN2
PAUSE 50
WEND
› Nested loops
VAR I = 0
WHILE (I < 5)
VAR J = 0
WHILE (J < 5)
PRINT I * 10 + J, " "
J = J + 1
WEND
PRINT // Line feed
I = I + 1
WEND
' Loop with array in condition
VAR DATA[10]
VAR I = 0
WHILE (I < 10 AND DATA[I] <> 0)
PRINT DATA[I]
I = I + 1
WEND
' Loop with Early Exit Through Condition
VAR FOUND = 0
VAR I = 0
WHILE (I < 100 AND FOUND = 0)
IF DATA[I] = TARGET THEN
FOUND = 1
PRINT "Found in position", I
ENDIF
I = I + 1
WEND
› Sensor data cycle
VAR STABLE = 0
VAR PREV = 0
VAR COUNT = 0
WHILE (STABLE = 0)
VAR CURR = ADC_IN1
IF ABS(CURR - PREV) < 0.01 THEN
COUNT = COUNT + 1
IF COUNT > 10 THEN
STABLE = 1
ENDIF
ELSE
COUNT = 0
ENDIF
PREV = CURR
PAUSE 10
WEND
PRINT "Value stabilized:", CURR
' Condition with variables
VAR MIN_VAL = 10
VAR MAX_VAL = 100
VAR VALUE = 50
WHILE (VALUE >= MIN_VAL AND VALUE <= MAX_VAL)
VALUE = VALUE + RND(-10, 10)
PRINT VALUE
PAUSE 100
WEND
PRINT "The value is out of range"
Expressions are used in assignments, IF/WHILE conditions, and command parameters.
Binary operators:**
Priority of operations (from high to low):
Examples:
VAR A = 5 + 3 // 8
VAR B = 10 - 4 // 6
VAR C = 3 * 4 // 12
VAR D = 15 / 4 // 3.75 (fractional division)
VAR E = 15 % 4 // 3 (integer division)
› Priority of operations
VAR X = 2 + 3 * 4 // 14 (multiplication first)
VAR Y = (2 + 3) * 4 // 20 (parentheses change priority)
' Compound expressions
VAR RESULT = (A + B) / (C - D)
VAR AVG = (X + Y + Z) / 3
VAR DEC = 255 // Decimal Number
VAR HEX = 0xFF // Hexadecimal (hex)
VAR BIN = 0b111111111 // Binary
VAR FLOAT = 3.14159 // Fractional number
' All formats are equal
IF DEC = HEX AND HEX = BIN THEN
PRINT "All three numbers are 255"
ENDIF
› Modulus of Number
VAR X = ABS(-5) // 5
' Trigonometry (argument in radians)
VAR S = SIN(1.57) // ~1.0 (sin(π/2))
VAR C = COS(3.14) // ~-1.0 (cos(π))
VAR T = TAN(0.785) // ~1.0 (tan(π/4))
' Rounding
VAR R1 = ROUND(3.7) // 4 (to the nearest integer)
VAR R2 = FLOOR(3.7) // 3 (down)
VAR R3 = CEIL(3.2) // 4 (up)
' Use in expressions
VAR ANGLE_DEG = 45
VAR ANGLE_RAD = ANGLE_DEG * 3.14159 / 180
VAR DISTANCE = 100
VAR X_POS = 160 + COS(ANGLE_RAD) * DISTANCE
VAR Y_POS = 120 + SIN(ANGLE_RAD) * DISTANCE
VAR R1 = RND // Random 0.0..1.0
VAR R2 = RND(10) // Random 0..10
VAR R3 = RND(5, 15) // Random 5..15
› Application
VAR DICE = RND(1, 6) // Dice roll
VAR COLOR_R = RND(0, 255)
VAR COLOR_G = RND(0, 255)
VAR COLOR_B = RND(0, 255)
VAR COLOR = RGB565(COLOR_R, COLOR_G, COLOR_B)
Bit operations work with integers and perform bitwise logical operations.
Syntax:
AND(a, b) // bitwise and
OR(a, b) // Bitwise OR
XOR(a, b) // Bitwise exclusive OR
NOT(a) // Bitwise NOT (inversion)
Description:
Examples:
Basic operations
VAR A = 0b1100 // 12 in binary
VAR B = 0b1010 // 10 in binary
VAR C1 = AND(A, B) // 0b1000 = 8
VAR C2 = OR(A, B) // 0b1110 = 14
VAR C3 = XOR(A, B) // 0b0110 = 6
VAR C4 = NOT(A) // Inversion of all bits
PRINT "A AND B = ", C1
PRINT "A OR B = ", C2
PRINT "A XOR B = ", C3
Working with masks
VAR FLAGS = 0b00000000
VAR FLAG_RED = 0b00000001 // bit 0
VAR FLAG_GREEN = 0b00000010 // bit 1
VAR FLAG_BLUE = 0b00000100 // bit 2
Setting flags
FLAGS = OR(FLAGS, FLAG_RED)
FLAGS = OR(FLAGS, FLAG_BLUE)
PRINT "Flags: ", FLAGS.b // 0b00000101
Flag check
VAR HAS_RED = AND(FLAGS, FLAG_RED)
IF HAS_RED > 0 THEN
PRINT "Red flag is set"
ENDIF
Clearing the flag (resetting the bit)
FLAGS = AND(FLAGS, NOT(FLAG_RED))
PRINT "After clear: ", FLAGS.b // 0b00000100
Flag toggle
FLAGS = XOR(FLAGS, FLAG_GREEN)
PRINT "After toggle: ", FLAGS.b // 0b00000110
Bitfield extraction
VAR DATA = 0x1A5 // 0001 1010 0101
VAR NIBBLE = AND(DATA, 0x0F) // Low 4 bits: 0101 = 5
VAR BYTE = AND(DATA, 0xFF) // Low Byte
Combination of operations
VAR MASK1 = 0b11110000
VAR MASK2 = 0b00001111
VAR FULL_MASK = OR(MASK1, MASK2) // 0b11111111
Working with RGB565 Colors
VAR COLOR = 0xF800 // Red in RGB565
VAR RED_BITS = AND(COLOR, 0xF800) // Extract Red Channel
VAR GREEN_BITS = AND(COLOR, 0x07E0) // Extract green channel
VAR BLUE_BITS = AND(COLOR, 0x001F) // Extract Blue Channel
Practical Application:
GPIO Pin Management via Bitmasks
VAR PORT_STATE = 0
VAR PIN0 = 0b00000001
VAR PIN1 = 0b00000010
VAR PIN7 = 0b10000000
Enable PIN0 and PIN7
PORT_STATE = OR(PORT_STATE, PIN0)
PORT_STATE = OR(PORT_STATE, PIN7)
Check PIN1 status
IF AND(PORT_STATE, PIN1) > 0 THEN
PRINT "PIN1 is HIGH"
ELSE
PRINT "PIN1 is LOW"
ENDIF
Creating Bitfields
VAR SENSOR_DATA = 0
Write temperature (12 bits) to high bits
VAR TEMP_VALUE = 850 // 850 = 0x352
SENSOR_DATA = OR(SENSOR_DATA, TEMP_VALUE)
Extract Temperature
VAR TEMP_READ = AND(SENSOR_DATA, 0xFFF) // Low 12 bits
Notes:
' Scalar Variables
VAR A = 10
VAR B = 20
VAR C = A + B // 30
› 1D arrays
VAR DATA[10]
DATA[0] = 100
DATA[1] = DATA[0] + 50 // 150
VAR SUM = DATA[0] + DATA[1] // 250
› 2D arrays
VAR MATRIX[3, 3]
MATRIX[0, 0] = 1
MATRIX[0, 1] = 2
VAR TOTAL = MATRIX[0, 0] + MATRIX[0, 1] // 3
' Indices can be expressions
VAR I = 5
VAR X = DATA[I * 2] // DATA[10]
VAR Y = MATRIX[I / 2, I % 3] // MATRIX[2, 2]
' Timer (milliseconds since last TIMER_RESET)
VAR ELAPSED = TIMER_GET
IF ELAPSED > 5000 THEN
PRINT "5 seconds passed"
ENDIF
' RTC (Real-Time Clock)
VAR YEAR = RTC_Y // Year (2025)
VAR MONTH = RTC_M // Month (1-12)
VAR DAY = RTC_D // Day (1-31)
VAR HOUR = RTC_H // Hour (0-23)
VAR MINUTE = RTC_MIN // Minute (0-59)
VAR SECOND = RTC_S // Second (0-59)
› Time Condition
IF RTC_H >= 9 AND RTC_H < 18 THEN
PRINT "Working Hours"
ENDIF
› ADC inputs (0-3.3V zoom voltage)
VAR V1 = ADC_IN1 // Input Voltage 1
VAR V2 = ADC_IN2
› ADC Terms
IF ADC_IN1 > 2.5 THEN
PRINT "High Voltage"
ENDIF
› Computing with ADC
VAR AVG = (ADC_IN1 + ADC_IN2 + ADC_IN3) / 3
VAR DIFF = ABS(ADC_IN1 - ADC_IN2)
› Temperature sensors DS18B20
VAR TEMP1 = DS1820[1] // Fahrenheit Temperature
VAR TEMP2 = DS1820C[2] // Temperature in Celsius
IF DS1820C[1] > 25 THEN
PRINT "Temperature above 25°C"
ENDIF
' RGB565 (16-bit color for most TFT displays)
VAR RED = RGB565(255, 0, 0)
VAR GREEN = RGB565(0, 255, 0)
VAR BLUE = RGB565(0, 0, 255)
VAR WHITE = RGB565(255, 255, 255)
VAR CUSTOM = RGB565(128, 200, 50)
' RGB888 (24-bit color)
VAR COLOR24 = RGB888(255, 128, 64)
' RGB666 (18-bit color for ST7796)
VAR COLOR18 = RGB666(255, 255, 0)
Using variables in RGB
VAR R = 255
VAR G = RND(0, 255)
VAR B = 0
VAR RANDOM_RED = RGB565(R, G, B)
' Solid Wood Color
VAR COLORS[3] = {255, 128, 64}
VAR MIXED_COLOR = RGB565(COLORS[0], COLORS[1], COLORS[2])
' Calculating the Average with Range Check
VAR SUM = 0
VAR COUNT = 0
FOR I = 0 TO 9
IF DATA[I] >= 0 AND DATA[I] <= 100 THEN
SUM = SUM + DATA[I]
COUNT = COUNT + 1
ENDIF
NEXT
VAR AVG = SUM / COUNT
' Normalizing the value to the range 0-100
VAR RAW = ADC_IN1
VAR MIN_VAL = 0.5
VAR MAX_VAL = 2.5
VAR NORMALIZED = (RAW - MIN_VAL) / (MAX_VAL - MIN_VAL) * 100
IF NORMALIZED < 0 THEN
NORMALIZED = 0
ENDIF
IF NORMALIZED > 100 THEN
NORMALIZED = 100
ENDIF
' Calculating Brightness from a Sine Wave
FOR T = 0 TO 360 STEP 10
VAR RAD = T * 3.14159 / 180
VAR BRIGHTNESS = (SIN(RAD) + 1) / 2 * 255
VAR COLOR = RGB565(BRIGHTNESS, BRIGHTNESS, BRIGHTNESS)
OUT(1, BRIGHTNESS)
PAUSE 50
NEXT
› Checking for a point in a circle
VAR CENTER_X = 160
VAR CENTER_Y = 120
VAR RADIUS = 50
VAR POINT_X = 180
VAR POINT_Y = 140
VAR DX = POINT_X - CENTER_X
VAR DY = POINT_Y - CENTER_Y
VAR DIST = (DX * DX + DY * DY) // Distance Square
IF DIST <= (RADIUS * RADIUS) THEN
PRINT "Point inside a circle"
ENDIF
Syntax:
DISPLAY_INIT(interface, controller, width, height, [rotation], [cs_out, dc_out, rst_out])
Options:
Examples:
' ST7735 (128x160, RGB565)
DISPLAY_INIT(SPI, ST7735, 160, 128, 0)
' ILI9341 (320x240, RGB565)
DISPLAY_INIT(SPI, ILI9341, 320, 240, 0)
' ILI9488 (480x320, RGB565)
DISPLAY_INIT(SPI, ILI9488, 480, 320, 0)
' ST7796 (480x320, RGB666)
DISPLAY_INIT(SPI, ST7796, 480, 320, 0)
' ST7789 (240x320, RGB565)
DISPLAY_INIT(SPI, ST7789, 240, 320, 0)
' SSD1306 OLED (128x64, I2C)
DISPLAY_INIT(I2C, SSD1306, 128, 64, 0)
' With custom pins for SPI (CS=OUT10, DC=OUT11, RST=OUT12)
DISPLAY_INIT(SPI, ILI9341, 320, 240, 0, 10, 11, 12)
Syntax:
DISPLAY_CLEAR([color])
Description:
Clears the display. If no color is specified, use black (0x0000).
Examples:
DISPLAY_CLEAR()
DISPLAY_CLEAR(RGB565(255, 255, 255))
Syntax:
DISPLAY_PIXEL(x, y, color)
Description:
Draws a single point on the display.
Examples:
DISPLAY_PIXEL(100, 100, RGB565(255, 0, 0))
Syntax:
Format 1: Plain Line (Backward Compatibility)
DISPLAY_LINE(x0, y0, x1, y1, color)
Format 2: Polyline on an array of points
DISPLAY_LINE(array[], color)
Format 3: Polyline with coordinates (up to 30 points)
DISPLAY_LINE(x0, y0, x1, y1, x2, y2, ..., color)
Description:
Draws a line from point to point. Supports three formats:
For array and enumeration: minimum 2 points, maximum 30 points.
Examples:
Simple Line
DISPLAY_LINE(0, 0, 320, 240, RGB565(255, 255, 255))
Grid
FOR I = 0 TO 320 STEP 20
DISPLAY_LINE(I, 0, I, 240, RGB565(100, 100, 100))
NEXT
Polyline on a solid wood
VAR PATH[10]
PATH[0-9] = {10, 10, 50, 100, 100, 50, 150, 120, 200, 60}
DISPLAY_LINE(PATH[], RGB565(0, 255, 0))
A polyline with a list of coordinates
DISPLAY_LINE(10, 10, 50, 100, 100, 50, 150, 120, 200, 60, RGB565(0, 255, 0))
Sine Wave Graph
VAR POINTS[100]
FOR I = 0 TO 49
POINTS[I*2] = I * 5
POINTS[I*2+1] = 120 + SIN(I * 0.2) * 50
NEXT
DISPLAY_LINE(POINTS[], RGB565(255, 128, 0))
Syntax:
DISPLAY_RECT(x, y, width, height, color)
Description:
Draws the outline of the rectangle.
Syntax:
DISPLAY_FILL_RECT(x, y, width, height, color)
Description:
Draws a filled rectangle.
Examples:
DISPLAY_FILL_RECT(10, 10, 100, 50, RGB565(255, 0, 0))
VAR X=10, Y=20, W=100, H=50
DISPLAY_FILL_RECT(X, Y, W, H, RGB565(0, 255, 0))
Syntax:
DISPLAY_CIRCLE(x, y, radius, color)
DISPLAY_CIRCLE(x, y, radius, start_angle, end_angle, color)
Description:
Draws a circle outline or arc.
Examples:
' Full Circle
DISPLAY_CIRCLE(160, 120, 50, RGB565(255, 255, 255))
' Arc from 0° to 90° (upper right quarter)
DISPLAY_CIRCLE(160, 120, 50, 0, 90, RGB565(255, 0, 0))
' Arc from 270° to 360° (upper left quarter)
DISPLAY_CIRCLE(160, 120, 50, 270, 360, RGB565(0, 255, 0))
› Clock Face
FOR I = 0 TO 330 STEP 30
DISPLAY_CIRCLE(160, 120, 80, I, I+10, RGB565(255, 255, 255))
NEXT
Syntax:
DISPLAY_FILL_CIRCLE(x, y, radius, color)
DISPLAY_FILL_CIRCLE(x, y, radius, start_angle, end_angle, color)
Description:
Draws a filled circle or sector.
Examples:
' Full Filled Circle
DISPLAY_FILL_CIRCLE(160, 120, 50, RGB565(0, 0, 255))
' Sector from 0° to 120° (one-third from the top)
DISPLAY_FILL_CIRCLE(160, 120, 50, 0, 120, RGB565(255, 0, 0))
› Pie chart
DISPLAY_FILL_CIRCLE(160, 120, 60, 0, 90, RGB565(255, 0, 0)) ' 25% red
DISPLAY_FILL_CIRCLE(160, 120, 60, 90, 180, RGB565(0, 255, 0)) ' 25% green
DISPLAY_FILL_CIRCLE(160, 120, 60, 180, 270, RGB565(0, 0, 255)) ' 25% Blue
DISPLAY_FILL_CIRCLE(160, 120, 60, 270, 360, RGB565(255, 255, 0)) ' 25% Yellow
' Concentric circles with gradient
FOR R = 10 TO 100 STEP 10
DISPLAY_FILL_CIRCLE(160, 120, R, RGB565(R*2, 255-R*2, 128))
NEXT
Syntax:
Format 1: Polygon by Point Array
DISPLAY_FILL_POLYGON(array[], color)
Format 2: Polygon with a list of coordinates (from 3 to 30 points)
DISPLAY_FILL_POLYGON(x0, y0, x1, y1, x2, y2, ..., color)
Description:
Draws a shaded polygon at specified points. The team supports from 3 to 30 vertices. Uses the scanline fill algorithm for efficient rendering.
Format 1: Dot Array
Format 2: Enumeration of coordinates
Examples:
' Triangle through the enumeration of coordinates
DISPLAY_FILL_POLYGON(160, 50, 100, 150, 220, 150, RGB565(255, 0, 0))
' Pentagon (pentagon)
DISPLAY_FILL_POLYGON(
160, 40,
220, 100,
190, 170,
130, 170,
100, 100,
RGB565(0, 255, 0)
)
' Star (8 peaks)
VAR STAR[16]
STAR[0-15] = {
160, 40, ' top
175, 100,
235, 100, ' right top
185, 140,
210, 200, ' right bottom
160, 160,
110, 200, ' left bottom
135, 140,
85, 100, ' left top
145, 100
}
DISPLAY_FILL_POLYGON(STAR[], RGB565(255, 215, 0))
' Hexagon on Array
VAR HEX[12]
FOR I = 0 TO 5
ANGLE = I * 60 * 3.14159 / 180
HEX[I*2] = 160 + COS(ANGLE) * 60
HEX[I*2+1] = 120 + SIN(ANGLE) * 60
NEXT
DISPLAY_FILL_POLYGON(HEX[], RGB565(128, 0, 255))
' Custom polygon (10 vertices)
DISPLAY_FILL_POLYGON(
50, 50,
100, 40,
150, 60,
180, 100,
170, 150,
140, 180,
100, 190,
60, 170,
40, 130,
45, 80,
RGB565(255, 128, 0)
)
' Rhombus
DISPLAY_FILL_POLYGON(160, 50, 220, 120, 160, 190, 100, 120, RGB565(0, 200, 200))
› Trapeze
DISPLAY_FILL_POLYGON(100, 80, 220, 80, 250, 160, 70, 160, RGB565(200, 100, 50))
Syntax:
For one-dimensional arrays:
DISPLAY_BITMAP(x, y, array[], width, height)
DISPLAY_BITMAP(x, y, array[], width, height, scale)
For two-dimensional arrays:
DISPLAY_BITMAP(x, y, array2d[])
DISPLAY_BITMAP(x, y, array2d[], scale)
Description:
Outputs the bitmap from the array to a scalable display. Each element of the array is the color of a pixel. Supports both one-dimensional and two-dimensional arrays.
Important - interpretation of colors:
Options:
Examples:
Creating a Simple 8x8 Bitmap
VAR SPRITE[64]
Filling in an array (emoticon)
FOR I = 0 TO 63
SPRITE[I] = RGB565(0, 0, 0) // Background black
NEXT
Eyes (red dots)
SPRITE[2*8 + 2] = RGB565(255, 0, 0)
SPRITE[2*8 + 5] = RGB565(255, 0, 0)
Mouth (yellow arc)
SPRITE[5*8 + 2] = RGB565(255, 255, 0)
SPRITE[5*8 + 3] = RGB565(255, 255, 0)
SPRITE[5*8 + 4] = RGB565(255, 255, 0)
SPRITE[5*8 + 5] = RGB565(255, 255, 0)
Output without scaling (8x8 pixels)
DISPLAY_BITMAP(0, 0, SPRITE[], 8, 8)
Output at x2 scale (16x16 pixels)
DISPLAY_BITMAP(20, 0, SPRITE[], 8, 8, 2)
Output at x4 scale (32x32 pixels)
DISPLAY_BITMAP(50, 0, SPRITE[], 8, 8, 4)
Creating a 16x16 gradient
VAR GRADIENT[256]
FOR Y = 0 TO 15
FOR X = 0 TO 15
VAR R = X * 16
VAR G = Y * 16
GRADIENT[Y*16 + X] = RGB565(R, G, 128)
NEXT
NEXT
DISPLAY_BITMAP(100, 100, GRADIENT[], 16, 16, 2)
Animating a Sprite Movement
VAR X=0
WHILE X < 200
DISPLAY_CLEAR()
DISPLAY_BITMAP(X, 50, SPRITE[], 8, 8, 3)
X = X + 5
PAUSE 50
WEND
Creating an icon using variables
VAR ICON[16] // 4x4 pixels
VAR RED = RGB565(255, 0, 0)
VAR GREEN = RGB565(0, 255, 0)
VAR BLUE = RGB565(0, 0, 255)
VAR YELLOW = RGB565(255, 255, 0)
ICON[0] = RED
ICON[1] = GREEN
ICON[2] = BLUE
ICON[3] = YELLOW
ICON[4] = GREEN
ICON[5] = RED
ICON[6] = YELLOW
ICON[7] = BLUE
ICON[8] = BLUE
ICON[9] = YELLOW
ICON[10] = RED
ICON[11] = GREEN
ICON[12] = YELLOW
ICON[13] = BLUE
ICON[14] = GREEN
ICON[15] = RED
Output with different scales
DISPLAY_BITMAP(10, 10, ICON[], 4, 4, 1) // 4x4
DISPLAY_BITMAP(30, 10, ICON[], 4, 4, 2) // 8x8
DISPLAY_BITMAP(60, 10, ICON[], 4, 4, 4) // 16x16
DISPLAY_BITMAP(100, 10, ICON[], 4, 4, 8) // 32x32
Examples with two-dimensional arrays:
Creating a 2D 8x8 Bitmap (More Intuitive Syntax)
VAR SPRITE2D[8, 8]
Filling in an array (emoticon)
FOR Y = 0 TO 7
FOR X = 0 TO 7
SPRITE2D[Y, X] = RGB565(0, 0, 0) // Background black
NEXT
NEXT
Eyes (red dots)
SPRITE2D[2, 2] = RGB565(255, 0, 0)
SPRITE2D[2, 5] = RGB565(255, 0, 0)
Mouth (yellow arc)
SPRITE2D[5, 2] = RGB565(255, 255, 0)
SPRITE2D[5, 3] = RGB565(255, 255, 0)
SPRITE2D[5, 4] = RGB565(255, 255, 0)
SPRITE2D[5, 5] = RGB565(255, 255, 0)
Output without scaling - dimensions are taken automatically!
DISPLAY_BITMAP(0, 0, SPRITE2D[])
Output with a scale of x2 - width/height is not needed!
DISPLAY_BITMAP(20, 0, SPRITE2D[], 2)
Creating a 16x16 Gradient in a 2D Pattern
VAR GRADIENT2D[16, 16]
FOR Y = 0 TO 15
FOR X = 0 TO 15
VAR R = X * 16
VAR G = Y * 16
GRADIENT2D[Y, X] = RGB565(R, G, 128)
NEXT
NEXT
DISPLAY_BITMAP(100, 100, GRADIENT2D[], 2)
Animating a Sprite Move with a 2D Pattern
VAR X=0
WHILE X < 200
DISPLAY_CLEAR()
DISPLAY_BITMAP(X, 50, SPRITE2D[], 3)
X = X + 5
PAUSE 50
WEND
Creating an 8x8 Chessboard
VAR CHESS[8, 8]
VAR WHITE = RGB565(255, 255, 255)
VAR BLACK = RGB565(0, 0, 0)
FOR Y = 0 TO 7
FOR X = 0 TO 7
IF (X + Y) % 2 = 0 THEN
CHESS[Y, X] = WHITE
ELSE
CHESS[Y, X] = BLACK
ENDIF
NEXT
NEXT
DISPLAY_BITMAP(10, 10, CHESS[], 4) // 8x8 pixels -> 32x32 on the screen
Creating a Simple 5x5 Heart Icon - Initialization on Announcement
VAR RED = RGB565(255, 0, 0)
VAR BG = RGB565(0, 0, 0)
VAR HEART[5, 5] = {
{BG, RED, BG, RED, BG},
{RED, RED, RED, RED, RED},
{RED, RED, RED, RED, RED},
{BG, RED, RED, RED, BG},
{BG, BG, RED, BG, BG}
}
DISPLAY_BITMAP(50, 50, HEART[], 5) // Increase by 5 times
Create a 10x10 rainbow gradient
VAR RAINBOW[10, 10]
FOR Y = 0 TO 9
FOR X = 0 TO 9
VAR HUE = (X + Y) * 25 // Value from 0 to 450
IF HUE < 256 THEN
Red -> Green
RAINBOW[Y, X] = RGB565(255 - HUE, HUE, 0)
ELSE
Green -> Blue
VAR VAL = HUE - 256
RAINBOW[Y, X] = RGB565(0, 255 - VAL, VAL)
ENDIF
NEXT
NEXT
DISPLAY_BITMAP(100, 10, RAINBOW[], 3)
Creating a 16x16 Circle (Pixel Art)
VAR CIRCLE[16, 16]
VAR CENTER_X = 7.5
VAR CENTER_Y = 7.5
VAR RADIUS = 7
FOR Y = 0 TO 15
FOR X = 0 TO 15
VAR DX = X - CENTER_X
VAR DY = Y - CENTER_Y
VAR DIST = SQR(DX * DX + DY * DY)
IF DIST <= RADIUS THEN
CIRCLE[Y, X] = RGB565(255, 255, 0) // Yellow circle
ELSE
CIRCLE[Y, X] = RGB565(0, 0, 128) // Blue Background
ENDIF
NEXT
NEXT
DISPLAY_BITMAP(200, 100, CIRCLE[], 2)
Function for creating an arrow
FUNCTION CREATE_ARROW(ARROW2D[], DIR)
DIR: 0=up, 1=right, 2=down, 3=left
VAR ARROW_COLOR = RGB565(0, 255, 0)
VAR BG_COLOR = RGB565(0, 0, 0)
Clear the array
FOR Y = 0 TO 6
FOR X = 0 TO 6
ARROW2D[Y, X] = BG_COLOR
NEXT
NEXT
IF DIR = 0 THEN // Up
ARROW2D[0, 3] = ARROW_COLOR
ARROW2D[1, 2] = ARROW_COLOR
ARROW2D[1, 3] = ARROW_COLOR
ARROW2D[1, 4] = ARROW_COLOR
ARROW2D[2, 1] = ARROW_COLOR
ARROW2D[2, 3] = ARROW_COLOR
ARROW2D[2, 5] = ARROW_COLOR
ARROW2D[3, 3] = ARROW_COLOR
ARROW2D[4, 3] = ARROW_COLOR
ARROW2D[5, 3] = ARROW_COLOR
ARROW2D[6, 3] = ARROW_COLOR
ENDIF
IF DIR = 1 THEN // Right
ARROW2D[3, 6] = ARROW_COLOR
ARROW2D[2, 5] = ARROW_COLOR
ARROW2D[3, 5] = ARROW_COLOR
ARROW2D[4, 5] = ARROW_COLOR
ARROW2D[1, 4] = ARROW_COLOR
ARROW2D[3, 4] = ARROW_COLOR
ARROW2D[5, 4] = ARROW_COLOR
ARROW2D[3, 3] = ARROW_COLOR
ARROW2D[3, 2] = ARROW_COLOR
ARROW2D[3, 1] = ARROW_COLOR
ARROW2D[3, 0] = ARROW_COLOR
ENDIF
You can add DIR=2 and DIR=3 in the same way
ENDFUNC
Using the
VAR ARROW_UP[7, 7]
CREATE_ARROW(ARROW_UP[], 0)
DISPLAY_BITMAP(50, 150, ARROW_UP[], 4)
VAR ARROW_RIGHT[7, 7]
CREATE_ARROW(ARROW_RIGHT[], 1)
DISPLAY_BITMAP(100, 150, ARROW_RIGHT[], 4)
Flashing 2D Sprite Animation
VAR STAR[6, 6]
VAR YELLOW = RGB565(255, 255, 0)
VAR BLACK = RGB565(0, 0, 0)
Creating a star
FOR Y = 0 TO 5
FOR X = 0 TO 5
STAR[Y, X] = BLACK
NEXT
NEXT
STAR[0, 3] = YELLOW
STAR[1, 2] = YELLOW
STAR[1, 3] = YELLOW
STAR[1, 4] = YELLOW
STAR[2, 1] = YELLOW
STAR[2, 2] = YELLOW
STAR[2, 3] = YELLOW
STAR[2, 4] = YELLOW
STAR[2, 5] = YELLOW
STAR[3, 2] = YELLOW
STAR[3, 3] = YELLOW
STAR[3, 4] = YELLOW
STAR[4, 3] = YELLOW
STAR[5, 3] = YELLOW
Flashing Animation
FOR I = 1 TO 10
DISPLAY_BITMAP(150, 150, STAR[], 6)
PAUSE 300
DISPLAY_CLEAR()
PAUSE 300
NEXT
Copying and modifying a 2D array
VAR SPRITE_ORIGINAL[4, 4]
VAR SPRITE_COPY[4, 4]
Filling out the original
FOR Y = 0 TO 3
FOR X = 0 TO 3
SPRITE_ORIGINAL[Y, X] = RGB565(X * 64, Y * 64, 128)
NEXT
NEXT
Copy and invert colors
FOR Y = 0 TO 3
FOR X = 0 TO 3
VAR COLOR = SPRITE_ORIGINAL[Y, X]
Simple inversion (not exact for RGB565, but demonstrative)
SPRITE_COPY[Y, X] = RGB565(255, 255, 255) - COLOR
NEXT
NEXT
DISPLAY_BITMAP(10, 200, SPRITE_ORIGINAL[], 8)
DISPLAY_BITMAP(100, 200, SPRITE_COPY[], 8)
Vertical bitmap reflection
VAR ORIGINAL[6, 6]
VAR FLIPPED[6, 6]
Creating an Asymmetrical Pattern
FOR Y = 0 TO 5
FOR X = 0 TO 5
ORIGINAL[Y, X] = RGB565(X * 40, Y * 40, 100)
NEXT
NEXT
Flip vertically
FOR Y = 0 TO 5
FOR X = 0 TO 5
FLIPPED[Y, X] = ORIGINAL[5 - Y, X]
NEXT
NEXT
DISPLAY_BITMAP(10, 300, ORIGINAL[], 5)
DISPLAY_BITMAP(80, 300, FLIPPED[], 5)
Note:
Syntax:
DISPLAY_ARC(center_x, center_y, radius, thickness, start_angle, end_angle, color, bg_color)
Description:
Draws an arc with a specified thickness.
Options:
Syntax:
DISPLAY_TEXT(x, y, arg1, arg2, ..., FONT, SCALE, color)
DISPLAY_TEXT(x, y, arg1, arg2, ..., FONT, SCALE, color, bg_color)
Description:
Displays text with support for combining string literals and variables. Supports integer scaling of fonts to achieve the desired size.
Options:
Number formatting:
For variables and expressions, you can specify formatting options separated by a dot:
'variable. N' - rounding to N decimal places
'variable. Nz' is rounding with the addition of leading zeros
'variable.h' - output in hexadecimal format
'variable.b' - output in binary format
Formatting examples:**
VAR TEMP = 5.6789
DISPLAY_TEXT(0, 0, TEMP, Font_7x10, 1, 0xFFFF) // "5.678900"
DISPLAY_TEXT(0, 20, TEMP.1, Font_7x10, 1, 0xFFFF) // "5.7"
DISPLAY_TEXT(0, 40, TEMP.2, Font_7x10, 1, 0xFFFF) // "5.68"
DISPLAY_TEXT(0, 60, TEMP.2z, Font_7x10, 1, 0xFFFF) // "05.68"
VAR COUNT = 7
DISPLAY_TEXT(0, 80, COUNT.0, Font_7x10, 1, 0xFFFF) // "7"
DISPLAY_TEXT(0, 100, COUNT.0z, Font_7x10, 1, 0xFFFF) // "07"
DISPLAY_TEXT(0, 120, COUNT.3z, Font_7x10, 1, 0xFFFF) // "07.000"
Hex and binary formatting
VAR NUM = 255
DISPLAY_TEXT(0, 140, "Dec: ", NUM, Font_7x10, 1, 0xFFFF) // "Dec: 255"
DISPLAY_TEXT(0, 160, "Hex: ", NUM.h, Font_7x10, 1, 0xFFFF) // "Hex: 0xFF"
DISPLAY_TEXT(0, 180, "Bin: ", NUM.b, Font_7x10, 1, 0xFFFF) // "Bin: 0b11111111"
VAR MASK = 0b1010
DISPLAY_TEXT(0, 200, "Mask: ", MASK.h, Font_7x10, 1, 0xFFFF) // "Mask: 0xA"
Examples:
Plain text without scaling (original size)
DISPLAY_TEXT(10, 10, "Hello World", Font_7x10, 1, RGB565(255, 255, 255))
Combination of text and variables
VAR TEMP = 23.456
DISPLAY_TEXT(10, 30, "Temperature: ", TEMP, " C", Font_11x18, 1, RGB565(255, 0, 0))
Formatting numbers, small text
VAR PI = 3.14159
DISPLAY_TEXT(10, 50, "Pi = ", PI.2, Font_6x8, 1, RGB565(0, 255, 0))
Outputs: "Pi = 3.14"
With Background Color
DISPLAY_TEXT(10, 70, "Status: OK", Font_16x26, 1, RGB565(0, 255, 0), RGB565(0, 0, 0))
2x Zoom
DISPLAY_TEXT(10, 100, "Scale 2x", Font_7x10, 2, RGB565(255, 255, 0))
3x Scaling
DISPLAY_TEXT(10, 130, "Scale 3x", Font_6x8, 3, RGB565(255, 255, 255))
Zero-filled
VAR COUNT = 5
DISPLAY_TEXT(10, 150, "Count: ", COUNT.2z, Font_7x10, 2, RGB565(255, 255, 255))
Displays: "Count: 05.00"
Multiple Variables
VAR X = 100, Y = 200
DISPLAY_TEXT(10, 170, "Position: (", X, ", ", Y, ")", Font_6x8, 1, RGB565(128, 128, 128))
Decorative font Baksheesh12pt (28px basic)
DISPLAY_TEXT(10, 190, "Beautiful", Baksheesh12pt, 1, RGB565(100, 200, 255))
Baksheesh20pt (46px Basic) with 2x scale = 92px
DISPLAY_TEXT(10, 230, "Elegant", Baksheesh20pt, 2, RGB565(255, 200, 100))
Baksheesh40pt (92px Basic)
DISPLAY_TEXT(10, 340, "Large", Baksheesh40pt, 1, RGB565(255, 100, 100))
VCRSCapsSSK Monospaced Font (Retro Style)
DISPLAY_TEXT(10, 10, "RETRO 8pt", VCRSCapsSSK8pt, 1, 0xFFFF) // 20px base
DISPLAY_TEXT(10, 35, "RETRO 12pt", VCRSCapsSSK12pt, 1, 0xFFFF) // 31px base
DISPLAY_TEXT(10, 70, "RETRO 24pt", VCRSCapsSSK24pt, 1, 0xFFFF) // 61px base
Scaling VCRSCapsSSK
DISPLAY_TEXT(10, 140, "RETRO 2x", VCRSCapsSSK8pt, 2, 0xFF00) // 20px * 2 = 40px
DISPLAY_TEXT(10, 185, "RETRO 3x", VCRSCapsSSK8pt, 3, 0x00FF) // 20px * 3 = 60px
Available fonts:
Fixed width (monospaced):
Decorative (variable width) - Baksheesh:
Retro Style (Variable Width) - VCRSCapsSSK:
Zoom Note:
Note:
Syntax:
BUTTON_INIT(x, y, width, height, color, "label", is_toggle, x_var, y_var, touched_var, press_handler, release_handler)
Description:
Creates an interactive button on the display with automatic touch handling. When the button is pressed and released, handlers are automatically invoked via the label mechanism and 'GOSUB/RETURN'.
Options:
How handlers work:
Handlers are labels in your code. When the button is pressed, the interpreter automatically performs 'GOSUB press_handler', when released, 'GOSUB release_handler'. Handlers must:
Examples:
Example 1: A simple START button with two handlers
FT6336U_INIT(TX, TY, TOUCHED, 50)
BUTTON_INIT(10, 10, 100, 50, RGB565(0, 255, 0), "START", 0, TX, TY, TOUCHED, OnStart, OnEnd)
WHILE 1
PAUSE 100
WEND
OnStart:
PRINT "Button pressed!"
DISPLAY_FILL_CIRCLE(160, 120, 30, RGB565(255, 0, 0))
RETURN
OnEnd:
PRINT "Button released!"
DISPLAY_FILL_CIRCLE(160, 120, 30, RGB565(0, 255, 0))
RETURN
Example 2: A button without a release handler
FT6336U_INIT(TX, TY, TOUCHED, 50)
BUTTON_INIT(10, 10, 100, 50, RGB565(255, 165, 0), "CLICK", 0, TX, TY, TOUCHED, OnClick, )
VAR COUNTER = 0
WHILE 1
DISPLAY_TEXT(10, 100, "Clicks: ", COUNTER, Font_7x10, 1, 0xFFFF)
PAUSE 100
WEND
OnClick:
COUNTER = COUNTER + 1
PRINT "Click #", COUNTER
RETURN
Example 3: Toggle button
FT6336U_INIT(TX, TY, TOUCHED, 50)
BUTTON_INIT(10, 10, 120, 50, RGB565(100, 100, 255), "TOGGLE", 1, TX, TY, TOUCHED, OnToggle, )
VAR LED_STATE = 0
WHILE 1
IF LED_STATE == 1 THEN
DISPLAY_TEXT(10, 100, "LED: ON ", Font_7x10, 1, RGB565(0, 255, 0))
ELSE
DISPLAY_TEXT(10, 100, "LED: OFF", Font_7x10, 1, RGB565(255, 0, 0))
ENDIF
PAUSE 100
WEND
OnToggle:
LED_STATE = 1 - LED_STATE // Invert State
PRINT "LED state:", LED_STATE
RETURN
Example 4: Managing PWM via Buttons
FT6336U_INIT(TX, TY, TOUCHED, 50)
VAR BRIGHTNESS = 50
BUTTON_INIT(10, 10, 80, 50, RGB565(0, 255, 0), "+", 0, TX, TY, TOUCHED, BtnPlus, )
BUTTON_INIT(100, 10, 80, 50, RGB565(255, 0, 0), "-", 0, TX, TY, TOUCHED, BtnMinus, )
WHILE 1
PWM1 CH1 1000, BRIGHTNESS, 0
DISPLAY_TEXT(10, 80, "PWM: ", BRIGHTNESS.0, "% ", Font_7x10, 1, 0xFFFF)
PAUSE 100
WEND
BtnPlus:
IF BRIGHTNESS < 100 THEN
BRIGHTNESS = BRIGHTNESS + 10
ENDIF
RETURN
BtnMinus:
IF BRIGHTNESS > 0 THEN
BRIGHTNESS = BRIGHTNESS - 10
ENDIF
RETURN
Example 5: Multi-button menus
FT6336U_INIT(TX, TY, TOUCHED, 50)
VAR MODE = 0
BUTTON_INIT(10, 10, 100, 40, RGB565(255, 0, 0), "MODE 1", 0, TX, TY, TOUCHED, SelectMode1, )
BUTTON_INIT(10, 60, 100, 40, RGB565(0, 255, 0), "MODE 2", 0, TX, TY, TOUCHED, SelectMode2, )
BUTTON_INIT(10, 110, 100, 40, RGB565(0, 0, 255), "MODE 3", 0, TX, TY, TOUCHED, SelectMode3, )
WHILE 1
IF MODE == 1 THEN
DISPLAY_TEXT(120, 20, "Current: MODE 1", Font_7x10, 1, 0xFFFF)
Mode 1 logic
ELSE IF MODE == 2 THEN
DISPLAY_TEXT(120, 20, "Current: MODE 2", Font_7x10, 1, 0xFFFF)
Mode 2 logic
ELSE IF MODE == 3 THEN
DISPLAY_TEXT(120, 20, "Current: MODE 3", Font_7x10, 1, 0xFFFF)
Mode 3 logic
ENDIF
PAUSE 100
WEND
SelectMode1:
MODE = 1
PRINT "Switched to MODE 1"
RETURN
SelectMode2:
MODE = 2
PRINT "Switched to MODE 2"
RETURN
SelectMode3:
MODE = 3
PRINT "Switched to MODE 3"
RETURN
Example 6: Visual feedback button
FT6336U_INIT(TX, TY, TOUCHED, 50)
VAR BTN_COLOR = RGB565(0, 200, 0)
BUTTON_INIT(100, 100, 120, 60, BTN_COLOR, "PRESS", 0, TX, TY, TOUCHED, OnPress, OnRelease)
WHILE 1
PAUSE 100
WEND
OnPress:
Change the color of the button when pressed
BTN_COLOR = RGB565(0, 100, 0) // Darker
DISPLAY_FILL_RECT(100, 100, 120, 60, BTN_COLOR)
DISPLAY_TEXT(120, 120, "PRESS", Font_7x10, 1, 0xFFFF)
RETURN
OnRelease:
Return to original color
BTN_COLOR = RGB565(0, 200, 0) // Lighter
DISPLAY_FILL_RECT(100, 100, 120, 60, BTN_COLOR)
DISPLAY_TEXT(120, 120, "PRESS", Font_7x10, 1, 0xFFFF)
RETURN
Important Notes:**
Syntax:
STEPPER_INIT(x, y, width, height, x_var, y_var, touched_var, value_var, min, max, step)
Description:
Creates a stepper widget (+/- buttons to change the value).
Options:
Examples:
VAR VOLUME = 50
STEPPER_INIT(10, 10, 150, 60, TX, TY, TOUCHED, VOLUME, 0, 100, 5)
Syntax:
PROGRESS_INIT(x, y, width, height, value_var, min, max, progress_color)
Description:
Creates a progress bar widget.
Options:
Examples:
VAR PROGRESS = 0
PROGRESS_INIT(10, 100, 300, 30, PROGRESS, 0, 100, RGB565(0, 255, 0))
FOR PROGRESS = 0 TO 100
PAUSE 50
NEXT
Syntax:
GAUGE_INIT(x, y, width, height, value_var, min, max, label, gauge_color)
Description:
Creates a gauge widget with segments and a label.
Options:
Examples:
VAR TEMP = 25
GAUGE_INIT(160, 120, 150, 150, TEMP, 0, 100, "°C", RGB565(0, 255, 0))
Pulse oximeter example
VAR HR = 0
VAR SPO2 = 0
GAUGE_INIT(120, 140, 150, 150, HR, 0, 120, "BPM", RGB565(255, 0, 0))
GAUGE_INIT(360, 140, 150, 150, SPO2, 0, 100, "%", RGB565(0, 0, 255))
Syntax:
SLIDER_INIT(x, y, width, height, x_var, y_var, touched_var, value_var, min, max, slider_color)
Description:
Creates a slider widget.
Options:
Examples:
VAR BRIGHTNESS = 50
SLIDER_INIT(10, 180, 300, 40, TX, TY, TOUCHED, BRIGHTNESS, 0, 100, RGB565(255, 165, 0))
Syntax:
GRAPH_INIT(x, y, width, height, data_array, min, max, update_interval_sec, graph_color)
Description:
Creates a graph widget to display an array of data as a line graph.
Options:
Examples:
Creating an array for data
VAR DATA[100]
Initializing the Graph
GRAPH_INIT(10, 10, 300, 200, DATA, 0, 100, 0.5, RGB565(0, 255, 0))
Populating an array with data
FOR I = 0 TO 99
DATA[I] = 50 + SIN(I * 0.1) * 30
NEXT
Temperature sensor data graph
VAR TEMPS[50]
DHT_INIT(T, H, 1000)
GRAPH_INIT(10, 10, 300, 150, TEMPS, 0, 50, 1.0, RGB565(255, 0, 0))
VAR INDEX = 0
WHILE 1
TEMPS[INDEX] = T
INDEX = (INDEX + 1) % 50
PAUSE 1000
WEND
Note:
Syntax:
WIDGET_REDRAW
Description:
Redraws all widgets on the display.
Syntax:
DHT_INIT(temp_var, hum_var, delay_ms)
Description:
Initializes a DHT sensor (DHT11/DHT22) to read temperature and humidity periodically.
Options:
Examples:
DHT_INIT(TEMP, HUM, 2000)
PRINT "Temperature: ", TEMP, " C"
PRINT "Humidity: ", HUM, " %"
Syntax:
HX711_INIT(var_name, delay_ms, dout_out, sck_out, gain)
Description:
Initializes the HX711 load cell.
Options:
Examples:
HX711_INIT(WEIGHT, 100, 1, 2, 128)
PRINT "Weight: ", WEIGHT
Syntax:
DS1820_INIT(array_name, delay_ms)
Description:
Initializes temperature sensors DS18B20 (1-Wire).
Options:
Examples:
DS1820_INIT(TEMPS, 1000)
PRINT "Sensor 1: ", TEMPS[0], " C"
PRINT "Sensor 2: ", TEMPS[1], " C"
Syntax:
APDS_INIT(als_var, prox_var, delay_ms)
Description:
Initializes the APDS9930 (light and proximity) sensor.
Options:
Examples:
APDS_INIT(LIGHT, PROX, 500)
PRINT "Light: ", LIGHT
PRINT "Proximity: ", PROX
Syntax:
FFT_INIT(array_name[], adc_channel, smoothing)
Description:
Initializes the FFT (Fast Fourier Transform) module to automatically analyze the signal spectrum from a specified ADC channel with EMA anti-aliasing support for smooth music visualization.
Options:
Features:
What is contained in the array:
Examples:
' Initialize and start FFT with a ADC_IN1 channel
FFT_INIT(SPECTRUM[], ADC_IN1)
FFT_START()
' Main Spectrum Display Cycle (Updates Automatically)
WHILE 1
• Spectrum display on LED matrix (first 32 bins)
FOR i = 0 TO 31
VAR HEIGHT = SPECTRUM[i] / 10
MATRIX_SET(i, 0, RGB888(0, 255, 0))
NEXT i
MATRIX_UPDATE()
DELAY(50)
WEND
' Audio Spectrum Visualization with Auto Update
FFT_INIT(AUDIO[], ADC_IN2)
FFT_START()
WHILE 1
' Color spectrum: low frequencies are red, high frequencies are blue
FOR i = 0 TO 31
VAR INTENSITY = AUDIO[i]
VAR RED = 255 - i * 8
VAR BLUE = i * 8
MATRIX_PRINT(i, 0, INTENSITY.0z, Font_6x8, RGB888(RED, 0, BLUE), 0x000000)
NEXT i
MATRIX_UPDATE()
DELAY(100)
WEND
› Analysis of specific frequencies
FFT_INIT(FREQ[], ADC_IN1)
FFT_START()
WHILE 1
' Indexes for specific frequencies:
' array[0] = 0 Hz (DC)
' array[16] = 1000 Hz (1 kHz) - 16 * 62.5 = 1000
' array[32] = 2000 Hz (2 kHz) - 32 * 62.5 = 2000
' array[80] = 5000 Hz (5 kHz) - 80 * 62.5 = 5000
VAR AMP_1KHZ = FREQ[16] ' Amplitude at 1 kHz
VAR AMP_2KHZ = FREQ[32] ' Amplitude at 2 kHz
VAR AMP_5KHZ = FREQ[80] ' Amplitude at 5 kHz
DISPLAY_TEXT(0, 0, "1kHz: ", AMP_1KHZ.0z, Font_7x10, 0xFFFF)
DISPLAY_TEXT(0, 10, "2kHz: ", AMP_2KHZ.0z, Font_7x10, 0xFFFF)
DISPLAY_TEXT(0, 20, "5kHz: ", AMP_5KHZ.0z, Font_7x10, 0xFFFF)
DELAY(100)
WEND
Syntax:
FFT_START()
Description:
Starts automatic signal capture and processing for FFT. The timer starts capturing samples at 16 kHz, automatically calculates FFT every 128 samples, and updates the array of results.
IMPORTANTLY:
After calling FFT_START(), the array will be constantly updated in the background (via a timer interrupt) about 125 times per second (every 8 ms) until you call FFT_STOP(). You don't need to call FFT_START() in a loop - just call once, and the array will automatically contain fresh spectrum data.
Requirements:
Examples:
› Basic Spectrum Analyzer
FFT_INIT(FREQ[], ADC_IN1)
FFT_START()
WHILE 1
'Find the dominant frequency
VAR MAX_VAL = 0
VAR MAX_IDX = 0
FOR i = 1 TO 127
IF FREQ[i] > MAX_VAL THEN
MAX_VAL = FREQ[i]
MAX_IDX = i
ENDIF
NEXT i
' Calculate Frequency in Hz (62.5 Hz per bin)
VAR PEAK_FREQ = MAX_IDX * 62.5
DISPLAY_TEXT(0, 0, "Peak: ", PEAK_FREQ, " Hz", Font_7x10, 0xFFFF)
DELAY(100)
WEND
› Start/stop FFT by button
FFT_INIT(SPECTRUM[], ADC_IN1)
VAR RUNNING = 0
WHILE 1
IF BUTTON(1) == 1 THEN
IF RUNNING == 0 THEN
FFT_START()
RUNNING = 1
DISPLAY_TEXT(0, 0, "FFT: ON", Font_7x10, 0x00FF00)
ELSE
FFT_STOP()
RUNNING = 0
DISPLAY_TEXT(0, 0, "FFT: OFF", Font_7x10, 0xFF0000)
ENDIF
DELAY(300) ' Debounce
ENDIF
WEND
Syntax:
FFT_STOP()
Description:
Stops automatic capture and processing of FFT. The timer stops, and the array of results stores the last calculated values.
Requirements:
Examples:
' Spectrum capture on demand
FFT_INIT(SPECTRUM[], ADC_IN1)
WHILE 1
' Capture & Analyze
FFT_START()
DELAY(100) ' Allow time for multiple FFT cycles
FFT_STOP()
' Display captured spectrum (first 64 bins on a 32x2 matrix)
FOR i = 0 TO 63
VAR HEIGHT = SPECTRUM[i] / 10
MATRIX_SET(i MOD 32, i / 32, RGB888(0, HEIGHT, 0))
NEXT i
MATRIX_UPDATE()
DELAY(1000)
WEND
Syntax:
AHT21_INIT(temp_var, hum_var, delay_ms)
Description:
Initializes the AHT21/AHT20 sensor (I2C temperature and humidity).
Examples:
AHT21_INIT(T, H, 2000)
Syntax:
SI7021_INIT(temp_var, hum_var, delay_ms)
Description:
Initializes the SI7021 (I2C temperature and humidity) sensor.
Syntax:
BMP280_INIT(temp_var, press_var, delay_ms)
Description:
Initializes the BMP280 (temperature and pressure) sensor.
Options:
Examples:
BMP280_INIT(TEMP, PRESS, 1000)
PRINT "Pressure: ", PRESS, " hPa"
Syntax:
SHT21_INIT(temp_var, hum_var, delay_ms)
Description:
Initializes the SHT21 (I2C Temperature and Humidity) sensor.
Syntax:
CCS811_INIT(co2_var, tvoc_var, delay_ms)
Description:
Initializes the CCS811 sensor (CO2 and TVOC).
Options:
Examples:
CCS811_INIT(CO2, TVOC, 2000)
PRINT "CO2: ", CO2, " ppm"
PRINT "TVOC: ", TVOC, " ppb"
Syntax:
CCS811_STATUS
Description:
Displays the status of the CCS811 sensor.
Syntax:
CCS811_BASELINE <value>
Description:
Sets the baseline for the CCS811 sensor.
Syntax:
CCS811_ENV <temp> <humidity>
Description:
Sets environmental data to compensate for CCS811 readings.
Syntax:
VL53_INIT(distance_var, delay_ms)
Description:
Initializes the VL53L0X laser rangefinder (I2C ToF distance sensor).
Options:
Examples:
VL53_INIT(DIST, 100)
PRINT "Distance: ", DIST, " mm"
Automatic Distance Response
VL53_INIT(RANGE, 200)
WHILE 1
IF RANGE < 100 THEN
PRINT "Object detected!"
DISPLAY_FILL_CIRCLE(160, 120, 30, RGB565(255, 0, 0))
ELSE
DISPLAY_FILL_CIRCLE(160, 120, 30, RGB565(0, 255, 0))
ENDIF
PAUSE 100
WEND
Note:
Syntax:
FT6336U_INIT(x_var, y_var, touched_var, delay_ms)
Description:
Initializes the FT6336U (I2C capacitive touch controller) to track touch on the display.
Options:
Examples:
A simple example of touch tracking
FT6336U_INIT(TX, TY, TOUCHED, 50)
WHILE 1
IF TOUCHED == 1 THEN
PRINT "Touch at: ", TX, ", ", TY
DISPLAY_FILL_CIRCLE(TX, TY, 10, RGB565(255, 0, 0))
ENDIF
PAUSE 100
WEND
Interactive drawing
FT6336U_INIT(X, Y, T, 20)
DISPLAY_CLEAR()
WHILE 1
IF T == 1 THEN
Draw a point at the point of touch
DISPLAY_FILL_CIRCLE(X, Y, 5, RGB565(0, 255, 0))
ENDIF
PAUSE 20
WEND
Virtual Buttons
FT6336U_INIT(PX, PY, PRESS, 30)
Drawing buttons
VAR BTN1_COLOR = RGB565(0, 255, 0)
VAR BTN2_COLOR = RGB565(255, 0, 0)
DISPLAY_FILL_RECT(10, 10, 100, 50, BTN1_COLOR)
DISPLAY_TEXT(20, 25, "Button 1", Font_7x10, 1, 0xFFFF)
DISPLAY_FILL_RECT(120, 10, 100, 50, BTN2_COLOR)
DISPLAY_TEXT(130, 25, "Button 2", Font_7x10, 1, 0xFFFF)
WHILE 1
IF PRESS == 1 THEN
Check for button 1
IF PX > 10 AND PX < 110 AND PY > 10 AND PY < 60 THEN
PRINT "Button 1 pressed!"
ENDIF
Checking for button 2
IF PX > 120 AND PX < 220 AND PY > 10 AND PY < 60 THEN
PRINT "Button 2 pressed!"
ENDIF
ENDIF
PAUSE 50
WEND
Note:
Syntax:
MAX30102_INIT(hr_var, spo2_var, delay_ms)
Description:
Initializes the MAX30102 pulse oximeter sensor (I2C heart rate and oxygen saturation sensor). The sensor uses an optical measurement method with red and infrared LEDs to detect heart rate (HR) and blood oxygen level (SpO2).
Options:
Examples:
Easy heart rate and SpO2 monitoring
MAX30102_INIT(HR, SPO2, 200)
WHILE 1
PRINT "Heart Rate: ", HR.0, " BPM"
PRINT "SpO2: ", SPO2.0, " %"
PAUSE 1000
WEND
Display visualization with GAUGE widgets
MAX30102_INIT(PULSE, OXYGEN, 200)
Creating Circular Indicators with Captions
GAUGE_INIT(120, 140, 150, 150, PULSE, 0, 120, "BPM", RGB565(255, 0, 0))
GAUGE_INIT(360, 140, 150, 150, OXYGEN, 0, 100, "%", RGB565(0, 100, 255))
WHILE 1
Displaying values in text
DISPLAY_TEXT(10, 10, "HR: ", PULSE.0, " BPM", Font_11x18, 1, RGB565(255, 0, 0))
DISPLAY_TEXT(10, 40, "SpO2: ", OXYGEN.0, " %", Font_11x18, 1, RGB565(0, 100, 255))
Checking Normal Values
IF PULSE > 0 AND PULSE < 200 THEN
DISPLAY_TEXT(10, 70, "Status: OK", Font_7x10, 1, RGB565(0, 255, 0))
ELSE
DISPLAY_TEXT(10, 70, "Status: --", Font_7x10, 1, RGB565(128, 128, 128))
ENDIF
PAUSE 100
WEND
Color status indication
MAX30102_INIT(BPM, O2, 200)
WHILE 1
Determine the color of the indication by the pulse rate
VAR HR_COLOR
IF BPM < 60 THEN
HR_COLOR = RGB565(0, 150, 255) // Blue - low heart rate
ELSE IF BPM < 100 THEN
HR_COLOR = RGB565(0, 255, 0) // Green - Normal
ELSE
HR_COLOR = RGB565(255, 150, 0) // Orange - High
ENDIF
Oxygen Level Indication Color
VAR O2_COLOR
IF O2 < 90 THEN
O2_COLOR = RGB565(255, 0, 0) // Red - Low
ELSE IF O2 < 95 THEN
O2_COLOR = RGB565(255, 200, 0) // Yellow - Medium
ELSE
O2_COLOR = RGB565(0, 255, 0) // Green is excellent
ENDIF
DISPLAY_FILL_RECT(10, 100, 200, 40, HR_COLOR)
DISPLAY_TEXT(20, 115, "HR: ", BPM.0, " BPM", Font_7x10, 1, 0xFFFF)
DISPLAY_FILL_RECT(10, 150, 200, 40, O2_COLOR)
DISPLAY_TEXT(20, 165, "SpO2: ", O2.0, " %", Font_7x10, 1, 0xFFFF)
PAUSE 500
WEND
Recording Measurement History to the Array
MAX30102_INIT(HEARTRATE, OXYGEN, 200)
VAR HISTORY[50]
VAR INDEX = 0
GRAPH_INIT(10, 10, 460, 150, HISTORY, 0, 120, 1.0, RGB565(255, 0, 0))
WHILE 1
Save the heart rate value to an array
HISTORY[INDEX] = HEARTRATE
INDEX = (INDEX + 1) % 50 // Cyclic buffer
DISPLAY_TEXT(10, 180, "Current HR: ", HEARTRATE.0, " BPM", Font_11x18, 1, 0xFFFF)
DISPLAY_TEXT(10, 210, "SpO2: ", OXYGEN.0, " %", Font_11x18, 1, 0xFFFF)
PAUSE 1000
WEND
Note:
Syntax:
ADC_READ
Description:
Displays the values of all available ADC channels in comma-separated volts, in order ADC_IN1, ADC_IN2, ADC_IN3, etc.
Examples:
ADC_READ
Output: 2.458,1.234,3.012,0.567,1.890,2.345
Note:
Syntax:
ADC_IN1
ADC_IN2
ADC_IN3
...
Description:
Functions for reading ADC channel values in volts. Used in expressions that are not commands.
Examples:
Reading to a variable
VAR V1 = ADC_IN1
VAR V2 = ADC_IN2
Value Output
PRINT "Voltage: ", ADC_IN1, " V"
Condition
IF ADC_IN3 > 2.5 THEN
PRINT "Voltage above 2.5V"
ENDIF
Use in Expressions
VAR AVG = (ADC_IN1 + ADC_IN2 + ADC_IN3) / 3
ADC brightness control
FOR I = 0 TO 100
VAR BRIGHTNESS = ADC_IN1 * 30
PWM1 CH1 1000, BRIGHTNESS, 0
PAUSE 100
NEXT
Note:
Syntax:
PWM<timer_id> CH<channel> <freq>, <duty>, <count>
Description:
Sets up and starts PWM on the specified timer and channel.
Options:
Examples:
PWM1 CH1 1000, 50, 0
PWM2 CH2 500, 25, 100
Syntax:
DAC1 <voltage_mv>
DAC2 <voltage_mv>
Description:
Sets voltage to external DACs (I2C MCP4725).
Options:
Address:
Examples:
DAC1 1650 // Set 1.65V to DAC1
DAC2 3300 // Set 3.3 V (maximum) to DAC2
DAC1 0 // Set 0 V to DAC1
DAC2 2500 // Set 2.5V to DAC2
Use with variables
VAR VOLTAGE = 1800
DAC1 VOLTAGE // Set 1.8V
Smooth variation
FOR V = 0 TO 3300 STEP 100
DAC1 V
PAUSE 50
NEXT
Note:
Syntax:
I2C_SCAN
Description:
Scans the I2C bus and displays the addresses of all found devices.
Examples:
I2C_SCAN
Will:
// [I2C] Scanning I2C bus...
// [I2C] Device found at address 0x3C
// [I2C] Device found at address 0x48
// [I2C] Scan complete. Found 2 devices
Syntax:
RTC_SET <year>, <month>, <day>, <hour>, <minute>, <second>
Description:
Sets the time and date of the RTC.
Options:
Examples:
RTC_SET 2025, 10, 13, 15, 30, 0
Syntax:
RTC_READ
Description:
Outputs the current time and date from the RTC.
Examples:
RTC_READ
Output: 2025,10,13 15:30:45
All matrix commands use the RGB888 (24-bit) color format. You can use:
Syntax:
MATRIX_INIT(width, height, layout, corner)
Description:
Initializes the LED matrix of the specified size and topology.
Options:
Note: The logical origin (0,0) is always in the lower-left corner, regardless of physical location.
Examples:
16x16 Horizontal Snake Matrix, Data Input Bottom Left
MATRIX_INIT(16, 16, "H", 0)
8x8 vertical snake sensor, data input top right
MATRIX_INIT(8, 8, "V", 2)
No optional parameters (default "H", 0)
MATRIX_INIT(16, 16)
Only by specifying layout (default corner 0)
MATRIX_INIT(16, 16, "V")
With variables
VAR W=16, H=16
MATRIX_INIT(W, H, "V", 3)
Syntax:
MATRIX_FILL(color)
Description:
Fills the entire matrix with the specified color (RGB888).
Examples:
With a constant
MATRIX_FILL(0xFF0000) // Krasny
With RGB888 function
MATRIX_FILL(RGB888(255, 0, 0))
With a variable
VAR RED = RGB888(255, 0, 0)
MATRIX_FILL(RED)
With hex literal
MATRIX_FILL(0x00FF00) // Green
With the expression
VAR BRIGHTNESS = 128
MATRIX_FILL(RGB888(BRIGHTNESS, BRIGHTNESS, BRIGHTNESS))
Syntax:
MATRIX_SET(x, y, color)
Description:
Sets the color of a single pixel of the sensor.
Examples:
With RGB888 function
MATRIX_SET(8, 8, RGB888(255, 0, 0))
With a variable
VAR COLOR = RGB888(0, 255, 0)
MATRIX_SET(10, 10, COLOR)
With hex literal
MATRIX_SET(5, 5, 0x0000FF)
Drawing a Line
FOR I = 0 TO 15
MATRIX_SET(I, I, RGB888(255, 255, 0))
NEXT
MATRIX_UPDATE()
With coordinate and color variables
VAR X=8, Y=8
VAR BLUE = RGB888(0, 0, 255)
MATRIX_SET(X, Y, BLUE)
Syntax:
MATRIX_BITMAP(x, y, array[], width, height)
Description:
Outputs the bitmap from the array to the matrix. The colors in the array must be in the RGB888 format.
Examples:
Simple 4x4 Bitmap
VAR IMG[16]
IMG[0] = RGB888(255, 0, 0) // Red
IMG[1] = RGB888(0, 255, 0) // Green
IMG[2] = RGB888(0, 0, 255) // Blue
IMG[3] = RGB888(255, 255, 0) // Yellow
// ... Fill in the remaining pixels
MATRIX_BITMAP(0, 0, IMG[], 4, 4)
Creating a pattern
VAR COLORS[4] = {0xFF0000, 0x00FF00, 0x0000FF, 0xFFFF00}
VAR PATTERN[16]
FOR I = 0 TO 15
PATTERN[I] = COLORS[I % 4]
NEXT
MATRIX_BITMAP(4, 4, PATTERN[], 4, 4)
MATRIX_UPDATE()
With hex literals
VAR SMILE[9] = {0x000000, 0xFF0000, 0x000000,
0xFF0000, 0x000000, 0xFF0000,
0x000000, 0xFF0000, 0x000000}
MATRIX_BITMAP(0, 0, SMILE[], 3, 3)
Syntax:
MATRIX_CHAR(x, y, "char", font_name, color)
Description:
Outputs a single character per matrix. RGB888 color.
Available fonts:
Examples:
With RGB888 function
MATRIX_CHAR(0, 0, "A", Font_7x10, RGB888(255, 0, 0))
With variable color
VAR GREEN = RGB888(0, 255, 0)
MATRIX_CHAR(8, 0, "B", Font_7x10, GREEN)
With hex literal
MATRIX_CHAR(0, 8, "!", Font_6x8, 0xFF00FF)
Output of all letters
VAR X=0, Y=0
VAR COLOR = RGB888(255, 255, 0)
MATRIX_CHAR(X, Y, "H", Font_7x10, COLOR)
X = X + 8
MATRIX_CHAR(X, Y, "i", Font_7x10, COLOR)
MATRIX_UPDATE()
Syntax:
MATRIX_PRINT(x, y, part1, part2, ..., font_name, color)
Description:
Prints text to a matrix (can combine strings and variables). RGB888 color.
Examples:
Plain text with RGB888
MATRIX_PRINT(0, 0, "Hello", Font_7x10, RGB888(255, 0, 0))
With variable color
VAR COLOR = RGB888(0, 255, 0)
MATRIX_PRINT(0, 8, "World", Font_6x8, COLOR)
Combination of text and variables
VAR COUNT = 42
MATRIX_PRINT(0, 0, "Count: ", COUNT, Font_7x10, RGB888(255, 255, 0))
With hex literal
MATRIX_PRINT(0, 0, "Status: OK", Font_6x8, 0x00FF00)
Formatting numbers
VAR TEMP = 23.456
MATRIX_PRINT(0, 0, "T:", TEMP.1, "C", Font_7x10, RGB888(255, 128, 0))
Counter animation
VAR I=0, COL = RGB888(0, 255, 255)
WHILE I < 100
MATRIX_FILL 0x000000
MATRIX_PRINT(0, 0, "Count:", I, Font_7x10, COL)
MATRIX_UPDATE
I = I + 1
PAUSE 50
WEND
Syntax:
MATRIX_UPDATE()
Description:
Updates the contents of the matrix (sends data to the device).
Syntax:
WS2812_SEND <array>[]
Description:
Sends data to the WS2812 addressable LED strip.
Options:
Examples:
VAR LEDS[10]
FOR I = 0 TO 9
LEDS[I] = RGB888(255, 0, 0)
NEXT
WS2812_SEND LEDS[]
Syntax:
SHIFT_LEFT <array>, <count>
Description:
Shifts the elements of the array to the left by 'count' positions (cyclically).
Examples:
VAR A[5] = {1, 2, 3, 4, 5}
SHIFT_LEFT A, 2
Result: {3, 4, 5, 1, 2}
Animation of a creeping line of LEDs
VAR LEDS[10]
FOR I = 0 TO 9
LEDS[I] = RGB888(255 - I*25, I*25, 0)
NEXT
WHILE 1
WS2812_SEND LEDS[]
SHIFT_LEFT LEDS, 1
PAUSE 100
WEND
Syntax:
SHIFT_RIGHT <array>, <count>
Description:
Shifts the elements of the array to the right by 'count' positions (cyclically).
Examples:
VAR A[5] = {1, 2, 3, 4, 5}
SHIFT_RIGHT A, 2
Result: {4, 5, 1, 2, 3}
Reverse Creeping Line Animation
VAR LEDS[10]
FOR I = 0 TO 9
LEDS[I] = RGB888(I*25, 255 - I*25, 128)
NEXT
WHILE 1
WS2812_SEND LEDS[]
SHIFT_RIGHT LEDS, 1
PAUSE 100
WEND
Syntax:
STUSB_INIT()
Description:
Initializes the USB Power Delivery STUSB4500 controller.
Syntax:
STUSB_SET_VOLTAGE(<voltage>[, <current>])
Description:
Requests the specified voltage from the USB-C PD power supply.
Options:
Examples:
STUSB_SET_VOLTAGE(12.0, 3.0)
STUSB_SET_VOLTAGE(20.0)
Syntax:
STUSB_GET_SOURCE
Description:
Lists the available voltages from the USB-C PD power supply.
Syntax:
DEBUG_ON [<delay_ms>]
Description:
Enables debugging mode with optional delay between lines.
Examples:
DEBUG_ON
DEBUG_ON 100
Syntax:
DEBUG_OFF
Description:
Disables debug mode.
Syntax:
END
Description:
Stops the execution of the program.
Syntax:
GOSUB <label>
...
<label>:
Command
RETURN
Description:
Call a routine on a check-in label.
Examples:
GOSUB DrawCircle
END
DrawCircle:
DISPLAY_FILL_CIRCLE(160, 120, 50, RGB565(255, 0, 0))
RETURN
Syntax:
VARS_READ(name1, name2, name3, ...)
Description:
Starts a background task to periodically poll and output the values of the specified variables. Used inside a BASIC script to monitor variables.
Options:
Examples:
Initializing sensors
DHT_INIT(TEMP, HUM, 2000)
BMP280_INIT(PRESS, TEMP2, 1000)
Run variable monitoring
VARS_READ(TEMP, HUM, PRESS)
The program continues to work
WHILE 1
Variables are automatically polled in the background
DISPLAY_TEXT(0, 0, "T:", TEMP.1, " C", Font_7x10, 1, 0xFFFF)
DISPLAY_TEXT(0, 20, "H:", HUM.1, " %", Font_7x10, 1, 0xFFFF)
PAUSE 500
WEND
Example with stopping monitoring
VARS_READ(X, Y, Z)
PAUSE 5000
STOP_VARS_READ
Note:
Syntax:
STOP_VARS_READ
Description:
Stops a background variable monitoring task started by the VARS_READ command.
Examples:
Start monitoring
VARS_READ(TEMP, HUM)
Work for 10 seconds
PAUSE 10000
Stop monitoring
STOP_VARS_READ
PRINT "Monitoring stopped"
SIN(x) // Sine (x in radians)
COS(x) // Cosine (x in radians)
TAN(x) // Tangent (x in radians)
ASIN(x) // Arx sine
ACOS(x) // Arccosine
ATAN(x) // Arctangent
ROUND(x) // Rounding to the nearest integer
FLOOR(x) // Rounding down
CEIL(x) // Round up
ABS(x) // Absolute value
POW(x, y) // x to the power of y
SQRT(x) // Square root
EXP(x) // e to the power of x
LOG(x) // Natural logarithm
LOG10(x) // Decimal Logarithm
RND() // Random number from 0.0 to 1.0
DHT_INIT(TEMP, HUM, 2000)
WHILE 1
VAR COLOR
IF TEMP > 30 THEN
COLOR = RGB565(255, 0, 0)
ELSE IF TEMP > 20 THEN
COLOR = RGB565(255, 165, 0)
ELSE
COLOR = RGB565(0, 255, 0)
ENDIF
DISPLAY_FILL_RECT(10, 10, 100, 50, COLOR)
PAUSE 1000
WEND
BUTTON_INIT(10, 10, 100, 50, RGB565(0, 255, 0), "START", 0, TX, TY, TOUCHED, OnPress, )
END
OnPress:
PRINT "Button pressed!"
DISPLAY_FILL_CIRCLE(160, 120, 30, RGB565(255, 0, 0))
RETURN
VAR PROGRESS = 0
PROGRESS_INIT(10, 100, 300, 30, PROGRESS, 0, 100, RGB565(0, 255, 0))
FOR PROGRESS = 0 TO 100
PAUSE 50
NEXT
PRINT "Complete!"
Creating an 8x8 Player Sprite
VAR PLAYER[64]
Drawing a simple man
VAR WHITE = RGB565(255, 255, 255)
VAR SKIN = RGB565(255, 200, 150)
VAR RED = RGB565(255, 0, 0)
VAR BLUE = RGB565(0, 0, 255)
VAR BLACK = RGB565(0, 0, 0)
Fill with a background (transparent = black)
FOR I = 0 TO 63
PLAYER[I] = BLACK
NEXT
Head (skin)
PLAYER[2*8 + 3] = SKIN
PLAYER[2*8 + 4] = SKIN
PLAYER[3*8 + 3] = SKIN
PLAYER[3*8 + 4] = SKIN
Body (red shirt)
PLAYER[4*8 + 3] = RED
PLAYER[4*8 + 4] = RED
PLAYER[5*8 + 3] = RED
PLAYER[5*8 + 4] = RED
Legs (blue pants)
PLAYER[6*8 + 3] = BLUE
PLAYER[6*8 + 4] = BLUE
Creating a 4x4 coin
VAR COIN[16]
VAR GOLD = RGB565(255, 215, 0)
COIN[0] = BLACK
COIN[1] = GOLD
COIN[2] = GOLD
COIN[3] = BLACK
COIN[4] = GOLD
COIN[5] = GOLD
COIN[6] = GOLD
COIN[7] = GOLD
COIN[8] = GOLD
COIN[9] = GOLD
COIN[10] = GOLD
COIN[11] = GOLD
COIN[12] = BLACK
COIN[13] = GOLD
COIN[14] = GOLD
COIN[15] = BLACK
Game Variables
VAR PX = 50 // Player position
VAR PY = 100
VAR CX = 200 // Coin Position
VAR CY = 100
VAR SCORE = 0
Gameplay Loop
WHILE 1
DISPLAY_CLEAR(RGB565(50, 150, 255)) // Sky
Earth
DISPLAY_FILL_RECT(0, 180, 320, 60, RGB565(100, 200, 50))
Drawing a player with a scale of x3
DISPLAY_BITMAP(PX, PY, PLAYER[], 8, 8, 3)
Drawing a coin with a scale of x4
DISPLAY_BITMAP(CX, CY, COIN[], 4, 4, 4)
Account
DISPLAY_TEXT(10, 10, "Score: ", SCORE, Font_7x10, 1, WHITE)
Control (via ADC or buttons)
VAR CONTROL = ADC_IN1 * 100
IF CONTROL > 50 THEN
PX = PX + 3
ENDIF
IF CONTROL < 30 THEN
PX = PX - 3
ENDIF
Collision Check (Simple)
IF PX > CX-20 AND PX < CX+20 AND PY > CY-20 AND PY < CY+20 THEN
SCORE = SCORE + 1
CX = RND() * 280 // New coin position
ENDIF
Traffic restriction
IF PX < 0 THEN
PX = 0
ENDIF
IF PX > 290 THEN
PX = 290
ENDIF
PAUSE 50
WEND
16x16 matrix initialization
MATRIX_INIT(16, 16)
Defining Colors Using Variables and RGB888 Functions
VAR RED = RGB888(255, 0, 0)
VAR GREEN = RGB888(0, 255, 0)
VAR BLUE = RGB888(0, 0, 255)
VAR YELLOW = RGB888(255, 255, 0)
Or via hex literals
VAR CYAN = 0x00FFFF
VAR MAGENTA = 0xFF00FF
VAR WHITE = 0xFFFFFF
Ticker Point Animation
VAR X=0, Y=0
WHILE X < 16
MATRIX_FILL 0x000000 // Clear Matrix (Black)
MATRIX_SET X, Y, RED // Set red dot
MATRIX_UPDATE // Refresh Display
X = X + 1
PAUSE 100
WEND
Gradient
FOR I = 0 TO 15
VAR BRIGHTNESS = I * 16
VAR COLOR = RGB888(BRIGHTNESS, 0, 255-BRIGHTNESS)
FOR J = 0 TO 15
MATRIX_SET I, J, COLOR
NEXT
NEXT
MATRIX_UPDATE
Creating a pattern with an array of
VAR COLORS[4]
COLORS[0] = RGB888(255, 0, 0)
COLORS[1] = RGB888(0, 255, 0)
COLORS[2] = RGB888(0, 0, 255)
COLORS[3] = RGB888(255, 255, 0)
FOR I = 0 TO 15
FOR J = 0 TO 15
VAR C_INDEX = (I + J) % 4
MATRIX_SET I, J, COLORS[C_INDEX]
NEXT
NEXT
MATRIX_UPDATE
Displaying variable color text
VAR COUNTER = 0
WHILE COUNTER < 10
MATRIX_FILL 0x000000
VAR TEXT_COLOR = RGB888(255, COUNTER*25, 0)
MATRIX_PRINT(0, 0, "Count:", COUNTER, Font_7x10, TEXT_COLOR)
MATRIX_UPDATE
COUNTER = COUNTER + 1
PAUSE 500
WEND
These commands are sent via USB or UART to control the device externally and are not part of the interpreter's BASIC script.
Syntax:
VARIABLE_SET(name1,value1:name2,value2:name3,value3...)
Description:
Sets the values of one or more variables from an external source (terminal, application PC). Variables are separated by a colon, within each pair, the name and value are separated by a comma.
Options:
Examples:
# Set a single variable
VARIABLE_SET(TEMP,25.5)
# Set multiple variables
VARIABLE_SET(X,100:Y,200:Z,50)
# With expressions
VARIABLE_SET(A,10:B,20:C,30.5:D,100)
# Mixed Value Types
VARIABLE_SET(VOLTAGE,3.3:COUNT,42:BRIGHTNESS,255)
Note:
Syntax:
VARIABLES_READ(Name1,Name2,Name3,...)
Description:
Triggers periodic sending of specified variable values via USB/UART. Values are automatically sent when they change.
Examples:
# Monitoring a single variable
VARIABLES_READ(TEMP)
# Multivariable Monitoring
VARIABLES_READ(TEMP,HUM,PRESSURE)
# Sensor Monitoring
VARIABLES_READ(ADC1,ADC2,ADC3,VOLTAGE)
Note:
Syntax:
STOP_VARIABLES_READ
Description:
Stops the periodic sending of variables triggered by the VARIABLES_READ command.