If you have any questions that you would like to know about the new designer (how something specific works, conduct an experiment with sensors or motors) - write to us - we will try out your suggestions. This way you can learn much more about EV3 even before it goes on sale.

Now it all starts with a review software EV3 block (EV3 firmware).

One of the features of the new unit is that it takes a long time to turn on and off. In terms of time, the process is comparable to the inclusion cell phone or home router, i.e. 20-30 seconds. After switching on, the following menu appears:

As you can see, compared to the NXT block, a lot has changed: the quality of fonts has improved, graphic elements have been more drawn, and the window interface has improved. First of all, this is due to the fact that the screen size has now increased - it has become 178 by 128 pixels, instead of 100 by 64, like the NXT block. Based on the presence of a window interface with integral buttons and scroll bars, it can be assumed that devices such as an external Touchpad it will even make more sense now.

From the first window it is possible to call programs loaded onto the block, as well as programs created directly on the block. Those. in order to start the program you now need to perform fewer clicks than on the NXT block.

Navigation through loaded programs, as well as to the second and subsequent screens (menu items), is carried out using control buttons, of which there are now 4.

Second screen - allows you to navigate through file system objects on the block. File system now supports traditional hierarchy: files and directories.

The third screen contains a submenu - applications that allow you to perform various actions with the block:

IN current version There are four software blocks of such applications:

• View sensors
• Motor control
• Remote control
• Programming on the block

The fourth screen is configuration. Besides basic settings: sound level, inactivity timer, turning on BlueTooth and WiFi, allows you to find out information about the unit’s software:

Selecting a specific menu item/application occurs with the middle button on the keyboard. And to exit any menu item or application, you need to press the “Exit” button, which is now located separately from the main buttons - on the left side under the screen.

Now you should go back to the third screen and start getting acquainted with the applications. So, the application "View sensors" (Port View).

Unlike a similar mode on the NXT block, you can now see information about all 8 devices connected to the block at once. Moreover, the declared functionality of automatic detection of sensors allows you to not manually indicate which sensor is connected where.

Information from motor encoders is displayed at the top, information from sensors is displayed at the bottom. In the center of the screen - information about specific device(V specific port), which can be selected by pressing the control buttons on the keyboard. The information includes a graphical representation of the sensor, its name and current readings:

Touch sensor:


Gyro sensor:


Color sensor in reflected light mode:


Ultrasonic distance sensor:

Here, by the way, you can see that the sensor now claims that it can measure distances with an accuracy of millimeters, and the minimum measured distance is now 3 cm.

Information from the left motor encoder.


The next application is motor control. Essentially, it allows you to use buttons to rotate the motors. With the central button you need to select which motors to rotate. And then use pairs of buttons up and down or left and right to rotate specific motors.

It was not possible to try the third application, since the standard delivery of the educational version of the EV3 kit does not include an infrared distance sensor and an infrared beacon. But apparently, on this screen you can configure which motors will be controlled from the infrared beacon.

Of course, the most interesting application is programming on a block. It has been significantly redesigned: a program can now contain up to 16 program elements (blocks), and created programs can be saved and, of course, reopened for modification.

When the program writing application opens, an empty execution loop is displayed (only one iteration will be executed) and a proposal to insert the first block. You can insert a block using the "Up" button.

In the block selection window that appears, 17 blocks are available (6 action blocks and 11 wait blocks) plus the action of deleting the current block.

The order of selection and sequence of blocks is determined by the programmer. It does not imply that after each action block there must be a wait block, as was previously the case with the NXT block.

The selected block in the program looks like this:

The behavior of the block can be specified by pressing the center button. For this block, for example, you can change the angle and direction of the robot’s rotation or stop the motors altogether (for example, after the previous waiting block).

By moving the “cursor” to the left or right, you can insert another block:

For example, an event wait block on a distance sensor:

And change its behavior (the event will occur if the distance becomes more than 60 cm):

Blocks can be inserted between existing blocks or even at the beginning of a program.

Here are more examples of wait blocks:

Time waiting block (you can set exactly how long to wait):


Or a block for waiting for an event from a gyroscopic sensor (you can set the angle of rotation of the sensor).


