CAD Files

RED was designed in SolidWorks. I know a full license of SolidWorks is expensive, but it is the most widely used tool for designing robots. If you are a student, you can get an educational version of SolidWorks for about $200, which is very reasonable.

This version has some a few problems:
– The belts don’t turn because the pulleys are fully defined.
– The design as a whole is under defined.

Despite these problems, you can still use the drawing to see what parts are needed and how the parts fit together. I’ll fix the problems when I get time.

In case you don’t have aceess to SolidWorks, here are some images of the important parts:

A SolidWorks pack and go file is available in my GitHub repository: https://github.com/osmaneralp/RED.

Arduino Files

The code for RED is contained in two sketches: robot.ino and motors.ino. Most of robot.ino is related to initializing the MPU-6050. I should really move it to a separate file. Most of the motors.ino file is for reading the wheel encoders. I am using an interrupt on each edge of both phases of the quadutrature signals for each wheel. That’s a lot of interrupts. The Arduino Due can keep up. I don’t know if a slower Arduino, such as the Uno, can keep up with so many interrupts. This is one reason I chose the Arduino Due.

In addition to the two sketches, I used the following libraries: I2Cdev, MPU6050, PID_v1, and PS2X_lib. The PS2X_lib did not work with the Arduino Due, so I made some modifications to make it work. One thing I discovered is that a lot of libraries are not yet ported to the Due. If you choose a Due, be prepared to make changes to code that works for all the AVR based Arduinos. Thus, I would not recommend the Due for a beginner.

The Arduino files are available in my GitHub repository: https://github.com/osmaneralp/RED.

Parts List

Item Vendor Part Number Qty Unit Extended
Mechanics
1 6″ Heavy Duty Wheels ServoCity 595610 2 9.99 $ 19.98
2 24″ Aluminum Channel ServoCity 585466 1 15.99 $ 15.99
3 12″ Aluminum Channel ServoCity 585454 2 9.99 $ 19.98
4 9″ Aluminum Channel ServoCity 585450 2 7.99 $ 15.98
5 6″ Aluminum Channel ServoCity 585466 2 5.99 $ 11.98
6 Pinion Pulley 16T 0.25″ ServoCity 615378 4 8.99 $ 35.96
7 Shaft Coupler 0.25″ to 6mmServoCity 625106 2 4.99 $ 9.98
8 Bearing 0.25″ ServoCity 635042 6 0.995 $ 5.97
9 Motor 37D 30:1 Pololu 1443 2 39.95 $ 79.90
10 Motor Mount ServoCity 555128 2 4.99 $ 9.98
11 Flat Single Channel BrackeServoCity 585468 2 1.29 $ 2.58
12 Hub Spacer 0.5″ ServoCity 545384 2 1.59 $ 3.18
13 Shaft Clamp Collar 0.25″ ServoCity 625102 4 2.495 $ 9.98
14 D-Shaft 0.25″ x 1.75″ ServoCity 634066 2 1.39 $ 2.78
15 Shaft Spacer ServoCity 633105 4 0.14 $ 0.56
16 Aluminum Clamp Colar 0.25″ServoCity 6157K12 2 4.99 $ 9.98
17 D-Shaft 0.25″ x 2.25″ ServoCity 634070 2 1.59 $ 3.18
18 Hub Adapter 1.5″ x 0.770″ ServoCity 545388 2 4.99 $ 9.98
19 Clamping Hub 0.25″ x 0.770ServoCity 545588 2 7.99 $ 15.98
20 Socket Head Screw #6 x 0.2ServoCity 632106 1 1.69 $ 1.69
21 Socket Head Screw #6 x 0.3ServoCity 632110 1 1.89 $ 1.89
22 Timing Belt XL 17″ ServoCity B375-170XL 2 4.95 $ 9.90
Electronics
23 Arduino Due SparkFun 11589 1 49.95 $ 49.95
24 Dual MC33926 Motor Driver Pololu 1213 1 29.95 $ 29.95
25 MPU-6050 Breakout SparkFun 11028 1 39.95 $ 39.95
——-
$417.23

Other Misc Parts
#6 Nuts
Hookup wire
Battery
PS2 Remote control
Acrylic

