DJI RoboMaster S1 V2
549.00€
Sisenege programmeerimis-, robootika- ja AI-maailma, kasutades DJI RoboMaster S1 haridusrobotit. See on lõbus ja interaktiivne praktiline robotitanker, mille ise konstrueerite ja programmeerite. Mängige mänge, täitke ülesandeid ja õppige väärtuslikke oskusi.
Küsi meilt pakkumist!
Out of stock
Saa teavitus tarneajast või toote saabumisest lattu
46 kohandatavat osa
RoboMaster S1 on kokku pandud 46 kohandatavast komponendist. See annab teile võimaluse teha Robomaster S1 endanäoliseks, laiendades ja kohandades selle võimalusi. Kuus PWM-porti on lisatud valikuliste lisaseadmete jaoks veelgi edasiseks kohandamiseks.
RoboMaster äpp
RoboMasteri rakendus on S1 pakutavate kogemuste keskmes. See annab teile roboti juhtimise ja võimaluse programmeerida sinna uusi oskusi. Rakendus toetab iOS-, Android- ja Windows-seadmeid, näiteks nutitelefonid, tahvelarvutid ja sülearvutid. Rakenduse mitmeplatvormiline olemus võimaldab erinevatel platvormidel koos mängida, samuti kohandatud programme jagada.
AI programmeerimine + 6 tuvastusfunktsiooni
See, mida RoboMaster teha saab, on täielikult teie enda otsustada ja kuidas kuut erinevat tuvastusfunktsiooni ühendada. Need hõlmavad visuaalse ja heli tuvastamise võimeid.
- Rea järgimine (Line Follow): looge oma lõbus ja interaktiivne rada, et S1 automaatselt järgneks teile
- Nägemismarkerid (Vision Markers): S1 suudab ära tunda kuni 44 visuaalset märgistust, näiteks numbreid, tähti ja erimärke, ning reageerida neile
- Järgige (Follow): saate anda S1-le võimaluse jälgida ja jälgida inimest tema vaateväljas
- Plaksutamine (Clap): programmi reageeringud helisignaalidele, mis põhinevad muutuval rütmil ja plaksude kogusel
- Käeliigutused (Hand Gestures): S1 suudab reageerida hulgale füüsilistele käeliigutustele
- S1 robotid (S1 Robots): teie S1 tunneb ära teised S1 robotid ja teeb teie programmeerimise põhjal kohandatud liigutusi
Tee meisterlikkusele
Projekteerimismõtte edendamiseks mõeldud projektipõhiste kursuste ja ülesannete seeria on loodud, et teid teha algajast eksperdiks.
RoboAkadeemia
RoboAkadeemiasse kaasatud videoõpetused on mõeldud kõikehõlmavate juhiste saamiseks RoboMaster S1 juhtimiseks. Need on mõeldud ka lõbusaks ja huvitavaks viisiks füüsika, matemaatika ja põhiprogrammeerimise paremaks mõistmiseks.
Scratch & Python
S1-le saab programmeerida erinevaid võimeid, et seda oma maitse järgi kohandada. Algajatele on Scratch 3.0 programmeerimiskeel, mis sobib suurepäraselt loogilise kodeerimise kontseptsioonide õppimiseks visuaalse, plokkidel põhineva kasutajaliidese abil. Edasijõudnumate programmeerijate jaoks toetab RoboMaster S1 ka laialdaselt kasutatavat Pythoni keelt.
Madala latentsusega HD FPV + 2-teljeline Gimbal
Kasutades madala latentsusega 1080p / 720p võimlemiskaamerat, saate sõidu ajal ja mängude ajal nautida esmapilgul vaadet toimingule. Kaamera on laiendatud vaatevälja jaoks kinnitatud 2-teljelise kinnitusklambri külge, millel on 540 ° suuna ja 65 ° kalle. Teie voogesituse video sujuva ja stabiilsena hoidmiseks töötab pöördkeha harjadeta mootoril, mis töötab koos IMU ja kohandatud algoritmidega, et hoida vibratsiooni kontrolli täpsus täpsusega ± 0,02 °.
Sisseehitatud lõhkaja (blaster) + mängurežiimid
Sisseehitatud lõhkaja kasutab LED-tulesid sihtmärkide ja vastaste jälgimiseks erinevates mängurežiimides, tulistades kas infrapunakiiri või füüsilisi mittetoksilisi geelihelmeid. Helmeste punker mahutab korraga umbes 430 helmeid. Heliefektide ja tagasilöögi kaasamine tulistamisel aitab teid elamusesse sukeldada. Täiendava ohutuse tagamiseks on S1-l piirangud tulistamiskiirusele ja -nurgale.
Lõhkajat saab kasutada erinevates mängurežiimides ja teie S1 reaktsioone mängu ajal saab täiendada kohandatud kodeerimisega, näiteks “Löö ja jookse”, kus saate teha S1 pöörde ja vasturünnaku automaatselt, kui see on tabatud.
Siin on nimekiri mängurežiimidest, mida saate S1-ga nautida
- Sihtpraktika ja võistlussõit (Target practise & Target race): üksikmängurežiimid, mis nõuavad visuaalsete märgiste skännimist S1-ga ja kas laskmist või võistlemist märgisest märgiseni
- Võistlus (Race): mitme mängija režiim, kus mitu S1-robotit võistlevad visuaalsete märgiste võimalikult kiire skännimiseks
- Kõigile vaba (Free-for-all): mitme mängijaga režiim, kus mitu S1-robotit kasutavad integreeritud lõhkajat (blasterit), et tulistada üksteise järel geelihelmeid või infrapunakiiri. Eelise saamiseks võib kasutada täiendavaid mõistatusboonuseid. Nende hulka kuuluvad pearinglus, elektromagnetilised häired, ülikiire kiirus ja hävitamatus
Arukas andur
Kuus intelligentset soomuspaneeli ümbritsevad robotit ja on loodud löökide tuvastamiseks teie RoboMaster S1-ga lahingus käies. See suudab tuvastada sissetuleva geeliraua laskemoona infrapuna- või füüsilisi lööke. Tabamused registreeritakse ja edastatakse mängu ajal reaalajas. Mitmed LED-tuled lõhkaja külgedel lülituvad pärast lööke ükshaaval välja, andes teile visuaalse tulemuse / kahjustuse.
4WD kahesuunaline liikumine
Kohandatud mootoril M3508I on integreeritud FOC ESC ja väljundmoment kuni 250 mN-n. Lineaarsed Halli efekti andurid aitavad teil nelikveoga esivedrustust täpselt juhtida. Igal neljal Mecanumi rattal on 12 rulli, mis võimaldab RoboMaster S1-l saavutada igasuunalist liikumist.
| Manufacturer | |
|---|---|
| Series |
Spec
Motor
| Motor Type | Brushless |
| Rotational Speed | 1000 rpm (Maximum) |
| Maximum Torque | 0.25N*m |
| Maximum Output Power | 19 W |
| Operating Temperature | 14 to 104°F / -10 to 40°C |
| Driver | Field Oriented Control (FOC) |
| Control Method | Closed-Loop Speed Control |
| Protections | Overvoltage Overtemperature Soft-Start Short-Circuit Chip & Sensory Anomaly |
| Controllable Range | -20° to +35° (Pitch) ±250° (Yaw) |
| Mechanical Range | -24° to +41° (Pitch) ±270° (Yaw) |
| Rotational Speed | 540°/s |
| Vibration | ±0.02° (On the platform surface with the blaster idle) |
| Latency | Connection via Wi-Fi: 80-100 ms Connection via Router: 100-120 ms NOTE: Latency times depend on environmental conditions and mobile device |
| Live View Resolution | 720p/30 FPS |
| Live View | Resolution: 720p/30 FPS Max Live View Bitrate: 6 Mb/s |
| Operating Frequencies | 2.4 GHz, 5.1 GHz, and 5.8 GHz |
| Operating Mode | Connection via Wi-Fi Connection via Router |
| Maximum Transmission Distance | Connection via Wi-Fi FCC: 2.4 GHz 55.1″ / 140.0 cm / 5.8 GHz 35.4″ / 90.0 cm CE: 2.4 GHz 55.1″ / 140.0 cm / 5.8 GHz 27.6″ / 70.0 cm SRRC: 2.4 GHz 51.2″ / 130.0 cm / 5.8 GHz 51.2″ / 130.0 cm MIC: 2.4 GHz 66.9″ / 170.0 cm / 5.1 GHz 55.1″ / 140.0 cmConnection via Router FCC: 2.4 GHz 70.9″ / 180.0 cm / 5.8 GHz 118.1″ / 300.0 cm CE: 2.4 GHz 70.9″ / 180.0 cm / 5.8 GHz 39.4″ / 100.0 cm SRRC: 2.4 GHz 70.9″ / 180.0 cm / 5.8 GHz 118.1″ / 300.0 cm MIC: 2.4 GHz 66.9″ / 170.0 cm / 5.1 GHz 70.9″ / 180.0 cm |
| Transmission Power | (EIRP) 2.400-2.4835 GHz FCC: ≤30 dBm SRRC: ≤20 dBm MIC: ≤20 dBm5.170-5.25 GHz FCC: ≤30 dBm SRRC: ≤23 dBm MIC: ≤23 dBm5.725-5.850 GHz FCC: ≤30 dBm SRRC: ≤30 dBm |
| Transmission Protocol | IEEE 802.11 a/b/g/n |
| Sensor | CMOS 1/4″ 5MP Effective Pixels |
| FOV | 120° |
| Still Image Resolution | 2560 x 1440 (Maximum) |
| Video Resolution | FHD: 1920 x 1080 30p (Maximum) HD: 1280 x 720 30p (Maximum) |
| Video Bitrate | 16 Mb/s |
| Photo Format | JPEG |
| Video Format | MP4 |
| Operating Temperature | 14 to 104°F / -10 to 40°C |
| Effective Range | Narrow Infrared Units (indoor lighting): 19.7′ / 6.0 m Wide Infrared Units (indoor lighting): 9.8′ / 3.0 m |
| Area | Between 40° to 10° (Narrow Infrared Units effective area decreases as distance from the target increases) |
| Width | 360° (indoor lighting) |
| Capacity | 2400 mAh |
| Charging Voltage | Nominal: 10.8 V Maximum: 12.6 V |
| Battery Type | Lithium-ion polymer (LiPo) 3S |
| Energy | 25.92 Wh |
| Battery Life | In Use: Up to 35 Minutes (Measured at a constant speed of 2 m/s on a flat surface) On Standby: Up to 100 Minutes |
| Charging Power Output | 29 W |
| Charging Temperature Range | 41 to 104°F / 5 to 40°C |
| Operating Temperature | 14 to 104°F / -10 to 40°C |
| Weight | 6.0 oz / 169.0 g |
| Input | 100-240 V, 50-60 Hz, 1 A |
| Output | 12.6 V=0.8 A or 12.6 V=2.2 A |
| Voltage | 12.6 V |
| Rated Voltage | 28 W |
| Speed Range | Forward: 0 to 3.5 m/s Backward: 0 to 2.5 m/s Sideways: 0 to 2.8 m/s |
| Rotation Speed | 600°/s (Maximum) |
| Dimensions (L x W x H) | 12.6 x 9.4 x 10.6″ / 32.0 x 24.0 x 27.0 cm |
| Weight | 7.3 lb / 3.3 kg |
| Other | Supports microSD cards up to 64 GB Blaster Controllable Launching Frequency: 1-8 Seconds Blaster Maximum Launching Frequency: 10 seconds Blaster Initial Launching Speed: (approximately) 26 m/s Blaster Average Load: (approximately) 430 Hit Detector Detection Requirements: For detection to be activated, the gel bead must be ≥0.2″ / 0.6 cm in diameter, launching speed must be ≥20 m/s, and the angle between the hit direction and hit detector plane must be no less than 45° Hit Detector Maximum Detection Frequency: 15 Hz Gel Bead Diameter: 0.2 x 0.3″ / 0.6 x 0.7 cm Gel Bead Weight: 0.1 oz / 0.1-0.2 g App Compatibility: iOS 9.0 or Later & Android 5.0 or Later |
| Package Weight | 11.05 lb |
| Box Dimensions (LxWxH) | 17.1 x 13.4 x 12″ |
Video
KKK
2. Make sure that the number of devices connected to router doesn’t reach the maximum value;
3. The router needs to allow communication among the linked devices;
4. The router connection does not need to do login confirmation twice.
Connection via Wi-Fi:
FCC, 2.4 GHz 140 m, 5.8 GHz 90 m
CE, 2.4 GHz 130 m, 5.8 GHz 70 m
SRRC, 2.4 GHz 130 m, 5.8 GHz 90 m
MIC, 2.4 GHz 130 m
Connection via Router:
FCC, 2.4 GHz 190 m, 5.8 GHz 300 m
CE, 2.4 GHz 180 m, 5.8 GHz 70 m
SRRC, 2.4 GHz 180 m, 5.8 GHz 300 m
MIC, 2.4 GHz 180 m
* Note: These results were achieved in an environment without signal interference or blockages. Blocked signals or signal interference will influence the transmission distance and effect. It is recommended to keep the S1 antenna as vertical as possible during use for optimal image transmission.
For Connection via Wi-Fi, the mobile device used for testing was a sixth-generation iPad (released in 2018). For Connection via Router, several router models were used for testing. FCC: TP-Link Archer C9; SRRC: TP-Link WDR8600; CE: TP-Link Archer C7; MIC: WSR-1160DHP3.
2.Gesture Recognition: the S1 can detect human gestures such as hand or arm signals and be programmed to execute custom responses.
3.S1 Robot Recognition: the S1 can detect other RoboMaster S1 units.
4.Vision Marker Recognition: the S1 can identify 44 kinds of official Vision Markers, which are comprised primarily of numbers, letters, and special characters. All of the files for these Vision Markers can be downloaded at insert web address.
5.Line Recognition: the S1 can detect and follow blue, red, and green tracks with a width of approximately 15-25 mm.
The following router brands and models are recommended:
TP-Link TL-WDR8600; TP-Link TL-WDR5640 (for users in China)
TP-Link Archer C7; NETGEAR X6S (for users outside of China)
PWM Ports: Support accessories such as steering engines, LEDs, and drivers. The PWM-pulse-signal-based mechanical arm and claw can be controlled precisely through programming, which should be coded beforehand in the Lab section of the RoboMaster app. More details can be found in the programming guide: RoboMaster S1 website -> Programming Guide -> chassis-> set the output percentage for a PWM port.
SBus Port: The RoboMaster S1 can be controlled by receiver, which supports standard SBus protocols such as a 6303SB receiver and a FUTABA controller. It is also possible to connect the S1 with external development boards and control the S1 by a program written via SBus protocol.
2.When disconnected during the updating process, the update will not be influenced because the app does not participate in the updating process. LED and voice alerts on the RoboMaster S1 will keep users informed of the update status.
2.A firmware update will fail if the internet is disconnected while the firmware kit is being downloaded.
Note: During the updating process, it is normal for the app to disconnect from the RoboMaster S1, which will not affect the update. You can reconnect the app to the S1 after the update is completed.
Programming Guide
Overview
The RoboMaster S1 lab offers hundreds of graphical programming blocks that allow you to access features like PID control, computer vision, and more. While at first this may be challenging for beginners unfamiliar with robots or basic programming, this guide includes instructions and example programs for each block to help new users develop their skills. We suggest first reading through the guide to gain a basic understanding of programming. Afterward, you can refer to it for help with any questions or challenges you encounter while programming.We hope you find this resource helpful to improving your programming skills, making the most of each block, and learning new ways to win.
The RoboMaster S1 programming lab offers five block types:
System
(1) Objective: Sets the first program executed when the robot powers on
(2) Type: Embedded block
(3) Example: Move forward 1 meter
This will control the S1 to move forward by 1 meter.
Note:
If blocks (other than event triggering blocks and function blocks) are not placed within the “Start” area, they will not be executed. For example, in the program shown below, the S1 will not be able to take a photo.
Python API:
Function: start()
Type: Main function
(1) Objective: Sets the travel mode
● Chassis Lead Mode: The gimbal follows the chassis to rotate along the yaw axis.
● Gimbal Lead Mode: The chassis follows the gimbal to rotate along the yaw axis.
● Free Mode: The gimbal and the chassis move without affecting each other.
(2) Type: Settings block
(3) Examples: Rotate with variable speeds, Rotate together, Rotate contra directionally
① Rotate with variable speeds
In Chassis Lead Mode, you will only set parameters for the chassis. When the chassis is rotating to the left or right with variable rotation speeds, check that the gimbal continuously follows the chassis and that the angle between the gimbal and the chassis front is zero when chassis motion stops.
Note:
1) Chassis Lead Mode is the S1’s default travel mode.
2) In Chassis Lead Mode, if the chassis is not rotating, the gimbal will not be able to rotate left or right on its own.
② Rotate together
In Gimbal Lead Mode, you will only set parameters for the gimbal.
When the gimbal is rotating along the yaw axis, check that the chassis also moves left and right and that it follows the gimbal to return to the original position.
Note:
In Gimbal Lead Mode, if the gimbal is not rotating, the chassis will not be able to rotate left or right on its own.
③ Rotate contra directionally
In Free Mode, the gimbal and the chassis rotate in opposite directions. In this mode, you will need to check whether the gimbal and the chassis are interfering with each other’s motion.
Note:
In free mode, the “set chassis to follow gimbal at (0) ° “and “set gimbal to follow chassis at (0)° ”blocks will not be able to take effect.
Python API:
Function: robot.set_mode(mode_enum)
Parameters:
● mode_enum(enum)
■ rm_define.robot_mode_gimbal_follow
■ rm_define.robot_mode_chassis_follow
■ rm_define.robot_mode_free
(1) Objective: Starts, pauses, or stops the timer
(2) Type: Execution block
(3) Example: Time a rotation
This measures the time it takes the chassis to complete one full rotation.
You can check details using the FPV window:
Note:
1) Selecting “Pause” will hold the time currently displayed on the timer. The timer will resume measurement from this time when it starts again.
Refer to the example below in which t1=2 and t2=5.
2) Select “Stop” to stop the timing process. The previously recorded time will be deleted, and the timer will begin measurement from zero when it starts again. You can refer to the example below in which t1=2 and t2=0.
Python API:
Function: tools.timer_ctrl(behavior_enum)
Parameters:
● behavior_enum(enum):
■ rm_define.timer_start
■ rm_define.timer_stop
■ rm_define.timer_reset
(1) Objective: Applies higher magnifications to support visual recognition over longer distances, enabling the robot to focus on unclear objects more accurately
(2) Type: Execution block
(3) Example: Enlarge camera frame
Place a Vision Marker 10 meters in front of the robot’s gimbal and set the camera magnification to 4; the robot will now be able to accurately recognize the Vision Marker at this distance.
Before running the enlarge camera frame program:
After enlarging the camera frame:
Python API:
Function: media_ctrl.zoom_value_update(value)
Parameters:
● value (int): [1, 4]
(1) Objective: Obtains the total time elapsed from when the timer first started to the current time (in seconds)
(2) Type: Information block (variable-type)
(3) Example: Time a rotation
This uses variables to measure the time it takes the chassis to complete one full rotation.
You can check details using the FPV window:
Python API:
Function: tools.timer_current()
Return value:
● time_stamp(float)
(1) Objective: Obtains the program running time (in seconds)
(2) Type: Information block (variable-type)
(3) Example: Calculate program runtime
This obtains the program running time using variables.
You can check specific details using the FPV window:
Python API:
Function: tools.run_time_of_program()
Return value:
● time (float)
(1) Objective: Acquires current time information including the year, month, day, hour, minute, and second
(2) Type: Information block (variable-type)
(3) Example: Compare time values
If the number of the current month is larger than the number of the current day, the robot will nod its head; if the number of the current month is less than or equal to the number of the current day, the robot will shake its head.
Python API:
Function: tools.get_localtime(time_enum)
Parameters:
● time_enum (enum):
■ rm_define.localtime_year
■ rm_define.localtime_month
■ rm_define.localtime_day
■ rm_define.localtime_hour
■ rm_define.localtime_minute
■ rm_define.localtime_second
Return value
● time (int)
(1) Objective: Indicates the total time elapsed from when the robot started running up to the current time (in seconds)
(2) Type: Information block (variable-type)
(3) Example: Calculate timestamp
This measures the total time elapsed from when the robot most recently started running up to the current hour, minute, and second.
You can check data changes using the FPV window.
The robot will need to take a break when program runtime reaches one hour.
(i.e., when runTime_hour＞1).
Note:
1) The start time refers to the time when the robot is powered on.
2) If the robot restarts after a power failure, it will recount the timestamp.
Python API:
Function: tools.get_unixtime()
Return value:
● time (float)
Led effects
(1) Objective: Sets the flash rate for LEDs (2 Hz = 2/s)
(2) Type: Settings block
(3) Example: Configure reverse light
This will set the rear LED of the chassis to flash red four times per second when reversing.
Python API:
Function: led_ctrl.set_flash(armor_enum, frequency)
Parameters:
● armor_enum(enum):
■ rm_define.armor_all
■ rm_define.armor_bottom_front
■ rm_define.armor_bottom_back
■ rm_define.armor_bottom_left
■ rm_define.armor_bottom_right
■ rm_define.armor_top_left
■ rm_define.armor_top_right
● frequency(int): [1, 10]
(1) Objective: Sets chassis LED colors and effects
● Solid: LED will remain steady
● Off: LED will switch off
● Pulse: LED will flicker
● Blink: LED will blink at a specified frequency
(2) Type: Execution block
(3) Example: Display streaming color effects
This will set the robot to switch off all LEDs on the chassis for one second, and then flash all LED colors in sequence.
Python API:
Function: led_ctrl.set_bottom_led(armor_enum, r, g, b, led_effect_enum)
Parameters:
● armor_enum(enum):
■ rm_define.armor_bottom_all
■ rm_define.armor_bottom_front
■ rm_define.armor_bottom_back
■ rm_define.armor_bottom_left
■ rm_define.armor_bottom_right
● r(int): [0, 255]
● g(int): [0, 255]
● b(int): [0, 255]
● led_effect_enum(enum):
■ rm_define.effect_always_on
■ rm_define.effect_always_off
■ rm_define.effect_breath
■ rm_define.effect_flash
(1) Objective: Sets gimbal LED colors and effects
● Solid: LED will remain steady
● Off: LED will switch off
● Pulse: LED will flicker
● Blink: LED will blink at a specified frequency
● Scrolling: Eight LEDs arranged in a circle will light up in clockwise direction
(2) Type: Execution block
(3) Example: Show off gimbal LED effects
This will set the robot to display all five gimbal LED effects in sequence.
Python API:
Function: led_ctrl.set_top_led(armor_enum, r, g, b, led_effect_enum)
Parameters:
● armor_enum(enum):
■ rm_define.armor_top_all
■ rm_define.armor_top_left
■ rm_define.armor_top_right
● r(int): [0, 255]
● g(int): [0, 255]
● b(int): [0, 255]
● led_effect_enum(enum):
■ rm_define.effect_always_on
■ rm_define.effect_always_off
■ rm_define.effect_breath
■ rm_define.effect_flash
■ rm_define.effect_marquee
(1) Objective: Sets the flash sequence for the gimbal LEDs; eight LEDs are located on each side of the gimbal and can be controlled independently
(2) Type: Execution block
(3) Example: Switch on a single light
This will set the robot to switch off all the gimbal LEDs, switch on the odd-numbered LEDs in ascending order, and then switch off all LEDs.
The figure below shows a counterclockwise LED arrangement.
Note:
You can choose multiple LEDs to activate simultaneously.
Python API:
Function: led_ctrl.set_signle_led(armor_enum, led_index, led_effect_enum)
Parameters:
● armor_enum(enum):
■ rm_define.armor_top_all
■ rm_define.armor_top_left
■ rm_define.armor_top_right
● index(int/list): [1, 8]
● led_effect_enum(enum):
■ rm_define.effect_always_on
■ rm_define.effect_always_off
(1) Objective: Switches off designated LEDs
(2) Type: Execution block
(3) Example: Configure signal light
This will set the robot to switch on LEDs on the right side of the gimbal before turning right; after the turn is complete, it will switch the LED off.
Python API:
Function: led_ctrl.turn_off(armor_enum)
Parameters:
● armor_enum(enum)
■ rm_define.armor_all
■ rm_define.armor_bottom_front
■ rm_define.armor_bottom_back
■ rm_define.armor_bottom_left
■ rm_define.armor_bottom_right
■ rm_define.armor_top_left
■ rm_define.armor_top_right
(1) Objective: Controls the trajectory light
(2) Type: Execution block
(3) Example: Launch the trajectory light
This will set the robot to switch on the trajectory light when firing shots.
Python API:
Function: led_ctrl.gun_on()
led_ctrl.gun_off()
Chassis
(1) Objective: Sets the output percentage for the PWM port; the larger the value used, the longer the port will maintain a high level of output over the specified time period. (The basic frequency for the PWM port is 50Hz.)
(2) Type: Settings block
(3) Examples: Turn LED on/off, Rotate navigation gear
① Turn LED on/off
This enables you to connect an LED to any PWM port and then turn the LED on or off.
② Rotate navigation gear
This enables you to connect an external navigation gear to any PWM port and then control its rotation.
Notes:
1) PWM ports are located on the chassis control module. To access them, remove the transparent cover.
There are six PWM ports in total.
2) PWM (pulse width modulation) controls the duration of a high level of output during a certain period, and is broadly used to control LEDs, navigation gears, and more.
3) For LEDs, the PWM output rate ranges from 0% to 100%, with 0% corresponding to an LED’s lowest brightness and 100% to its highest brightness.
4) For navigation gears, the PWM output rate ranges from 2.5% to 12.5%. Because most navigation gears have a control impulse frequency of 50Hz and a control period of 20 ms, and because the high-level pulse width of outputs with an adjustable angle range of -90°to 90° ranges from 0.5ms to 2.5ms, control of the navigation gear’s duty ratio ranges from 0.5/20 to 2.5/20, which is to say from 2.5% to 12.5%.
You can set the navigation gear PWM output percentage based on the rotation angles you wish to control.
Python API:
Function: chassis_ctrl.set_pwm_value(pwm_port_enum, output_percent)
Parameters:
● pwm_port_enum(enum)
■ rm_define.pwm_all
■ rm_define.pwm1
■ rm_define.pwm2
■ rm_define.pwm3
■ rm_define.pwm4
■ rm_define.pwm5
■ rm_define.pwm6
● output_percent(int): [0, 100]
(1) Objective: Enables/disables the chassis accelerator
(2) Type: Settings block
(3) Example: Operate chassis accelerator When the chassis is moving automatically, this will enable you to use the joystick to manually rotate or translate the chassis and increase its translation speed.
Notes:
1) If the “Enable chassis accelerator” block has not been added, you will not be able to manually control the chassis while running the program. After adding this block, you will be able to manually control and accelerate the robot’s movements.
2) Joystick sensitivity refers to the push range of the joystick; the joystick’s sensitivity ranges from -1 to 1.
In the image below, the virtual joystick shown on the FPV interface has reached its upper limit, meaning its sensitivity value is 1.
3) When the chassis accelerator is enabled, the programmed speed will be added to the current speed.
As the image below shows, the chassis translates at a programmed speed of 0.5 m/s. When the joystick is pushed to its limit and the chassis accelerator is enabled, the robot will add the two speeds together and translate in a forward direction at a total speed of 1.5 m/s (0.5 m/s + 1 * the joystick’s maximum speed).
Python API:
Function: chassis_ctrl.enable_stick_overlay()
chassis_ctrl.disable_stick_overlay()
(1) Objective: In Gimbal Lead Mode, maintains a specific angle for the chassis relative to the movement of the gimbal
(2) Type: Settings block
(3) Example: Gimbal Lead Mode
The angle between the chassis and the movement of the gimbal will increase at first, then eventually fall to zero.
Notes:
1)This block will not work in Chassis Lead Mode or in Free Mode.
2)A zero-degree angle between the chassis and the movement of the gimbal means that the chassis and the gimbal are rotating in the same direction along the yaw axis.
Python API:
Function: chassis_ctrl. set_follow_gimbal_offset(degree)
Parameters:
● degree(int): [-180, 180]°
(1) Objective: Sets the default translation speed of the chassis to 0.5 m/s; the chassis will move faster when set to a higher speed value.
(2) Type: Settings block
(3) Example: Reduce reversal speed
This will control the chassis to translate forward at 1 m/s for 1.5 seconds, then translate backwards at 0.5 m/s for three seconds to return to the starting point.
Note:
Please ensure there are no obstacles in the robot’s intended path before setting the chassis to a high translation speed.
Python API:
Function: chassis_ctrl.set_trans_speed(speed)
Parameters:
● speed(float): [0, 3.5] m/s
(1) Objective: Sets the default rotation speed of the chassis to 30°/s; the chassis will rotate faster when set to a higher rotation speed value.
(2) Type: Settings block
(3) Example: Set acceleration warning
As the warning LED color changes, the rotation of the chassis will accelerate.
Python API:
Function: chassis_ctrl.set_rotate_speed(speed)
Parameters:
● speed(int): [0, 600]°/s
(1) Objective: Allows each wheel’s rotation speed to be set independently; only valid combinations of rotation direction and speed will take effect.
(2) Type: Execution block
(3) Examples: Reversing in an “S” pattern, Translating in a circle
① Reversing in an “S” pattern This will control the chassis to move backwards along an S-shaped path.
② Translating in a circle
This will control the robot to translate along a circular path.
Notes:
1) The robot will translate forward at the default rotation speed of 100 rpm for the front-left wheel, 100 rpm for the front-right wheel, 100 rpm for the rear-left wheel, and 100 rpm for the rear-right wheel.
2) To determine a valid combination of wheel rotation directions and speeds, push the robot manually to move it in the desired pattern and observe the rotational direction of each wheel; the rotation speed’s value should be positive for wheels rotating forward and negative for wheels rotating backward.
For example:
When the robot translates to the right, the front-left wheel and rear-right wheel will rotate forward, so their rotation speed values should be positive, while the front-right wheel and the rear-left wheel will rotate backward, so their rotation speed values should be negative.
When the robot translates backward and to the left, the front-left wheel and the rear-right wheel will rotate backward, so their rotation speed values should be negative, while the front-right wheel and the rear-left wheel will stay still, so their rotation speed values should be zero.
When the robot rotates to the left, the front-right wheel and the rear-right wheel will rotate forward, so their rotation speed values should be positive, while the front-left wheel and the rear-left wheel will rotate backwards, so their rotation speed values should be negative.
Python API:
Function: chassis_ctrl.set_wheel_speed(lf_speed, rf_speed, lr_speed, rr_speed)
Parameters:
● lf_speed(int): [-1000, 1000] rpm
● rf_speed(int): [-1000, 1000] rpm
● lr_speed(int): [-1000, 1000] rpm
● rr_speed(int): [-1000, 1000] rpm
(1) Objective: Sets the chassis to translate in a specified direction
(2) Type: Execution block
(3) Example: Make a round trip
This will control the S1 to translate forward for one second, then turn around and return to the starting point.
Note:
This block will control the chassis to continuously translate in a specified direction until the robot receives a “set chassis to stop moving,” ”wait (1) s,“ or other command that controls it to stop.
Python API:
Function: chassis_ctrl.move(degree)
Parameters:
● degree (int): [-180, 180]°
(1) Objective: Sets the duration of time the chassis will translate in a specified direction
(2) Type: Execution block
(3) Example: Translate in an X-pattern
This will control the robot to translate to the right, forward-left, right, and backward-left in an X-shaped sequence.
Python API:
Function: chassis_ctrl.move_with_time(degree, time)
Parameters:
● degree(int): [-180, 180]°
● time(float): [0, 20] s
(1) Objective: Sets the distance the chassis will translate in a specified direction
(2) Type: Execution block
(3) Example: Translate in a cross-pattern
This will control the robot to translate forward, backward, left and right in a cross-shaped sequence.
Python API:
Function: chassis_ctrl.move_with_distance(degree, distance)
Parameters:
● degree(int): [-180, 180]°
● distance(float): [0, 5] m
(1) Objective: Sets the chassis to translate in a specified direction and at a specified speed
(2) Type: Execution block
(3) Example: Return to starting position
This sets the chassis to translate forward and to the right at 1 m/s, then translate backward and to the left at 0.5 m/s to return to the original position.
Python API:
Function: chassis_ctrl.move_degree_with_speed(speed, degree)
Parameters:
● speed(float): [0, 3.5] m/s
● degree(int): [-180, 180]°
(1) Objective: Sets the chassis to rotate in a specified direction
(2) Type: Execution block
(3) Example: Rotate at variable speed This will control the chassis to rotate increasingly quickly to the right.
Note:
1) This block is not available in Gimbal Lead Mode.
2) Be sure there are no obstacles around the robot before setting a high chassis rotation speed.
3) This block will set the chassis to rotate constantly in a specified direction until it receives a “set chassis to stop moving”,“wait (1) s” or other command that causes it to stop.
Python API:
Function: chassis_ctrl.rotate(direction_enum)
Parameters:
● direction_enum(enum):
■ rm_define.clockwise
■ rm_define.anticlockwise
(1) Objective: Sets the duration the chassis will rotate in a specified direction
(2) Type: Execution block
(3) Example: Cross-rotate the gimbal and chassis
Note:
This block is not available in Gimbal Lead Mode.
Python API:
Function: chassis_ctrl.rotate_with_time(direction_enum, time)
Parameters:
● direction_enum(enum):
■ rm_define.clockwise
■ rm_define.anticlockwise
● time(float): [0, 20] s
(1) Objective: Sets the angle and direction of chassis rotation
(2) Type: Execution block
(3) Example: Translate continuously back and forth This sets the S1 to translate back and forth continuously with the gimbal directed outward.
Note:
This block is not available in Gimbal Lead Mode.
Python API:
Function: chassis_ctrl.rotate_with_degree(direction_enum, degree)
Parameters:
● direction_enum(enum):
■ rm_define.clockwise
■ rm_define.anticlockwise
● degree(int): [0, 1800]°
(1) Objective: Sets the chassis to move in a specified direction while rotating simultaneously
(2) Type: Execution block
(3) Example: Translate in a figure-8 pattern
This sets the robot to translate in a figure-8.
Note:
The “set the robot to rotate” block is not available in Gimbal Lead Mode; however, the “set the robot to translate” block is supported in Gimbal Lead Mode.
Python API:
Function: chassis_ctrl.move_and_rotate(degree, direction_enum)
Parameters:
● degree(int): [-180, 180]°
● direction_enum(enum):
■ rm_define.clockwise
■ rm_define.anticlockwise
(1) Objective: Sets the chassis to translate in a specified direction and at a specified speed
(2) Type: Execution block
(3) Example: Translate in a circle with the gimbal aimed toward the central point
Python API:
Function: chassis_ctrl.move_with_speed(speed_x, speed_y, speed_rotation)
Parameters:
● speed_x(float): [0, 3.5] m/s
● speed_y(float): [0, 3.5] m/s
● speed_rotation(int): [-600, 600]°/s
(1) Objective: Stops all chassis movements
(2) Type: Execution block
(3) Example: Rotate chassis right
This sets the chassis to translate forward for 2 seconds at default speed, then turn right and stop moving
Python API:
Function: chassis_ctrl.stop()
(1) Objective: Obtains the current pitch angle for the chassis along its current yaw/pitch/roll axes based on the chassis location when the robot begins running
(2) Type: Information block (variable-type)
(3) Example: Signal turn
This sets the yellow LED indicator to come on when you manually control the robot to turn left, and sets the blue LED indicator to come on when you manually control the robot to turn right.
Note:
1) Rotating the chassis along the yaw axis results in left and right rotation.
2)Rotating the chassis along the pitch axis results in up and down rotation.
3) Rotating the chassis along the roll axis will cause the robot to turn over.
Python API:
Function: chassis_ctrl.get_attitude(attitude_enum)
Parameters:
● attitude_enum(enum):
■ rm_define.chassis_yaw
■ rm_define.chassis_pitch
■ rm_define.chassis_roll
Return value:
● degree(float)
(1) Objective: Obtains the current location coordinates and orientation of the chassis
(2) Type: Information block (variable-type)
(3) Example: Obtain current position information This enables you to check numerical data for the current chassis position by manually pushing the robot back and forth or turning it left and right.
You can observe numerical changes using the FPV interface.
Note:
Because the chassis is under closed-loop control, it is normal to feel some resistance when moving the robot manually.
Python API:
Function: chassis_ctrl.get_position_based_power_on(action_enum)
Parameters:
● action_enum(enum):
■ rm_define.chassis_forward
■ rm_define.chassis_translation
■ rm_define.chassis_rotate
Return value:
● position(float)
(1) Objective: Runs the program for the corresponding block when the chassis hits an obstacle while driving
(2) Type: Event block
(3) Example: Self-defend
This enables the self-defense mechanism to activate when the chassis impacts an obstacle, causing the robot to retreat and stop running the block.
Python API:
Function: def chassis_impact_detection(msg)
Type: Event callback
(1) Objective: Returns “True” when the chassis hits an obstacle while driving; otherwise, returns “False”
(2) Type: Boolean block
(3) Example: Emit danger warning If the chassis impacts an obstacle while the robot is being controlled through the FPV interface, the “hit” sound will play and all red LED indicators for the chassis and gimbal will blink; in all other scenarios,these indicators will remain on in a steadystate.
Python API:
Function:chassis_ctrl.is_impact()
Return value:
● impact_status(bool)
Gimbal
(1) Objective: Enables/disables the gimbal accelerator
(2) Type: Settings block
(3) Example: Activate semi-automatic defense
This allows you to use the FPV interface to manually control the gimbal’s rotation for aiming and firing, while the robot’s chassis continuously rotates left and right.
Python API:
Function: gimbal_ctrl.enable_stick_overlay()
gimbal_ctrl.disable_stick_overlay()
(1) Objective: Allows the gimbal to maintain a specific angle according to the chassis’ movement in Chassis Lead Mode
(2) Type: Settings block
(3) Example: Chassis Lead Mode
This will set the gimbal to turn 45 degrees clockwise, and then 90 degrees counterclockwise before returning to the center when the chassis is stationary.
Note:
1)This block is not available in Gimbal Lead Mode or Free Mode.
2) A zero-degree angle indicates that the gimbal and chassis are translating in the same direction along the yaw axis.
3) This is an alternative way to control the gimbal’s to left and right rotation.
Python API:
Function: gimbal_ctrl.set_follow_chassis_offset(degree)
Parameters:
● degree(int): [-180, 180]°
(1) Objective: Sets default gimbal rotation speed to 30°/s; the higher the value, the quicker the rotation
(2) Type: Settings block
(3) Example: Rotate with variable speeds This will set the chassis to rotate clockwise with the gimbal as it gradually increases its speed.
Note:
Before increasing the gimbal’s rotation speed, ensure that there are no obstacles near the robot.
Python API:
Function: gimbal_ctrl.set_rotate_speed(speed)
Parameters:
● speed(float): [0, 540]°/s
(1) Objective: Sets gimbal movements
● Recenter: The gimbal will return to its original position along the pitch axis and yaw axis.
● Stop: The gimbal will stop translating but can still be controlled.
● Sleep: The gimbal will go to sleep.
● Wake: The gimbal will power on again.
(2) Type: Execution block
(3) Example: Wake gimbal up, Hovering
① Wake gimbal up
In Sleep Mode, there is no power from the motor, so the gimbal can be translated freely by hand. When the gimbal wakes up, it will power on again and rotate to its designated position before returning to center.
Note:
In Chassis Lead Mode, “set gimbal to recenter” is not available.
②Hovering
This will set the gimbal to rotate upward for 0.5 second, then pause for 2 seconds. It will then rotate downward for 0.5 second, then return to its original position and stop translating.
Python API:
Function: gimbal_ctrl.recenter()
gimbal_ctrl.stop()
gimbal_ctrl.suspend()
gimbal_ctrl.resume()
(1) Objective: Sets a specific rotation direction for the gimbal
(2) Type: Execution block
(3) Example: Rotate chassis and gimbal in opposite directions
Note:
1) In Chassis Lead Mode, only the “set gimbal to rotate (up/down)” block is available; the “set gimbal to rotate (left/right)” block is not available.
2) This block sets the gimbal to constantly rotate to a specific direction until it receives a command such as “set gimbal to stop”, “wait (1)s”and so on.
Python API:
Function: gimbal_ctrl.rotate(direction_enum)
Parameters:
● direction_enum(enum):
■ rm_define.gimbal_up
■ rm_define.gimbal_down
■ rm_define.gimbal_left
■ rm_define.gimbal_right
(1) Objective: Sets the gimbal to rotate at a specific angle and direction
(2) Type: Execution block
(3) Example: Gimbal rotation
This will set the gimbal to rotate left or right with the selected sound effect.
Note:
In Chassis Lead Mode, only the “set gimbal to rotate (up/down) in (0)°” block is available; the “set gimbal to rotate (left/right) in (0)°” block is not available.
Python API:
Function: gimbal_ctrl.rotate_with_degree(direction_enum, degree)
Parameters:
● direction_enum(enum):
■ rm_define.gimbal_up
■ rm_define.gimbal_down
■ rm_define.gimbal_left
■ rm_define.gimbal_right
● degree(int): [0, 55]°
(1) Objective: Sets the gimbal to rotate along yaw axis to a designated position
(2) Type: Execution block
(3) Example: Configure rear gun
This will set the chassis to translate forward while the gimbal continuously fires shots behind it.
Note:
1) In Chassis Lead mode this block is not available.
2) The gimbal will rotate left and right along the yaw axis and up and down along the pitch axis.
Python API:
Function: gimbal_ctrl.yaw_ctrl(degree)
Parameters:
● degree(int): [-250, 250]°
(1) Objective: Sets the gimbal to rotate along pitch axis to a designated position
(2) Type: Execution block
(3) Examples: Simulate the power on process, Follow arrow markers
①Simulate power on process
This will simulate the power on process for the robot.
②Follow arrow markers
Note:
The gimbal will rotate up and down along the pitch axis and left and right along the yaw axis.
Python API:
Function: gimbal_ctrl.pitch_ctrl(degree)
Parameters:
● degree(int): [-20, 35]°
(1) Objective: Sets the gimbal to rotate at a specific angle at a designated position
(2) Type: Execution block
(3) Example: Tiered firing
Note:
1)In Chassis Lead Mode, the “set gimbal to rotate along pitch axis to (0)°” block is available but the “set gimbal to rotate along yaw axis to (0)°” block is not.
2)
”set gimbal to rotate (up) in (0)°” refers to the position relative to the gimbal’s current position.
3)
“set gimbal to rotate along yaw axis to (0)°”、“set gimbal to rotate along pitch axis to (0)°”、“set gimbal to rotate along yaw axis to (0)°, and pitch axis to (0)°” refers to the absolute position based on the chassis’ current location.
Python API:
Function: gimbal_ctrl.angle_ctrl(yaw_degree, pitch_degree)
Parameters:
● yaw_degree (int): [-250, 250]°
● pitch_degree (int): [-20, 35]°
(1) Objective: Sets the gimbal to rotate on its yaw and pitch axis simultaneously at a specified rotation speed
(2) Type: Execution block
(3) Example: Flexible neck rotation
Note:
The value of the rotation speed represents the gimbal’s rotation direction.
At the yaw axis, a positive value indicates right rotation, and a negative value indicates left rotation.
At the pitch axis, a positive value indicates upward rotation, and a negative value indicates downward rotation.
Python API:
Function: gimbal_ctrl.rotate_with_speed(yaw_speed, pitch_speed)
Parameters:
● yaw_speed(float): [-360, 360]°/s
● pitch_speed(float): [-360, 360]°/s
(1) Objective: Obtains the current attitude angle for the gimbal along its current yaw or pitch axes
(2) Type: Information block (variable-type)
(3) Example: Translate in the gimbal’s direction
This will set the gimbal to aim towards a specific direction. The robot will translate towards the specified direction for one second after the gimbal is pressed.
Python API:
Function: gimbal_ctrl.get_axis_angle(axis_enum)
Parameters:
● axis_enum (enum):
■ rm_define.gimbal_axis_yaw
■ rm_define.gimbal_axis_pitch
Return value:
● degree(int)
You may also like…
Related products