It should again be noted that the sensor auto-detection functionality simplifies the programming process on the unit. There is no longer any need to adhere to the rule that certain sensors must be connected to certain ports.

If the program must be executed several times, the number of iterations of the control loop can be changed:

The program is launched by selecting the very first block:

When you start the program, the following will be displayed on the screen:

The program can be saved, and you can specify a file name for later search:

Letters are selected using the keyboard (hello, touchpad!)

If you try to close an unsaved program, the following not very clear message will be displayed and an unpleasant sound will be produced:

You can later open the created program and make changes to it.

Naturally, only programs created on the block are opened.

In conclusion, I would like to show what turning off a block looks like:

USB connection

LEGO Mindstorms EV3 can connect to a PC or another EV3 via a USB connection. The connection speed and stability in this case are better than with any other method, including Bluetooth.

LEGO Mindstorms EV3 has two USB ports.

Communication between LEGO EV3 and other LEGO EV3 blocks in daisy chain mode.

Daisy chain mode is used to connect two or more LEGO EV3 blocks.

This mode:

• designed to connect more than one LEGO Mindstorms EV3;
• serves for connection more sensors, motors and other devices;
• allows communication between several LEGO Mindstorms EV3 (up to 4), which gives us up to 16 external ports and the same number of internal ports;
• makes it possible to control the entire chain from the main LEGO Mindstorms EV3;
• cannot function when active Wi-Fi connection or Bluetooth.

To enable the daisy chain connection mode, go to the project settings window and check the box.

When this mode is selected, then for any motor we can select the EV3 block that will be used and the necessary sensors.

The table shows options for using EV3 blocks:

Action	Medium motor
	Big motor
	Steering
	Independent management
	Gyroscopic
	Infrared
	Ultrasonic
	Motor rotation
	Temperatures
	Energy meter
	Sound

Connection via Bluetooth

Bluetooth allows LEGO Mindstorms EV3 to connect to a PC, other LEGO Mindstorms EV3, smartphones and other Bluetooth devices. Communication range via Bluetooth is up to 25 m.

You can connect up to 7 blocks to one LEGO Mindstorms EV3. The EV3 Master Brick allows you to send and receive messages to each EV3 Slave. EV3 Slaves can only send messages to the EV3 Master Brick, not to each other.

EV3 connection sequence via Bluetooth

In order to connect two or more EV3 blocks to each other via Bluetooth, you need to perform the following steps:

1. Open a tab Settings.

2. Select Bluetooth and press the center button.

3. We put Checkbox visibility Bluetooth.

4. Check that the Bluetooth sign ("<") виден на верхней левой стороне.

5. Do the above procedure for the required number of EV3 Bricks.

6. Go to the Connection tab:

7. Click on the Search button:

8. Select the EV3 you want to connect to (or to which you want to connect) and press the center button.

9. We connect the first and second blocks with the access key.

If you do everything correctly, the icon " will appear in the upper left corner<>", connect other EV3 blocks in the same way if there are more than two of them.

If you turn off LEGO EV3, the connection will be lost and you will need to repeat all the steps.

Important: each block must have its own program written.

Example program:

First Block: When the touch sensor is pressed, the first EV3 Block transmits the text to the second Block with a delay of 3 seconds (Main Block).

Example program for block 2:

The second block waits to receive the text from the first block, and once it receives it, it will display a word (in our example, the word "Hello") for 10 seconds (the slave block).

Connect via Wi-Fi

Longer range communication is possible by connecting the Wi-Fi Dongle to the USB port on EV3.

