Main window

After starting TRIK Studio, you will see the start page that displays the version of TRIK Studio, quick access to recent projects, and buttons for opening an existing project and creating a new one.

Project creation

To create a new project, click the "New project" button on the TRIK Studio home page.

Or select File → New project from the main menu.

A window opens with a new program in the visual programming language:

Read about programming in a visual language in the article:

Read about creating a new text program in the article:

Launch an existing project

To start an existing project, click the "Open project" button on the TRIK Studio start page.

Or in the main menu, select File → Open....

By default, TRIK Studio searches for files in the *.qrs format or the last open format (for example, *.js). If you need an existing project in a different format, select the desired format (for example, *.py) or All files (*.*).

The main menu of TRIK Studio contains a set of basic operations and environment settings:

• File

• Edit

• View

• Tools

• Settings

• Help

File

• New project — create a new project.

• Recent projects — open one of the recently used projects.

• New diagram — create a new chart in the current project.

• Open… — open a saved project. Projects are stored on disk in files with the .qrs extension.

• Save — save the current project.

• Save as… — save the current project to the selected location. Subsequent saves will be made to the selected file.

• Save diagram as a picture… — save the current image on the scene to disk.

• Print — print a chart or text using the standard print dialog.

• Quit — exit the program.

• Restore default settings and Quit — restore the default settings and exit the program.

Edit

• Undo — cancel a completed action.

• Redo — make a canceled action again.

• Copy — copy the selected item.

• Paste — insert the selected item.

• Cut — cut the selected item.

• Find... — open the search dialog for the project.

• Find and replace — open the project search dialog and replace.

View

• Zoom in — zoom in on the scene.

• Zoom out — to reduce the scale of the scene.

• Panels — enable/disable the display of various windows.

• To main page — go back to the main page.

Tools

• Mouse gestures — open a tab with a list of available mouse gestures (see the "Adding blocks with mouse gestures" section).

• Run — start execution of the diagram currently displayed in interpretation mode (the item is available only in interpretation mode).

• 2D model — switch the interpretation mode to a two-dimensional model.

• Real robot — switch the interpretation mode to control the real robot via Wi-Fi, Bluetooth, or USB, depending on the platform used and the settings for connecting to the robot.

• Robot settings — open the settings window of the robot model with which you work in TRIK Studio (for more details see the "Robots" section in the article "TRIK Studio settings").

• Save as task… — save the current diagram and two-dimensional model as an exercise for students. In an exercise, you cannot modify some parts of a solution. For example, the location of objects in a two-dimensional model or the configuration of sensors. Selecting this menu item opens a dialog in which you can select the parts to be frozen (for more information about exercises, see the article "Exercises").

• Subprograms — subprograms management (for more details see the article "Subprograms").

• Generate code — open a tab with the generated code corresponding to the current diagram and the selected text language (this item may look like "Generate JavaScript code", "Generate Python code", "Generate C code", etc.). The code is not downloaded to the robot and is not executed, but can be edited and downloaded later.

• Upload program — only generate code and upload to the robot without executing.

• Upload and execute program — generate the code corresponding to the current diagram, load it and execute on the robot.

• Stop robot — interrupt the execution of the program and send the robot commands to turn off the motors.

• Connect — establish a connection with the robot. The robot must be turned on. The item is available only if the selected mode of working with the robot requires a constant connection (for example, interpretation of the program via Bluetooth or Wi-Fi).

Settings

• Preferences… — open the TRIK Studio environment settings window (see the article "TRIK Studio settings").

• Show grid — enable/disable grid on the scene.

• Show alignment — enable/disable the display mode for vertical and horizontal guidelines for positioning objects relative to each other.

• Switch on grid — enable/disable automatic grid alignment.

• Switch on alignment — enable/disable vertical and horizontal guidelines for positioning blocks relative to each other.

• Show all text — enable/disable displaying all block properties directly on the diagram. If the text below the blocks is disabled, properties can be viewed and edited in the property editor at the top left.

Help

• Small help — open help.

• About TRIK Studio — view brief information about TRIK Studio.

• Open logs — open a folder with log files.

• Check for updates — get information from the Internet about the availability of a new version of the environment or any of the plug-ins, and run auto-updates if necessary.

TRIK help — a guide for working with the free robot programming environment TRIK Studio. You can find the open-source TRIK Studio code in our repository at GitHub.

The help also describes how TRIK Studio interacts with supported platforms:

• TRIK controller.

• LEGO EV3.

• LEGO NXT.

• Pioneer Kit.

The TRIK Studio version is displayed in the window title.

And also on the start page.

Robot settings in TRIK Studio can be opened in two ways.

Way 1

Using the toolbar button:

Way 2

1. Choose in the main menu Settings → Preferences → Robots.

2. In the opened window open the tab "Robots".

Settings window

To open TRIK Studio preferences press the corresponding item in the :Settings → Preferences....

The left bar contains the next tabs:

Behaviour

User Interface

• Language — environment language. After the change, a restart of TRIK Studio is required. The setting "<System language>" means that the language will be determined by the current language of the operating system.

Automatics

• Autosave — the option to enable or disable autosave of an open project, as well as set the autosave interval in seconds.

• Delay after gesture — the time period of the system expectation between the finishing of a mouse gesture and its execution. Delay allows you to draw a gesture in a few strokes. The value is indicated in milliseconds.

• Check for updates on start — connect at startup with the update server and start auto-update if necessary.

