DanShope.com

Syncing up SolidWorks

2009-11-24T13:03:00.009-05:00

As a man on the move who needs access to my data from many different machines, I had struggled to find a good solution to access my SolidWorks files.

The Requirements

Should be free or low cost (hopefully not subscription based)
Should synchronize files with minimal user input
Just works, never needs me to doctor it

I've worked with the professional solutions like Activault, but didn't need quite that level of functionality for my personal use. A subversion utility was intriguing, but generally required too much interaction (commits, updates, etc) for my general workflow.

After manually copying files onto thumb drives, remote desktop-ping, and trying to get a network drive up and running I decided enough was enough. So began a journey through several sync solutions.

Dropbox was my first solution, and worked nearly flawlessly. Updates were transparent, and I could share with other users as well as keep certain folders private. The versioning system was pretty nice and saved me some hassles a few times. I finally ran up against a few limits with the Dropbox service: storage capacity and directory limitations.

Dropbox Storage

You only get 2GB free, which is pretty sweet, but not really enough. My only other option was to purchase a subscription plan, which starts at a hefty $10 per month for 50GB. That's the same as my web hosting, which gets me unlimited storage!!

Dropbox Single Directory

One of Dropbox's most annoying limitations is the use of a single catchall folder. I wanted to retain my file structure which is a complex of files spread across multiple partitions. The more I relied on the service, the more this limitation made the service unusable. It just interrupted my workflow.

This service didn't quite get the full treatment as I was already a little jaded from my Dropbox experience. Overall it was a major step forward - I could impose my own file structure, syncing was seamless, and there were the nice versioning and web-interface features.

Syncplicity is a fantastic service, and probably cuts it for most people. It's gotten rave reviews, it just wasn't the right product for me. If you want access to more than 2 computers, you have to upgrade, again with a monthly subscription fee. It is also Windows only (for the moment)...

Which brings us to the winner,

Not quite fully cross-platform, this service allows syncing between PCs and Macs. Much like Syncplicity, you have full control over directory structure and updates occur immediately when machines are connected to the 'net.

The web interface needs a little work, but for the most part was snappy enough to keep me happy. The syncing occurs fast enough that I get versions of the little temp files (~XXX.sldprt) that SolidWorks creates while you're working. If you've just synced a large number of files and they aren't yet downloaded, double-clicking on the placeholder file will bump it up in the queue. Nicely it also alerts you when the file gets downloaded to your machine.

I found that full versioning control wasn't really necessary for my daily use. A nice trick occurs when you delete a file (this can be done from any synced machine, not just the creator). A deleted file will get moved to the recycle bin on any synced machines. This is generally enough of a safeguard to recover accidently deleted files.

End Result? Happily synced files! I've been using this for the past few days, and it's been quite amazing. I have to remind myself that I can access my files from anywhere. Best of all? It's all free!

Autonomous Platoons: Brought to you by Over-Engineered Solutions

2009-11-12T09:13:00.007-05:00

I was reading my news this morning when I stumbled across a new study funded by the European Union that got a little under my skin. (http://www.botjunkie.com/2009/11/12/truck-and-car-platoons-could-allow-for-autonomous-driving/).

The problem?

Drivers are lazy and can cause accidents.

Their solution? *European Union

Adaptive cruise-control vehicles that follow a lead vehicle on the highway. The lead vehicle is driven by a professional and the rest of the cars follow the leader while their drivers "take their hands off the wheel, read a book or watch TV."

There are a few problems with this. Overlooking the fact that trains have existed for decades, so this isn't truly a new concept, there are serious control issues that need to be addressed.

Follow the who?

How do you decide which vehicle is the lead? "Okay, so Bob is in front, and he's a truck, so I'll follow him. WOW! Bob is a terrible driver!" But I don't notice, because I'm sitting back, reading the morning newspaper.

Sure, you could have some smart software that decides Bob isn't going to get you to your destination safely, but if you're already going to have all that processing, why not just have full autonomy?

Make a left turn now!!

"Where am I?" Turns out Bob decided to take Exit 5, a few miles ahead of my actual destination. Since I wasn't really in control of my car, I lost time and fuel.

Perhaps there is some solution like pre-programming your route into GPS and letting the software take care of following its own path. But still, there's no guarantee that the driver hasn't fallen asleep when you need him to take back manual control.

Questionable Efficiency

The article cites a 20-40% efficiency gains from vehicles following closely, much like geese flying in a vee. What it fails to acknowlege is the fact that every member of this "platoon" has its own locomotion system. That efficiency calculation will probably tank when compared to a conventional train. There's also problems with wear and tear on each engine versus only needing to service a one or two engines, as in a train.

Conclusion to the Saga

There are definitely some interesting challenges to solve here, so I agree the study is worthwhile. It just seems like the focus is wrong -- a solution searching for a problem. And a problem that already has a better solution.

Mass transit isn't everywhere, and trains only work well on special tracks. The ability to travel in a train configuration while still retaining independent destination control is appealing. Our road systems and vehicle technology, however, do not have the necessary infrastructure to safely allow drivers to tune out while rolling down the highway at 60mph.

We've seen some great results from the recent DARPA Urban Challenge that alludes to the possible future of fully autonomous vehicles. I don't see a hybrid solution (people + robot) working out any time soon.

UPDATE: The NavLab at Carnegie Mellon did demonstrations of this technology back in the 80's.

Extending the Scout robot platform

2009-11-06T03:43:00.008-05:00

The Scout is a capable platform on its own, able to traverse rough terrain and avoid obstacles at high speeds. Even so, one of the main strengths of the Scout is its (rear) accessory interface.

Many research platforms were designed around a single purpose or only provide the ability for "expansion" cards in the form of networked printed circuit boards. Researchers working on the Scout platform won't be restricted to the current sensor/manipulation package, nor will they be constrained to fixed size add-on modules. The Scout provides power, data, and hardware attachment points to allow a variety of mechanical or sensor add ons. You can see the six threaded hard points in the rear of the vehicle, as well as a thrust bearing for pivoting accessories.

Dumb vs. Smart

The accessory interface attempts to be as non-restrictive as possible while providing both basic and advanced functionality to the designer. To that end we've denoted two classes of accessories, those with "smarts" (onboard processor) and those without. Both classes of accessories must identify their type/function as matched against an accessory database stored on each robot. This allows the OS to configure communications between the ARM and AVR at the bandwidth necessary for desirable performance.

"Dumb" Add-Ons

Dumb accessories are simple devices that only require power and access to an analog (input) or (2) digital I/O. This might be as simple as a wagon with a potentiometer for tracking position and a switch to indicate whether a load is present. Basic I/O pins are provided by the AVR.

"Smart" Add-Ons

A smart accessory has its own on-board microcontroller that handles all the low-level control. An I2C connection straight to the ARM9 processor is provided. Smart accessories can still access the AVR pins, although it should rarely be necessary. The forklift shown below is a "smart accessory" since it requires active control of the lift position and active monitoring of the RFID reader and loading.

Forklift/ Autonomous Distribution Warehouse

My favorite accessory to date, the forklift gives the Scout 0" to 6"+ lift capacity. Pulling tasks off the server, robots will autonomously move packages around, pausing to recharge when necessary. Mobile robots are already in use in semi-automated distribution centers, such as Staples.

The mechanism uses a three stage lift actuated by a cable pulley system. The RFID reader sits behind the carriage. When closed, the forklift does not extend into the sonar's sensing cone, enabling use of rear ranging data. The charging contacts also had to remain exposed so the robots can dock for battery refueling.

Dig & Haul/ Autonomous Excavation

Design to test cooperation between two or more robots, the dig and haul attachments provide an entertaining and challenging application of swarm robotics.

The designs both employ micro servos for actuation. Hauler also uses a load cell (force sensing resistor) to determine when the bucket is full and instruct the digger to halt loading.

Hauler could easily be implemented as a "dumb" accessory, but Digger requires it's own micro due the increased complexity of the control and positioning system.

What next?

Plans are in place to design a simple webcam interface, surveillance package, and a pan/tilt semi-automatic cannon. Have an idea of a sweet accessory? Add your concept to the comments below! I love hearing new ideas, no matter how radical.

Designing & Testing Robots: Colony Scout

2009-11-05T09:08:00.005-05:00

Colony Scout Updated Design

Between classes, eating, and sometimes sleeping I've been hard at work refining the Colony Scout robot. The core feature set has remained the same -- four wheel drive, rocker pivot platform powered by a lithium ion pack. The sensor package includes a front bumper, dual sonar rangefinders, battery level monitoring, localization beacons, xbee communications, wheel encoders, yaw gyroscope, and three axis accelerometer.

Shown here in green (one of many colors), the Scout now sports a vented enclosure for the electronics. RGB (multicolor) LED "headlights" shine out the front hood, which is magnetically clasped for easy access to the processing board.

The team has been hard at work designing the Scout board, which runs an ARM9 core mated to an ATmega 128A as a coprocessor. The ARM9 does the heavy lifting but leaves the very important role of gathering sensor data and driving the motors to the lower powered AVR chip.

Board design is custom and includes components specific to the platform. We are looking into POE (power over ethernet), USB, and external charging to power the system.

Scout will run a Linux RTOS -- as yet to be decided. Linux brings a lot of functionality to the table but also has its own quirks that will be interesting during development and testing. We hope to have a first run dev board in testing by December.

Diagnostic Station

Testing and validating the robot design only goes as far as production. The diagnostic station aids the maintenance process over the lifetime of the robot(s).

I went for a pipelined design whereby tests are separated spatially to allow faster throughput with multiple robots. This results in an elongated testing platform, but it still measures in under a yard...so far :-)

