Welcome




Welcome to my website! You can explore my entire blog below, all the way back to October 2010, or filter it to see just posts in the Robots or Photography categories.

There are also static accumulation pages that cover stuff from specific categories the blog in one place, which you can access from the header above. If you’re here for math notes, go to leonoverweel.com/mathnotes.

PS: There are Easter eggs hidden on the static pages of this site; see if you can find them! Also, this post is sticky, newer ones are right below.

TU Delft Summer Internship: 3mxl Control Table XML Interface


By on July 31, 2014

Long time no write! Between SATs, APs and SAT IIs, my junior year at Rye High has been extremely busy–so I haven’t been able to build too many robots lately. I have, however, been working on a couple of long-term projects. I’ll have updates up on those soon.

Now that school has ended, though, I’ve got a lot more time on my hands, and I’ve spent a lot of it at a month-long internship at the TU Delft Robotics Institute in (you guessed it) Delft, the Netherlands. I got the opportunity to intern there thanks to my Science Research mentor, Guus Liqui Lung, who is Research Engineer at the university’s Biomechanical Engineering group.

What I’ve been doing

The “purpose” of my internship there was for me to learn about using ROS (Robot Operating System). ROS is a big open source project that consists of a collection of interoperating drives, nodes and packages that allow you to add a bunch of functionality to all kinds of robots; I’m interested in ROS because I’d like to integrate the library I’ve been developing in Science Research into it (more on that soon).

The robotic wheel platform I tested my code on at the internship

The Robotics Institute at the TU has developed a board called the 3mxl, which integrates up to 253 daisy chained motors into ROS using the Dynamixel protocol. The board keeps a 256 byte “control table” for each motor, which contains user-set parameters to make the motor behave as it should (things like the gearbox ratio, encoder resolution, motor constant, wheel diameter, spring stiffness, etc.).

This is extremely useful for abstracting away a lot of the lower level functionality, but it is kind of hard to edit, which is where the project I worked on comes in: I made an easy way for both first-time users (Minor students) and experienced users to quickly view and edit the data contained in the control table through a combination of XML files and a custom RQT-based GUI.

The startup screen of my GUI, before the program scans for motors on the bus

The basic premise behind my program is that it scans the 3mxl board for motors, and then, for each one it finds, reads out relevant parts of the control table (using either existing get methods, single byte reading, or bitwise shifts to combine low and high bytes for longer data types). It then applies appropriate type changes and unit conversion factors, and finally writes the parameters to both a standards-compliant XML file and to an external struct (maintained by my library) that allows both the GUI and user-made programs to access the control table data.

The GUI in editing mode

Through the GUI, the user can then edit the parameters in the struct (which was read from the current control table on the 3mxl when the XML file was generated, or imported from a GUI-made XML), and write them back to the 3mxl.

Whenever that happens, the most recent changes are used to update the XML file, which looks something like this:

<control table>
<motor id="106">
<constant name="motorEncoderDir">1</constant>
<constant name="motorGearBoxRatio">19.700</constant>
...
</motor>
<motor id="107">
<constant name="motorEncoderDir">0</constant>
<constant name="motorGearBoxRatio">6.200</constant>
...
</motor>
</control table>

The XML file is completely portable, so a file generated on one computer-robot combination can be used to import parameters to any other computer-robot combination (provided that it has the same amount of motors, and the motors have the same IDs). All this functionality is also available as a library, so the user can, in a few lines of code, parse the XML file at the beginning of their code without having to go through the GUI.

Because of that, the user can change the parameters just by editing the XML file (by hand or through the GUI), and make changes to the control table without having to slowly write and recompile any code–particularly useful for tuning a PID algorithm, for example.

The GUI after having updated the motor’s PID gains.

Being able to import and export data between XML files and the control table also adds the advantage that someone who knows what they’re doing (e.g. my mentor) can generate a couple of standard XML files that the students can then import (and slightly tweak if necessary) and load onto their robots very easily without needing much prior knowledge.

The binaries of the two packages (the XML generation/ parsing backend and the GUI front end) are now available on TU Delft’s private SVN for Minor students to start using next year.

The Takeaway

It’s been awesome working in the lab because, even though I was testing my code on a lowly wheel base, I could see the really cool, really complex, really big (and really secret) robots my code can be run on to make the researchers’ lives a little bit easier.

It was also nice to be working with C++ again–which I hadn’t done since I took an online class on it sophomore year–and I learned a lot of new stuff, from all the 3mxl interface stuff to structs to bitwise operations to Ct GUIs and to what the hell a CMake file is.

And, of course, I got a pretty good understanding of ROS and how to interface with it, which I’ll be able to apply to my own Science Research project next year at school–more on that in a later post.

Overall, it was a great month. :D

