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!

1. Create a new document, and choose the Right plane to start your sketch.
   
   
   
   
   
   
2. Draw a horizontal straight line about 2” long (start at the origin)
3. Select the spline tool. Click on the end of your last line, and draw a loop.
1. You may need to play around with this a little since you don’t want your loop to overlap itself at all
2. We need smooth curvature, so be sure not to make any “sharp” bends
   
   
   
   
   
   
   
   
   
   
4. 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.
5. Select the circle tool and sketch a small circle at the origin.
1. If you created the other lines properly, this should be centered on the straight line.
6. Dimension this circle with a 0.0625” (1/16”) diameter using the “smart dimensions” tool.
   
   
   
   
   
7. Now click the Sweep/Swept feature button on the Features Toolbar.
   
   
   
   
   
   
   
8. Your profile is the circle; your path is the line.
1. You might see how this could be useful for making complex paths
2. Feel free to play with this feature when you have some free time!
   
   
   
   
   
   
9. If you get an error message and SW doesn’t let you create the sweep, there might be something wrong with your model.
1. 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
2. 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.
10. 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.
    
    
    
    
    
    
11. Create a new Assembly document (File, New, Assembly).
12. Using the “Insert Components” dialog (replaces the property manager), select your yo-yo body or using the browse dialog locate and insert this.
1. 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.
13. We will use the concept of mates—creating relationships between the parts using the geometry we have created.
1. For this step we will use a less-useful mate, the “tangent” mate to fix our string to the inner radius of the yoyo.
14. Not completely constrained, but it will work for this non-functional model (prop)
15. Your yo-yo is complete!

Labels: 3d modeling, CAD, CAD lesson, guide, Parametric Modeling, SolidWorks, yo yo

Labels: guide, Managing a Website, marketing your site, starting a website

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.

Labels: Databases, INSERT, JOIN, MySQL, relational databases, SELECT, SQL, UPDATE

In the last few topics I’ve been talking about these information storage repositories called databases, but what are they really? We’ll talk about SQL databases as applied to MySQL examples, but understand that the fundamental principles of databases apply to all the engines, whether you’re using SQL Server, PostgreSQL, Oracle, SQLlite, MySQL, or some other variant.

Merriam-Webster’s defines a database as:

 “a collection of data organized especially for rapid search and retrieval (as by computer)”

If you open any given database file you’ll see a bunch of plaintext (human-readable) characters, and some large chunks of numbers. If the database is encrypted for security purposes, you won’t be able to read it like this. From this we can see that the actual data storage isn’t really what’s special; it’s the SQL engine that interprets this data.

Data is stored in tables, or sets of similar data. Inside a table is a set of columns, just like in a spreadsheet. Let’s look at an example of this data structure. Say we have a database, MyLibrary. Inside MyLibrary you can imagine we might have tables for Books, Magazines, Movies, and Music. The books table would have columns for (Title, Author Last, Author First, Genre, Publisher, ISBN, Call Letters, etc.). When we insert data into the books table, we simply add a new row. Each of the other tables (Magazines, Movies, and Music) would have similar columns to store and sort the relevant data.

So how do we actually create our databases? Once you have your selected client installed, you need to construct a CREATE TABLE statement that will form the database table and columns we want. For our books table, we would execute the following:

mysql> CREATE TABLE Books (Title TEXT, AuthorLast VARCHAR(30), AuthorFirst VARCHAR(30), Genre VARCHAR(50), Publisher TEXT, ISBN VARCHAR(13), CallLetters VARCHAR(3) );

Let’s break the statement down and look at what each part means. The “mysql>” part isn’t something you would type – that’s the prompt in the MySQL Command Line window (graphic). The words after each of our columns are format specifiers that set the data type of each column. All of the data we are storing right now is text-based (TEXT and VARCHAR). TEXT columns can store large amounts of text data, such as news articles or essays. VARCHAR columns are fixed-width, meaning you must specify the maximum number of characters that can be stored. For the Author fields, I assumed that most names are not going to be over 30 characters long. The ISBN is a much more valid assumption since the maximum ISBN is indeed 13 characters long. If you try to insert data that is longer than the field width it will simply be truncated to length. There are several other datatypes we can store such as INT (numbers), DECIMAL (numbers with decimal places), and BLOB (binary data, such as pictures).