References

Balancing robots have been around for many years. The first balancing robot I encountered, nBot, was created by David Anderson. His robot remains one of the best even after many years. He describes his robot on his website: http://www.geology.smu.edu/~dpa-www/robo/nbot/.

Back in 2010, Kas started a thread on the Arduino blog called Balancing robot for dummies. This was around the same time as I was building my first balancing robot, Blinky. I didn’t use an Arduino in Blinky, but I learned a lot from that thread. It is still an excellent source of information for building a balancing robot.

The only way that I was able to create the code for RED in only a few weeks is because of the work of others, particularly those who created open source Arduino libraries, such as Jeff Rowberg’s I2Cdevlib, Brett Beauregard’s PID library, and Bill Porter’s PlayStation 2 controller library. Many thanks!

The post Files for RED, the balancing robot appeared first on OzBotz.

The results of the contest will be announced on Friday, Oct 31, 2014.

The post My Video for the ServoCity Balancing Robot Contest appeared first on OzBotz.

September 13, 2014 – Today, I started working on the design for my entry into the ServoCity balancing robot contest. I’ve built balancing robots before, and the Actobotics kit is the best available for building robots, in my opinion, so how difficult can this be? The contest requires that everyone use a 24 inch piece of tubing or channel. I plan to use this channel as the vertical backbone of the robot. A smaller horizontal channel will attach at the bottom of the backbone. On this channel will mount the wheels. The primary mechanical challenge is finding a way to mount the wheels to the channel. I can think of four methods:

1. Mount the motor inside the channel, as shown in the following drawing:
   
   This seems like the best method because the motor is protected. ServoCity sells a small planetary gearhead motor that would fit in the channel. However, there is currently no way to attach the motor to the inside of a channel, and the motor does not have an encoder. For these two reasons, I will need to try another method.
2. Mount the motor on top of the channel, as shown in the following image on the ServoCity website:
   
   The problem with this method is objects can get caught in the point where the two gears mesh. I know from previous experience that balancing robots can get a bit “wild” in their movements, particularly during initial testing. I can envision fingers getting crunched in the exposed gears. If I had time, I could fashion a cover for the gears, but the robot needs to be done in a month, so for now I need another method of mounting the motor.
3. Mount the motor to a vertical piece of channel, as shown in the following drawing:
   
   Adapters are available to mount a gearhead motor such as the Pololu 37D motor. In this configuration, the wheel is supported by a bearing, which is good because the 37D motor has only a bushing. However, the big problem with this arrangement is that the motor is too exposed. It would be easy for the motor to hit an object and become damaged.
4. Mount the motor high up and connect it to the wheel using a pulley and belt, as shown in the following drawing:
   
   The disadvantage of this method is that it is more complicated than the direct drive method just described. However, the motor is protected, and the wheel is supported by two bearings, which is great.

After weighing the pros and cons of each method, I have choosen method #4. Another major design decision is what microcontroller (MCU) to use. I would love to use a cheap $15 STM32 developement board, but the contest requires that all electronics be purchased from ServoCity, Pololu, or SparkFun. SparkFun sells a Cortex M board that is designed to work with mbed. That’s tempting, but because of the desire to make a kit for the masses, I’m going to try an Arduino. I found a product called the Netduino Plus 2 on SparkFun. It even uses an STM32, so if I run into a limitation in the Arduino IDE, I can always program it directly using a J-Link and Keil.

September 24, 2014 – I showed my robot at the Homebrew Robotics meeting tonight. I also mentioned the ServoCity contest. Someone asked what the prize was and how much money I will spend. I explained that the prize was $1000 worth of parts, and I will probably spend close to $500. Thus, to make this a financially profitable venture, my odds of winning would need to be greater than 1 in 2! Video from the meeting is posted on the Homebrew Robotics YouTube channel. I’m the guy in the gray shirt. Here is the robot in its current state:

September 25, 2014 – I figured out how I’m going to attached the electronics and at the same time give my robot a more natural contour: I will cut out an hour glass shape out of acrylic and attach it between the upper and lower aluminum channels, as shown in the following drawing: The curvy shape gives the robot a more organic appearance which helps to offset the industrial feel of the aluminium. The acrylic will be red. The color red is a bold color that stands out in a crowd, and it implies that the robot has life in it because blood is red.  The color also give my robot a simple name: Red.