Assuming the robot can navigate to the station, it will ascend the ramp and proceed through the three stages. All tests and robot maneuvers are controlled by the Colony server, which handles scheduling and task assignments for all the robots.

Stage 1: Chassis Dyno & rBOM Tester

The motors and encoders are tested across the speed range of the robot. A sequence of tests is also performed with loading on the dyno rollers. This simulates the robot driving across different terrains.

Stage 2: Cliff Bridge

Between the two larger stations, the bridge tests the three cliff sensors through several cycles (see ladder-like design). This comes after the encoders/motors are calibrated for straight line driving. We don't want robots to go splat during a maintenance run!

Stage 3: Gyro & Accelerometer Station

The final and most complex station latches onto the robot and spins it for gyro testing. Accelerometer tests are also performed by spinning and tilting the robot. I'm still designing the internal mechanisms -- should be interesting.

Dyno Station Mock up (who doesn't love Legos(R)?)

Other News

I've also been working on the design and function of the charging station. So far it's pretty sweet with a low profile, modular design. I'll try to post some renders and details up soon!

Sharp IR Rangefinders and Arduino: Make your Robot Smarter

2009-06-24T02:00:00.011-04:00

Adding distance or proximity sensors to your robot is a great way to start exploring your environment intelligently. Rangefinders allow a non-contact method of “seeing” obstacles and can be employed in mapping and maze solving as well.

The Sharp family of infrared (IR) rangefinders is very popular amongst hobby roboticists because they are low-cost and easy to interface with (Voltage, Ground, and Signal). These hook up to a single analog input pin on the Arduino or similar microcontroller systems. There are a few caveats to watch out for though.

If your application is very time sensitive and needs tightly controlled, you’ll want to find out how long polling your sensor(s) takes. The Sharp sensors output an analog value (as a voltage), but microcontrollers only understand digital values (1 or 0), so that analog value has to be converted. Analog to digital conversion is pretty fast, but it can introduce some delays.

The sensors are also very noisy, meaning the analog output signal has a lot of "jitter" -- 20cm does not always equal 280, etc. Your code will have to account for this jitter, so you'll need to collect some real-world values to build your sensor model. This problem is exacerbated by the next issue, but can be overcome with a little bit of thought and time. I don't provide you the solution here because it's really dependent on your application. There is, however, a tool to help you evaluate your sensors (see below).

Moving on, take a look at this graph:

You’ll notice something interesting here – the graph has a weird curve and isn’t linear at all. This becomes tricky when trying to teach the robot to understand distance from the analog output of the sensor.

There are a few ways to get around this. If all you want is a simple threshold say “nothing closer than 20cm” then you can simply run a few tests with an object placed 20cm away from the sensor, and then hardcode that value into your program. Generally it’s a bit more complicated, if you want the program to understand varying distance.

Method 1:
Approach: Find a best-fit curve (generally exponential or polynomial) using a statistics package (Excel, R, Minitab)
Pros: Easy to implement, gets you started fast.
Cons: Requires floating point math, which isn’t natively supported by most microcontrollers. You can still use floating point, but it’s slow and inefficient in most cases.

Method 2:
Approach: Gather some data points and create a look up table of values. Your code will linearly interpolate values between each data point (ie, 5cm=600, 10cm=300, etc).
Pros: Uses integer math which is fast and efficient
Cons: Takes up more memory and doesn’t give exact values

Method 2 is the preferred approach as most embedded system developers take great pains to avoid floating point math. You can have some floating point math on the Arduino and be alright. I have a large (6KB) program right now that has floating point littered all over the place (it’s necessary for this code) and execution time runs just fine.

To help with gathering your data for both method 2 and simple thresholding I wrote a quick little application that interfaces with the Arduino’s serial connection. This app will pull your data in and calculate some basic statistics such as standard deviation, mean average, and range of values. You can store the data for future computation and reference.

Download the IRanalzyer at http://www.danshope.com/calton/ir.html

To use the IRanalyzer you need to send values from the Arduino. Here’s a sample sketch to get you started:


#define SerialSpeed 115200 //typical values are 9600 or 115200
#define SampFrequency 10 //sampling frequency in Hz (cycles per second)
#define AnalogPIN 0 //define your pin here

int mDelay;

void setup()
{
Serial.begin(SerialSpeed);
mDelay = 1000/SampFrequency; //calculate delay for proper sampling rate
}

void loop()
{
delay(mDelay); //delay in milliseconds
Serial.println( analogRead(AnalogPIN) ); //reads the analog port and prints value over serial
}

Inside the $400 Colony Scout: Robot on a Budget

2009-06-03T01:42:00.010-04:00

Now that I posted some videos of the Colony Scout in action, I’ll discuss the platform in a little more detail.

The basics: It’s a compact (4.75”x6”), four wheel-drive robot equipped with an array of IR distance sensors, automatic recharging capability, and other features yet to come. The current talk is to use an ARM7 based board running at 40MHz, paired with an unspecified ATMega for additional I/O.

Some background: The goal of the Colony project at the CMU Robotics Club is to develop a low cost swarm robotics platform capable of structured coordination to carry out tasks too difficult for a single machine.

Colony has been around for several years and has made great strides with a few robot upgrades along the way. The team is prepping the Scout as a potential replacement for the current ATMega 128L based robots.

The goal: The Scout is a deviation from the 2-wheel differential drive robots used in the past. While a common and versatile form factor, the two wheeled platform balked at any non-level terrain. Even driving up ramps or over wires can become an issue. Scout is designed to expand the exploration options beyond level and rectangular environments.

What’s new? Faster processors and an efficient code base will permit the Scout to actively respond to a complex environment. The new sensor array extends the current 5 IR sensors to 7 for additional range and cliff detection. A bump switch returns for the front bumper to detect obstacle collision (useful when purposely pushing objects).

Each of the Pololu wheels comes equipped with a quadrature encoder that gives ~3mm linear accuracy. The 10x12mm micro metal gearmotors are lighter, faster, and stronger than the Solarbotics GM8s on the current robots. Using four motors does draw more current, so the battery is upped from a 6V 2200mAh NiMH pack to a beefy 7.2V 4000mAh Li-Ion pack.

Conclusion: The Colony Scout is a tough little machine that can cross rough terrain while employing a multitude of sensors, all for a sub-$400 cost per robot. Plans are in place to make the robots “smarter” than ever before, and able to respond to the environment faster and in a more coordinated manner.

Summer 2009 is all about prototype testing – learning about the platform and its capabilities and limitations, so stay tuned – More videos and posts will be coming your way!

What do you think? What types of functionality, from line sensing to 3D mapping, do you think a cheap robot should have?

See http://www.danshope.com/blog/2009/05/putting-colony-scout-robot-through-its.html for more pics and vids on the Colony Scout.

Putting the Colony Scout robot through its paces

2009-05-31T00:10:00.007-04:00

The new Colony Scout platform was up and running for a few hours today as I continued testing the AWD system. Scout is a prototype platform for swarm robotics at the Carnegie Mellon Robotics Club.

We remade the baseplate out of 6061 aluminum on the CNC mill as the previous handcut plate was too soft and imprecise. I wanted the alignment of all the motors/wheels to be as consistent as possible for straight tracking with minimal correction from software.

The headers you see sticking up beside each wheel are for quadrature encoders - the encoders give the robot about 3mm linear resolution, which is decent for a vehicle of this size.

Another exciting component added today was the rocker, which allows the front and rear axles to swivel (vertically). This allows all four wheels to contact the ground during most terrain crossing, improving traction. The updated platform outperforms the Scout of two days ago, which featured a rigid baseplate.

The new components have a high degree of polish accomplished by good design and machining practices. Our club machine shop allows us to turn out quality parts and have a fast turn around time from concept to prototype.

Click through to http://www.youtube.com/watch?v=ePaPGyjW2uk to watch the video in HD.

There's also some great tests on http://www.youtube.com/watch?v=fyRmg570KJw from a few days ago.

Keep tuned for more updates this week!

Quick Gear Reduction Design Reference

2009-05-28T11:24:00.006-04:00

A properly designed gear train is very important for effective power transmission and efficient usage of your power supply. Often overlooked for hobby robotics, putting a little thought into your gear train can go a long way toward a successful design.

Many factors need to be taken into consideration, such as gear material, gear manufacturing method, speed, loading, and space considerations, as well as desired noise level and configuration (offset, concentric, etc). There are books of equations governing tooth profiles and gearing efficiency but for most work you’ll find an involute tooth profile governed by the Lewis formula with an American Gear Manufacturers Association (AGMA) dynamic correction factor.

The following information is provided as a generalized reference to gear train design and assumes you are familiar with basic gear geometry and types. For serious work use the linked references as they are more comprehensive and thorough.

Spur Gears

High efficiency, high power (98-99% eff)
Lowest cost for machining
Exert high radial loads on bearings
Offset drive

Helical Gears

High efficiency, very high power (97-99% eff)
Loses some efficiency due to high axial load and tooth slipping
Geometry allows full tooth contact à good for high power transfer
Quiet running (increase helix angle for quieter transmission)
Offset drive

Planetary/Epicyclical Gearbox

Fairly high efficiency, high power
Low radial loading from concentric design
Complicated assembly and varying torque outputs
Concentric drive

Harmonic Drive

Moderately efficient
Very high gear reduction in a compact size (30:1 to 350:1)
Zero backlash (30% of teeth always in contact)
Concentric drive

Bevel Gears

High efficiency (97-99%)
Used where right angle drive is required
Typically 1:1 to 6:1 ratios used
Complex tooth profile can be difficult to machine

Worm Mesh

Poor efficiency
High gear reduction in a compact size
Non back-driveable
Unsuitable for low velocity ratios
Offset drive (90deg)

See http://www.engineersedge.com/gear_design.htm for a detailed table on different gear setups.

Notes:

1) Higher pressure angle increase radial loading on bearings (called separation force), but decreases stress on gear teeth and minimizes bending. A higher pressure angle results in a lower contact ratio and thus a noisier gear train.