To interact with your database you can use either a GUI (graphical user interface) based system where you click and drag elements around to insert, update, and delete data, or a command line tool. Both are equally good methods of working with data, but you will learn a lot more if you use the command line tool. It might look a little bit intimidating at first, but if you follow the syntax given here everything should work just fine. To insert data we need to use the following syntax:

mysql> INSERT INTO Books (Title, AuthorLast, AuthorFirst, Genre, Publisher, ISBN, CallLetters) VALUES (‘My First Book’, ‘Brown, ‘Joe’, ‘Romance’, ‘Tommy Nelson Publishers’, ‘0194820184928’, ‘BRO’);

After we specify the table name (Books) we must send a list of columns we want to insert data into. In this example we were inserting data into every single column, so we could have omitted the section between Books ... VALUES. However, in general we need to specify these columns since generally we don’t know all of the information for a particular record at time of insertion.

Once we have some data added, we can use a SQL Query to retrieve records from our database. A record is just a set of data about a unique record. If I want to see all of the books I own, I would execute the following query:

mysql> SELECT * FROM Books;

We start with “SELECT”, which just tells SQL that we will be returning records. Later we’ll look at other words that start SQL statement like DELETE, UPDATE, and INSERT. The “*” is a wildcard character. In this case it means “return all data about this record” or “return all columns of data for this record”. In place of the star we could list a specific subset of the columns or just specify our own order such as (Title, Author Last, Genre) to only return three columns of data. “FROM Books” just tells the database engine that we are trying to get data out of the Table named “Books.” This could have just has easily been Magazine, Movie, or Music, as long as the columns listed in the statement appear in that table. For example, we couldn’t perform a search for a column named “Call Letters” on a Music table if that table didn’t have its own column named “Call Letters”. The semicolon “;” is just a terminating character that tells MySQL to execute the preceding statement.

Now say we want to get a list of books by a specific author. This is where databases start to get really cool – they’re great at sorting your data very quickly. If we want to look up books by Joe Brown, we would construct a query like

mysql> SELECT * FROM Books WHERE AuthorLast = ‘Brown’;

This looks pretty much like our last query, but we’ve added a WHERE clause. The WHERE clause allows us to filter our data so we only retrieve those records we are interested in. You can construct advanced WHERE clauses, such as filtering only books by Joe Brown in the Romance genre published after December 21^st, 1995. That WHERE clause would use “AND” between each statement, such as

… WHERE AuthorLast =’Brown’ AND Genre=’Romance’ AND PublishDate > ‘1995-21-12’;

Another useful filtering uses “OR” between statements. We can use OR to select books by multiple authors or genres, for example. A sample query for using WHERE and OR might look like

… WHERE AuthorLast =’Brown’ OR AuthorLast=’Martin’ OR AuthorLast=’Samson’;

Now you have learned what a database is, how to create a table, store some data, and pull it out with intelligent queries. Next time we’ll talk about what it means to have a so-called “relational” database and how to exploit a fuller feature set of the MySQL database engine.

Labels: Databases, Lesson, MySQL, PHP, SQL

The "suspension bridge" design (cutaway view) modeled in SolidWorks

Plastic composite fingers were strong and stylish

The final design (prototyping material)

Labels: cmu robotics club, news, roborchestra, robotic flutophone, SolidWorks

Labels: CAD, carnegie mellon, cmu robotics club, drumming robot, news, roborchestra, robot arm, robotic drummer, snarebot

 

Both of these tools are very useful for relating symmetrical geometry about an axis, whether 2D or 3D. If you get any errors during the lesson (highlighted lines and SW will tell you somethings wrong) try deleting some sketch relations. You can tweak the model after we're finished, but make sure you save it since we'll be working with it again later!

1. Open a new part in SolidWorks

2. Click the ‘Edit Sketch’ button (alternative way to start a sketch), and select the front plane.

3. Draw ½ of the top of a yo-yo (1/4 of a yo-yo) shape using lines and a sketch-fillet
a. Sketch fillets work the same way as feature fillets, but are faster to calculate
b. They can make geometry changes later on more difficult, so use them wisely

4. Add a centerline and mirror the top half of the yo-yo by selecting the entire sketch (left click and drag) and clicking the axis we want to mirror across. In this case we want to use the vertical centerline that starts at the origin (short line). This will simply reflect all of the lines we selected across that axis. You can dynamically change either side and the other side updates in real time to show the modifications. Pretty sweet!

