More LabVIEW Development for the Xbox Kinect April 7, 2011
Posted by emiliekopp in code, labview robot projects.Tags: code, driver, kinect, labview, open_source, robotics, vision, xbox
3 comments
So remember when I said the Xbox Kinect was going to revolutionize robotics (at least from a sensor-hardware point of view)?
Well, when it rains, it pours: More and more LabVIEW developers are uniting, creating and sharing drivers that allow you to communicate with the Xbox Kinect hardware using LabVIEW software.
An NI Community member, anfredres86, has published his VI driver library, making it easy to download and install the necessary files for you to start developing robotics applications in LabVIEW that utilize the Kinect hardware for robot sensing.
Here is a video of the 2D occupancy grid mapping example he put together using LabVIEW and the Kinect:
I encourage everyone to check out (and download) his code:
Kinect Drivers for Labview: http://decibel.ni.com/content/docs/DOC-15655
And be sure to share your examples on the NI Robotics Code Exchange as well!
Open Source Code: Using LabVIEW to Acquire iPhone Accelerometer Data April 1, 2011
Posted by emiliekopp in code, labview robot projects.Tags: accelerometer, code, control, iphone, labview
add a comment
Ok, so this week’s post proves that I simply can’t get enough of John Wu’s blog, RIOBotics. John is cranking out LabVIEW code for robotics applications , left and right.
This time, John helps you use LabVIEW to acquire and plot data directly from your iPhone’s accelerometer through UDP. (I bet this is similar to how Waterloo Labs was able to build an iPhone app that allowed them to steer a car by tilting their iPhone from side to side.)
Xbox Kinect Hack Using LabVIEW March 7, 2011
Posted by emiliekopp in code, labview robot projects.Tags: 3d, code, example, kinect, labview, open_source, visualization
3 comments
If you haven’t seen this already, you need to. The Xbox Kinect is not only revolutionizing gaming, it will revolutionize the way humans interact with machines, including robots (think: robots can now more easily interpret human gestures).
Ryan Gordon, from http://ryangordon.net/, got things started by building and sharing a LabVIEW wrapper for the OpenKinect library. Then John Wu, another LabVIEW programmer, took things one step further building an example VI for 3D scene construction using the Kinect sensor and point clouds.
Download John’s example on his blog post: LabVIEW, Xbox Kinect, and 3D point cloud visualization
Thank you John and Ryan! This is the beginning of some incredible and exciting work!
DARPA Arm Robot Controlled via LabVIEW January 25, 2011
Posted by emiliekopp in code, labview robot projects.Tags: arm, code, control, darpa, labview, simulator
add a comment
By now, you’ve all heard of one of DARPA’s latest robotics projects, but just in case:
DARPA is introducing its Autonomous Robotic Manipulation (ARM) program. The goal of this 4 year, multi-track program is to develop software and hardware that allows an operator to control a robot which is able to autonomously manipulate, grasp and perform complicated tasks, given only high-level direction. Over the course of the program in the Software Track, funded performers will be developing algorithms that enables the DARPA robot to execute these numerous tasks. DARPA is also making an identical robot available for public use, allowing anyone the opportunity to write software, test it in simulation, upload it to the actual system, and then watch, in real-time via the internet, as the DARPA robot executes the user’s software. Teams involved in this Outreach Track will be able to compete and collaborate with other teams from around the country.
One of NI’s R&D engineers, Karl, has developed a LabVIEW wrapper for the DARPA arm simulator in his spare time and has graciously shared it on the NI Robotics Code Exchange (ni.com/code/robotics).
Using Karl’s code, you can directly control the arm simulator using LabVIEW. This means you develop your own control code and easily create UIs using LabVIEW’s graphical programming environment (two of the things LabVIEW is best for).
Check out Karl’s blog to request the code:
MiNI-HUBO Series: LabVIEW Driver for Dynamixel Motors July 9, 2010
Posted by emiliekopp in code, labview robot projects.Tags: code, driver, dynamixel, free, hubo, labview, robotis
add a comment
Recall Mini-Hubo, the small, humanoid research platform developed by RoMeLa. I had mentioned his joints are actuated by Robotis Dynamixel motors, high-performance networked actuators built specifically for robots.
Karl, our resident humanoid expert, has graciously shared the LabVIEW drivers that allow you to communicate with these robot-specific motors, plug-and-play style. Check out the LabVIEW Robotics Code Exchange to automatically download the driver and install it into LabVIEW. For anyone using Dynamixel motors for their own robot designs, this will save you lots of driver development time.
Download Dynamixel Motor Driver
Don’t have LabVIEW? You can check it out for free here.
Open Source LabVIEW Code: Humanoid Robot Walking Gait May 19, 2010
Posted by emiliekopp in code, labview robot projects.Tags: code, hubo, humanoid, mini hubo, open_source
1 comment so far
This is the latest update to the MiNI Hubo series I started awhile back. You may recall the previouis video of MiNI Hubo walking, which used LabVIEW code that was simply playing back a recorded motion.
This video shows MiNI Hubo walking using a parametric gait generated dynamically and online:
And best of all, Karl Muecke, NI R&D engineer, is sharing all of the LabVIEW code that controls MiNI Hubo’s walking gait.
You can download the VIs and see how Karl designed the control code on the NI Robotics Code Exchange.
Meet Mini Hubo: part 1 of series March 31, 2010
Posted by emiliekopp in labview robot projects.Tags: code, dr hong, dynamixel, fitpc, hubo, humanoid, kaist, mini hubo, romela, rx-28, virginia tech
3 comments
Meet Mini Hubo, a small, humaniod robot based on an original, full scale humanoid design by the Korea Advanced Institute of Science and Technology (KAIST). The original Hubo was replicated and scaled smaller in size by RoMeLa at Virginia Tech since not everyone has the funds or resources to have their own life-size humanoid walking around the lab; Dr. Hong and his students created a more accessible version. The goal of Mini Hubo is to serve as an affordable and open-ended research platform to expand knowledge in the human robotics field.
Since we’re good friends with the engineers at RoMeLa, we recently got our hands on a Mini Hubo here at NI. One of our interns, RJ Gross from Drexel University, spent some quality time with the robot, which we began to refer to as MiNI Hubo, since all of our robots have some sort of emphasis on “NI” (see NIcholas, DaNI, NIro, NItro, GreeNI, etc). As a result, RJ will be sharing a lot of the LabVIEW code he developed to control MiNI-Hubo (coming soon!).
In the meantime, here’s some mechanical specs on our MiNI Hubo:
Height: 46cm
Weight: 2.9 kg
DOF: 22 (but don’t worry, Mini Hubo comes with documentation that includes his forward and inverse kinematics, whew!)
Motors: Robotis Dynamixel RX-28 (LabVIEW drivers for these particular motors will be published soon, so you can get your hands on them too)
Controller: We chose to use the FitPC2 to controller our MiNI Hubo, although the humanoid platform is flexible, so you could use practically anything, like Gumstix, NanoATX, PC104, etc.
OS/SW: Our MiNI Hubo is programmed using LabVIEW Robotics and runs Windows on the FitPC2. RJ will be publishing a white paper on running LabVIEW on the FitPC2 soon as well. But again, depending on what controller is selected, the OS/SW is flexible.
Vision: We used a USB webcam. This is also a flexible option for Mini Hubo.
Power: Lithium-ion polymer batteries
We’ll be getting more up-close and personal with this robot in the coming weeks, so stay tuned. I have some video of MiNI Hubo walking at one of the cubicles in R&D that I look forward to sharing.
For anyone considering who’s interested in a Mini Hubo of his/her own, be sure to contact RoMeLa. They sell the Mini Hubo platform to researchers.
iPhone Controlled Car: More How-To Materials November 12, 2009
Posted by emiliekopp in code, labview robot projects.Tags: car, code, diy, how-to, iphone, labview, open_source, remote_control, waterloo_labs
add a comment
So if you’ve been following the phenomenal DIY application that has made it to sites like Gizmodo and Cars.com, you might be interested in the detailed How-To docs that the guys behind this wicked-awesome app created. Just in case you haven’t checked out their blog (which you should!), here’s some of the technical materials they’ve shared with us:
- Technical Tutorial: Remotely Controlled Automobile – iPhone, Power Wheels, Laptop — Includes system overview as well as a grocery list of all the hardware used
- Technical White Paper: Use of Prototyping tools in the “Drive a Car with an iPhone” Video — Lists the software used to rapidly prototype the control system, including LabVIEW
- Open Source Code: Code for iPhone Controlled Car — Download the zip file that contains the LabVIEW project and all subVIs that they used in order to control the Oldsmobile with an iPhone, Power Wheels, and Laptop
And there’s plenty more tutorials they’ve created to help explain exactly how they did it. Check them out.
Open Source LabVIEW Code: The RoBoard RB-100 November 3, 2009
Posted by emiliekopp in code, labview robot projects.Tags: bioloid, code, hobbyist, khr, kondo, labview, open_source, rb-100, roboard, robonova, robosavvy, robot
add a comment
This tasty chunk of code comes from the RoboSavvy Forum, a great place for hobbyist and robotics enthusiasts to find low-cost robotics kits, materials and information.
Mr. Richard van der Wolf from the Netherlands created his own open-source RoBoIO library in LabVIEW, which allows you to communicate with and control the Roboard RB-100. This board is compatible with several robot kits that are already out there, including the Kondo Humanoid Robot (KHR), Hitec’s Robonova, the Robotis Bioloid and Robobuilder. In addition, if you build your own hardware platform from scratch, you have plenty of communication standard options to choose from. You can find all the info you would need on the board’s hardware here, on the RoboSavvy site.
And here’s Mr. van der Wolf’s LabVIEW code (man, I wish my name was cool like that): http://www.roboard.com/labview/Labview_RoBoIOv15b.zip
If you run into any issues, I suggest you hit up this forum thread, as it’s specific to the LabVIEW files for the RB-100. Thanks RoboSavvy!
How to Build a Quad Rotor UAV October 6, 2009
Posted by emiliekopp in code, labview robot projects.Tags: .m-file, code, FPGA, how_to, labview, national_instruments, quad_rotor, robotics, sbRIO, UAV, xkcd
20 comments
Blog Spotlight: Dr. Ben Black, a Systems Engineer at National Instruments, is documenting his trials and tribulations in his blog as he builds an autonomous unmanned aerial vehicle (UAV), using a SingleBoardRIO (2M gate FPGA+400MHz PowerPC processor), four brushless motors, some serious controls theory and lots of gorilla glue.
I particularly appreciate his attention to the details, stepping through elements of UAV design that are often taken for granted, like choosing reference frames, when you should use PID control, and the genius that is xkcd.
Like most roboticists, throughout the design process, he has to wear many hats. I think Ben put it best:
I think that the true interdisciplinary nature of the problems really makes the field interesting. A roboticist has to have at minimum a working knowledge of mechanical engineering, electrical engineering, computer science / engineering and controls engineering. My background is from the world of mechanical engineering (with a little dabbling in bio-mechanics), but I end up building circuits and writing tons of code. I’ve had to pick up / stumble through the electrical and computer science knowledge as I go along, and I know just enough to make me dangerous (I probably don’t always practice safe electrons…sometimes I let the magic smoke out of the circuits…and I definitely couldn’t write a bubble sort algorithm to save my life).
My point in this soap-box rant is that in the world of robotics it’s good to have a specialty, but to really put together a working system you also need to be a bit of a generalist.
For anyone even considering building a UAV (or just likes to read about cool robotics projects), I suggest you check it out. He shares his .m-files, LabVIEW code, and more. Thanks Ben.
subscribe by email
LabVIEW Robotics 