2) The most common pressure angle is 20deg. Case hardened 25deg teeth can carry about 20% more torque than a 20deg form. Because of factors discussed in Note 1, a 22.5deg form is a good compromise that provides about 11% more torque carrying capacity.

3) Gear efficiency in multiple stages (spur gear) is calculated by the product of the efficiency of each stage: E_stage1*E_stage2*100=E_total à 0.98*0.98*100=96.04% efficiency.

4) Hunting ratio: non-integer ratio where a given pinion tooth will touch every tooth on the gear before touching the same gear tooth twice (13:48 is a hunting ratio, 12:48 is not). This design reduces wear and tear on individual teeth as the gear teeth mesh at different points from revolution to revolution.

References:
1. Dudley, Darle W. Handbook of Practical Gear Design. CRC Press. 1994.
2. RoyMech Engineering Reference. http://www.roymech.co.uk/Useful_Tables/Drive/Gear_Efficiency.html
3. SDP/SI Tech Library. http://www.sdp-si.com/Sdptech_lib.htm.
4. Epicyclic Gearing. Wikipedia. http://en.wikipedia.org/wiki/Epicyclic_gearing
5. Basics of Harmonic Drives. http://www.powertransmission.com/issues/0706/harmonic.htm

SolidWorks Models

2009-05-12T23:49:00.004-04:00

If you're not familar with 3DContentCentral.com, hop on over and check it out -- it's a great warehouse for 3D parts from both official manufacturers and common users like you and me.

I have a bunch of "robotics" parts -- gearmotors, brackets, battery packs, motor controllers, etc, as well as some miscellaneous furniture/electronics.

You can view my feed at http://www.3dcontentcentral.com/RssSubscription.aspx?pageFrom=ContribSumm&profileId=248781&userName=Daniel%20Shope

That's Just Boulderdash!

2009-04-06T01:58:00.003-04:00

The Carnegie Mellon team participated at the 2009 ASME Mars Rocks competition in Dayton, OH a few weekends ago. You can watch our robot, Boulderdash here http://www.youtube.com/watch?v=oY4gXETGdrw or see a competition recap at http://www.youtube.com/watch?v=nQIlcrWNil0.

I'll be posting more about the design of our rock sweeper soon! Until then enjoy the videos. Thanks to Jimmy Bourne for the media editing.

Do You Know How to Arduino?

2009-03-12T22:54:00.008-04:00

I had a great day prototyping with new Arduino Duemilanove. Other than the frustaingly long name we got along pretty well!

The board came from SparkFun along with a protoboard -- I didn't get the protoshield yet, but it's only another $16 so it might be a future purchase. Also arriving today was the compact accelerometer breakout board from RobotShop. One box came by snail mail, the other by UPS, so it was quite exciting when they arrived literally within minutes of each other.

The Duemilanove is a great board -- solid components, automatic power switching, plenty of IO, and an upgraded ATmega chip. I'm definitely going to like having the extra storage on board for my new project.

I had to do a lot of fiddling to get the accelerometer to work well, but most of this was software tweaking. The actual circuitry took all of fifteen minutes and the arudino sketch was really fast.

#include

void setup()
{
  Serial.begin(115200);
}

void loop()
{
  Serial.print("X");
  Serial.print(analogRead(2));
  Serial.print(",Y");
  Serial.print(analogRead(1));
  Serial.print(",Z");
  Serial.print(analogRead(0));
  Serial.print("|");
  delay(250);
}

There's the arduino code to read three analog values from the accelerometer -- I've pushed them into a format that looks like 'X000,Y000,Z000|' for ease of parsing. The code sets up the serial communications at 115200, a common speed for PC work.

If you're hooking your board up to say a BASIC stamp or other board, the speed will typically be 9600baud. This is simple - just change the setup code to say Serial.begin(9600);.

So, back to the filtering issues -- the Arduino board runs at 5V, so it expects an analog pin to input between 0 to 5V. The accelerometer outputs from 0 to 3.3V, so it effectively loses 33% of the full range of the arduino pin.

Arduino outputs a signal (when it reads the pin) between 0 and 1024. For an accelerometer, 0 means full negative acceleration, while 1024 means full positive accleration. What "Full" means varies on your accelerometer sensitivity range. Mine is adjustable from +/-1.5g to +/-6g (g==multiples of gravity, i.e. 9.81m/s^2).