PS: More updates coming soon; I’m also going to start looking into using ROS with the LEGO Mindstorms NXT motors and sensors I already have–probably with a UDOO Mini PC and an Arduino board to interface it with the NXT stuff.

Dual Axis Motorized RC Camera Rig for Lumia 928


By on July 24, 2013

I got a new phone a couple of weeks ago: the Nokia Lumia 928. It has a great camera, so I decided to build a rig for panning and tilting it.

The robot features two degrees of freedom that can be manipulated independently, is controlled through Bluetooth via an easy to use remote, and rotates the phone exactly around where the lens is located. I’ll get into all those things individually after the video; building instructions are at the bottom of the page.

Lumia Rig demo video

Hardware

The robot itself has two motors. The first moves a single small gear that spins the turntable and pans the phone. The second is a little more complex; it drives a worm wheel through the center of the turntable, which, through another series of gears, is responsible for tilting.

To get rid of the obnoxiously high amount of vibrations caused by the Mindstorms NXT motors at high speeds, the entire base rests on the rubber shock absorbers that come with the NXT set.

The remote is very minimalistic, featuring a symmetrical design with two motors on the sides that are used to input remote control data into the system, and nothing else. Both follow the red with shades of gray color scheme I’ve been using for most of my robots lately.

Software

The remote and the rig are both programmed in RobotC and connected via Bluetooth; three types of signals (control mode, motor A speed, motor B speed) are encoded and sent between them 33 times a second.

The “control mode” variable tells the rig what mode the remote is in: you can either control the position, where the rig quickly moves the same amount of degrees the remote control wheels are turned, or the speed, where the dials control how fast the motors use. The other two variables then tell the motors how much to move.

Because of the hardware design, if the base were to spin while the tilting motor stands still, the camera would still tilt (the gears would rotate around the worm wheel and spin themselves). To compensate for that, the remote makes sure the worm wheel is always spinning at 1/7th the speed of the panning speed; that speed is then increased or decreased to tilt. This allows for truly individual control over the different functions of the rig.

Build Your Own

If you’ve got a Lumia 928 and would like to build this robot yourself, you can use the resources below.

If you have a different phone: the robot was designed to be adjustable for different sized phones fairly easily.

UPDATE: My friend over at One Mindstorm has created a version of the Lumia Rig optimized for iPhones. You can check it out here for building and programming instructions.

If you have any questions, tweet them to me and I’ll get back to you ASAP.

NYC Chinatown & Little Italy Cinemagraphs


By on July 21, 2013

I went to the city with my parents a couple of days ago. I took lots of regular DSLR pictures, but also tried out taking Cinemagraphs on my phone for the first time:

Lots of people sitting around here, mostly playing board games and cards. Some tables had quite the crowd of spectators around them.

View outside the restaurant where we ate.

Steaming hot pots of food at another restaurant we walked by.

The Little Italy sign changed colors every couple of seconds.

Two cowboys having a drink at a Little Italy bar.

RHS Science Research Symposium Flyer Robot


By on June 25, 2013


The RHS Science Research Symposium Flyer Robot, about to hand out a program.

A couple of weeks ago, we had our annual Science Research symposium, where Rye High School students show visitors the research they’ve done over the year in either a poster or PowerPoint presentation.

A poster I drew for the symposium, featuring illustrations for everyone’s research.

For my research, which I’ll share more about later, I built a demo robot to hand out the flyers/ programs to the people who came by. See the video I made of it below:

Device-wise, the robot consists of the following functional parts:

  • 2 Mindstorms NXT Intelligent Bricks (1.0 & 2.0)
  • 2 100mm Firgelli Linear Actuators ~
  • 2 Mindstorms NXT Motors
  • 1 LEGO Technic Small Motor
  • 4 Mindsensors Flexi-Cables for NXT (1 meter long & 1.5 meters long) ~
  • 1 Custom-made NXT-Technic Motor cable ~
  • 3 Touch Sensors
  • 1 Ultrasonic Sensor

As for how it worked, the process was fairly simple; it’s explained in the gallery below:

After the Ultrasonic Sensor registers a new visitor, the Master NXT (“Jeeves”) sends a Bluetooth signal to the Slave NXT (“Alfred”), which would then turn four wheels that push the bottom program into the arm’s gripper.

Then, Alfred closes the gripper to grab the program once its pushed forward enough to hit a touch sensor (that in-focus gray axle extends into the sensor.)

Once a Bluetooth signal is sent back when Alfred finishes, Jeeves uses the Linear Actuators to move the flyer to the desired position.

A second joint, also controlled by Jeeves, assists in handing out the flyer.

Finally, Jeeves once agains signals Alfred to let go of the program, and the arm returns to its default position, assisted by two more touch sensors used to calibrate different parts of the arm.

Originally, I’d also planned to use an IMU to measure when the visitor grabs a program and only let go of it then; due to time constraints, however, I decided to just use a two second timer. The arm itself, as you can see in the video, is pretty shaky too, so it would have been hard to filter out those vibrations from those caused by a potential visitor grabbing the program.