September 26, 2014 – I tried to use the NetDuino Plus 2 that I bought from SparkFun and had hoped to use as the controller for Red. I discovered that it is not really an Arduino, and it does not work with the Arduino IDE. It requires Visual Studio Express. Ugghh. I’ve have some basic experience with the Arduino IDE, and I use Keil every day. I don’t have time to install and learn another IDE in time for this contest, so I need another controller board. One of the goals of this contest is to create a kit. An Arduino is a good choice for a kit because Arduinos are so ubiquitous. A kit that required someone to lean Keil probably wouldn’t sell as well to the general maker community. The Arduino Due looks promising because it is fast and has a lot of inputs and outputs, so I will try one of those.

Sunday, October 12, 2014 – Today I went to the office  and 3D printed “mittens” to represent hands and a “neck” to hold the phone at the top of the robot. I also laser cut the body panels. The back panel has holes in it to mount the electronics. I discovered the the 3D model I downloaded for an Arduino Mega, which has the same hole pattern as the Due that I am using, had a mistake in the positioning of the holes! Fortunately, I cut the first panel out of paper. I found the problem when I dry fit all of the electronics on the paper panel.  The lesson learned is to double check critical sizing elements of models that I don’t create myself. All of the electronics and mechanics were finished today. Tomorrow I will try to finish the software before the deadline, but it’s looking doubtful that I will finish on time. Here is a picture of Red without his front panel:

The eyes are an Android app from the Oddwerx project. Oddwerx was originally a prototype for a commercial product. It is now an open source project.

Monday, October 13, 2014 – The deadline for submitting a video of the robot balancing has been extended two weeks to October 27! I have a chance now of completing the software on time.

Tuesday, October 14, 2014 – I discovered today that the MPU-6050 does not give accurate readings when mounted vertically. I believe that I am running into the gimbal lock problem. When I tested the MPU-6050 on my desk, it was lying horizontally. I should thought to test it in the position that it would be installed in the robot. To fix the problem, I attached the MPU-6050 to a small piece of acrylic which I glued to the back panel in a horizontal position:

Thursday, October 16, 2014 – Red’s motors moved for the first time today on the mechanically and electronically complete frame. I consider this step to be the birthday of my robots.

Saturday, October 18, 2014 – I was going to port code for a PID control loop from a previous project to the skectch for RED, but then I found an awesome open source PID library for the Arduino. The author, Brett Beauregard, does a great job of explaining how the library work on his website. With mininal additional work, I was able to make RED move like a Segway. When RED tilts forward, the wheels move forward. When he tilts back, the wheels move back. The more he tilts, the faster the wheels move. This is “proportional gain”  portion of the PID control loop. RED is not able to balance on his own at this point. A human is required for balance. To make RED balance and achieve full PID control, I will need to add Integral and Derivative gain.

Monday, October 20, 2014 – PID tuning is turning out to be a major pain. The only way I have to change the PID parameters is to edit the sketch and recompile. This process takes me about a minute on the Arduino Due. I’m tempted to create a separate box with rotary dials that could plug into the Arduino so that I can input new PID parameters.

Tuesday, October 21, 2014 – I decided that I don’t have time to implement my “PID box.” I will make it a separate project after RED is complete because I’m sure that I’ll be making more balancing robots.

After a bit of PID tuning, RED is now able to balance on his own! He is still a bit wobbly, but, nonetheless, this is a major milestone.

Friday, October 24, 2014 – I spent two days just tuning the PID loop. I have finally achieved a stable balance. Now on to the video that I need to submit for the contest!

Sunday, October 26, 2014 – Friday afternoon and part of Saturday I shot video of RED operating in various situations, including being used as a telepresence robot. After two days of video editing, I have a video that I can submit for the contest. I’m actually done a day before the deadline!

You can watch the video here:

The results of the contest will be announced on Friday. It will be interesting to see what other people came up with.

The post Build Report: Red, A Robot for the ServoCity Balancing Robot Contest appeared first on OzBotz.