5. Click the ‘exit sketch’ button once your sketch is fully defined

6. Click the ‘rotational extrude’ button and select the bottom line through the origin as our central axis. This is really similar to the mirror, except we are rotating a 2D sketch through space to create a 3D volume. You can do some pretty cool stuff with this tool (try making chess pieces!) so learn how to use it!.

7. Click the green check mark to create the 3d model

8. Play with your virtual yo-yo!

9. We can go back into our feature by right clicking on that feature in the Property Manager and selecting Edit Feature or Edit Sketch, depending on what we want to do.

10. Let’s select Edit Feature, and change the angle from 360 to 180 or 123 or 25.

11. Change your model back to 360, and click okay, or just click the red X.

12. Now let’s try Edit Sketch. This will allow us to go back and change our geometry.
a. Since we used a mirror, we only have to update one quarter of the geometry for everything to work. What a time saver!
b. You can drag the geometry around a little, or enter new dimensions.
c. Once you are satisfied with the changes, click the green check mark.

Labels: 3d modeling, CAD, CAD lesson, SolidWorks, yo yo

What is in a CMS?

Your basic run of the mill content management system will have feature such as page addition, modification, deletion, access control (priviliges), the ability to restructure your site on the fly, and a file managment utility. The major CMSs have lots of functionality that you can expose with third party or open source plugins. If a CMS is making you do more work than using notepad and an FTP client, something is wrong. In fact, the whole point of a CMS is to make maintaining your site as pain free as possible. That's why so much of the work has been done for you. Those third party plugins can save you a lot of time and give your site functionalities that you wouldn't have ever thought of by yourself.

KISS

I'll admit, at first blush I thought a CMS was totally cheating. It's funny that I can be so young and yet an "old-school" web developer. After trying to manage my ever-expanding site a few years back, and barely coming up for air, I've seen the light. Some of you may be familar with the acronym KISS (Keep It Simple, Stupid). It's a helpful thing to keep in your backpocket no matter what type of project you find yourself involved with. A CMS is a beautfiul example of KISS in action.

Properly implemented, I should be able to log in to my site, and in just a few clicks be ready to publish a new article, open a forum, or revamp my home page. That's the goal of the custom CMS used at DanShope.com, and for the most part it works pretty well. The great thing about writing it myself is that I know how everything works and when I learn a new trick, I can apply it to my site.

That being said, open source solutions such as Drupal, Joomla, and OpenCMS also expose the code to you. If you're interested you can learn how these powerful suites work, and even become a contributor to the next release. Just be sure that you don't get so wrapped up in it you neglect your own site!

Why make a custom solution?

Well, seperate from the reason given above, I really like to control my content from the ground up. It's partly a matter of trust and partly OCD. Okay, so maybe not too extreme, but I do like to know what's going on. The CMSs listed above are very stable projects and you shouldn't have any fears of implementing them on your site.

That being said, for DanShope.com I wanted both the experience of writing my own CMS and the safety of owning my code and not being tied to anyone else's development. Since I wrote the scripts behind this site, I don't have to wade through pages of someone else's source code to try to add a new feature if community development stops.

Lets talk graphics

The other major facet of a custom CMS is related to graphics and site presententation. I'm not really talking about the ability to customize your site instead of blindly applying templates, but speaking more to the styling of the CMS itself.

As the graphics designer of DanShope.com I am obviously happy with my work (or else it would get changed). Since I am going to be using the CMS just as often as regular site interaction, I want to get to use the pretty interface as well. Thus, with my own solution I can control the CMS layout, down to the pixel. Thus, I get a consistent view whether I'm showing someone an article on the site or adding the next news post. That consistency also comes across as very professional. Part of good website design is re-using thematic elements as often as possible. Now, you don't want a boring layout that seems repetitive, but it should feel unified.

This can be difficult on large corporate sites that have multiple departments publishing content with different perspectives on good site layout. A CMS helps relieve that stress by forcing content into a particular mold, but a mold that you control. If sometime down the road you want to change site layout, you can propagate that change through all of your pages without blinking. Compare that to manually retrieving the source of each and every page and updating it to reflect the new changes. Believe me, I've done it and gone through a lot of ibuprofen in the process.