Overall, though, I’m happy with how the arm turned out, and I’m glad it attracted some people to my poster.

Celebrating 50+ FCCYSF Videos and 50+ Subs


By on June 24, 2013

About a year ago, I started FCCYSF, a YouTube channel to host Creative Commons stock footage available for anyone to use completely for free, with neither upfront nor royalty costs.

Some featured FCCYSF videos

I’m proud to say the channel has recently passed 50 subscribers, and has over 50 videos uploaded. Right now, I’ve started contacting more people possibly interested in contributing. Other than myself, there is one so far.

If you’re interested in becoming a contributor (you’ll get a 70% cut of the advertisement profits made on your footage), or know anyone who might be, drop me an email at fccysf@gmail.com.

The Minerals Page for Just Over Art


By on June 18, 2013

My mom has recently started using epoxy resin to make multi-layered paintings, and they look great. Some of her newest ones are centered around different types of rocks and minerals, which are what the page on her site I made showcases.

Screenshotting it hasn’t given me any good results due to scaling and such, but you can check it out right here. Here’s a picture of one of the paintings instead:
One of Lisette Overweel's Minerals paintingsOne of Lisette Overweel’s Minerals paintings, as seen on her site.

The basic idea behind the page is that there’s a static background that can adapt to anything from a 2560p Cinema Display, to a 16:9 Surface held vertically to a smartphone; the content scrolls in front of it, boxed in by a white background.

The background also adapts to browsers that don’t allow for it to be static, and instead duplicates itself. The way that works without being ugly/ inconsistent is that every other one is vertically flipped, so that there are no harsh breaks between the tops and bottoms of any two occurrences of the image.

Posted in: Web | Tags: , | Leave a comment

Science Olympiad 2013


By on April 2, 2013

Our local 2013 Science Olympiad was held in late February and my friend Michael Chen and I, among others, represented Rye High School for the Robot Arm challenge. We did fairly well and finished in 7th place.

Our arm features four controllable Degrees of Motion: the base rotates, the arm moves at the shoulder and elbow joints, and the gripper opens and closes. Although it wasn’t driven by any motors, the wrist the gripper was attached to moves too, always keeping itself vertical assisted by gravity.

It was controlled using a Surface Pro running RobotC, connected to the base via USB cable. On the Surface, the interface was fairly simple: the up and down arrow keys on the keyboard or the remote NXT shifted which of the robot’s functions was being controlled, while the left and right arrow keys executed the selected function. The NXT brick connected to the computer relayed its commands to the second NXT brick via Bluetooth.

The code for the master is available here and the code for the slave is available here.

We’re planning to enter again next year, and there are a lot of things we’ve learned that we’ll use to make improvements in both the robot itself and our competition strategy.

This Site


By on March 30, 2013

By now, after a couple of months of on and off work, I’m pretty certain I’m happy with the way this site looks and feels. It’s got a solid grid-based foundation, simple CSS classes to fit content within the frame, all the static pages I can think of, a header and a footer, and now a WordPress-powered blog to push out updates, like this one.

Purpose

This site, leonoverweel.com, is meant to unify and replace my other sites, World of Mindstorms and NY Snapshot, and to be a portfolio of stuff I’ve done. The static pages, linked above, mostly take care of the latter while the blog this is posted on replaces the two old blogs; it’ll cover topics like these:

  • Robotics
  • Photography
  • Software/ Programming
  • Web

I’ve imported most of the posts from the other two blogs, but they haven’t been optimized for this layout; so, disclaimer: any post older than this one is not guaranteed to look good.

Design

Horizontally, most content on the site fits into a grid consisting of four 200 pixel wide columns with 10 pixels in between each, adding up to 830 pixels of total width. That gives you content that can be 200, 410, 620 or 830 pixels wide, or of course combinations thereof, as illustrated below.

Grid

The blog is generally restricted to just the left three quarters, with the fourth quarter left open for the post author, date and title; the picture above is an exception.

At the top and bottom of every page, a header and footer respectively contain quick links. Both following the grid like the rest of the site, the header links to social networks and bigger static portfolio-type pages, while the footer has miscellaneous links.

Future

You may have noticed that my other blogs haven’t seen too many new posts since the school year started, which was mostly, well, because of school. Sophomore year is pretty busy, but now that I’ve started Science Research at least I have a period every day to work on robot-type stuff.

Right now I’m researching HCI, Human Computer Interaction, pointed toward robotics of course, and I’m working on some RobotC-based Mindstorms NXT software for robot arm hardware abstraction.

Posted in: Updates, Web | Tags: , , | Leave a comment

© 2009-2013

Unless otherwise specified, all rights reserved to Leon Overweel.

Links
Social
Search