The post Blinky Finds a Friend at Maker Faire 2014 appeared first on OzBotz.

To complete the steps in this guide, you will need to install the following software:

• gerbv – Available from http://sourceforge.net/projects/gerbv/files/
• Inkscape – Available from http://www.inkscape.org/en/download/

You will also need the paste layer of your PCB design in a gerber file. The creation of the paste gerber file is not covered in this guide because the process is different for each PCB design tool.

Complete the following steps:

1. Convert the paste gerber file to an SVG file. The conversion is needed so the paste layer can be modified with Inkscape, a vector editing tool, in step 2.
   1. Start gerbv.
   2. Choose File -> Open layer(s). Select your paste gerber file, and click Open.
   3. Choose File -> Export -> SVG…. Enter a new file name, such as paste.svg, for the exported SVG file, and click Save.
   4. Close gerbv.
      
      
2. Reduce the size of the paste area on each pad. Most PCB design tools that I have used define the paste area to be the same as the pad area. I have found that reducing the paste area helps prevent putting too much solder paste on the board. Too much solder paste will lead to shorts on fine pitch parts. Some tools, such as Altium Designer, have options in the library to specify the size of the paste mask. If you have defined a paste mask in your library to be smaller than the pad size, skip this step.
   1. Start Inkscape.
   2. Choose File -> Open. Select the SVG file you exported in step 1c, and click Open.
   3. Click once on any of the polygons. All of the polygons should now be selected as a group, as indicated by the dotted line around your design.
   4. Choose Object -> Ungroup. You should now see a dotted line around each individual object.
   5. With all objects still selected, choose Object -> Transform. Select the Scale tab. Enter 85% for the Width and Height. Make sure “Scale proportionally” and “Apply to each object separately” are checked. Click Apply.
   6. Choose File -> Save As. Change the file type to “Portable Document Format (*.pdf)”. Enter a file name, such as paste.pdf. Click Save.

      NOTE: In this step, I save the file as a PDF instead of a SVG because Corel Version 15 (X5), which is the software used with the laser cutter that I use, cannot read the SVG files produced by Inkscape. The latest version of Corel, version 16 (X6), *can* read the Inkscape SVG files. Thus, if your laser cutter uses Corel X6, you can save your modified paste file as either a PDF or an SVG file.

3. Send the PDF file to your laser cutter using raster settings. The polygons in the paste file are too small to be cut out of the kapton like you might cut out a pattern in acrylic. Instead, you will burn away the polygons by telling the laser to interpret the file as a raster image.The instructions below use CorelDRAW connected to a Helix 30W laser. The exact steps will vary based on your software and the model of your laser cutter.
   1. Place the kapton on the bed of the laser cutter.
   2. Press the Pointer button on the laser cutter to turn on the red visible laser pointer.
   3. Press the X/Y off button to release the carriage. With your hands, physically move the carriage to the point that will be the upper left point of the stencil.
   4. Press the Go button to re-engage the carriage.
   5. Open Corel Draw.
   6. Choose File -> Open. Select the PDF file you exported in step 2f, and click Open.
   7. Choose File -> Print.
   8. Select the Layout tab, select “Reposition images to”, and select “Top left corner”, as shown in the following image.
      
   9. Select the General tab, and click Preferences.
      
   10. Adjust the Resolution to the maximum. Set the Job Type to Raster. Set the Speed to 40% and the Power to 90%. If you are using a laser that is more than 30 watts, you can try increasing the speed slightly.
       
   11. Click Print.
   12. On the laser cutter, press Go.

After completing the steps listed above, your stencil will be burned into the kapton. The burning process creates a lot of charred debris. I use acetone on a paper towel to wipe the kapton several times on each side to remove the debris.

Here is an image of a stencil created with the process described above:

The pitch of the QFP in the image above is 0.5 mm. Most of the R & Cs are 0603 imperial. The five small parts in the lower right are 0201 imperial.

Please let me know if you have any feedback on this process by leaving comments below.

The post How to Laser Cut a PCB Solder Paste Stencil on Kapton appeared first on OzBotz.

I like to create paper models of my robots before I cut parts out of acrylic on the laser cutter. To verify that all the parts will fit together properly, it’s important that the paper models are printed at the exact size of drawings.