Touch

• Touch mode — enable user interface optimization for touch screens.

Widgets

• Dockable mode — detaches windows for free alignment.

Miscellaneous

Graphics

• Antialiasing — the line drawing mode with smoothing improves the appearance of diagrams due to a slight decrease in the speed of the system.

Other

• Show splashscreen — enable / disable the display of the splashscreen with the TRIK Studio logo at startup.

Images

Set of icons to use to display the diagram.

Toolbars

• Size — configure the size of the buttons on the toolbar.

Editor

Font

• Use some of system fonts — replace the font for displaying labels on the diagram with one of the fonts installed in the system. The sizes of the labels on the blocks are set rigidly, so changing the font can lead to the crawl of the labels on each other, but you can experiment.

Grid

• Show grid — display the alignment grid on the scene of the diagram editor.

• Activate grid — align blocks on a grid.

• Show alignment — display alignment lines on the scene of the diagram editor. Alignment lines appear when a block is on the same horizontal or vertical line with another block, and help align the blocks in the scene.

• Activate alignment — align the blocks along the alignment lines.

• Width — thickness of alignment lines. Adjustable depending on the brightness of the monitor or projector.

• Cell size — size of one cell. The default size is selected so that the block covers four cells.

Node Elements

Edge

• Line mode — mode of drawing links on the diagram.

  • broken — links are drawn as broken lines with break points that are added by the user.

  • square —connections are drawn as broken lines, each segment of which is parallel to the coordinate axes. Break points in this case are automatically added by the system.

  • curve — connections are drawn as smooth curves, the curvature of which can be set by the user.

• Loop edges indent — indent size for loop connections.

Embedded Linkers

• Indent — indent of the built-in linker from the block icon.

Palette

• Representation — choice between the mode of displaying icons and names or only icons in the palette.

• Count of items in a row — the number of icons per line of the palette with the selected "Icons" mode.

Robots

The composition of this tab depends on the installed plug-ins and on the currently selected platform. Typical tab items are described below.

Robotics construction kit

Robot model

Choosing the type of execution model for the selected constructor. In most cases, this is a 2D model or a real robot, but for some robotics kits one of the models may not be available, in this case this item would not be displayed.

2D robot image

The appearance of the robot in a 2D model.

Connection settings

Kit-specific settings for connecting to the robot, such as the IP address for TRIK controllers or the COM port of the Bluetooth connection for Lego NXT controllers. If a connection in the selected mode is not required, the item would not be displayed.

External tools settings

Kit-specific settings for programs not supplied with TRIK Studio, which must be installed on the computer. For most operating modes, additional installed programs are not needed, so the corresponding items are not displayed in the window.

Sensor settings

The section indicates which sensors are connected to the ports of the robot.

Uploading & Running

• Running after uploading — run the program immediately after downloading it to the robot or not. Applicable only for some modes of some kits (for example, for Lego NXT in generation mode).

Graphics watcher update interval

• Sensors — interval in milliseconds after which a new point with a sensor reading is added.

• Autoscaling — the interval in milliseconds after which the graph automatically changes its scale to optimally display the values.

• Text info — the interval in milliseconds after which the labels with values ​​are updated on the chart.

Shortcuts

This tab allows you to set or change hotkeys for the most commonly used actions. To do this, select the cell corresponding to the action, and in the "Combination" line at the bottom of the window, press the desired key combination.

The "Clear" button removes the key combination from the cell.

All hotkeys installed by default, you can find in the article:

Export settings

TRIK Studio allows you to export the current settings to a file for uploading them to another computer. To do this, click the "Export" button at the bottom of the window.

Import settings

TRIK Studio allows you to import settings from a previously exported file. To do this, click the “Import” button at the bottom of the window and select the desired .ini file.

Defines walls. Used as a container, has no attributes. In addition to creating a virtual world of robots in TRIK Studio, you can do more flexible customization by editing an XML file: specify the location of objects, color, width, and other parameters more precisely.

First, you need to create an XML file for the virtual model.

2D model coordinate system

In the 2D model window the axes located as follows:

An XML file creation

To create an empty XML file you should use your OS' standard tools such as Notepad in Windows or whatever.

To save the world model created in TRIK Studio:

1. Switch to the 2D model mode.

2. Go to the "Debug mode".

4. Specify the location and file name to save.

Editing an XML file

Open a saved XML file in a text editor. Notepad++, for example.

The XML file contains tags and attributes.

Tags

Tag is a markup language element. There is the start (opening) and end (closing) tags. The text contained between the start and end tags is displayed and placed according to the properties specified in the start tag.

Example:

<walls> <!-- start (opening) tag -->
     <wall begin="200:-200" id="{a3ede76b-1d7e-4c72-9ed4-08d8ea9af4bf}" end="200:150"/>
</walls> <!-- end (closing) tag -->

Attributes

Attributes are tag properties that provide additional text formatting capabilities. They are recorded as a combination of "attribute name-value". Text values are enclosed in quotation marks.

In the above example, the attributes are:

begin="200:-200" id="{a3ede76b-1d7e-4c72-9ed4-08d8ea9af4bf}" end="200:150"

The simplest virtual world model without objects in .xml the format is as follows:

<?xml version='1.0' encoding='utf-8'?>
<root>
    <world>
        <background/>
        <walls/>
        <skittles/>
        <balls/>
        <colorFields/>
        <images/>
        <regions/>
    </world>
    <robots>
        <robot direction="0" id="trikKitRobot" position="0:0">
            <sensors/>
            <startPosition direction="0" id="{name}" y="25" x="25"/>
            <wheels left="M4###output###М4###" right="M3###output###М3###"/>
        </robot>
    </robots>
</root>

Robots

The following tags are available for describing robots:

<robots>...</robots>

Defines a robot on stage. Used as a container, has no attributes.

<robots>
     <robot id="trikKitRobot" position="0:0" direction="0">
</robots>

<robot>...</robot>

Adds a robot to the scene. Can be used as a container.

Attributes

Example:

<robot id="trikKitRobot" position="0:0" direction="0">

<sensors>...</sensors>

Defines sensors on a robot. Used as a container, has no attributes.

<sensors>
     <sensor type="kitBase::robotModel::robotParts::Motor" direction="0" port="M4###output###JM4$$$D$$$4###" position="75:25"/>
</sensors>

<sensor/>

Sensors ports configuration.

Attributes

There are 5 types of sensors for TRIK and 9 types of sensors for EV3:

Example:

<sensor position="75:25" direction="0" port="A1###input###А1###sensorA1"
type="trik::robotModel::parts::TrikInfraredSensor"/>

<startPosition/>

Defines the starting position of the robot.

Attributes

Example:

<startPosition id="{7a326d25-82f4-4eb4-9b42-1e75576f35a4}" direction="0" x="25" y="25"/>

<wheels/>

Motor ports configuration.

Attributes

Example:

<wheels left="M4###output###М4###" right="M3###output###М3###"/>

<wheels left="B###output###В###" right="C###output###С###"/>

Objects

The following tags are available for describing objects:

<wall>

Adds a wall to the scene.

Attributes

Example:

<wall id="{wall1}" begin="50:-50" end="250:-50"/>

<skittle>

Adds a skittle to the scene.

Attributes

Example:

<skittle rotation="0" id="{skittle1}" markerY="44" startRotation="0" x="220" y="44"
markerX="220"/>

<ball>

Adds a ball to the scene.

Attributes

Example:

<ball rotation="0" id="{ball1}" markerY="169" startRotation="0" x="-18" y="169" markerX="-18"/> 

<line>

Adds a line to the scene.

Attributes

Example:

<line stroke-width="6" fill-style="none" end="250:-50" id="{line1}" stroke-style="solid"
fill="#ff000000" stroke="#ff000000" begin="50:-50"/>

<cubicBezier>

Adds a Bezier curve.

Attributes

Example:

<cubicBezier id="{cubicBezier1}" fill-style="none" stroke-width="6" end="-106.577:134.894"
begin="-112.95:-192.25" fill="#ff000000" cp1="-142.95:-192.25" cp2="17.0502:-192.25"
stroke="#ff000000" stroke-style="solid"/>

<rectangle>

Adds a rectangle.

Attributes

Example:

<rectangle stroke-width="6" fill-style="none" end="344:511" id="{rectengle1}" 
stroke-style="solid" fill="#ff000000" stroke="#ff000000" begin="285:229"/>

<ellipse>

Adds an ellipse.

Attributes

Example:

<ellipse stroke-width="6" fill-style="none" end="-178:300" id="{ellipse1}" 
stroke-style="solid" fill="#ff000000" stroke="#ff000000" begin="-260:7"/>

<stylus>

Defines a stylus for drawing.

Attributes

Example:

<stylus stroke-width="6" fill-style="none" id="{stylus_name}" stroke-style="solid" 
fill="#ff000000" stroke="#ff000000">

<stylusLine>

Allows you to draw arbitrary shapes using the stylus. This block of code consists of many segments.

Attributes

Example:

<stylusLine stroke-width="6" fill-style="none" end="-334:259" id="{name1}" stroke-style="solid"
fill="#ff000000" stroke="#ff000000" begin="-334:260"/>
<stylusLine stroke-width="6" fill-style="none" end="-333:258" id="{name2}" stroke-style="solid"
fill="#ff000000" stroke="#ff000000" begin="-334:259"/>
<stylusLine stroke-width="6" fill-style="none" end="-333:254" id="{name3}" stroke-style="solid"
fill="#ff000000" stroke="#ff000000" begin="-333:258"/>

<region>

Allows you to add regions to the scene. There are 2 types of regions:

• rectangle

• ellipse

Attributes

Example:

<regions>
            <region filled="true" type="rectangle" height="300" width="300" textX="0" 
text="Finish" textY="0" x="1300" y="-200" visible="true" id="Start" color="#ff0000"/>
</regions>

2D model setup example

The "Barcode" task

You need to draw a barcode. The barcode consists of white and black lines of the same thickness. The black line specifies 1 in a binary number, and the white one 0. The first black line in the robot path is the first bit of the number.

The barcode lines order: 1001011011.

World creation

In this task, the lines should be the same thickness and length. It’s very difficult to draw lines by hand using the Line or Stylus tool, so edit the lines manually:

1. Draw 10 lines on the scene.

2. Save the model of the world.

3. Open the resulting XML file in any convenient editor. Pay attention to the code block with the<line...>tag.

4. For convenience, name each line black1-black5 and white1-white5. You can do this in the "id" attribute. Name the lines in the order shown above.

5. Specify the line thickness "50" in the stroke-widthattribute.

6. Assign the color to each line: #ff000000 is black, #ffffffff is white. You can do this in the attribute fill. Assign colors so that you get a barcode.