Third party CMS solutions can be really clunky since they need to be general purpose and work for a wide variety of sites. Truth be told, I'm not sure of a good way to implement a generic CMS that can look nice without sacrificing functionality. Since I know the type of content on DanShope.com I can intelligently structure the CMS so I can do what I need to while using a graphically consistent interface that feels intuitive to use.

How does it work?

The CMS solution on this site works as follows. I log in to a control panel, and select the type of managment I want to do (post to the blog, add a news article, welcome a new member, etc.). Once I select my action, I'm brought up to a page that let's me accomplish my goal. For a news site, this is a bunch of well placed text boxes that let me construct the article title, author, any references, and the article itself. I also have scripts to let me insert pictures into an article and create novel layouts at my whim.

When I'm done inserting content, I simply press "publish" and my page is inserted into the database, and a link is added to the news index. The news home and archive cached pages are both deleted so that they reflect the newly added content. None of the other articles need to be touched, unless I want to update the article relationships (related article suggestions).

The interface used to manage all news articles. It uses the same fonts, colors, and layout as the rest of the site so it feels very fluid and unified.

Later on, if I want to edit an existing article I simply click an edit button on the article page and am taken to another interface that mirrors the article creation page. The only difference here is that my content is preloaded and when I hit "publish" this time it will update the existing record instead of creating a whole new page. The cached pages get deleted again to reflect the updated record.

Conclusion

I hope that you now have a little better understanding of a general CMS and how the DanShope.com management system came to be. If you're looking for a free and easy to use CMS that includes hosting, why not start a blog? It's simple, and you get to join an ever growing community of bloggers (who are really cool, by the way). If you have your own domain, check out Joomla or Drupal. Both of these solutions are well-formed and have active development. I also recommend you do some reading. There's a lot that can be discussed about CMSs, too much to cover here, so if you want to learn something specific just ask in the comments!

Labels: CMS, Content Management, Managing a Website

The main shoulder joint is driven by a Hitec HS-805BB servo, a real monster. I like this servo a lot because it can pretty much give whatever you ask from it. Stall torque is rated at 343oz-in and I also had a gear reduction on the shoulder joint that increased the torque by about 1.75x.

The elbow joint was a lot of fun because I chose to use two HS-311 servos in conjunction. This configuration provides stability for both sides of the joint and bumps up the maximum torque. Since I still had a lot of mass to control outset from the elbow the extra capacity was necessary. These servos produce around 42oz-in of stall torque, which was sufficient for this design. In the actual controller code the servos rotate in opposite directions, so I had to be concious of them trying to fight each other. Overall this joint performed the best and was super fast!

Here's a side view of the whole 'bot. The gripper mechanism is pretty neat but not functional. You can sort of deduce this from the one piece of aluminum sheet metal holding it on. I ran out of time to make it work well, but decided to attach it for asthetic purposes. The basic mechanism has a rotating cam that spreads the two fingers. The grip is supplied by spring returns on each finger. It also features a passive locking system on the cam when the fingers are completely closed.

The large gear on the shoulder joint gave me a lot of problems since it wasn't a very high quality part. The interface between the HS-805BB servo and the shoulder gear was difficult to maintain and the joint frequently slipped when it was moved too fast. In an attempt to maintain that joint better I added the large aluminum brackets you see here. They did help a lot, but still couldn't maintain the level of consistency I wanted from the arm. I plan on re-machining everything from aluminum when I build the snare-bot arm (similar design) for strength and precision.

You can see the press-fit bearings used at the shoulder joint. It was pretty epic putting precision bearings into fibrous hardboard material. They fit quite snug, looked pretty, but were totally over-engineered for this choice of construction material. You can also see the controller board here -- a Lynxmotion SSC32. This board is my favorite serial servo controller I've used so far with 32 outputs, daisy chaining capabilities, a wide range of baud rates, and a relatively compact footprint.

The controller board was connected by serial cable to a laptop running Windows and a serial servo controller program I wrote. This is the "kid" version of the software which has pre-scripted macros for cool demonstrations. I typically use a stripped down version of this program to run all of my 'bots that use the SSC-32. If you are interested in the board go to Lynxmotion and check it out. If you get or have the board and want the basic software (8 channel control and terminal window) send me an email!

Labels: lynxmotion, robot arm, robotics, servos