To print at actual size in SketchUp, follow these instructions:

1. Choose Camera -> Standard Views -> Top to adjust the camera view so that you are looking directly at the face of the drawing you want to print, as shown in the following image:
   
2. Choose Camera -> Parallel Projection to produce a flat drawing with no perspective lines:
   
3. Choose Camera -> Zoom Extents. to make the drawing as large as possible in the window:
   
4. Resize the window to reduce the amount of white space around the drawing. This step is important because when you print, SketchUp will print not just your drawing but all the space around it too. Thus, if your drawing is a one inch square, but the window shows six inches of space on each side of the square, the drawing will be spread across multiple pages when you print.
   
5. Choose File -> Print.
   
   
6. In the Print option window, uncheck the “Fit to page” and “Use model extents” options. Set both scale values to 1.
   
7. Verify that the “Tiled Sheet Print Range” shows “Pages from: 1 to: 1“. If is says pages from 1 to 2 (or any other number), your print will span multiple pages. If your drawing is larger than the size of the paper, there is no way to avoid the print spanning multiple pages and still print at actual size.
   
   NOTE: The “Page size” does not always match the actual page size. In the previous image, the page width is shown as 3.9202 inches, but my drawing measures exactly 5 inches on the printed page.
   
   
8. Click OK.

Your drawing should now print on one piece of paper at actual size. If you drawing is still not actual size, it’s possible that your printer might be scaling the print. For example, my Epson ink jet photo printer prints very accurately (as one might expect from a photo printer). However, my HP Officejet all-in-one printer scales printed drawings by about 0.96 in the Y direction.

Please let me know your results using this procedure by leaving a comment below.

The post How To Print At Actual Size (1:1) In SketchUp appeared first on OzBotz.

My robot Blinky competed in the Balancer Race this year. It’s a bit of a conflict of interest to organize the race and compete in it, but there were so few other competitors that if Blinky didn’t enter, the race would not have qualified for the medal ceremony. So I don’t feel too conflicted. A balancing robot is one of the most challenging types of robots to build, so just entering a robot in the race is an accomplishment.

In the end, Blinky completed the course faster than any other robot and was awarded first place. Here is a video of his final run. Yes, I know the video is vertical. I gave my phone to someone who didn’t know that video is supposed to be shot horizontally!

The post Blinky Competes at RoboGames 2013 appeared first on OzBotz.

This guide describes how to install and configure OpenCV 2.4.2 and its dependencies on Ubuntu 12.04. This guide includes instructions for both 32-bit and 64-bit systems.

Revision History:
[2012-09-12] Updated guide to work with OpenCV 2.4.2. Updated ffmpeg section: ffmpeg 0.11.1 now requires -pic option on 64-bit systems.
[2012-06-05] Updated guide to work with OpenCV 2.4.1 and Ubuntu 12.04. Added instructions for 64-bit systems.
[2011-08-11] Initial version. Worked with OpenCV 2.3.1 and Ubuntu 11.10. Archived here.

If you need help troubleshooting OpenCV installation problems, see the companion guide “A Comprehensive OpenCV Installation Troubleshooting Guide.”

The Installation Procedure

To install and configure OpenCV 2.4.1, complete the following steps. The commands shown in each step can be copy and pasted directly into a Linux command line.

1. Remove any installed versions of ffmpeg and x264.
   

   sudo apt-get remove ffmpeg x264 libx264-dev

2. Get all the dependencies for x264 and ffmpeg.
   

   sudo apt-get update
sudo apt-get install build-essential checkinstall git cmake libfaac-dev libjack-jackd2-dev libmp3lame-dev libopencore-amrnb-dev libopencore-amrwb-dev libsdl1.2-dev libtheora-dev libva-dev libvdpau-dev libvorbis-dev libx11-dev libxfixes-dev libxvidcore-dev texi2html yasm zlib1g-dev

3. Download and install gstreamer.
   

   sudo apt-get install libgstreamer0.10-0 libgstreamer0.10-dev gstreamer0.10-tools gstreamer0.10-plugins-base libgstreamer-plugins-base0.10-dev gstreamer0.10-plugins-good gstreamer0.10-plugins-ugly gstreamer0.10-plugins-bad gstreamer0.10-ffmpeg