7. Set the position of each line in the beginand endattributes without gaps, so that you get a smooth barcode.

The result

A program in the TRIK Studio is represented as a sequence of the blocks connected by the links.

Each program corresponds to the main diagram, which may contain other diagrams (subprograms). Diagrams are packaged in projects stored on the disk.

Main diagram

The main diagram is created when the project is created. About adding and removing blocks to the scene, read the article:

Subprograms

The diagrams with subprograms are created automatically when you add the block "Subprogram" to the scene. In this case, the subprogram is displayed by double-clicking on the "Subprogram" block on the scene.

Read more about subprograms in the article:

If the program is launched in the interpretation mode on the robot or in the two-dimensional model, you can see the readings of the robot sensors on the graph in the special window.

The graph is scaled automatically so that the readings curve fits entirely in height.

From the drop-down list below you can select a sensor, the values ​​from which will be displayed on the graph.

When you hover over a point on the graph, the value at that point will be displayed.

To the right of the graph there are four buttons for working with it:

Interface language can be changed in the TRIK Studio settings.

1. Choose Settings → Preferences ... in the main menu

2. Choose the "Behaviour" tab in the opened window.

3. Select necessary language. Now TRIK Studio supports English, Russian and French.

“<System language>” means that the TRIK Studio interface language will be determined by the language of the operating system.

4. Press "OK".

5. Restart TRIK Studio to apply the changes.

Interactive simulation mode is a distinctive feature of TRIK Studio. In that mode, the commands are executed for the virtual robot model displayed on the screen. For TRIK, Lego EV3 and Lego NXT kits the model is a three-wheeled cart.

Initially, the robot is in an infinite empty space, and the user has the opportunity to set different scene objects like walls, draw colored lines and areas on the floor.

At the same time, the work of the majority of the real robot sensors is emulated. For example, touch sensor, ultrasonic distance sensor, color and light sensors for NXT, compass, and gyroscope for EV3, infrared and ultrasonic distance sensors, touch sensor and light sensor for TRIK, and many others.

A two-dimensional model may have devices that are not available on a real robot. For example, the ability to draw colored lines with a marker on the floor. The appearance and set of devices of the two-dimensional model depend on the chosen platform.

The two-dimensional model mode is useful for debugging programs in the absence of a real robot.

2D model window

2D model elements:

• Tools for editing world model

• Grid

• Ruler

• "Return to start" button

• "Start/Stop" button

• Panel for interpretation speed control

• Model settings

  • Display emulator and buttons of the robot

  • Ports control

  • Motors control

  • Robot physics settings

  • Model parameters

• Robot popup menu

Tools for editing world model

Editing the model of the world is carried out using the corresponding panel.

Editor of lines, stylus, and ellipse

When a line, Bézier curve, stylus, rectangle, or ellipse is selected, a pop-up window appears that allows you to adjust their color and thickness.

The ellipse and rectangle tools have the ability to paint over the inner area with the specified color. You can also edit the size, shape, and position of the selected geometric objects.

Working with background

In addition to various geometric objects on the scene, it is possible to load an image from a file using the Image tool.

If you select an image, you can move it, resize it and configure the following parameters:

Model settings panel

To open the settings panel, click the button to the right of the scene:

This panel contains:

• Display emulator

• Sensors control panel

• Motors control panel

• Robot physics control

• Model settings

Display emulator

The emulator of the robot screen allows displaying colored primitives on the screen. The emulator of the buttons to emulate buttons clicking (by clicking on the corresponding button on the robot).

Sensors control panel

The port control panel allows you to change the configuration and location of the sensors of the robot model.

When you change the configuration of the sensors from the settings, the sensors in the two-dimensional model are automatically adjusted. In this case, it will be considered that the sensor is connected to the robot. That is, when the robot icon moves, the sensors will move with it, even if they are at some distance from the robot model.

A gray cone is displayed next to the ultrasound or infrared sensor, indicating the area in which the sensor will detect obstacles.

Rotate and move sensors

For each port, you can select the sensor of interest, and it will automatically be added to the scene. Added sensors are always mounted on the robot, they can be moved and rotated.

When rotating with the Shift key pressed, the sensor rotates either at a right angle or at an angle of 45° relative to the borders of the window.

Motors control panel

The motor control panel allows you to specify which of the motor ports will correspond to the left and right wheels.

Robot physics control

• Realistic physics more accurately emulate the forces acting on the robot: it turns when it collides with a wall, accelerates with acceleration, etc.

• Realistic sensors — enable/disable emulation of inaccurate sensors.

• Realistic engines — enable/disable emulation of inaccurate motor control.

Model settings

Displays the parameters of the robot model:

• wheel diameter,

• robot height,

• robot width,

• robot mass.

Context menu

Also, the functions of the two-dimensional model are available when you click the right mouse button on the scene.

Grid

Turn on the grid on the scene and snap the walls to its nodes. The slider allows you to adjust the size of the grid.

Panel to control simulation speed

The speed control panel allows you to set the simulation speed.

When choosing a low speed, one second of model time corresponds to a few seconds of real-time, when choosing a high speed - vice versa.

The current model time elapsed since the launch of the program is also displayed here. It may differ from real-time (depending on the speed settings and computer capabilities).

Ruler

The ruler shows the distance on the scene, in centimeters (relative to the size of the robot).

"Return to start" button