To graph the data I needed to scale my output == instead of 1024 being max, 675 was the new maximum; 0 stayed the same. There was also a dropout issue where the signal would drop to full negative (0V, 0 output) every few seconds. This was determined to be a software issue, so I simply discarded any input that matched this characteristic.

It's pretty trivial in most langauges to set up a serial port monitor -- you can also simply use the serial port monitor right in the Arduino IDE, but you can't do anything except watch the raw data scan by....pretty useless for actual work, but great for debugging.

I consider myself a visual learner, and assuming you're the same -- here's the final accelerometer data. The green is the Z axis, red == X axis, and blue == Y axis. The X and Y axis average to around zero, which is good == the board was level and stationary. The green axis is hovering below the rest...do you know why?

Yep, we still haven't figured out how to turn gravity off. I think that's a good thing! If we're properly calibrated, the Z axis will be registering an average of 1g when standing still.

Well, I'm off to prototype more stuff! Now to try a Sharp IR rangefinder and some more serial data transfer using the digitial pins (0 & 1).

Simple Guide to Backing up your MySQL Database

2009-02-25T04:19:00.006-05:00

Lesson number one: never fully trust the hardware your database is running on. If there’s ever a crash or some level of corruption you lose your data, which is bad, bad bad.

How do we avert this calamity? Frequent backups – using the MySQLDump Utility. This is also really useful to test on your off-network machine before moving new scripts to your production server – think of it as real-world dummy data.

The Basics

MySQLDump is a little utility that is packaged with your MySQL installation. It can be found in the installation path, in the bin folder (C:\Program Files\MySQL\MySQL Server 5.0\bin).

Open the Windows Command Line prompt (start, run, cmd) and use the following format:

mysqldump -u [user name] -p [database name] > [dump file]

Some people will tell you to enter both your username and password here, but I like to omit the plaintext password as the utility will then prompt you in the next screen and use the ****** mask, so the person walking behind you doesn’t get your root password. The “-p” flag just tells the export utility to expect a password for authentication.

Break it down

[user name]: I usually export using my root account, so “root” would go here. You can use any account that has high enough privileges.

[database name]: Here’s where things get fun. You can set all kinds of parameters if you wan to export a single database, all databases, just the data, just the schema, etc. Here we’ll list a single database for simplicity’s sake.

[dump file]: This is the full path (file name included) that you want to export to. I find it’s really easy just to dump right into the C: drive using “C:/output.sql” or something of that form. The greater than arrow just tells the utility we are dumping the left argument into the right argument, much like a funnel.

Let’s Review Our final query should look like the following:

cmd> mysqldump -u root –p students_db > C:/output.sql cmd> Enter Password: *************

Cross your fingers, hit enter, and see what happens! You’ll need to open your local disk through My Computer to check if the file was exported.

Troubleshooting If there doesn’t seem to be any response from the command window and no file is outputted, try using the full file path the function likeso:

cmd> “C:/Program Files/MySQL/MySQL Server 5.0/bin/mysqldump” -u root –p students_db > C:/output.sql

You need the quotation marks since there are spaces in the filename. Otherwise the command line will interpret separations as different arguments and won’t work properly.

If you still aren’t getting a file, make sure that your password and username are valid, and that the database name you gave actually exists.

Conclusion

You can open the outputted file right in notepad, it looks like the following (not to scary, eh?)

- MySQL dump 10.11 -- -- Host: localhost Database: students_db -- ------------------------------------------------------ -- Server version 5.0.51a-community-nt

/*!40101 SET @OLD_CHARACTER_SET_CLIENT=@@CHARACTER_SET_CLIENT */; /*!40101 SET @OLD_CHARACTER_SET_RESULTS=@@CHARACTER_SET_RESULTS */; /*!40101 SET @OLD_COLLATION_CONNECTION=@@COLLATION_CONNECTION */; /*!40101 SET NAMES utf8 */; /*!40103 SET @OLD_TIME_ZONE=@@TIME_ZONE */; /*!40103 SET TIME_ZONE='+00:00' */; /*!40014 SET @OLD_UNIQUE_CHECKS=@@UNIQUE_CHECKS, UNIQUE_CHECKS=0 */; /*!40014 SET @OLD_FOREIGN_KEY_CHECKS=@@FOREIGN_KEY_CHECKS, FOREIGN_KEY_CHECKS=0 */; /*!40101 SET @OLD_SQL_MODE=@@SQL_MODE, SQL_MODE='NO_AUTO_VALUE_ON_ZERO' */; /*!40111 SET @OLD_SQL_NOTES=@@SQL_NOTES, SQL_NOTES=0 */;

…SOME CODE OMITTED…

/*!40101 SET SQL_MODE=@OLD_SQL_MODE */; /*!40014 SET FOREIGN_KEY_CHECKS=@OLD_FOREIGN_KEY_CHECKS */; /*!40014 SET UNIQUE_CHECKS=@OLD_UNIQUE_CHECKS */; /*!40101 SET CHARACTER_SET_CLIENT=@OLD_CHARACTER_SET_CLIENT */; /*!40101 SET CHARACTER_SET_RESULTS=@OLD_CHARACTER_SET_RESULTS */; /*!40101 SET COLLATION_CONNECTION=@OLD_COLLATION_CONNECTION */; /*!40111 SET SQL_NOTES=@OLD_SQL_NOTES */;

-- Dump completed on 2009-02-25 9:12:38

If the basic export doesn’t cover your needs, check out http://dev.mysql.com/doc/refman/5.1/en/mysqldump.html to see what flags you can set. I’ll be covering importing your data back into MySQL soon – there are several different ways to do this, some better than others.

RobOrchestra Update: Bass Drummin' Bot

2009-02-16T00:14:00.007-05:00

This past Friday was quite productive for the RobOrchestra team as two instruments were constructed -- the first two for this year.

A few of the guys got together Friday afternoon and built a hurdy-gurdy prototype. The stringed instrument is constructed from a cardboard box and plywood frame. So far the instrument sounds decent when turned, but needs some work on amplification. Using material other than cardboard should definitely help the acoustics...

Fellow RobOrchestra member Andrew Burks and I spent the better part of Friday night (yay social life) working in the shop on the bass drumming robot (as yet unnamed). Andrew made an awesome SolidWorks model which we used as a reference for the parts.

The basic design uses a Bimba air cylinder limited to ~0.5" stroke under 30psi. The cylinder has pivot points at both ends. The pivot points took a lot of machining as we had some pre-existing components that needed to be modified to allow attachment points. One screw up and we were out those parts and had no spares. Fortunately, everything went off without a hitch.

Once the cylinder has pivots at both ends, one end gets attached to the "shoe" of the pedal, the other end inside our robo-leg. We have some sweet plans for decorating said leg -- but until then...

here's a truly amazing picture of yours truly, oh how flattering :-)

Project SIGMO: Humanoid Robot

2009-01-23T08:19:00.002-05:00

As you may have noticed, a few projects went live in the robotics playground this week. My pet project, SIGMO (synthetic intelligent mobility), an efficient humanoid robot, is one of those projects.

SIGMO uses a so-called passive dynamic design to accomplish bipedal walking. Instead of using motors to govern the kinematics of each joint, some joints are passive and thus energy is conserved. Walking is a complicated process but is largely controlled by mechanics inherent to the system.

A properly designed mechanism can thus walk with little power, getting closer to the walking efficiency of the homosapien. Robots like ASIMO consume lots of power to move around, whether they are walking on level ground, downhill, or up stairs. A passive dynamic robot is most efficent when walking downhill, requires a little more input when walking on level ground, and for the most part can never walk up stairs.

It's my goal to find a balance between the two -- essentially using two or more modes of locomotion. The motorized system rides along during flat and level walking, and engages only when directed power is needed -- such as in the event of stairs, uneven terrain, or if the robot is falling.