4. Download and install gtk.
   

   sudo apt-get install libgtk2.0-0 libgtk2.0-dev

5. Download and install libjpeg.
   

   sudo apt-get install libjpeg8 libjpeg8-dev

6. Create a directory to hold source code.
   

   cd ~
mkdir src

7. Download and install install x264.
   1. Download a recent stable snapshot of x264 from ftp://ftp.videolan.org/pub/videolan/x264/snapshots/. The exact version does not seem to matter. To write this guide, I used version x264-snapshot-20120528-2245-stable.tar.bz2, but I have used previous versions too.
      

      cd ~/src

      wget ftp://ftp.videolan.org/pub/videolan/x264/snapshots/x264-snapshot-20120528-2245-stable.tar.bz2

      tar xvf x264-snapshot-20120528-2245-stable.tar.bz2

      cd x264-snapshot-20120528-2245-stable

   2. Configure and build the x264 libraries.
      

      ./configure --enable-static
make
sudo make install

      IMPORTANT: If you are running a 64-bit version of Ubuntu, you must configure x264 as shown in the following command:

      ./configure --enable-shared --enable-pic

      The -shared and -pic options might also be required when you compile for some other architectures, such as ARM. You know you need these options if you get the following error when compiling OpenCV:

      [ 25%] Building CXX object modules/highgui/CMakeFiles/opencv_highgui.dir/src/bitstrm.cpp.o