The "Return to start" button sets the robot to its initial position, which is set by the red cross on the scene.

The cross can be rotated around its axis, highlighting it and dragging the end of the arrow that appears. This sets the initial direction of the robot.

When added with the Shift key pressed, the cross arrow is placed either at a right angle or at an angle of 45° relative to the borders of the window.

"Start/Stop" buttons

Pop-up robot menu

A pop-up menu for controlling the robot appears when clicking on the robot.

An array is one of that stores a set of values ​​(array elements) identified by an index. The numbering of indices in the array starts at 0.

Arrays can be created explicitly using the following expressions (the next lines are equivalent):

Or with explicit indices:

You can use arrays without creating them. For example, like this:

In this case, "empty spaces" in the array (indices that did not have an explicit assignment) will be filled with default values:

• 0 — for real and integer;

• false — for boolean;

• empty lines for arrays of strings.

Array values ​​can also be used without curly braces if used as the return value. For example, this expression will return an array of numbers 1 and 2:

This is implemented in order to interpret the enumerations of values ​​(for example, the ports of motors in the block ) as arrays. Therefore, wherever you use a comma-separated value notation, you can use an array.

Add blocks to the scene

You can add blocks to the in TRIK Studio in three ways:

1. the corresponding icons from the palette of elements onto the diagram.

2. .

3. between blocks using a linker.

Drag and drop from the palette

Left-click on the necessary block located in the panel. Without releasing the mouse button, move the block onto the scene.

Use mouse gestures

Draw on the scene a special image of the block with the Right mouse button. The block appears in the center of the drawn image.

Available conditional images can be found in two ways:

1. In the "Mouse Gestures" window, which opens through the main menuTools → Mouse gestures.

2. In the tooltip that appears when you hover over a block in the Palette panel.

Add block when creating a new connection

2. In the menu that appears, select "Create new element". A new menu with blocks will appear.

3. Select the block you need.

Delete block

Deleting a block from the scene is possible in two ways:

1. Select the block with the left mouse button and then click the "Delete" button on the keyboard.

2. Right-click on the block and select "Delete" in the menu that appears.

Delete several blocks

1. Select the necessary blocks in one of the following ways.

1.1. Hold down the "Ctrl" button and right-click the necessary blocks.

1.2. Right-click on an area in the scene with the necessary blocks.

2. Delete the selected blocks in one of the following ways.

2.1. Press the “Delete” button on the keyboard.

2.2. Right-click on any selected block and select "Delete" from the menu that appears.

Replace block

To replace the block on the scene:

1. Right-click on the block and select "Replace by..." in the menu that appears.

2. Select the block that you want to put instead of from the list.

TRIK Studio modes

The TRIK Studio interface depends on the selected mode. TRIK Studio has two modes:

1. It is intended for creating a robot control diagram and executing it in the generation mode.

2. It is intended for executing and debugging a program on a 2D model or in interpretation mode on a real robot.

Switching between modes

There are three ways to switch modes:

1. Keyboard shortcuts Ctrl+1 / Ctrl+2.

3. .

Editing mode

TRIK Studio in edit mode has the following interface elements:

Editor window/scene

The scene displays the diagram and allows you to edit it.

Read about creating a new project and working with the diagrams in the articles:

Editor mode also displays the current executable block when interpreting diagrams.

Main menu

The main menu of TRIK Studio contains a set of basic operations and environment settings:

For more information, see the article:

File panel

Edit panel

View panel

The View panel contains buttons that allow you to scale diagrams.

You can also zoom the scene using:

1. Hold down the Ctrl key and roll the mouse wheel.

2. Keyboard shortcut Ctrl+= и Ctrl+-.

Interpreter panel

When working with a real robot in interpretation mode, this panel also contains a "Connect" button.

Generators panel

The Generators panel contains commands for generating code and loading the program to the robot.

"Other" panel

"Other" panel may contain various information depending on the chosen platform.

Panel for switching between editing and debugging modes

The panel for mode switching displays the current TRIK Studio mode and allows you to switch between editing and debugging modes.

Property editor panel

The property editor is used to display and edit the property values ​​of selected objects (blocks, links).

About working with the property editor see article:

Sensors settings panel

Sensor settings allow you to specify which sensors are used on which port. The same can be done from the robot settings dialog.

Palette panel

The Palette panel contains a set of available blocks and the relationships between them, which can be added to the diagram.

How to add and remove blocks to the scene in TRIK Studio read in the article:

Variables panel

Status bar

Debug mode

The elements of the TRIK Studio interface in debug mode repeat the elements in edit mode, except for the editor window, property editor panels and palette. Instead of these elements, the next elements are displayed:

2D model window

The 2D model window opens if a 2D model is selected as the program execution mode.

The window allows you to set the environment in which the robot will be executed, set the robot sensors and observe how the program written in edit mode will work.

Read more about the 2D model in the article:

Robot settings panel

Opening robot settings panel

Error panel

In the case of syntactic and semantic errors in the TRIK Studio, a window with the corresponding messages appears.

To view the block where the error occurred, click on the message.

Plots panel

The Plots window displays the values sent by the sensors in real-time.

Read more in the article:

Unlike , the TRIK Studio language is statically-typed, that is, the type of each expression and each variable must be known at compile time. Moreover, the language does not require (and does not even allow!) to explicitly write the types of variables. It uses automatic type inference for the use of variables.

For example, environment "understands" from the expression a = 1 that type of a is integer.

