1. Jumper: Rise Of Robots Mac Os 11
2. Jumper: Rise Of Robots Mac Os X
3. Jumper: Rise Of Robots Mac Os Catalina
4. Jumper: Rise Of Robots Mac Os 13

If you plan to install Mac within your PC, you get two easy alternatives over the method; you can directly install the operating system; Mac OS X on your driver or, utilize a Mac emulator concerning Windows. The first stated alternative would provide you with great performance yet, the other one is very easy to go with. The Incredibles: Rise of the Underminer is a 2005 action-adventure video game which serves as an alternative sequel to the animated film The Incredibles (2004) as well as its associated video game tie in. Incredible and Frozone fighting The Underminer's legion of robot minions. The game features cameo appearances by the rest of.

• Apr 13, 2021 You can find frantic shooters, low-key indies, grand strategy behemoths, and much more for your Mac. Here are the best Mac games you should have in 2021.
• New open-source app extracts passwords stored in Mac OS X keychain Proof-of-concept Keychaindump extracts passwords for all logged-in users. Dan Goodin - Sep 6, 2012 3:04 pm UTC.
• Bot development halted for now (but it's still usable) It seems it's not clear enough, but this bot is a personal project, not for commercial use, you have to tweak it yourself, I just give you enough information about it so you can setup and tweak/develop it yourself.

This is the home page of the textbook 'Modern Robotics: Mechanics, Planning, and Control,' Kevin M. Lynch and Frank C. Park, Cambridge University Press, 2017, ISBN 9781107156302. Purchase the hardback through Amazonor through Cambridge University Press, or check out the free preprint version below.

New! You can purchase the Chinese translation of the book.

From the foreword:

'Frank and Kevin have provided a wonderfully clear and patient explanation of their subject.' Roger Brockett, Harvard University

'Modern Robotics imparts the most important insights of robotics .. with a clarity that makes it accessible to undergraduate students.' Matthew T. Mason, Carnegie Mellon University

From the IEEE Control Systems Magazine book review:Dead run (sokpop collective) mac os.

'It is the pedagogical strength of this book that concepts from Lie group theory (which form the building blocks of modern kinematics) are presented in a way that will appeal to undergraduate students as well as to researchers and roboticists in general. .. For some time, this approach was deemed too complicated to be taught in undergraduate robotics classes. However, this book by Lynch and Park should change the conventional wisdom on this issue. .. With its consolidated modern approach, Modern Robotics is destined to become a classic in the field.' Andreas Mueller, Johannes Kepler University, Austria

Book, Practice Exercises, and Linear Algebra Review

Purchase the hardback through Amazonor through Cambridge University Press, or check out the free preprint version below. You can also purchase the Chinese version of the book.

The current version of the book is the updated first edition (online preprint dated December 2019, printed published version from Cambridge marked '3rd printing 2019' or later). The updated first edition (also referred to as 'version 2') includes several corrections and minor additions to the original first edition (first published in May 2017).

This book is the result of course notes developed over many years for the course M2794.0027 Introduction to Robotics at Seoul National University and ME 449 Robotic Manipulation at Northwestern University. The evolving course notes have been posted on the internet for years to support these classes.

The for-purchase version of the book from Cambridge University Press has improved layout and typesetting, updated figures, different pagination (and fewer pages), and more careful copyediting, and it is considered the 'official' version of the book. But the online preprint version of the book has the same chapters, sections, and exercises, and it is quite close in content to the Cambridge-published version.

We are posting four versions of the book. All versions have exactly the same contents and pagination. They differ only in the sizes of the margins and the size of the print, as manipulated in Adobe Acrobat after latex'ing. Two of the versions have working hyperlinks for navigating the book on your computer or tablet.

With working hyperlinks. (To navigate the book using the hyperlinks, click on the hyperlink. To go back where you came from, choose the button or keystroke appropriate to your pdf reader. For example, on the Mac with Acrobat or Acrobat Reader, use cmd-left arrow. With Preview on the Mac, use cmd-[. Some readers on other operating systems use alt-left arrow. You can google to see which solution works for your pdf reader.)

• Default 8.5x11 or A4 version. Printable version with 10 pt font and large margins.
• Tablet version. Margins have been eliminated so that no space is wasted when viewing the document on a computer or tablet.

Printable versions without working hyperlinks.

• Large font 8.5x11 or A4 version. Printable version with 12 pt font equivalent and smaller margins than the 10 pt default version.
• 2up version. Printable version with 2 book pages per page, for saving paper if you have good eyes. Approximately 8.5 pt font equivalent.

These files have been compressed to about 7 MB. Let us know if you have any problems reading them. Please note that some versions of the default Mac OS X pdf reader, Preview, are known to have bugs displaying certain images in pdf files. If a figure is not appearing properly, please try a better pdf viewer, like Acrobat Reader.

Table of Contents:

1. Preview
2. Configuration Space
3. Rigid-Body Motions
4. Forward Kinematics
5. Velocity Kinematics and Statics
6. Inverse Kinematics
7. Kinematics of Closed Chains
8. Dynamics of Open Chains
9. Trajectory Generation
10. Motion Planning
11. Robot Control
12. Grasping and Manipulation
13. Wheeled Mobile Robots

Appendix A. Summary of Useful Formulas

Appendix B. Other Representations of Rotations

Appendix C. Denavit-Hartenberg Parameters

Appendix D. Optimization and Lagrange Multipliers

Practice Exercises and Linear Algebra Review

• Practice exercises
  • Practice exercises to give you more experience with the material. These practice exercises come with solutions, since Cambridge makes the end-of-chapter solutions available to instructors only.
  • 2017 exams from Seoul National University, with solutions.
  • 2018 exams from Seoul National University, with solutions.
  • 2019 exams from Seoul National University, with solutions.
  • 2020 exams from Seoul National University, with solutions.

Videos

• Click here to watch the video lectures embedded in a convenient viewing environment.
• Click here if you prefer to watch the videos within the YouTube environment.

Videos are made with Northwestern's Lightboard. We have used this tool in the past to make the mechatronics videos at http://nu32.org.

You can see an excellent collection of robotics videos at the Springer Handbook of Robotics Multimedia Extension. Also check out the Robot Academy at Queensland University of Technology.

Slides for Classroom or Online Teaching

You can download summary slides for classroom teaching, covering much of the material in Chapters 2, 3, 4, 5, 6, 8, 9, 11, and 13. (In my current class, I (Lynch) do not have time to cover any material from Chapters 7, 10, and 12, nor parts of the material from Chapters 8, 11, and 13.) These slides are summaries only, leaving out full derivations, and they are used in class after students have watched the videos on their own time. (In my class, students also complete lecture comprehension problems on Coursera before attending the live class.)

I project the slides in powerpoint and write on them using powerpoint's 'Draw' function and a Wacom One tablet during class. Writing on the slides helps with pacing and makes the class more interactive. In the first part of class I review the material from the videos and reading, perhaps asking questions of the whole class. At the end of most slide decks, there are rather simple conceptual problems for small-group discussion. No computers or difficult calculation needed. These discussions, which may take place via breakout rooms on Zoom, are to encourage student engagement with the material. After the small-group discussions, we reconvene to share our answers.

Each slide deck is meant to roughly correspond to one 50-minute class, but some classes have more material than others. In some classes, more discussion time would be helpful. In others, class ends a bit early.

The slides are available in two formats, pdf and powerpoint. For each format, there are 'original' slides and 'edited' slides. I distribute the 'original' slides as pdfs to the students in advance of class, and I write on these slides (in powerpoint) during class to produce the 'edited' slides. If you decide to use the slides this way, you can look at the 'edited' versions of the slides for ideas of what you could write on the 'original' slides.

Before class, I add translucent white boxes (95% opacity) to cover up some of the material on particularly busy slides. Then, as I teach, I delete the white boxes when it is time to discuss that material. Covering up material that we are not yet discussing helps students focus on the parts of the slide I am currently talking about. I prefer this alternative to the option of turning a single busy slide into a several-slide sequence, giving the final file an artificially large number of pages.

Solution Manual

If you are an instructor, you can obtain a copy of the exercise solutions from Cambridge University Press. Go to the 'Resources' section of the Cambridge University Press webpage for the book.

Prerequisites

This book was written to be accessible to engineering students after taking typical first-year engineering courses. The student should have an understanding of:

• freshman-level physics, including f = ma; free-body diagrams with masses, springs, and dampers; vector forces; and vector torques (or moments) as the cross product of a distance vector and a force;
• linear algebra, including matrix operations, positive definiteness of a matrix, determinants, complex numbers, eigenvalues, and eigenvectors;
• some calculus, derivatives, and partial derivatives; and
• basic linear ordinary differential equations.

The student should also be prepared to program, but only basic programming skills are needed. Code is provided in python (freely available), MATLAB (for purchase, or you could use the freely available GNU Octave clone), and Mathematica (for purchase), so those languages are preferred.

Errata

Software

The software accompanying the book is written in Mathematica, MATLAB, and Python. It is written to be educational and to reinforce the concepts in the book, not to be as computationally efficient or robust as possible.

The origin of the software is student solutions to homework exercises. A major update was committed in January 2017, correcting some bugs in the earlier version.

Simulation

We have found the CoppeliaSim robot simulation environment (formerly known as V-REP) to be a valuable learning tool accompanying the book. It is free for educational use and cross platform. In ME 449 at Northwestern, we use it to experiment with the kinematics of different robots and to animate solutions to inverse kinematics, dynamic simulations, and controllers.

This page gets you started with CoppeliaSim quickly.

This page provides 'scenes' that allow you to interactively explore the kinematics of different robots (e.g., the Universal Robots UR5 6R robot arm and the KUKA youBot mobile manipulator) and to animate trajectories that are the results of exercises in chapters on kinematics, dynamics, and control.

Online Courses

Modern Robotics is now available as a MOOC (massive open online course) Specialization on Coursera!

This is a link to the Specialization home page. The Specialization consists of six short courses, each expected to take approximately four weeks of approximately five hours of effort per week: Konami slots free chips codes.

This page collects together some of the supplemental material used in the Coursera MOOCs.

The material in Modern Robotics also forms the basis for two edX online courses. These courses were created before the book was finished, so some of the notation used is a bit different from that used in the book.

Using the Online Course Materials in a Traditional Classroom Course

If you are using the book in a traditional university setting, you can ask your students to sign up for the relevant courses on Coursera (see above). They can audit the courses, so they don't have to pay. They will have access to the video lectures and to the video comprehension questions that follow each video lecture. They will also have access to discussion forums. (They won't have access to graded tests and peer-graded assignments, which require paying the Coursera fee.) If students watch the videos and do the reading before class, you can spend class time working on example problems, homework problems, or discussing points where confusion arises, rather than delivering a traditional lecture.

Supplemental Information

• UR5 parameters you can use for dynamic simulations (note: the values are not exact, and do not account for the effect of gearing at the joints)
• The UR5 URDF file from Chapter 4 of the book (.pdf format or .txt format). For learning purposes only, not actual use; it contains only kinematic and inertial properties, and does not fully account for the effects of gearing. This file is based on the UR5 URDF from the ROS-Industrial team.
• Peter Corke's excellent Robotics Toolbox for MATLAB and other robotics software linked to from his site.
• Open-source software for time-optimal time scaling (Chapter 9.4), courtesy of Quang-Cuong Pham.

About the Authors

Kevin M. Lynch is Professor and Chair of the Mechanical Engineering Department at Northwestern University. He is director of the Center for Robotics and Biosystems and a member of the Northwestern Institute on Complex Systems. His research focuses on dynamics, motion planning, and control for robot manipulation and locomotion; self-organizing multi-agent systems; and physically interacting human-robot systems.

He is Editor-in-Chief of the IEEE Transactions on Robotics, former Editor-in-Chief of the IEEE International Conference on Robotics and Automation Conference Editorial Board, and a former Editor of the IEEE Transactions on Robotics, the IEEE Robotics and Automation Letters, and the IEEE Transactions on Automation Science and Engineering. He is a co-author of The Principles of Robot Motion (MIT Press, 2005) and Embedded Computing and Mechatronics with the PIC32 Microcontroller (Elsevier, 2015), an IEEE fellow, and the recipient of the IEEE Early Career Award in Robotics and Automation, Northwestern's Professorship of Teaching Excellence, and the Northwestern Teacher of the Year award in engineering. He earned a BSE in Electrical Engineering from Princeton University and a PhD in Robotics from Carnegie Mellon University.

Frank C. Park received his BS in electrical engineering from MIT and his PhD in applied mathematics from Harvard University. From 1991 to 1995 he was assistant professor of mechanical and aerospace engineering at the University of California, Irvine. Since 1995 he has been professor of mechanical and aerospace engineering at Seoul National University, where he is currently chair of the department. His research interests are in robot mechanics, planning and control, vision and image processing, and related areas of applied mathematics. He has been an IEEE Robotics and Automation Society Distinguished Lecturer, and received best paper awards for his work on visual tracking and parallel robot design. He has served on the editorial boards of the Springer Handbook of Robotics, Springer Advanced Tracts in Robotics (STAR), Robotica, and the ASME Journal of Mechanisms and Robotics. He has held adjunct faculty positions at the HKUST Robotics Institute, NYU Courant Institute, and the Interactive Computing Department at Georgia Tech. In 2014 he received the Seoul National University Teaching Excellence Award. He is a fellow of the IEEE, former Editor-in-Chief of the IEEE Transactions on Robotics, and developer of the edX courses Robot Mechanics and Control I, II.

Mechatronics

Modern Robotics is written at the system level: you learn about the kinematics, dynamics, motion planning, and control of an entire robot system. If you would like to learn more about the details of implementation, e.g., joint-level feedback control, driving motors (including brushed, brushless, steppers, and servos), gearing, sensors, signal processing, etc., check out Embedded Computing and Mechatronics by Lynch, Marchuk, and Elwin, Elsevier 2015.

• 1Hardware
• 2Getting Started
  • 2.5Finding the USB serial ports used
  • 2.6PC interface
  • 2.7Installing the dependencies for firmwares updates
• 3Main microcontroller
• 4Radio module
• 5Programmer
  • 5.2Firmware update

Overview

The following figures show the main components offered by the e-puck2 robot and where they are physically placed:

Specifications

The e-puck2 robot maintains full compatibility with its predecessor e-puck (e-puck HWRev 1.3 is considered in the following table):

This is the overall communication schema:

Documentation

• Main microcontroller: STM32F407, datasheet, reference-manual
• Programmer/debugger: STM32F413, datasheet, reference-manual
• Radio module: Espressif ESP32, datasheet, reference-manual
• Camera: PixelPlus PO8030D CMOS image sensor, datasheet, no IR cut filter

From about July 2019, the camera mounted on the e-puck2 robot is the Omnivision OV7670 CMOS image sensor, datasheet

• Microphones: STM-MP45DT02, datasheet
• Optical sensors: Vishay Semiconductors Reflective Optical Sensor, datasheet
• ToF distance sensor: STM-VL53L0X, datasheet, user-manual
• IMU: InvenSense MPU-9250, product-specification, register-map
• Motors: details
• Speaker: Diameter 13mm, power 500mW, 8 Ohm, DS-1389 or PSR12N08AK or similar
• IR receiver: TSOP36230

Migrating from e-puck1.x to e-puck2

The e-puck2 robot maintains full compatibility with its predecessor e-puck, but there are some improvements that you should be aware of.

First of all the e-jumper, that is the small board that is attached on top of the e-puck1.x, isn't anymore needed in the e-puck2. The components available on the e-jumper are integrated directly in the robot board. On top of the e-puck2 you'll see a quite big free connector, this is used to attach the extensions board designed for the e-puck1.x that are fully compatible with the e-puck2; you must not connect the e-jumper in this connector.

Secondly you don't need anymore to unplug and plugin the battery for charging, but instead you can charge the battery (up to 1 ampere) directly by connecting the USB cable. If you want you can still charge the battery with the e-puck1.x external charger, in case you have more than one battery.

Moreover you don't need anymore a special serial cable (with probably an RS232 to USB adapter) to be able to communicate with the robot, but you can use the USB cable. Once connected to the computer a serial port will be available that you can use to easily exchange data with the robot.

Extensions

All the extensions (ground sensors, range and bearing, RGB panel, gumstix and omnvision) are supported by the e-puck2 robot, this means that if you have some extensions for the e-puck1.x you can still use them also with e-puck2.
For more information about using the gumstix extension with e-puck2 robot refer to http://www.gctronic.com/doc/index.php?title=Overo_Extension#e-puck2.

The e-puck2 robot features 3 chips onboard:

• the main microcontroller, that is responsible for handling the sensors and actuators and which runs also the demos/algorithms
• the programmer, that provides programming/debugging capabilties and moreover it configures the USB hub and is responsible for the power management (on/off of the robot and battery measure)
• radio module, that is responsible for handling the wireless communication (WiFi, BLE, BT), the RGB LEDs and the user button (the RGB LEDs and button are connected to the radio module due to the pin number limitation on the main microcontroller)

The robot is shipped with the last firmware version programmed on all 3 chips, so you can immediately start using the robot.
The following sections explain the basic usage of the robot, all the users should read this chapter completely in order to have a minimal working system ready to play with the e-puck2 robot. Some sections will have more detailed information that can be read by following the links provided.

When required, dedicated informations are given for all platforms (Windows, Linux, Mac). The commands given for Linux are related to the Ubuntu distribution, similar commands are available in other distributions.

Turn on/off the robot

To turn on the robot you need to press the power button (blue button) placed on the bottom side of the board, near the speaker, as shown in the following figures:

To turn off the robot you need to press the power button for 1 second.

Meaning of the LEDs

The e-puck2 has three groups of LEDs that are not controllable by the user. Sizzling hot deluxe online.

Top view of the e-puck2

• Charger: RED if charging, GREEN if charge complete and RED and GREEN if an error occurs
• USB: Turned ON if the e-puck2 detects a USB connection with a computer
• STATUS: Turned ON if the robot is ON and OFF if the robot is OFF. When ON, gives an indication of the level of the battery. Also blinks GREEN if the program is running during a debug session.

Battery level indications (STATUS RGB LED):

• GREEN if the system's tension is greater than 3.5V
• ORANGE if the system's tension is between 3.5V and 3.4V
• RED if the system's tension is between 3.4V and 3.3V
• RED blinking if the system's tension is below 3.3V

The robot is automatically turned OFF if the system's tension gets below 3.2V during 10 seconds.

Connecting the USB cable

A micro USB cable (included with the robot in the package) is needed to connect the robot to the computer. There are two connectors, one placed on top of the robot facing upwards and the other placed on the side of the robot, as shown in the following figures. Both can be used to charge the robot (up to 1 ampere) or to communicate with it, but do not connect two cables at the same time. Connect the USB cable where is more comfortable to you.

Installing the USB drivers

The USB drivers must be installed only for the users of a Windows version older than Windows 10:

1. Download and open zadig-2.3.exe
2. Connect the e-puck2 with the USB cable and turn it on. Three unknown devices appear in the device list of the program, namely e-puck2 STM32F407, e-puck2 GDB Server (Interface 0) and e-puck2 Serial Monitor (Interface 2).
3. For each of the three devices mentioned above, select the USB Serial (CDC) driver and click on the Install Driver button to install it. Accept the different prompts which may appear during the process. At the end you can simply quit the program and the drivers are installed. These steps are illustrated on Figure 3 below.

Note : The drivers installed are located in C:Users'your_user_name'usb_driver

Example of driver installation for e-puck2 STM32F407

The drivers are automatically installed with Windows 10, Linux and Mac OS.

Anyway in Linux in order to access the serial ports, a little configuration is needed. Type the following command in a terminal session: sudo adduser $USER dialout. Once done, you need to log off to let the change take effect.

Finding the USB serial ports used

Two ports are created by the e-puck2's programmer when the USB cable is connected to the robot (even if the robot is turned off):

• e-puck2 GDB Server. The port used to program and debug the e-puck2.
• e-puck2 Serial Monitor. Serial communication between the PC and the radio module (used also to program the radio module).

A third port could be available depending on the code inside the e-puck2's microcontroller. With the factory firmware a port named e-puck2 STM32F407 is created.

Windows

1. Open the Device Manager
2. Under Ports (COM & LPT) you can see the virtual ports connected to your computer.
3. Do a Right-click -> properties on the COM port you want to identify.
4. Go under the details tab and select Bus reported device description in the properties list.
5. The name of the port should be written in the text box below.
6. Once you found the desired device, you can simply look at its port number (COMX).

Linux

1. Open a terminal window (ctrl+alt+t) and enter the following command: ls /dev/ttyACM*

2. Look for ttyACM0 and ttyACM1 in the generated list, which are respectively e-puck2 GDB Server and e-puck2 Serial Monitor. ttyACM2 will be also available with the factory firmware, that is related to e-puck2 STM32F407 port

Note : Virtual serial port numbering on Linux depends on the connections order, thus it can be different if another device using virtual serial ports is already connected to your computer before connecting the robot, but the sequence remains the same.

Mac

1. Open a terminal window and enter the following command: ls /dev/cu.usbmodem*

2. Look for two cu.usbmodemXXXX, where XXXX is the number attributed by your computer. You should find two names, with a numbering near to each other, which are respectively e-puck2 GDB Server (lower number) and e-puck2 Serial Monitor (higher number). A third device cu.usbmodemXXXX will be available with the factory firmware, that is related to e-puck2 STM32F407 port

Note : Virtual serial port numbering on Mac depends on the physical USB port used and the device. If you want to keep the same names, you must connect to the same USB port each time.

PC interface

A PC application was developed to start playing with the robot attached to the computer via USB cable: you can have information about all the sensors, receive camera images and control the leds and motors.
Beware that it's not mandatory to download this application in order to work with the robot, but it is a nice demo that gives you an overview of all the sensors and actuators available on the robot, this is a first step to gain confidence with the robot.

With the factory firmwares programmed in the robot, place the selector in position 8, attach the USB cable and turn on the robot. Enter the correct port (the one related to e-puck2 STM32F407) in the interface and click connect.

The source code is available from the repository https://github.com/e-puck2/monitor.

Available executables

• Windows executable: tested on Windows 7 and Windows 10

On Linux remember to apply the configuration explained in the chapter Installing the USB drivers in order to access the serial port.

Installing the dependencies for firmwares updates

You can update the firmware for all 3 chips: the main microcontroller, the radio module and the programmer. For doing that, you need some tools to be installed on the system.

Windows

To upload a new firmware in the microcontroller or in the radio module, you don't need to install anything, the packages provided include all the dependencies.

To upload a new firmware in the programmer you need to install an application called DfuSe released by STMicroelectronics. You can download it from DfuSe_V3.0.5.zip.

Linux

To upload a new firmware in the microcontroller or in the radio module, you need:

• Python (>= 3.4): sudo apt-get install python3
• Python pip: sudo apt-get install -y python3-pip
• pySerial (>= 2.5): sudo pip3 install pyserial

Jumper: Rise Of Robots Mac Os 11

To upload a new firmware in the programmer you need:

• dfu-util: sudo apt-get install dfu-util

Mac

Install the Homewbrew package manager by opening a terminal and issueing:
/usr/bin/ruby -e '$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)'
and then:
brew upgrade

To upload a new firmware in the microcontroller or in the radio module, you need:

• Python (>= 3.4): brew install python (it will install also pip)
• pySerial (>= 2.5): pip3 install pyserial

To upload a new firmware in the programmer you need:

• dfu-util: brew install dfu-util

PC side development

This section is dedicated to the users that develop algorithms on the PC side and interact with the robot remotely through a predefined communication protocol. These users don't modify the firmware of the robot, but instead they use the factory firmware released with the robot. They update the robot firmware only when there is an official update.
The remote control of the robot, by receiving sensors values and setting the actuators, is done through the following channels: Bluetooth, Bluetooth Low Energy, WiFi, USB cable.
Examples of tools/environment used by these users:

1. Aseba
2. Simulator (e.g. Webots)
3. ROS
4. iOS, Android apps
5. Custom PC application
6. IoT (e.g. IFTTT)

If you fall into this category, then follow this section for more information: PC side development.

The e-puck2 robot main microcontroller is a 32-bit STM32F407 that runs at 168 MHz (210 DMIPS) and include DSP, FPU and DMA capabilities. The version chosen for the e-puck2 has 192 KB of total RAM and 1024 KB of flash, so there is a lot of memory to work with.
This chip is responsible for handling the sensors and actuators and runs also the demos and algorithms.

Factory firmware

The main microcontroller of the robot is initially programmed with a firmware that includes many demos that could be started based on the selector position, here is a list of the demos with related position and a small description:

• Selector position 0: Aseba
• Selector position 1: Shell
• Selector position 2: Read proximity sensors and when an object is near a proximity, turn on the corresponding LED
• Selector position 3: Asercom protocol v2 (BT)
• Selector positoin 4: Range and bearing extension (receiver)
• Selector position 5: Range and bearing extension (transmitter)
• Selector position 6: Move the robot back and forth exploiting the gyro, with LEDs animation
• Selector position 7: Play a wav (mono, 16 KHz) named 'example.wav' from the micro sd when pressing the button
• Selector position 8: Asercom protocol v2 (USB)
• Selector position 9: Local communication: transceiver
• Selector position 10: this position is used to work with the Linux extensions. To work with gumstix refer to Overo Extension: e-puck2 , to work with Pi-puck refer to Pi-puck: Requirements .
• Selector position 11: Simple obstacle avoidance + some animation
• Selector position 12: Hardware test
• Selector position 13: LEDs reflect orientation of the robot
• Selector position 14: Compass
• Selector position 15: WiFi mode

The pre-built firmware is available here main microcontroller factory firmware (11.01.21).

Firmware update

Now and then there could be an official firmware update for the robot and it's important to keep the robot updated with the last firmware to get possibile new features, improvements and for bug fixes.
The onboard programmer run a GDB server, so we use GDB commands to upload a new firmware, for this reason a toolchain is needed to upload a new firmware to the robot.
The following steps explain how to update the main microcontroller firmware:
1. Download the package containing the required toolchain and script to program the robot: Windows, Linux 32 bits/64 bits, Mac OS
2. Download the last version of the main microcontroller factory firmware (11.01.21), or use your custom firmware
3. Extract the package and put the firmware file (with elf extension) inside the package directory; beware that only one elf file must be present inside this directory
4. Attach the USB cable and turn on the robot
5. Run the script from the package directory:

Windows: double click program.bat

Linux/Mac: issue the following command in a terminal ./program.sh. If you get permission errors, then issue sudo chmod +x program.sh to let the script be executable.

When the upload is complete you'll see an output like in the following figure:
The final lines should contain the entry '.data',, this means that the upload was successfull. You can then close the terminal window if it is still open.

If you encounter some problem, try to unplug and plug again the USB cable and power cycle the robot, then retry.

Robot side development

If you are an embedded developer and are brave enough, then you have complete access to the source code running on the robot, so you can discover what happen inside the main microcontroller and modify it to accomodate your needs. Normally the users that fall into this category develop algorithms optimized to run directly on the microcontroller, such as:

1. onboard image processing
2. swarm algorithms
3. fully autonomous behaviors
4. ..

For more information about programming the robot itself, refer to section Robot side development

The radio module chosen for the e-puck is the new ESP32 chip from Espressif, integrating a dual core that run up to 240 MHz, 4 MB of flash and 520 KB of RAM. It supports WiFi standards 802.11 b/g/n (access point mode supported), Bluetooth and Bluetooth LE 4.2. It is the successor of the ESP8266 chip. The following figure shows the various peripherals available on the ESP32:

This chip first of all is responsible for handling the wireless communication, moreover it handles also the RGB LEDs (with PWM) and the user button. The RGB LEDs and button are connected to the radio module due to the pin number limitation on the main microcontroller.

Factory firmware

The radio module of the robot is initially programmed with a firmware that supports Bluetooth communication.
The pre-built firmware is available here radio module factory firmware (11.12.18).

WiFi firmware

At the moment the factory firmware supports only Bluetooth, if you want to work with WiFi you need to program the radio with a dedicated firmware, refer to section PC side development: WiFi.

BLE firmware

At the moment the factory firmware supports only calssic Bluetooth, if you want to work with Bluetooth Low Energy you need to program the radio with a dedicated firmware, refer to section Mobile phone development.

Firmware update

In order to update the firmware of the ESP32 WiFi module you need to use a python script called esptool provided by Espressif (manufacturer of the chip). This script was modified to work with the e-puck2 robot and is included in the provided package. The following steps explain how to update the radio module firmware:
1. Download the package containing the required tools and script to program the robot: Windows, Linux / Mac
2. Download the last version of the radio module factory firmware (11.12.18), or use another firmware (e.g. WiFi, BLE, your own). The firmware is composed by 3 files named bootloader.bin, ESP32_E-Puck_2.bin and partitions_singleapp.bin
3. Extract the package and put the firmware files inside the package directory; beware that the name of the .bin files must be the same as indicated in step 2
4. Attach the USB cable and turn on the robot
5. Run the script from the package directory:

Windows: double click program.bat

Linux/Mac: issue the following command in a terminal ./program.sh. If you get permission errors, then issue sudo chmod +x program.sh to let the script be executable.

The upload should last about 10-15 seconds and you'll see the progress as shown in the following figure:
When the upload is complete you'll see that all 3 bin files are uploaded correctly as shown in the following figure:

Sometime you could encounter a timeout error as shown in the following figures; in these cases you need to unplug and plug again the USB cable and power cycle the robot, then you can retry.

Development

Probably, you'll never need to touch the firmware running in the radio module, but in case you need to modify the code or you're simply curious about what is happening at the low level, then refer to the section Radio module development.

The e-puck2 robot is equipped with an onboard programmer and debugger that let you update the firmware of the robot and debug your code easily using a standard USB interface. There is a dedicated STM32F413 microcontroller that acts as the programmer with built in GDB server, so you can control exactly what happens using the GNU Project Debugger in your host machine.
The programmer microcontroller is also in charge of handling various low level features such as the configuration of the USB hub and the power button.

Factory firmware

The programmer is initially programmed with a firmware based on a modified version of Black Magic Probe programmer/debugger.
The pre-built firmware is available here programmer-firmware.bin (28.05.20); it is also available in dfu format here programmer-firmware.dfu (28.05.20).

Firmware update

The programmer's microcontroller features a factory bootloader that can be entered by acting on some special pins, the bootloader mode is called DFU (device firmware upgrade). You can enter DFU mode by contacting two pinholes together while inserting the USB cable (no need to turn on the robot). The two pin holes are located near the USB connector of the e-puck2, see the photo below.

Jumper: Rise Of Robots Mac Os X

Location of the pin holes to put the programmer into DFU

The programmer will be recognized as STM Device in DFU Mode device.

Note for Windows users: the device should be recognized automatically (in all Windows versions), but in case it won't be detected then you need to install a libusbK driver for the DFU device.
Follow the same procedure as explained in section Installing the USB drivers using libusbK driver instead of USB Serial (CDC).

Linux/Mac

In order to update the programmer firmware you need an utility called dfu-util, it should be already installed from section Installing the dependencies for firmwares updates.
To uplaod the firmware, issue the following command: sudo dfu-util -d 0483:df11 -a 0 -s 0x08000000 -D programmer-firmware.bin

Windows

Start the DfuSe application (previously installed from section Installing the dependencies for firmwares updates). The programmer in DFU mode will be automatically detected as shown in figure 1. Then you need to open the compiled firmware by clicking on choose and then locating the file with dfu extension, as shown in figure 2. Now click on the upgrade button, a warning message will be shown, confirm the action by clicking on yes as shown in figure 3. If all is ok you'll be prompted with a message saying that the upgrade was successfull as shown in figure 4.

Development

Jumper: Rise Of Robots Mac Os Catalina

The programmer code shouldn't be modified, but if you know what you're doing then refer to section Programmer development.

Jumper: Rise Of Robots Mac Os 13