To use Wi-Fi, you need to install a special module on the EV3 block using a USB connector (Wi-Fi adapter (Netgear N150 Wireless Adapter (WNA1100), or you can connect a Wi-Fi Dongle.

If you, like us, lack the capabilities of standard EV3 sensors, 4 ports for sensors in your robots are not enough, or you want to connect some exotic peripherals to your robot - this article is for you. Believe me, a homemade sensor for EV3 is easier than it seems. A “volume knob” from an old radio or a couple of nails stuck into the ground in a flower pot as a soil moisture sensor are perfect for the experiment.

Surprisingly, each EV3 sensor port hides a number of different protocols, mainly for compatibility with NXT and third-party sensors. Let's look at how the EV3 cable works

It’s strange, but the red wire is ground (GND), the green wire is the plus of the 4.3V power supply. The blue wire is both SDA for the I2C bus and TX for the UART protocol. In addition, the blue wire is the input of the analog-to-digital converter for EV3. The yellow wire is both SCL for the I2C bus and RX for the UART protocol. The white wire is the input of the analog-to-digital converter for NXT sensors. Black - digital input, for sensors compatible with NXT - it duplicates GND. Not easy, isn't it? Let's go in order.

EV3 analog input

Each sensor port has an analog-to-digital converter channel. It is used for sensors such as Touch Sensor (button), NXT Light Sensor and Color Sensor in reflected light and ambient light mode, NXT Sound Sensor and NXT Thermometer.

A resistance of 910 Ohms, connected according to the diagram, tells the controller that this port must be switched to analog input mode. In this mode, you can connect any analog sensor to EV3, for example from Arduino. The exchange rate with such a sensor can reach several thousand polls per second; this is the fastest type of sensor.

Light sensor

Thermometer

Soil moisture sensor

You can also connect: a microphone, a button, an IR rangefinder and many other common sensors. If 4.3V power is not sufficient for the sensor, you can power it with 5V from the USB port located on the side of the EV3 controller.

The above-mentioned “volume knob” (also known as a variable resistor or potentiometer) is an excellent example of an analog sensor - it can be connected like this:

To read values ​​from such a sensor in the standard LEGO programming environment, you must use the blue RAW block

I2C protocol

This is a digital protocol; for example, the NXT ultrasonic sensor and many Hitechnic sensors, such as IR Seeker or Color Sensor V2, work on it. For other platforms, for example for Arduino, there are a lot of i2c sensors, you can also connect them. The scheme is as follows:

A resistance of 82 ohms is recommended by the LEGO Group, but various sources mention 43 ohms or less. In fact, we tried to abandon these resistances altogether and everything works, at least “on the table”. In a real robot operating in conditions of various kinds of interference, the SCL and SDA lines should still be connected to the power supply through resistances, as indicated in the diagram above. The i2c operating speed in EV3 is quite low, approximately 10,000 kbps, which is why everyone’s favorite Hitechnic Color Sensor V2 is so slow :)

Unfortunately, for the standard EV3-G from LEGO there is no full-fledged block for two-way communication with an i2c sensor, but using third-party programming environments such as RobotC, LeJOS or EV3 Basic you can interact with almost any i2c sensors.

The EV3's ability to operate using the i2c protocol opens up an interesting possibility for connecting multiple sensors to one port. The I2C protocol allows you to connect up to 127 slave devices to one bus. Can you imagine? 127 sensors for each EV3 port :) Moreover, often a bunch of i2c sensors are combined in one device, for example in the photo below there is a 10 in 1 sensor (contains a compass, gyroscope, accelerometer, barometer, etc.)

UART

Almost all standard non-EV3 sensors, with the exception of Touch Sensor, operate using the UART protocol and that is why they are not compatible with the NXT controller, which, although it has the same connectors, does not have UART implemented on its sensor ports. Take a look at the diagram, it is a little simpler than in previous cases:

UART sensors automatically match the speed of their operation with EV3. Initially connecting at a speed of 2400 kbit/s, they agree on operating modes and exchange rates, then moving to an increased speed. Typical exchange rates for different sensors are 38400 and 115200 kbit/s.
LEGO has implemented a rather complicated protocol in its UART sensors, so there are no third-party sensors that were not originally intended for this platform, but are compatible with it. Nevertheless, this protocol is very convenient for connecting “homemade”
sensors based on microcontrollers.
There is a wonderful library for Arduino called EV3UARTEmulation, written by famous LeJOS developer Lawrie Griffiths, which allows this board to pretend to be a UART-LEGO-compatible sensor. His LeJOS News blog has a lot of examples of connecting gas sensors, an IMU sensor and a digital compass using this library.

Below in the video is an example of using a homemade sensor. We don't have enough original LEGO distance sensors, so we use a homemade one on the robot:

The robot's task is to start from the green cell, find a way out of the maze (red cell) and return to the starting point by the shortest route, without going into dead ends.

The article describes the experience of using the Lego Mindstorms EV3 constructor to create a prototype of a robot with its subsequent software and manual control using Robot Control Meta Language (RCML).

• Assembling a robot prototype based on Lego Mindstorms EV3
• Quick installation and configuration of RCML for Windows
• Software control of the robot based on the EV3 controller
• Manual control of robot peripherals using a keyboard and gamepad

Looking ahead a little, I’ll add that to implement control of a Lego robot using a keyboard, you need to create a program containing only 3 lines of program code. More details on how to do this are written under the cut.

1. To begin with, a robot prototype was created from the Lego Mindstorms EV3 constructor, which will be used for programming and manual piloting.

Description of the robot prototype

The robot has a design similar to a car chassis. Two motors mounted on the frame have one common axis of rotation, which is connected to the rear wheels through a gearbox. The gearbox converts torque by increasing the angular velocity of the rear axle. The steering is assembled on the basis of a bevel gear.

2. The next step is to prepare RCML for working with the Lego Mindstorms EV3 constructor.

You should download archives with executable files and library files and .

The downloaded archives must be extracted to a directory with an arbitrary name, but you should avoid Russian letters in the title.

Contents of the directory after unpacking the archives into it

Next, you need to create a configuration file config.ini, which must be located in the same directory. To implement the ability to control the EV3 controller using a keyboard and gamepad, you must connect the lego_ev3, keyboard and gamepad modules.

Listing of the config.ini configuration file for RCML

Module = lego_ev3 module = keyboard module = gamepad

Next, you need to pair the EV3 controller and adapter.

Instructions for pairing the EV3 controller and Bluetooth adapter

The instructions contain an example of pairing the Lego Ev3 controller and a PC running the Windows 7 operating system.

1. You need to go to the settings section of the Ev3 controller, then to the “Bluetooth” menu item.

2. Make sure that the configuration parameters are set correctly. The checkboxes should be checked next to the “Visibility”, “Bluetooth” items.

3. You need to go to “Control Panel”, then “Devices and Printers”, then “Bluetooth Devices”.

4. You must click the “Add device” button. A window will open to select available Bluetooth devices.

5. Select the “EV3” device and click the “Next” button.

6. The EV3 Controller displays the “Connect?” dialog box. You need to select the checkbox option and confirm your choice by pressing the center key.

7. Next, the “PASSKEY” dialog box will be displayed, the numbers “1234” should be indicated in the input line, then you should confirm the key phrase for pairing devices by pressing the center key on the position with a check mark.

8. In the device pairing wizard, a form will appear for entering the key for pairing devices. You need to enter the code “1234” and press the “Next” button.

10. On the PC, you need to return to the “Control Panel”, then “Devices and Printers”, then “Bluetooth Devices”. The list of available devices will display the device that was paired with.

11. Double-click to go to the “EV3” connection properties.

14. The COM port index specified in the properties should be used in the config.ini configuration file of the lego_ev3 module. The example shows the Bluetooth connection properties of a Lego EV3 controller using a standard COM14 serial port.

Further configuration of the module comes down to the fact that it is necessary to write in the configuration file of the lego_ev3 module the address of the COM port through which communication with the Lego robot is carried out.

Listing of the config.ini configuration file for the lego_ev3 module

Connection = COM14 dynamic_connection = 0

Now you need to configure the keyboard module. The module is located in the control_modules directory, then keyboard. You should create a configuration file config.ini next to the keyboard_module.dll file. Before you create a configuration file, you need to determine what actions should be performed when pressing keys.

The keyboard module allows you to use keys that have a specific numeric code. You can view the table of virtual key codes.

As an example, I will use the following keystrokes:

• The up/down arrows are used to rotate the rear wheel motor forward/backward
• Left/right arrows turn wheels left/right

The keyboard module configuration file describes which axes are available to the programmer to interact with the robot in manual control mode. Thus, in the example there are two control groups - these are the keyboard axes. To add a new axis, you must adhere to the following rules for describing axes.

Rules for describing axes for the keyboard module

1. When adding a new axis, it is necessary in the section add a property whose name is the axis name and assign it the value of the keyboard button in HEX format, and a similar record is created for each button, i.e. an axis name can be used multiple times. In general, writing to a section will look like this:

Axis_name = keyboard_button_value_in_HEX_format
2. It is necessary to set the maximum and minimum value that can be plotted along this axis. To do this, you need to add a section in the configuration file on a new line config.ini, the same as the axis name, and set the properties upper_value And lower_value, which correspond to the maximum and minimum of the axis, respectively. In general, this section looks like this:

[axis_name] upper_value = maximum_axis_value lower_value = minimum_axis_value
3. Next, you need to determine what value the axis will have if you press a button on the keyboard that was previously attached to it. The values ​​are determined by creating a section, the name of which consists of the name of the axis and the value of the keyboard button in HEX format, separated by an underscore. To set the default (unpressed) and pressed state, use the properties unpressed_value And pressed_value respectively, into which the values ​​are transferred. The general view of the section in this case looks like this:

[axis-name_keyboard-key-value] pressed_value = axis_value when_key_pressed unpressed_value = axis_value_when_key_pressed
The spoiler text is copied from the RCML documentation for ease of viewing.

To implement control of the robot prototype, a configuration file for the keyboard module was created, which includes the go and rotate axes. The go axis is used to set the direction of movement of the robot. When you press the “up arrow” key, the axis will receive a value of 100; when you press the “down arrow” key, the axis will receive a value of -50. The rotate axis is used to set the steering angle of the front wheels. When you press the left arrow key, the axis value will be -5, when you press the right arrow key, the axis value will be 5.

Listing of the config.ini configuration file for the keyboard module

;Required section ;axis_name = key_code (in HEX format) ;go axis receives values ​​from up_arrow go = 0x26 ;go axis receives values ​​from go_down_arrow = 0x28 ;rotate axis receives values ​​from left_arrow rotate = 0x25 ;rotate axis receives values ​​from right_arrow rotate = 0x27 ;Description of the go axis, must always have both keys ;Upper limit of go axis values ​​upper_value = -100 ;Lower limit of go axis values ​​lower_value = 100 ;Description of the rotate axis, must always have both keys;Upper limit of rotate axis values ​​upper_value = - 100 ;Lower limit of axis values ​​rotate lower_value = 100 ;Description of the behavior of the go axis for the *up_arrow* key (0x26) ;When pressing the *up_arrow* key, set the axis value to 50 pressed_value = 100 ;When releasing the *up_arrow* key, set the axis value to 0 unpressed_value = 0 ;Description of the behavior of the go axis for the *down_arrow* key (0x28) ;When pressing the *down_arrow* key, set the axis value to -50 pressed_value = -50 ;When releasing the *down_arrow* key, set the axis value to 0 unpressed_value = 0 ;Description behavior of the rotate axis for the *left_arrow* key (0x25) ;When pressing the *left_arrow* key, set the axis value to -5 pressed_value = -5 ;When releasing the *left_arrow* key, set the axis value to 0 unpressed_value = 0 ;Description of the behavior of the rotate axis for the key *right_arrow* (0x27) ;When pressing the *right_arrow* key, set the axis value to 5 pressed_value = 5 ;When releasing the *right_arrow* key, set the axis value to 0 unpressed_value = 0

Next, to implement control using a gamepad, you need to configure the gamepad module. Configuring a module involves creating a configuration file config.ini next to gamepad_module.dll, located in the control_modules directory, then gamepad.

Universal module configuration file for interacting with a gamepad

;Required section describing the axes used ;Axis to end manual control mode Exit = 9 ; 11 binary axes corresponding to the gamepad buttons B1 = 1 B2 = 2 B3 = 3 B4 = 4 L1 = 7 L2 = 5 R1 = 8 R2 = 6 start = 10 T1 = 11 T2 = 12 ; 4 stick axes; Right stick up/down movement RTUD = 13 ; Right stick left/right movement RTLR = 16 ; Left stick up/down movement LTUD = 15 ; Left stick left/right movement LTLR = 14 ; 2 axes of the cross;Movement of the cross up/down arrowsUD = 17 ;Movement of the cross left/right arrowsLR = 18 ;Description of the behavior of the B1 axis;When pressing the B1 button, set the axis value to 1 upper_value = 1;When releasing the B1 button, set the axis value to 0 lower_value = 0 upper_value = 1 lower_value = 0 upper_value = 1 lower_value = 0 upper_value = 1 lower_value = 0 upper_value = 1 lower_value = 0 upper_value = 1 lower_value = 0 upper_value = 1 lower_value = 0 upper_value = 1 lower_value = 0 upper_value = 1 lower_value = 0 upper_value = 1 lower_value = 0 upper_value = 1 lower_value = 0 ;Description of the behavior of the right stick axis moving up/down ;Axis value when moving to the maximum possible upper position upper_value = 0 ;Axis value when moving to the maximum possible lower position lower_value = 65535 upper_value = 0 lower_value = 65535 upper_value = 0 lower_value = 65535 upper_value = 0 lower_value = 65535 ;Description of the behavior of the D-pad axis up/down movement ;Axis value when pressing the up arrow upper_value = 1 ;Axis value when pressing the down arrow lower_value = -1 upper_value = 1 lower_value = -1

Additional information about the specifics of setting up the gamepad module is displayed in the RCML reference manual.

3. The next step is to write a program in RCML.

In the root of the created directory, you need to create a program file. The name of the program file and its extension can be anything, but you should avoid Russian letters in the name. The file name used in the example is hello.rcml.

For the lego_ev3 module, the robot reservation code has the following form:

@tr = robot_lego_ev3;

The lego_ev3 module connection page describes most of the functions supported by the controller. As a test example, a program was created to automatically enter the robot into a skid.

The program algorithm is as follows:

After reserving the first free robot, a connection is established between the two motors for subsequent work with them as if they were one. Then the robot begins to perform drifts. A software description of the robot’s actions allows you to accurately set the angles of rotation of the front wheels and the rotation speed of the rear wheels. Using this technique allows you to achieve results that are difficult to replicate during manual piloting with a keyboard or gamepad.

Program listing for Lego robot in RCML language

function main() ( @tr = robot_lego_ev3; //Reserve the robot @tr->setTrackVehicle("B","C",0,0); //Setting motor synchronization @tr->motorMoveTo("D",100, 0,0); system.sleep(500); @tr->trackVehicleForward(-100); system.sleep(1000); @tr->motorMoveTo("D",50,-50,0); system.sleep (4000); @tr->motorMoveTo("D",50,50,0); system.sleep(4000); @tr->trackVehicleOff(); system.sleep(1000); )

To compile the program, you must use the window command line. First, you should move to the created directory with the executable files rcml_compiler.exe and rcml_intepreter.exe. Next you need to enter the following commands.

Command to compile hello.rcml file:

Rcml_compiler.exe hello.rcml hello.rcml.pc
As a result of compiling, a new file hello.rcml.pc will appear in the created directory.

Screenshot of the command line after successful compilation

Now you need to make sure that the EV3 controller is turned on and paired with the Bluetooth adapter. The gamepad must be connected to the PC. After this, you need to execute the command to execute the program file:

Rcml_intepreter.exe hello.rcml

Appearance of the command line during program execution

A video demonstrating the robot's movement program is located at the bottom of the article.

4. The next step is to control the robot manually using the keyboard.

Using the keyboard, you can control any robot motor. The example implements control of the following mechanisms:

• Front wheel steering angle
• Direction of rotation of the rear wheels

Listing of the program for interaction between the keyboard and the Lego robot based on the EV3 controller

function main() ( @tr = robot_lego_ev3; //Reserve the robot @tr->setTrackVehicle("B","C",0,0); //Setting motor synchronization system.hand_control(@tr,"keyboard"," straight","go", "speedMotorD","rotate"); )

Next, you need to compile the program and run it. The result of manually controlling a Lego robot using a keyboard is shown in the video at the bottom of the page.

5. In addition to the keyboard, a gamepad module is available that allows you to manipulate the robot using a gamepad. To implement robot control using a gamepad, it is necessary to describe at the program level which axes of the robot will take the values ​​of the gamepad axes.

Listing of the program for interaction between the gamepad and the Lego robot

function main() ( @tr = robot_lego_ev3; //Reserve the robot @tr->setTrackVehicle("B","C",0,0); //Setting engine synchronization system.hand_control(@tr,"gamepad", " straight","RTUD", "speedMotorD","RTLR"); )

Next, you should repeat the process of compiling the program and then execute it. The following shows the result of manually controlling a Lego robot using a gamepad, and all previously connected methods:

This article briefly demonstrates just some of the capabilities of RCML. The most detailed description can be found in the reference manual.

Description of the presentation by individual slides:

1 slide

Slide description:

2 slide

Slide description:

EV3 Brick Interface The EV3 Brick is the control center that powers your robots. With the screen, Brick control buttons, and the EV3 Brick interface, which contains four main windows, you have access to a stunning variety of unique EV3 Brick features. These can be simple functions, such as starting and stopping a program, or complex, like writing the program itself.

3 slide

Slide description:

Interface: The EV3 Menu has a menu that consists of 4 parts: Recent Programs File Navigation Brick Applications Brick Settings

4 slide

Slide description:

Recent Programs Launch programs recently downloaded from your desktop PC. This window will remain blank until you start downloading and running programs. This window will display the programs you have launched recently. The program at the top of the list, which is selected by default, is the program that was launched last.

5 slide

Slide description:

File Manager Access and manage all files stored in the microcomputer memory, as well as on the memory card. From this window you will access and manage all files in your EV3 Brick, including files stored on the SD card. The files are organized into project folders, which, in addition to the actual program files, also contain the sounds and images used in each project. Files can be moved or deleted using the file navigator. Programs created using the module programming environment and module data logging applications are stored separately in the BrkProg_SAVE and BrkDL_SAVE folders.

6 slide

Slide description:

EV3 Control Box Applications has 4 pre-installed applications: A. Port View. B. Motor control. B. IR control. D. Module programming environment.

7 slide

Slide description:

A. Port View In the first window of the Port View application, you can quickly see which ports have sensors or motors connected to them. Use the EV3 Brick control buttons to navigate to one of the occupied ports and you will see the current readings from the sensor or motor. Install several sensors and motors and experiment with different settings. To view or change the current settings for installed motors and sensors, press the center button. To return to the main application window of the module, click the “Back” button.

8 slide

Slide description:

B. Motor Control Control the forward or reverse movement of any motor connected to one of the four output ports. There are two different modes. In one mode, you will be able to control motors connected to port A (using the Up and Down buttons) and to port D (using the Left and Right buttons). In the other mode, you control motors connected to port B (using the Up and Down buttons) and port C (using the Left and Right buttons). Switching between these two modes is done using the central button. To return to the main application window of the module, click the “Back” button.

Slide 9

Slide description:

IR Control Control the forward or reverse motion of any motor connected to one of the four output ports using the remote infrared beacon as the remote control and the infrared sensor as the receiver (the infrared sensor must be connected to port 4 on the EV3 Brick). There are two different modes. In one mode you will use channels 1 and 2 on the remote infrared beacon. On channel 1, you will be able to control motors connected to port B (using buttons 1 and 2 on the remote IR beacon) and port C (using buttons 3 and 4 on the remote IR beacon). On channel 2 you will be able to control the motors connected to port A (using buttons 1 and 2) and to port D (using buttons 3 and 4). In another mode, you can control the motors in the same way, using channels 3 and 4 on the remote infrared beacon instead. Switching between these two modes is done using the central button. To return to the main application window of the module, click the “Back” button.

10 slide

Slide description:

Brick Programming Environment The EV3 Brick comes with software installed on it. The application is similar to software installed on your computer. These instructions contain the basic information you need to get started.

11 slide

Slide description:

EV3 Brick Settings This window allows you to view and adjust various general settings in the EV3 Brick.

12 slide

Slide description:

Adjusting Volume You can increase or decrease Volume in the Settings tab in EV3.

Slide 13