See the article about the syntax of expressions in blocks:

Besides constants, in TRIK Studio reserved variables are available that store the values ​​of the readings of sensors connected to the corresponding ports.

These values ​​can be assigned to variables and used in mathematical expressions.

Variables have the form

sensor<port name>

For example, sensorA1 for TRIK or sensor1 for Lego NXT.

A complete list of sensor variables is provided in sections for specific platforms:

• TRIK.

• LEGO EV3.

• LEGO NXT.

• Constraint description structure

• Conditions

• Atomic conditions

• Variable types and arithmetic operations

• Triggers

• Sensor names

• Additional robot properties

• Working with the controller screen

• Restrictions example

It is possible to add restrictions by editing an XML file to prepare exercises for students.

There are three types of restrictions:

1. Time restrictions. For example, a time limit to complete a task or a specific action in a specific time frame.

2. Spatial. For example, adding regions ("Start", "Finish") or prohibiting/forcing a robot, its sensor, or some moving object to be at a certain time in a certain place.

3. Device restrictions. For example, a limitation on the set of sensors or on the behavior of devices.

Constraint description structure

The main tag<constraints>...</constraints>which contains all the restrictions is used to describe them. Used as a container. Restrictions are described inside the tag, each inner tag must be one of four:

<constraints>...</constraints>

The main tag containing all restrictions. Used as a container.

<constraints>
     <!-- Time limit -->
     <timelimit value="30000"/>
     
     <!-- Conditional constraint. An error message will be shown at violation. -->
     <constraint checkOnce="true" failMessage="The robot must be at start before run!">
          <inside objectId="robot1" regionId="start_zone"/>
     </constraint>
     
     <!-- Initializing variable x with value 2 -->
     <init>
          <setter name="x">
               <int value="2"/>
          </setter>
      </init>

</constraints>

<timelimit/>

Time limit. Mandatory.

Attributes

Syntax:

<timelimit value="35000"/>

<constraint>...</constraint>

A constraint with an arbitrary condition. If the condition is violated a specified error message will be displayed. Can be used as a container. Has one child tag: <conditions>...</conditions>.

Attributes

Syntax:

<constraint checkOnce="true" failMessage="The robot must be at start before run!">

<!-- Checks if the IR distance sensor is connected to the A1 port -->
<constraint checkOnce="true" failMessage="The IR distance sensor must be connected to the robots A1 port!">
    <equals>
        <typeOf objectId="robot1.A1"/>
        <string value="twoDModel::robotModel::parts::RangeSensor"/>
    </equals>
</constraint>

<!-- Checks if the robot is inside the specified region for the entire program execution time-->
<constraint failMessage="The robot has left the allowed zone!">
    <inside objectId="robot1" regionId="warzone"/>
</constraint>

<event>...</event>

The main tool for setting dynamic constraints. Used as a container.

An event is just a pair (condition, trigger).

Attributes

Syntax:

<event id="finish checker" settedUpInitially="false">
	<condition>
		<inside objectId="robot1" regionId="finish"/>
	</condition>
	<trigger>
		<success/>
	</trigger>
</event>

<init>...</init>

Unconditional event executing before the program starts.

Example:

<!-- Setting the "my_value" variable to the value of two-->
<init>
    <setter name="my_value">
        <int value="2"/>
    </setter>
</init>

Conditions

Now lets talk about the conditions in the <constraint> and <event> elements. Conditions are set using the <condition> tag if only one of the atomic conditions is tested, or the <conditions> tag if a compound condition is tested.

<condition>...</condition>

The condition being checked is described inside this tag.

Example:

<condition>
    <!-- The condition of equality of two values is described inside the tag -->
    <equals>
        <objectState object="robot1.display.smiles"/>
        <bool value="true"/>
    </equals>
</condition>

<conditions>...</conditions>

Used to create compound conditions. The logical bond is the mandatory attribute. The bond may be and or or. Negation is specified by the <not> tag without attributes. Other <conditions> elements may also appear among subexpressions.

Attributes:

Syntax:

<conditions glue="and">
   <!-- Condition1 -->
   <!-- Condition2 -->
   <!--    ...   -->
   <!-- ConditionN -->
</conditions>

<conditions glue="and">
   <not>
      <!-- Condition1 -->
   </not>
</conditions>

<conditions glue="and">
   <timer timeout="1000" forceDropOnTimeout="true"/>
   <conditions glue="or">
      <greater>
         <objectState object="robot1.display.labels.size"/>
         <int value="20"/>
      </greater>
      <less>
         <objectState object="robot1.display.labels.size"/>
         <int value="19"/>
       </less>    
    </conditions>
</conditions>

Atomic conditions

Atomic condition is one of the following elements:

<equals>...</equals>

Equals. The functional symbols value comparison operation. Can be used as a container.

Syntax:

<equals>
	<objectState object="robot1.display.labels.first.text"/>
	<string value="finish"/>
</equals>

<notEqual>...</notEqual>

Not equal. The functional symbols value comparison operation. Can be used as a container.

Syntax:

<notEqual>
	<objectState object="robot1.display.labels.first.text"/>
	<string value="finish"/>
</notEqual>

<greater>...</greater>

Greater. The functional symbols value comparison operation. Can be used as a container.

Syntax:

<greater>
	<objectState object="robot1.display.labels.size"/>
	<int value="0"/>
</greater>

<less>...</less>

Less. The functional symbols value comparison operation. Can be used as a container.