This worked well for a long time as few sites had frequently changing content and almost all pages were static. Once the web got more advanced and more news sites and other "dynamic" content started popping up, it became apparent that the old management schemes wouldn't be sufficient. Maintaining a site with any reasonable number of pages gets very difficult, especially as you add more and more content. Take for example a news site that includes a link to a monthly archive on each page. For the first few months, everything is pretty simple, but even four or five months in, you might be editing upwards of 150 pages with each coming month! That's absolute craziness and a waste of your time.

The solution? Keep your website under five pages. Just kidding. So how do you support dynamic content without the personal overhead? First, let's define "dynamic" content. Dynamic pages are those created on the fly by virtue of a content management system. CMSs are great because they allow the rapid addition, modification, and deletion of content from a website with only a few clicks. No more opening the HTML code and tediously copying tables and pasting the new data in place. There are commercial CMS packages that you can purchase, but I recommend one of the free open source solutions. Or, you could be really cool and roll your own!

To get back on topic, that sounds cool, but what does that have to do with caching? Old sites basically had the cache thing down pat. Their pages were static and required very little computation overhead from the server. All it had to do was say "Here! Found it!" and return the page. By contrast, SQL and PHP based systems have to pull the information from the database and generate the markup code EVERY time someone asks for it. That's like writing the same report over and over again: from scratch.

Caching is Your Friend

At the heart of caching is an inherent laziness. I like to call it working smart. Caching a page just means that the first time someone asks for the page, I create it, then store that pre-processed version. When the next person comes along, I just pull that pre-processed page off of my desk and hand it off, a nice throw back to the good ole' days of static web pages and animated gifs. This caching reduces the computational overhead (over time) since we can rely on work we did in the past. The only catch is that we have to be concious of deleting the cached pages every time a change is made.

So our flow looks more like that above. User requests a page, PHP scripts say "Hey! Do you have a cached version?" If not, the SQL database is polled to compile the page, and it's then stored on the server as a cached file. Once the next user comes along, the PHP script can pull the pre-processed page off the server and quickly display it to the user.

Show me the code!

This is the basic format of the page caching utility used by the news section at DanShope.com. Since there is one script that is accessed to display every single news article we must have some way of indentifying which page to render, which we pass as "id". The page first looks to see if a cached version of itself exists. If a file does exist, then it reads in the cached page and displays it, then exits. No more work needs to be done by the script, since we are relying on previously compiled markup.

If the cached file doesn't exist, we must create it. This is where the ob_start() function call comes in. It's simply a PHP function that freezes all data we write out into a buffer so that we can access it later. After the page is displayed the PHP script at the bottom simply gets all of the information out of the buffer and writes it to disk. Voila, you have a cached page.

<?php
....
$cacheFile=$_SERVER['DOCUMENT_ROOT']."/cache/id".$_GET["id"].".html";

if (file_exists($cacheFile)) //we can read this cache file back reduce database load
{
header("Content-Type: text/html");
readfile($cacheFile);
exit;
} else {
ob_start(); //start buffering so we can cache for future accesses
}
...
?>

<html><body>
DO THE HTML RENDERING HERE
</body></html>

<?php

// get the buffer
$buffer = ob_get_contents();

// end output buffering, the buffer content
// is sent to the client
ob_end_flush();

// now we create the cache file
$fp = fopen($cacheFile, "w");
fwrite($fp, $buffer);
fclose($fp);
?>

Labels: cache, CMS, Content Management, MySQL, PHP

Labels: CMS, Content Management, MySQL, PHP

Labels: Login, OpenID, OpenID Provider, Security

For your first lesson we'll start off with the basics. After this lesson you should know some basic techniques of CAD modeling and begin to understand the Solidworks interface. You might also be hungry, if we do a good job with our donut!

1. Start with a new part (File, New, Ctrl+N)
   
   
2. Click the ‘Extrude Boss/Base’ button
   
   
3. Now we will need to select a plane – TOP
1. If you hover over a plane, it will be outlined in red
2. Clicking on this plane will select it – if you make a mistake, we can exit the sketch and start over
   
   
4. The window will rotate to the top view, centered on the origin
   
   
5. Click on the ‘circle’ tool on the sketch toolbar
   
   
6. Click on the origin, then click again outside of the origin
1. While you are moving the mouse, you will see the circle being created
2. We will set the size later on
   
   
7. Now make another larger circle using the same technique.
   
   
8. Now our sketch is created, but we should put sizes on.
1. Locate the ‘smart dimension’ button on the dimensions toolbar
2. Click this, then click the inner circle
3. Drag your mouse away to see the different dimensions (diameter)
4. Click again to set the diameter
   i.      You can drag this dimension around at any point in time