So far I am designing the new skeletal structure, a test bed of sorts, for the new components I will be adding shortly. The "old" SIGMO was a short (<2feet>

SIGMO 2.0 will retain this funcionality, add some more DOF, and still have room for the electronics box and power supply. The method of accomplishing this is to upsize the robot, which has always been a goal of the project. The new robot will be more lifesize -- it should be slightly taller than ASIMO, closer to 5 feet. I'm not sure on the exact size yet, but it will be several times larger than the existing model.

You can check out the project's humble beginnings at the robotics playground website.

Organizing Site Content Effectively

2009-01-19T14:44:00.009-05:00

In an earlier post I discussed the balance that must be struck between template driven design and full on user-creativity. Below is the strategy employed by the robotics playground, which provides an array of templates to get you started on organized project documentation, fast.

General Layout
This layout encompasses all general publishing needs. The layout is flexible and allows you to document your project as you see fit. Use it to create unique layouts and present novel ideas.

History

The project history layout incorporates elements specific to documenting your project’s progress over time. Use it like a journal in realtime and get updates published to your project’s home page!

Meet the Team

Create a members page where viewers can meet the members of your team. Who knows, it could be a great way to get a job offer or put a plug in for your website/blog.

Materials/Parts List

One of the least actively documented facets of a project is purchasing. A few months or years from now you probably won't remember what's in a particular project without tearing it apart. Avoid the hassle and allow others to reproduce the awesomeness you created!

Assembly Instructions

The cousin of the parts list, assembly instructions can prove vital to continuing projects. Popular projects will encourage future development from other members by providing some instructions for reproduction. It's a great way to involve the community.

Frequently Asked Questions

A great way to involve users interested in your project is to provide a question and answer area where they can quickly learn background and supporting information about the technologies you use in your project..

These are just a few of the templates that allow you to create site content. There's more where they came from, and based on your suggestions I'm sure we'll create more. Again with the balance, there won't be so many templates that it's hard to choose between 2, or too many to look at...!

What templates would you like to see/use?

Update: Robotics Playground Templates

2009-01-19T14:33:00.002-05:00

The last few weeks have been focused on getting the robotics playground up and running for the beta testers. A big part of configuring the system is deciding how to organize and deliver the user content.

On one hand, we can take the MySpace approach and give users nearly free reign to post whatever they want. This is good, because it allows creativity and novel presentation of design. The bad thing is, general 'net users don't create very compelling designs -- even if you know what looks good/bad, you aren't always motivated to create good design.

Enter the Facebook/LinkedIn approach -- novel content, "strict" layout. This is good because it allows people to post content without requiring much effort in design. It appeals to a different but broader set of users.

The DanShope.com Robotics Playground paradigm finds somewhat middle ground. The software will provide some basic templates that expose targeted functionality for different facets of project documentation. There is also a more general template that allows for some level of customization.

While this is in no way a new concept, our approach feels very hands off while guiding the design elements into an aesthetically pleasing form. This balance is something that must be considered at both the user interface and the back end/supporting software phases of development.

If the platform is too restrictive, it doesn't inspire users to post their creative content -- but if it's too loose, viewers en masse might find it displeasing to hunt out information and won't feel comfortable on the site.

I'll be posting more about these templates shortly.

I'm Back!

2009-01-18T17:32:00.003-05:00

So, I sort of went on hiatus for a while over winter break. Now the new semester has started and I'm back with high-high-high speed internet versus that painful dialup connection at home.

I vow to start posting some new stuff again! My big focus for the past few weeks has been the robotics playground -- there are two sample projects to check out right now in the robotics section. I'm pretty happy with the layout so far and the design is fundamentally about information delivery.

That means form follows functionality, which for most website content, is a must. If you have any feedback on the design, let me know and I'll see what I can do! The robotics playground can't get off the ground without user feedback, so I'm all for lists of pros & cons!

d out.

Using PHP include() to Create a MySQL Login

2008-12-11T02:20:00.011-05:00

Last time we looked at connecting and transferring data between MySQL and PHP, but it was all in one file. In practice, we need to separate the “calling” code and the login code so that if our login information ever changes, we only have to update it in one place. This is also more secure as we can store the do_login function in a secure directory, instead of having the username and passwords stored in large number of files and directories.

The first file we’ll need to create is do_login.php (see below). We’ll reference this file in every page that needs access to the database. It’s the same code as I used before, with a few changes. First, the code is wrapped in a function doDB, so that we can call it from our page code. I also added a parameter called $data_name so that we can pass in a particular database.

This can be very useful if you are using multiple databases, such as one for Members, Books, News…etc. If we didn’t use this parameterized function we’d need a different do_login file for each different database, which uses more file space and requires more maintenance.

do_login.php

<?php 
//set up a database login function
function doDB($data_name) {
            global $mysqli;
            //connect to server and select database; you may need it
            $mysqli = mysqli_connect("localhost", "username", "password", $data_name);
            //if connection fails, stop script execution             if (mysqli_connect_errno()) {
                        printf("Connect failed: %s\n", mysqli_connect_error());
                        exit();

            }}
?>p;

This file alone is pretty useless as it just attempts to establish a connection to the database and gives an error if it’s unsuccessful. We need to attach this file to our other code – the worker code that retrieves data from the Members database.

memberlist.php

<?php  
//recall the do_login file
include($_SERVER['DOCUMENT_ROOT']."/resource/do_login.php");  
//make the connection using the function call doDB
doDB("memberDB");  
//get member information
$get_data_sql = "SELECT lastname, firstname, email FROM members WHERE lastname LIKE “F%”;  
//get the data or exit if there is an error
$get_data_res = mysqli_query($mysqli, $get_data_sql) or die(mysqli_error($mysqli));  
while ($member_info = mysqli_fetch_array($get_data_res)) {
            $lastN = $member_info['lastname'];
            $firstN = $member_info['firstname'];
            $email = $member_info['email'];  
echo “Last Name: “.$lastN.”First Name: “.$firstN.”Email: “.$email.”; 
}  
//close connection to MySQL
mysqli_close($mysqli);  
?>

The last 2/3 of this code should be pretty familiar – it’s the same as the previous memberlist code we looked at last time. The big change is at the top. The line

include($_SERVER['DOCUMENT_ROOT']."/resource/do_login.php");

uses an in-built php function “include” that just says – take the file inside the parentheses and paste it into this document.” The include directive pulls in the specified file and treats it like a text file. If you could see the php code after this include statement is executed it would look something like (some code omitted):

<?php
//set up a database login function function doDB($data_name) {

global $mysqli; //connect to server and select database; you may need it

……….

//make the connection using the function call doDB
doDB("memberDB");

//get member information
……….

Congratulations! Now you know how to connect files in PHP using the include() function. You’ve also seen a function call – doDB(“memberDB”) calls the function doDB, which in turn attempts to establish a connection the the database memberDB. You can use this code from anywhere on your site – the $_SERVER[‘DOCUMENT_ROOT’] part ensures that PHP starts looking for your file from the domain root (www/).

This same strategy can be employed to load static headers and footers on each of your webpage so that navigation only has to updated in one place! If you want to dynamically load the title into each webpage, all you have to do is pass a $title parameter to the function you write! It’s really that simple, and you’ll be on your way to mastering PHP.

MySQL Engine Wars: InnoDB vs MyISAM

2008-12-05T13:39:00.000-05:00

This isn’t a post to start the flame wars between the MyISAM and InnoDB camps, it’s just a short blurb to list some facts about both and let you hash it out in the comments. For those of you not in the know, two of the widely used MySQL database engines (engines control how the data is stored and accessed) are MyISAM and InnoDB, both which have their niche. If you look this up online, there’s a whole lot of discussion about “which is better”, but there’s not really one overall metric that sums up either engine.

I was going to write a little guide with a table comparison of different features such as row locking, key constraints, and full text indexing, but I came across this great post over at Tag1 Consulting. Hop on over for a good read about the differences between the two engines and when it is appropriate to choose one over the other.

MyISAM vs. InnoDB @ Tag1 Consulting