Linking CXX shared library ../../lib/libopencv_highgui.so
/usr/bin/ld: /usr/local/lib/libavcodec.a(avpacket.o): relocation R_X86_64_32S against `av_destruct_packet' can not be used when making a shared object; recompile with -fPIC
/usr/local/lib/libavcodec.a: could not read symbols: Bad value


8. Download and install install ffmpeg.
   1. Download ffmpeg version 0.11.1 from http://ffmpeg.org/download.html.
      

      cd ~/src
wget http://ffmpeg.org/releases/ffmpeg-0.11.1.tar.bz2
tar xvf ffmpeg-0.11.1.tar.bz2
cd ffmpeg-0.11.1

   2. Configure and build ffmpeg.
      

      ./configure --enable-gpl --enable-libfaac --enable-libmp3lame --enable-libopencore-amrnb --enable-libopencore-amrwb --enable-libtheora --enable-libvorbis --enable-libx264 --enable-libxvid --enable-nonfree --enable-postproc --enable-version3 --enable-x11grab

      make
sudo make install

      IMPORTANT: Just like with x264 in the previous step, you must configure ffmpeg with the -shared and -pic options if you are running a 64-bit version of Ubuntu or some other architectures, such as ARM.

      ./configure --enable-gpl --enable-libfaac --enable-libmp3lame --enable-libopencore-amrnb --enable-libopencore-amrwb --enable-libtheora --enable-libvorbis --enable-libx264 --enable-libxvid --enable-nonfree --enable-postproc --enable-version3 --enable-x11grab --enable-shared --enable-pic

9. Download and install install a recent version of v4l (video for linux) from http://www.linuxtv.org/downloads/v4l-utils/. For this guide I used version 0.8.8.
   

   cd ~/src

   wget http://www.linuxtv.org/downloads/v4l-utils/v4l-utils-0.8.8.tar.bz2

   tar xvf v4l-utils-0.8.8.tar.bz2
cd v4l-utils-0.8.8
make
sudo make install

10. Download and install install OpenCV 2.4.2.
    1. Download OpenCV version 2.4.2 from http://sourceforge.net/projects/opencvlibrary/files/
       

       cd ~/src

       wget http://downloads.sourceforge.net/project/opencvlibrary/opencv-unix/2.4.2/OpenCV-2.4.2.tar.bz2

       tar xvf OpenCV-2.4.2.tar.bz2

    2. Create a new build directory and run cmake:
       

       cd OpenCV-2.4.2/
mkdir build
cd build
cmake -D CMAKE_BUILD_TYPE=RELEASE ..

    3. Verify that the output of cmake includes the following text:
       • found gstreamer-base-0.10
       • GTK+ 2.x: YES
       • FFMPEG: YES
       • GStreamer: YES
       • V4L/V4L2: Using libv4l
    4. Build and install OpenCV.
       

       make
sudo make install

11. Configure Linux.
    1. Tell linux where the shared libraries for OpenCV are located by entering the following shell command:
       

       export LD_LIBRARY_PATH=/usr/local/lib

       Add the command to your .bashrc file so that you don’t have to enter every time your start a new terminal.

       Alternatively, you can configure the system wide library search path. Using your favorite editor, add a single line containing the text /usr/local/lib to the end of a file named /etc/ld.so.conf.d/opencv.conf. In the standard Ubuntu install, the opencv.conf file does not exist; you need to create it. Using vi, for example, enter the following commands:

       sudo vi /etc/ld.so.conf.d/opencv.conf
G
o
/usr/local/lib
<Esc>
:wq!

       After editing the opencv.conf file, enter the following command:

       sudo ldconfig /etc/ld.so.conf

       .

    2. Using your favorite editor, add the following two lines to the end of /etc/bash.bashrc:
       

       PKG_CONFIG_PATH=$PKG_CONFIG_PATH:/usr/local/lib/pkgconfig
export PKG_CONFIG_PATH

After completing the previous steps, your system should be ready to compile code that uses the OpenCV libraries. The following example shows one way to compile code for OpenCV:

g++ `pkg-config opencv --cflags` my_code.cpp  -o my_code `pkg-config opencv --libs` 

More Information

• If you encounter problems installing OpenCV, see the companion guide, “A Comprehensive OpenCV Installation Troubleshooting Guide.”
• Utkarsh Sinha runs AiShack, a site that has easy-to-understand tutorials using OpenCV to solve real-world problems: http://www.aishack.in/topics/tutorials/
• Sebastian Montabone has several articles on installing OpenCV and image processing. His web site is http://www.samontab.com/
• FakeOutdoorsman’s posted an excellent dependency install guide, which is located on the Ubuntu forums: http://ubuntuforums.org/showthread.php?t=786095

The post A Comprehensive Guide to Installing and Configuring OpenCV 2.4.2 on Ubuntu appeared first on OzBotz.

The code used in this example is based on the swave.c program from the kernel.org RT wiki, which is located here: https://rt.wiki.kernel.org/articles/s/q/u/Squarewave-example.html.

For instructions on how to run realtime Linux on your PandaBoard, refer to the tutorial that I posted on the Homebrew Robotics Club wiki titled “Installing Ubuntu With Real Time Patches On The PandaBoard.”

Code

The following code is all that you need to create the square wave. Save the code in a file called swave_panda.c.

// file: swave_panda.c
/* compile using  "gcc -o swave_panda swave_panda.c -lrt -Wall"  */

#include <stdlib.h>
#include <stdio.h>
#include <time.h>
#include <sched.h>
#include <sys/io.h>
#include <unistd.h>

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h>

#define NSEC_PER_SEC    1000000000

/* using clock_nanosleep of librt */
extern int clock_nanosleep(clockid_t __clock_id, int __flags,
      __const struct timespec *__req,
      struct timespec *__rem);

static inline void tsnorm(struct timespec *ts) {
    while (ts->tv_nsec >= NSEC_PER_SEC) {
        ts->tv_nsec -= NSEC_PER_SEC;
        ts->tv_sec++;
    }
}

int main( int argc, char** argv )
{
    struct timespec t;
    struct sched_param param;
    int interval=50000;  // 50000ns = 50us, cycle duration = 100us

    int fd;
    char zero_string[] = "0";
    char one_string[] = "1";
    char buffer[32];
    unsigned char value = 0;

    // Enable GPIO_32, which comes out pin 18 of J6. A list of available GPIOs
    // can be found in the PandaBoard System Reference Manual.
    {
        if ((fd = open("/sys/class/gpio/export", O_WRONLY | O_NDELAY, 0)) == 0) {
            printf("Error: Can't open /sys/class/gpio/export.\n");
            exit(1);
        }   
        strcpy( buffer, "32" );
        write( fd, buffer, strlen(buffer) );
        close(fd);
        printf("Added GPIO 32.\n");
    }

    // Set the direction of the GPIO to "out."
    {
        if ((fd = open("/sys/class/gpio/gpio32/direction", O_WRONLY | O_NDELAY, 0)) == 0) {
            printf("Error: Can't open /sys/class/gpio/gpio32/direction.\n");
            exit(1);
        }
        strcpy( buffer, "out" );
        write( fd, buffer, strlen(buffer) );
        close(fd);
        printf("Direction set to out.\n");
    }

    // Open the "value" node. We will write to it later.
    {
        if ((fd = open("/sys/class/gpio/gpio32/value", O_WRONLY | O_NDELAY, 0)) == 0) {
            printf("Error: Can't open /sys/class/gpio/gpio32/value.\n");
            exit(1);
        }   
        printf("Value opened for writing.\n");
    }

    if ( argc >= 2 && atoi(argv[1]) > 0 ) {
        printf("Using realtime, priority: %d.\n",atoi(argv[1]));
        param.sched_priority = atoi(argv[1]);
        // Enable realtime fifo scheduling.
        if(sched_setscheduler(0, SCHED_FIFO, &param)==-1){
            perror("Error: sched_setscheduler failed.");
            exit(-1);
        }
    }
    if ( argc >= 3 )
        interval=atoi(argv[2]);

    clock_gettime(0,&t); // Get current time.
    t.tv_sec++;          // Start after one second.

    while (1) {
        // wait untill next shot.
        clock_nanosleep(0, TIMER_ABSTIME, &t, NULL);
        if(value) {
            write( fd, one_string, 1 );
            //printf("...value set to 1...\n");
        } else {
            write( fd, zero_string, 1 );
            //printf("...value set to 0...\n");
        }
        value = !value;
        // Calculate next shot.
        t.tv_nsec+=interval;
        tsnorm(&t);
   }
   return 0;
}

Compile the program with the following command:

gcc -o swave_panda swave_panda.c -lrt

To run the program with a real time priority of 90, enter the following command:

sudo ./swave_panda 90

Hardware Setup

To view the output on a oscilloscope, connect the probe to pin 18 on J6. You can find ground on pins 27 and 28 of J3.

Results

After you run the program and connect your oscilloscope probe to pin 18, you should see a 10 KHz square wave, as shown in the following image.

The square wave is solid even when the system is under moderate load. Under heavy load, I can see a jitter of a few microseconds. I have yet to determine from where the jitter originates. I don’t know if there is some uncertainty in the kernel or if there is a uncertain amount of delay in the userspace GPIO drivers. None of my robots operate in conditions that are dangerous to humans or property, so I will probably be able to tolerate an uncertainty of a few microseconds. If you are designing a surgical robot, for example, a few microseconds of uncertainty might be too much. I will be investigating if this little bit of observed jitter can be reduced or eliminated.

More Informaion

I am interested in creating more realtime applications for the PandaBoard. If you have any experience creating such programs and you have any advice to offer or you would like to exchange ideas, please send me an email or add a comment to this post.

The post A Simple Realtime Application on the PandaBoard: <br>A 10 KHz Square Wave appeared first on OzBotz.

Update October 9, 2014: The Homebrew Robotics Wiki is down. An archived copy of the tutorial from the Wiki is repeated below.

git clone git://git.kernel.org/pub/scm/linux/kernel/git/clrkwllms/rt-tests.git
cd rt-tests
make

root@panda1:~# sudo cyclictest -t1 -p99 -n -i 100 -l 10000
policy: fifo: loadavg: 0.00 0.01 0.05 1/277 1542         
T: 0 ( 1542) P:99 I:100 C:  10000 Min:      0 Act: 1701 Avg:  729 Max:   14157

root@panda1:~# sudo cyclictest -t1 -p99 -n -i 100 -l 10000
policy: fifo: loadavg: 1.62 1.59 0.70 1/308 1738         
T: 0 ( 1738) P:99 I:100 C:  10000 Min:     11 Act:   12 Avg:   12 Max:      40

The post Installing Ubuntu With Real Time Patches On The PandaBoard appeared first on OzBotz.