9. BEFORE you put a value in, let’s get a dimension between the two circles
1. Find the “Smart Dimension” button on the toolbar and click on it.
2. Select both circles, one after the other – order doesn’t matter here.
3. Do this first so the inner dimension remains the inner circle.                                                              i.      Your initial drawing scale may be off enough that this matters.
4. We could get have used the offset dimension
   i.      Useful for more complex geometries

10. Set this to 1 inch.
1. SW will automatically convert dimensions for you if you are using the suffix (mm, inches, etc.)
2. You can change the mode (for this document) by going to tools (menu), options (menu), document properties (tab), then units (list), choose IPS
11. Now double-click on the first dimension, and set it to 1.0 inches
12. We will now click the “exit sketch” button to get the Extrusion options dialog
1. Type 1” for the height of the extrusion – the direction doesn’t matter
2. Click the Green Check (okay button)
13. You should now have a washer shaped 3D object – you can zoom, rotate, and scale the viewport (dimensions are constrained)
14. Let’s make a donut – click on the fillet button (rounded corner)
    a. Set the radius to 0.5” (1/2”); select both the top and bottom edge inside & outside edge of our model (4 selections).
    i. The inside and outside faces could also be selected (2 selections)
    b. Click the green check mark.

14. Now we have a donut!
1. You can set the color or texture
2. We can take a bite out of it….but that’s another lesson!

We could have made this several different ways – you could have made a cylinder, and cut a hole in the middle, then filleted. You could have started with a square and rounded the corners, cut out a hole, and then filleted. In general, the more you do with a sketch, the more efficient your model is.

Labels: 3d modeling, CAD, CAD lesson, donut, SolidWorks

I'm starting a series of lessons on beginning CAD with SolidWorks, a great 3D package that I have grown to depend on and enjoy. SolidWorks has some great tutorials within the software you can use - I started writing these tutorials as part of  a one day course I taught for beginners. These are designed for use while using a copy of SolidWorks. So, without further ado, let your introduction to parametric modeling begin!

SolidWorks is a great tool, because you can sit down and learn how to do things yourself.  Some other modeling programs have such a complicated workflow that it is almost necessary to have either a teacher or manual.  SolidWorks is a powerful CAD package, but is presented in a format that is easy to process and understand. I encourage you to play around and learn your own workflow and explore features we may not cover here.

What to take away:
- A basic understanding of how 3D CAD works (terminology, etc) and how to leverage the tools provided to produce simple and functional models.
- “Best practices” or design methodologies to create models that are realistic in terms of constraints and manufacturing techniques
- Design intent – constraining your sketches & dimensions in ways that simplify future modification without losing the reasoning behind certain dimensions (1/2 of width d, etc)

Basic Features
Extrude Boss/Base
Extrude Cut
Sweeps
Rotational Solids
Rotational Cuts
Lofts
Sheet Metal
Fillets/Chamfers

How do we create parts? With sketches - using basic shapes – circles, rectangles, lines, curves – or complex geometry such as splines, repeating patterns, etc.

Solidworks allows rapid model creation by allowing the use of pre-existing geometry to constrain features & sketches.

Lesson 1.1: The Interface

The Solidworks interface is a large window where you create and modify your design, surrounded by toolbars that enhance your interaction with the 3d model.

When starting out, you can use large icons with text labels – as you get more advanced, you can turn the labels off, use small icons, even turn toolbars on and off.  When you feel really comfortable with the program, you can customize toolbars down to the order of icons and set the content for each toolbar.

Throughout the different versions of SolidWorks the icons for different operations have remained the same. The yellowish icons are for operations called "features" -- they modify or create 3D geometries. The blue icons are sketch related operations and create 2D layouts that are used to create 3D geometries through extrusions, cuts, and rotations. You can intuit this from the well-designed buttons that either show an enclosed volume or a line segment.

**Tools you will make use of** the zoom functions and standard views are your best friends! Learn to be comfortable with them, and understand the rotation of your models. I highly recommend that you add the standard views to your toolbar if they aren't already there. Just right click anywhere on the toolbar and select "Standard Views."

Labels: CAD, CAD lesson, Parametric Modeling, SolidWorks

Labels: DanShope, robotics, the beginning