MySQL & PHP: Connecting and Transferring Data

2008-12-03T10:51:00.005-05:00

In previous posts I’ve covered a general overview of how SQL and PHP work together and the benefits of creating dynamic content. We have discussed content management systems and how they can simplify your life as a webmaster. Now we’ll start to look at how to actually construct a content management system, starting with connecting PHP to MySQL.

First, we need to establish a connection using the builtin PHP function, “mysqli_connect”. The old PHP functions for MySQL communication have been outdated by the new “mysqli” family of functions. The standard functions haven’t been deprecated, so you can still use them, but the added functionality of the “mysqli” group is very useful to have.

Let’s set up an example where we connect to a MySQL database and pull out the member names, just like in the other examples. For clarity’s sake I’ll use the standard SQL functions instead of regular expressions.


<?php
 //declare a global variable for database interaction (can be called by any function)
global $mysqli;  
//connect to server and select database; you may need it
$mysqli = mysqli_connect("localhost", "username", "password", “memberDB”);  
//if connection fails, stop script execution
if (mysqli_connect_errno()) {
            printf("Connect failed: %s\n", mysqli_connect_error());
            exit();
}   
//get member information
$get_data_sql = "SELECT lastname, firstname, email FROM members WHERE lastname LIKE “F%”;
  //get the data or exit if there is an error
$get_data_res = mysqli_query($mysqli, $get_data_sql) or die(mysqli_error($mysqli));
while ($member_info = mysqli_fetch_array($get_data_res)) {
            $lastN = $member_info['lastname'];
            $firstN = $member_info['firstname'];
            $email = $member_info['email'];
echo “Last Name: “.$lastN.”First Name: “.$firstN.”Email: “.$email;
 }
//close connection to MySQL
mysqli_close($mysqli);
?>

When using this code, you will need to fill in “username” and “password” with the actual values you have set up for your database. It is bad practice to use the root account for this, as any script would have administrative access. Instead, set up another account that only has SELECT, INSERT, and UPDATE privileges.

In the (while) loop we are pulling the data out of an array we construct from the record that MySQL returns based on our query. We then echo or print to screen the information so we can verify the script is working. Notice the break (
) tags inside the echo line – we are embedding HTML tags in PHP scripts. The other parts of the notation enable us to string together strings and variables. When the final print out is made, we will have something like the following:

Last Name: Falwell
First Name: James
Email: jfalwell@gmail.com

Last Name: Farney
First Name: Sarah Marie
Email: sarah_baby@msn.net

….

Last Name: Flaherty
First Name: Timothy
Email: tflaherty@salvationarmy.org

Pretty neat huh? We can use similar code to insert data into the database. The main code that we will reuse is the connection code, so perhaps we should make it modular and stick it into its own function. Next time I’ll show you how to make a login console that you can access from everywhere on your site and connect to different databases or using different logins! We’ll also discuss the php include() directive and how to make your page code modular to save space and leverage the power of the PHP scripting language.

Quick MySQL Reference Sheet

2008-12-01T14:55:00.005-05:00

As promised here is a quick guide to some of the most frequently used commands in any SQL environment. You can find a more detailed description in the introduction to relational databases.

Commands are not case-sensitive - they do not need to be capitalized. It's common practice to use all caps for commands so that dynamic data (table names, inserted values) can be noticed with ease.

CREATE Command - is used to create a database/table.
SELECT Command - is used to retrieve data from the database.
DELETE Command - is used to delete data from the database.
INSERT Command - is used to insert data into a database.
UPDATE Command - is used to update the data in a table.
DROP Command - is used to delete or drop the database/table.

Syntax for Query Commands

CREATE Command
The Create command is used to create a table by specifying the tablename, fieldnames and constraints as shown below:

Syntax:

mysql> CREATE TABLE tablename;

Example:

mysql> CREATE TABLE tblstudent(fldstudid int(10) NOTNULL AUTO_INCREMENT PRIMARY KEY,fldstudName VARCHAR(250) NOTNULL,fldstudentmark int(4) DEFAULT '0' ;

SELECT Command
The Select command is used to select the records from a table using its field names. To select all the fields in a table, '*' is used in the command. The result is assigned to a variable name as shown below:

Syntax:

mysql> SELECT field_names FROM tablename;

Example:

mysql> SELECT * FROM tblstudent;

DELETE Command
The Delete command is used to delete the records from a table using conditions as shown below:

Syntax:

mysql> DELETE * FROM tablename WHERE condition;

Example:

mysql> DELETE * FROM tblstudent WHERE fldstudid=2";

INSERT Command
The Insert command is used to insert records into a table. The values are assigned to the field names as shown below:

Syntax:

mysql> INSERT INTO tablename(fieldname1,fieldname2..) VALUES(value1,value2,...) ;

Example:

mysql> INSERT INTO Tblstudent(fldstudName,fldstudmark) VALUES(Baskar,75) ;

UPDATE Command
The Update command is used to update the field values using conditions. This is done using 'SET' and the fieldnames to assign new values to them.

Syntax:

mysql> UPDATE Tablename SET (fieldname1=value1,fieldname2=value2,...) WHERE fldstudid=IdNumber;

Example:

mysql> UPDATE Tblstudent SET (fldstudName=siva,fldstudmark=100) WHERE fldstudid=2;

DROP Command
The Drop command is used to delete all the records in a table using the table name as shown below:

Syntax:

mysql> DROP tablename;

Example:

mysql> DROP tblstudent;

A Simple Guide to Constructing Advanced SQL Queries

2008-12-01T14:14:00.002-05:00

Last time we defined the meaning of a database and picked apart a few examples queries from the MySQL camp. To recap, we looked at CREATE TABLE, INSERT, UPDATE, ALTER TABLE, and SELECT statements. Just to refresh your memory, they use the following syntax (abbreviated listing):

SELECT a, list, of, stuff FROM tablename

ALTER TABLE tablename ADD name datatype other_parameters

UPDATE tablename SET colname = somevalue WHERE somecolumn = ‘some_value’

INSERT INTO tablename (list, of, colnames) VALUES (‘list’, ‘of’, ‘values’)

CREATE TABLE (colname_1 datatype, colname_2 datatype, …colname_N datatype)

These are just a few of the basic commands or queries that are typically executed on a daily basis. Create Table is a little rarer in an established application since we are focusing on getting data into and out of an existing database. Applications that must dynamically create a database every run time are a niche product and do not represent typical behavior.

SQL Search Engine
Let’s say you want to make a SQL search engine that pulls data out from our members database. Suppose we want to generate a listing of all of the members, sorted alphabetically. We could construct the following query:

mysql> SELECT * FROM members ORDER BY lastname ASC;

This will pull all of the data about each member and return a list that is sorted from A to Z. If we want the data returned from Z to A we would specify DESC (descending) after ORDER BY instead of ASC (ascending). At a minimum SQL will let you sort by an integer column, alphabetical (VARCHAR or TEXT), decimal or floating point, and date columns. Since the SQL engine doesn’t know the lexical ordering of raw binary data, BLOB columns aren’t typically sorted. Even TEXT columns, since they have an “unlimited” length, will only sort up to X amount of characters (this value can be changed at the cost of system efficiency).

Grouping the Data
Well, that was fine and dandy, but I have over 25,000 members and that’s just too large of a list. Perhaps we could break it down a little more, let’s say by letter. We want to be able to create an interface like that below, where we can click on a letter and get all of the last names that begin with that letter, sorted alphabetically to return the following results:

A B C D E F G H I J K L M N O P Q R S T U V W X Y Z

Name Email

Falwell, James jfalwell@gmail.com

Farney, Sarah Marie sarah_baby@msn.net

Fardwood, Alexandra cutsiepie99@hotmail.com

Fickleton, Martin martin_fickleton@cnn.com

Fiduciary, Dixon fdixon@gatech.edu

Fixington, Thomas thomas-the-tank@gmail.com

Flaherty, Timothy tflaherty@salvationarmy.org

We would construct the query:

mysql> SELECT lastname, firstname, email FROM members WHERE lastname LIKE “F%”;

The syntax used here is a call to a SQL function “LIKE” that can take parameters such as the “F” and “%”. The % is a wildcard that matches any number of characters. There are different wildcards that can match single characters, or a specified number of characters.

Perhaps you want a more advanced engine than can find parts of words (substrings) inside a given column. We can modify the above example by adding a “%” before the letter.

mysql> SELECT lastname, firstname, email FROM members WHERE lastname LIKE “%F%”;

Now we will get any and all members that have an “F” somewhere in their last name. The wildcards just say “find an f” even if there are letters to the left or right. Notice that % matches zero or more characters – the search will still return the members who’s last names begin with “F”.

Regular Expressions
If you want to do even more advanced searches you can use regular expressions. Regular expressions provide a concise and flexible means for identifying strings of text of interest, such as particular characters, words, or patterns of characters. Regular expressions are written in a formal language that can be interpreted by a regular expression processor, a program that either serves as a parser generator or examines text and identifies parts that match the provided specification. They can be very complex or very simple – returning results such as those above, or employed in an advanced data processing suite. Regular expressions are not SQL based, they are used in almost every developed programming language available.

Regex based searches are generally very efficient and can be optimized for speed by an advanced programmer. As with most programming paradigms, there are many ways to employ regex strings to attack any one problem. There are “best-practices” to follow when using regular expressions, but in general you need to become familiar with the technology and syntax before you start optimizing statements.

As exemplified by this XKCD comic, regular expressions are a very powerful tool that you will make you wonder what you ever did without them. Now, it’s not absolutely required that you start using regular expressions right now; in fact, it’s probably better for you to get accustomed to the SQL syntax before delving into this more complex topic. That being said, I’ll show you a few quick examples of what regex searches can do for you!

Let’s start with the example above. We wanted to find all members whose last names started with the letter “F”. To make this into a regular expression based search, we’d simply type the following.

mysql> SELECT lastname, firstname, email FROM members WHERE lastname REGEXP “^F”;

or to be more explicit,

mysql> SELECT lastname, firstname, email FROM members WHERE lastname REGEXP “^F.+$”;

If we break down the search string “^F” we have two components, the letter we are searching by and some other character “^”. This character just tells the regex engine to start looking at the beginning of the word. If we would omit the “^” we would get all results that had an “F” anywhere in the lastname column.

The second example adds a few more characters that explicitly define our search as “starting at the beginning of the last name, search for an F and any other characters until the end.” The dollar sign “$” is a tag for the end of the string. “.+” just represents any number of any characters. The “.” specifier matches any character, including numbers and whitespaces, while the “+” symbol says to apply the previous specifier to any number of characters.

This is a very basic example of regular expressions and the syntax used in more advanced SQL queries. I’ll be posting a simple table guide later so you don’t have to wade through an entire post to get the information you need! Let me know your thoughts in the comments!

SolidWorks Lesson 1.4: Sweeps, Assemblies, & Mates (Yo-Yo String)

2008-11-30T23:20:00.003-05:00

Last time we created a yo-yo body and learned how to use rotational extrusions and mirrored sketches. In this lesson we'll learn how sweeps work, start using assemblies, and learn about the SolidWorks assembly attachments called "mates". At the end we'll have a functional yo-yo...well, sort of! Let's get started!

Create a new document, and choose the Right plane to start your sketch.
Draw a horizontal straight line about 2” long (start at the origin)
Select the spline tool. Click on the end of your last line, and draw a loop.

You may need to play around with this a little since you don’t want your loop to overlap itself at all
We need smooth curvature, so be sure not to make any “sharp” bends

Now selecting the Front plane, start a new sketch. You will need to rotate the view manually either by clicking with the center mouse wheel and dragging across the window, or by using the standard view buttons.
Select the circle tool and sketch a small circle at the origin.

If you created the other lines properly, this should be centered on the straight line.

Dimension this circle with a 0.0625” (1/16”) diameter using the “smart dimensions” tool.
Now click the Sweep/Swept feature button on the Features Toolbar.
Your profile is the circle; your path is the line.

You might see how this could be useful for making complex paths
Feel free to play with this feature when you have some free time!

If you get an error message and SW doesn’t let you create the sweep, there might be something wrong with your model.

Make sure that the circle we are “sweeping” over the long profile is significantly smaller than the line. If the 3D solid will intersect itself because the loop is too small or the circle too large, SW will give you an error message
There may be a sharp angle between the straight line and the loop. To fix this, simply apply a large sketch fillet to the first sketch, say, ½ to 1” radius.

If you went through the yo-yo tutorial, you should now we have a yo-yo string and a body, but they’re in separate documents. We create a SolidWorks assembly document to put our pieces together.
Create a new Assembly document (File, New, Assembly).
Using the “Insert Components” dialog (replaces the property manager), select your yo-yo body or using the browse dialog locate and insert this.

The first part you insert into an assembly will be the “origin”. If you delete this origin part and insert parts later, the assembly will NOT be constrained in 3D space, a big problem for FEA or any physical simulations.

We will use the concept of mates—creating relationships between the parts using the geometry we have created.

For this step we will use a less-useful mate, the “tangent” mate to fix our string to the inner radius of the yoyo.

Not completely constrained, but it will work for this non-functional model (prop)
Your yo-yo is complete!

The 8 Step Guide to Starting & Marketing Your Website

2008-11-29T01:16:00.006-05:00

Perhaps you've been browsing the web lately and thought about starting your own site. You might have something you want to share with the world, or just want to show off your work. There's also the lucrative prospect of marketing your product via the web. A lot of beginner's guides out there only talk about how to pick out a website template and neglect to tell you about how to market your site and scams to watch out for. The 8 step guide is designed to get your site a good footing and help you build on this solid foundation. Post any remaining questions in the comments!

Set a Clear Goal.
The first order of business is having a clear goal for your site. Who is your target audience, and what are you trying to "sell" to them? Whether you're actually selling a product or not, you are marketing your site to build up readership. If you don't offer something of value to your customers, they won't have a reason to come back. Try to find compelling content that is in line with your company or focus and that your viewers will appreciate.
Custom or Pre-fabbed?
Once you have a focus for your site, you'll want to start thinking about how you will present this content to your viewers. Should you get your own domain (web address) and start from scratch, or would blogging software (Blogger, WordPress, MoveableType, LiveJournal, Xanga) better suit your needs? Blogs are great because you can be up and running literally in minutes. A custom site takes more work but can be very rewarding in the long term. No matter what course you decide to take, make sure that you can supply your site with the time and care it needs to maintain fresh content and get recognized by search engines.

If you're going the custom route, you will need both a domain name and hosting. The domain name should be a (.com,.org,.edu,.biz) based on your needs. In my experience it's best to start with a .COM unless you are an organization, in which case .ORG will resonate with your viewers better. Most people will try .COM by default if they forget the full website address, so it might be good to have this domain registered anyway. Hosting just means where your pages will be stored and people can access them from. Potential viewers will type in your website address, get pointed to your domain, and a page request will be made. There's a lot of mixed reviews out there, but some good companies for both hosting and domain purchasing are GoDaddy.com, IPower.com, and Register.com.
Research SEO.
Before you open your site do some research on SEO or Search Engine Optimization. SEO is a science in its own right; trying to figure out how the big search engines work is a full time job. Luckily for you numerous companies, such as HubSpot.com and PepperJam, have sprung up in recent years and specialize in this topic. You can rely on their expertise to fashion your website into a robust marketing tool. You can also find books at your local library or book retailer focused on SEO. These can be an invaluable resource in marketing your website to the masses.
Designing your site.
If you're starting a custom site it might be useful to hire a graphics designer or find someone with an art and publications background. You want to organize your layouts in a manner that is optimized for the content that is the most important to your viewers. Later we'll discuss in more detail how to determine the optimal layout for your site based on your long term goals.

A great way to start thinking about your site's design is to keep a list of websites that you like in terms of style and layout. Start constructing a color palette that will compose your site. You can hand these to your designer to help streamline the design process. If you're doing the work yourself, you'll have some choice references to work from. I even like to take screenshots of the sites I like and keep a folder of designs styled to my liking. When I need to do a new layout or refresh the site's look, I'll pull out my portfolio of resources which saves a lot of time and doesn't require me to revisit the sites. This is especially helpful if the site's layout changes in the meantime, or if the site becomes unavailable.
Creating your site layout.
Once you've determined the niche your site will fulfill, and have an idea of the colors and some graphics you like, you are ready to optimize your page layout(s). Start by listing the different elements of your site for a given page. You might have a list like the following:

Logo
News & Updates
Testimonials/Quotes
Banner Ad
Weekly Blurb
Blog Posts
Footer

You should rank these by importance and give each a weight (out of 100%). Do a little research about what users look at on websites. A great study is eye-gaze tracking, which is widely used by marketers to create better targeted layouts. I could try to give you the perfect recipe here, but the fact is layouts can be different for every site and you should expect to do some research when creating your site. Website design and maintenance is a time-consuming but fun process that will pay off in the end. The next phase is called "wire-framing" where you create box layouts for each element of your site we listed above. The placement of these boxes should be determined by the ranking you set for each of your elements. Read this great article about wire framing pages and creating site flowcharts. If you're looking for something more radical, this article from Usability Post has some great graphics examples and a guide to "breaking out of the box." There are other great, comprehensive guides out there, just do a search for "how to start a website" or "creating my website".
Bringing the Design to Life.
Now that you have your website design, you'll want to start building the code behind your site. The designer should have a solid understanding of HTML, CSS, Javascript, and PHP, CGI, SQL for more advanced dynamically driven sites. If you're using blogging software, consult the documentation for your particular vendor. You can find well-designed templates online or design your own, but you must use the proper markup for your vendor.
Testing and Validation.
Before you put your site online, TEST TEST TEST. Test it from all the major browsers (Internet Explorer 6/7/8, Firefox, Safari, Opera) as well as clicking on all the links to make sure they work. If you are using forms on your site, walk through the entire process of submitting a form. If users are signing up for accounts, make sure you have code that tests against duplicate usernames and invalid passwords, or expired validation links if you're sending out confirmation emails. When your site goes live, everything should "just work." Remember that whole thing about first impressions? Yep, it applies here big time. Don't rely on your visitors coming back if they have a bad experience the first time around. In fact, studies have shown that users browsing the web make a decision on any given site (whether to stay or go) within seconds of loading.
Marketing your website.
The worst thing you could do at this point is forget to market your website. No, I'm not talking about spending thousands of dollars on your local radio station ads, or doing some fancy-schmancy TV ad. Those are all well and good but there are some much easier and less-costly ways to get your site noticed. One of the best things you can do is social networking. This buzz word just means get out and establish an online identity that people will recognize. Get on Facebook, LinkedIn, ZoomInfo, StumbleUpon, Digg, Delicious, and all those other Web 2.0 sites and start posting. Now, DON'T do link spamming or any other nefarious method of getting links to your site. The point here is to intrigue people enough about "who is this guy?" that they go to your profile and click on the link to your site. Also, people WILL start to notice frequent posters across various domains. Just be sure not to give out any personally identifiable information as ID theft is a real issue here.

Be wary of linking schemes and sites that advertise "google-bombing" and other means to instantly propel your site to the top of the search ranks. The truth is getting your site recognized takes time, but the legitimate links you establish will outlast and out value any artificially elevated search engine trickery. Also, you risk removal from Google's index if you are found to participate in these schemes.

Conclusion
So let's recap! You should find a focus or niche for your site, design what type of hosting you want to use, and go about designing your website in a way that will be robust and extensible in the future. Once you have your design on paper, start turning it into useable markup language and test it out on a secure area of your site. Once you're ready, publish your site and start marketing! You're on the way to success.

Update: I just read a great post from ProBlogger about starting out your blog with great content and how to market yourself. Head on over to ProBlogger for a useful read!

Starting MySQL: What’s a Relational Database?

2008-11-27T19:03:00.005-05:00

Relational databases tie data together to reduce repetition and minimize storage used. Data can be stored compactly with intelligent relationships between tables and columns. When we start exploiting the features of a properly constructed relational database, the power of the SQL language is available to us. A relational database can be defined as

A database structure composed of more than one flat file (2-dimensional arrays) that can be transformed to form new combinations because of relations between the data in the records, in contrast to hierarchical and network database structures.

For example, in an earlier post I discussed the Members table of the content management system used at DanShope.com. The Members table contains all of the information provided by any given user, associated to a primary key, ID. Other tables such as the Projects table references this as MemberID so that we can tie specific projects to a particular member without repeating all of the member data in each project record.

In the same way, each project has its own ID that is referenced by the Pages table as ProjectID. Now we can have lots of pages that all point to one project, which points to one member. Any one member can have lots of projects that each contains lots of pages. This is an example of a one-to-many relationship, where the one MemberID is related to many projects, and each ProjectID is related to many pages.

Getting back to the MyLibrary example, we might also add another table called Members and a few columns to our existing tables, (ID, MemberID, SignedOut). The ID column should be configured as an Unsigned Integer (only positive whole values), Auto_Increment (each new record has an ID 1+ the last ID), and Primary Key (Each ID is used only once). To add a column to an existing table we use the following

mysql> ALTER TABLE Books ADD id INT UNSIGNED NOT NULL AUTO_INCREMENT PRIMARY KEY;

I also specified this column as “NOT NULL” which means a value is always required. Since this is an auto_increment field, we WILL always have a value, automatically. MemberID will also be an unsigned integer so that it matches the ID column we will create for the Members table. However, it should not be auto_increment since we will need to specify this relation manually.

When we need to sign a book out of the library, the book record is updated to set the SignedOut field to true and the MemberID field to the ID of the member receiving the book. We can do this using the following syntax:

mysql> UPDATE Books SET MemberID = ‘1’, SignedOut =’true’ WHERE ID=’2’;

To use the UPDATE syntax we must already know which record we are updating using the WHERE clause. For other types of queries we can use nested or joined statements, such as getting the names of all the members who currently have books out.

mysql> SELECT Books.Title, Members.Name FROM Books LEFT JOIN Members ON Books.MemberID = Members.ID WHERE Books.SignedOut=’true’;

Here we are doing something pretty magical. I’m able to pull intermixed data from two seemingly unrelated tables, Members and Books. Indeed, by searching through the Books table for records that are signed out, pulling the associated MemberID, and comparing it to the ID in Members, I can get the Member’s name or any other pertinent information. You can see that if we added a date due column I could even test which members had books overdue and automatically compile a list for the librarian.

There are different types of JOINs based on what you are trying to accomplish and which SQL engine you are using. In this example we used a LEFT (INNER) join; there are also RIGHT (OUTER) joins. Left joins just mean that we will return every single unique record from the table listed leftmost (Books) and any records that match it from the right table (Members). If we did a RIGHT join we would get a list of all members whether they had books signed out or not.

Oh, how far we’ve come from our simple SELECT * FROM Books statement just moments ago. Now we are really starting to see the power of SQL and how properly constructed statements can do the heavy lifting of our data once we have it inserted.

Getting the data in place isn’t that difficult, and for a dedicated application you would hard code the statements instead of manually typing them every time. Even with these hardcoded statements, the data that doesn’t stay the same (anything after the equals sign) could remain dynamic. “Hardcoded” could either be a string or set of strings we store inside our application, or they could be SQL Prepared Statements, a really nifty feature we will discuss later. They both have the same end result (getting our data), but prepared statements have some neat benefits in the realms of security and database efficiency.

There’s a lot to be said about relational databases, indeed entire volumes have been published about the subject and it is still an area of constant research and refinement. I’ll post more examples later on that utilize data connections between tables that allow us to export valuable statistics and other data that would be time-consuming to correlate without the magic of SQL.