Syntax:

<less>
    <objectState object="robot1.display.labels.size"/>
    <int value="10"/>
</less>

<inside/>

Sets spatial constraints.

Attributes

Syntax:

<!-- Limits the location of the "robot1" robot to the "start" zone -->
<inside objectId="robot1" regionId="start"/>

<settedUp/> and <dropped/>

Checks whether the event set up or not.

Attributes

Syntax:

<!-- The "event1" event is set up condition -->
<condition>
    <settedUp id="event1"/>
</condition>

<!-- The "event2" event is dropped condition -->
<condition>
    <dropped id="event2"/>
</condition>

Example:

The "check event" event conditions check that the other "Try move" event is set up and the "Go back" event is dropped. If both of them return "true" after the check the program successfully ends.

<event id="check event" settedUpInitially="true">
    <conditions glue="and">
        <settedUp id="Try move"/>
        <dropped id="Go back"/>
    </conditions>
    <trigger>
        <success/>
    </trigger>
</event>

<timer/>

A predicate that starts to return "true" when the specified time has passed since the moment when this event was set, and up to that moment it returns "false".

Attributes

Syntax:

<timer timeout="1000" forceDropOnTimeout="false"/>

Example

Let's look at using <timer/> with different forceDropOnTimeout attribute values.

The "check region" event checks time and spatial limits. The first condition (timer) becomes true after 1000ms. Its value doesn't change after that. The second one (inside) checks that the robot is inside the "start_zone" region. When both conditions will be met simultaneously the program will end successfully.

1. Since the forceDropOnTimeout attribute is "false", the event will be still set up after a specified timeframe and wait for the second condition to be met.

<event id="check region" settedUpInitially="true">
    <conditions glue="and">
        <timer timeout="1000" forceDropOnTimeout="false"/>
        <inside objectId="robot1" regionId="start_zone"/>
    </conditions>
    <trigger>
        <success/>
    </trigger>
</event>

2. Since the forceDropOnTimeout attribute is "true", the event will be dropped after the specified timeframe despite the presence of a second condition. Therefore, if the robot is not in the required region right after 1000 ms, then the success message will not be displayed even if the robot will be there after some time.

<event id="check region" settedUpInitially="true">
    <conditions glue="and">
        <timer timeout="1000" forceDropOnTimeout="true"/>
        <inside objectId="robot1" regionId="start_zone"/>
    </conditions>
    <trigger>
        <success/>
    </trigger>
</event>

Variable types and arithmetic operations

<int/>, <double/>, <string>, <bool/>

Setting a constant.

Attributes

Syntax:

<int value="0"/>

<string value="finish"/>

<variableValue/>

Variable value.

It is possible to take the property of any variable using a dot. For example, "rect.width" will return the width of the rectangle stored in "rect".

Attributes

Syntax:

<variableValue name="rotation"/>

<objectState/>

Get the object state.

Attributes

Syntax:

<objectState object="robot1.display.labels.first.text"/>

Example

<!-- Assign to the "rotation" variable the robots rotation angle -->
<setter name="rotation">
     <objectState object="robot1.rotation"/>
 </setter>
<!-- Checking if the "rotation" value equals to the robots rotation angle -->
<equals>
   <variableValue name="rotation"/>
   <objectState object="robot1.rotation"/>
</equals>

<typeOf/>

Get the objects with specified ID meta-type. For example, the type of the wall object with id=777 will be wall.

Most often, this element will be needed to check the type of connected sensors and motors.

Attributes

Syntax:

<typeOf objectId="robot1.A3"/>

<minus>..</minus>, <abs>...</abs>

Unary arithmetic operations for changing the sign and taking the modulus of a number.

Syntax:

<minus>
    <objectState object="robot1.rotation"/>
</minus>

<abs>
    <objectState object="robot1.rotation"/>
</abs>

Example:

<!-- Modulus of the difference of the "rotation" variable and the robots rotation angle -->
<abs>
    <difference>
        <variableValue name="rotation"/>
        <objectState object="robot1.rotation"/>
    </difference>
</abs>

<sum>, <difference>, <min>, <max>

Sum and difference of values. Minimum and maximum value.

Example:

<!-- The difference of the "rotation" variable and the robots rotation angle -->
<difference>
       <variableValue name="rotation"/>
       <objectState object="robot1.rotation"/>
</difference>

<!-- The sum of the "counter" variable and one -->
<sum>
       <variableValue name="counter"/>
       <int value="1"/>
</sum>

Triggers

<trigger>...</trigger>

An action or a group of actions that will be performed one or many times after the event condition is met.

Syntax:

<trigger>
	<success/>
</trigger>

<fail/>

Display an error message. Finish checking the task.

Attributes

Syntax:

<fail message="Wrong answer!"/>

<success/>

The task is successfully done.

Attributes

Syntax:

<success/>

<setter>...</setter>

Set the variable value.

Attributes

Example:

<!-- Creating the "total_score" variable with the value of zero -->
<setter name="total_score">
       <int value="0"/>
 </setter>

<!-- Addind 2 to the "total_score" -->
<setter name="total_score">
       <sum>
              <variableValue name="total_score"/>
              <int value="2"/>
       </sum>
</setter>

<setUp/>, <drop/>

Setting up or dropping an event.

Attributes

Example:

<!-- Set up the "finish checker" event -->
<triggers>
				<setUp id="finish checker"/>
</triggers>

Sensor names

TRIK Robot Sensors

Lego EV3 Robot sensors

Additional robot properties

Working with the controller display

Example

Checking that the word “message” was displayed on the controller screen. The case is important.

<equals>
        <objectState object="robot1.display.labels.first.text"/>
        <string value="message"/>
</equals>

Restrictions example

You need to start in the blue square then drive along the wall to the red one using the IR distance sensor.

<?xml version="1.0" encoding="UTF-8"?>
<root>
   <world>
      <background />
      <walls>
         <!-- The wall-->
         <wall id="{wall1}" end="300:150" begin="0:100" />
         <wall id="{wall2}" end="550:100" begin="300:150" />
         <wall id="{wall3}" end="650:200" begin="550:100" />
         <wall id="{wall4}" end="850:300" begin="650:200" />
         <wall id="{wall5}" end="1200:300" begin="850:300" />
         <wall id="{wall6}" end="1600:50" begin="1200:300" />
      </walls>
      <skittles />
      <balls />
      <colorFields />
      <images />
      <regions>
         <!-- Regions-->
         <region visible="true" id="finish" x="1300" color="#ff0000" text="Finish" type="rectangle" width="300" textX="0" textY="0" y="-200" filled="true" height="300" />
         <region visible="true" id="start_zone" x="-50" color="#0000ff" text="Start" type="rectangle" width="150" textX="0" textY="0" y="100" filled="true" height="-150" />
         <region visible="false" id="warzone_1" x="-50" color="#ffff00" text="warzone1" type="rectangle" width="650" textX="0" textY="0" y="-50" filled="true" height="200" />
         <region visible="false" id="warzone_2" x="600" color="#ffff00" text="warzone2" type="rectangle" width="250" textX="0" textY="0" y="0" filled="true" height="250" />
         <region visible="false" id="warzone_3" x="850" color="#ffff00" text="warzone3" type="rectangle" width="750" textX="0" textY="0" y="50" filled="true" height="250" />
      </regions>
   </world>
   <robots>
      <!-- Robot description -->
      <robot id="trikKitRobot" position="0:0" direction="0">
         <sensors>
            <sensor port="A1###input###А1###sensorA1" position="75:25" type="trik::robotModel::parts::TrikInfraredSensor" direction="45" />
            <sensor port="M3###output###JM3$$$C$$$3###" position="75:25" type="kitBase::robotModel::robotParts::Motor" direction="0" />
            <sensor port="M4###output###JM4$$$D$$$4###" position="75:25" type="kitBase::robotModel::robotParts::Motor" direction="0" />
         </sensors>
         <startPosition id="{ee2c46c1-23fc-4cda-98f4-77d9de775305}" x="25" y="25" direction="0" />
         <wheels left="M3###output###М3###" right="M4###output###М4###" />
      </robot>
   </robots>
   <constraints>
      <!-- Time limit (30 seconds) -->
      <timelimit value="30000" />
      <!-- Spatial restriction of the start region. Checks once at the program start -->
      <constraint checkOnce="true" failMessage="The robot must be inside the blue square at the start!">
         <inside regionId="start_zone" objectId="robot1" />
      </constraint>
      <!-- Sensors type and presence restriction -->
      <constraint checkOnce="true" failMessage="Only the IR distance sensor must be connected to the A1 port">
         <conditions glue="and">
            <equals>
               <typeOf objectId="robot1.A1" />
               <string value="trik::twoDModel::robotModel::parts::RangeSensor" />
            </equals>
            <equals>
               <typeOf objectId="robot1.A2" />
               <string value="undefined" />
            </equals>
            <equals>
               <typeOf objectId="robot1.A3" />
               <string value="undefined" />
            </equals>
            <equals>
               <typeOf objectId="robot1.A4" />
               <string value="undefined" />
            </equals>
            <equals>
               <typeOf objectId="robot1.A5" />
               <string value="undefined" />
            </equals>
            <equals>
               <typeOf objectId="robot1.A6" />
               <string value="undefined" />
            </equals>
            <equals>
               <typeOf objectId="robot1.D1" />
               <string value="undefined" />
            </equals>
            <equals>
               <typeOf objectId="robot1.D2" />
               <string value="undefined" />
            </equals>
         </conditions>
      </constraint>
      <!-- Robot ride control -->
      <constraint failMessage="The robot tried to move out of the permitted area!">
         <conditions glue="or">
            <inside regionId="warzone_1" objectId="robot1" />
            <inside regionId="warzone_2" objectId="robot1" />
            <inside regionId="warzone_3" objectId="robot1" />
         </conditions>
      </constraint>
      <!-- An event that checks if the robot has entered the finish area -->
      <event settedUpInitially="true">
         <condition>
            <timer timeout="100" forceDropOnTimeout="true" />
         </condition>
         <trigger>
            <setUp id="finish checker" />
         </trigger>
      </event>
      <!-- Event reporting the successful finish -->
      <event id="finish checker" settedUpInitially="false">
         <condition>
            <inside regionId="finish" objectId="robot1" />
         </condition>
         <trigger>
            <success />
         </trigger>
      </event>
   </constraints>
</root>

TRIK Studio — free robot programming environment.

It allows you to solve problems using both visual and textual programming languages.

A distinctive feature of TRIK Studio is an interactive simulation mode. You don't need to have a constructor to learn how to program.

TRIK Studio — universal software for teaching programming basics. It provides a smooth transition from diagrams to text languages.