Grades check has been posted

Grade update as of 09/27/13

I have uploaded a locked Excel spreadsheet to the google drive. This spreadsheet contains the grades that have been recorded for 

• Pre-Lab 1
• Pre-Lab 2
• Pre-Lab 3
• Quiz 1
• Quiz 2
• SolidWorks mini-project 1

Please review the grades and send an email to your TA if you come across an error or have a question. The TA's are

• Christie Bielmeier
• Sections 804, 805, 806
• christie_bielmeier@student.uml.edu
• Pengtao (Peter) Wang
• Sections 801, 803, 808
• pengtao_wang@student.uml.edu
• Kevin Truong
• Sections 802, 807, 809
• kevin_truong@student.uml.edu

A number of students have made mistakes sending in their quizzes and their quiz grades are listed as QNF (quiz not found). At the present time, the TA's are looking through the email directories in an effort to locate these misplaced quizzes.

I have included in the spreadsheet a calculation of each student's current grade in the class - the results (see below) are not encouraging.

I would normally expect that most students would have either an A or B grade in this course. To find that 53% of the class presently have a C or lower does not bode well for the rest of the semester.

So...shall we get to work???

Lab 4 - SolidWorks mini-challenge

SolidWorks Mini-Challenge

Assigned: Lab 4
Due: Lab 5

Task Description

Create a six-bar linkage assembly in SolidWorks and perform a motion analysis

The six bar mechanism is an approximation of a design from the text "Mechanisms in Modern Engineering Design, Vol 1" by I. I. Artbolevsky which was published by the USSR Academy of Sciences in 1947. The following image is from the text...

The mechanism that you are going to create in this challenge is only an approximation of this design because the ratio of the lego beam lengths do not match those stated in the design. You may want to repeat the design of the assembly using parts of your own design to see if this mechanism actually creates straight-line motion.

Step 1

Create a new SolidWorks assembly and create the six-bar linkage shown below using the Lego parts that are available here.

The parts required for the assemble are:

• beam_3
• beam_7
• beam_11
• beam_13
• beam_15

The assembly can be created using only two types of mates: concentric and coincident. 

Note that this assembly is configured such that the beams do not pass through each other when the mechanism is actuated. The parts can be thought of as being connected by "virtual pins" but the coincident and concentric mates are sufficient to define the geometry.

Step 2

Add a motor to the input link (beam_3) and use it to drive the mechanism. 

The following video shows how to add a motor to an assembly and perform a motion analysis. The second video shows the resulting motion for the 6-bar assembly.  

The third video below shows another linkage that is a bit more challenging... If you are able to complete the 6-bar linkage, go ahead and give this one a shot. This assembly uses the following parts:

• 1 - beam_15.SLDPRT
• 1 - gear_40.SLDPRT
• 1 - axle_12.SLDPRT
• 2 - crossblock_extender.SLDPRT

Lecture 4 - Rapid prototyping

Additive Manufacturing - 3D Printing

Fused Deposition Modeling

3D printers that run on FDM Technology build parts layer-by-layer by heating thermoplastic material to a semi-liquid state and extruding it according to computer-controlled paths.

FDM uses two materials to execute a print job: modeling material, which constitutes the finished piece, and support material, which acts as scaffolding. Material filaments are fed from the 3D printer’s material bays to the print head, which moves in X and Y coordinates, depositing material to complete each layer before the base moves down the Z axis and the next layer begins.

Sratasys uPrint

Polyjet 3D Printing

PolyJet 3D printing is similar to inkjet document printing. But instead of jetting drops of ink onto paper, PolyJet 3D printers jet layers of liquid photopolymer onto a build tray and cure them with UV light. The layers build up one at a time to create a 3D model or prototype. Fully cured models can be handled and used immediately, without additional post-curing. Along with the selected model materials, the 3D printer also jets a gel-like support material specially designed to uphold overhangs and complicated geometries. It is easily removed by hand and with water.

PolyJet 3D printing technology has many advantages for rapid prototyping, including superior quality and speed, high precision, and a very wide variety of materials. Based on PolyJet technology, Objet Connex 3D Printers from Stratasys are the only additive manufacturing systems that can combine different 3D printing materials within the same 3D printed model, in the same print job.

Applications

Cortex is a 3D printed exoskeletal cast designed to be fit around the wearer and snapped shut with fasteners.

Process

Create model

Generate STL (stereo lithography file)

Generate tool paths

Print part

Laser Cutters/Engravers

Application video

Lego Assemblies

Making Assemblies and Machines...

When creating assemblies it is convenient to have a wide range of predefined parts which can be used to create test assemblies. 

A group at Carnegie-Mellon has created a library of Lego parts that can be used for this purpose. The parts can be downloaded from http://www.education.rec.ri.cmu.edu/downloads/lego/solidmodel/

You can also grab a zipped folder of all the parts from the 22.201 google drive.

Lab 4 will provide you a chance to work with these parts to create assemblies that can be used to perform motion studies. 

Multiview parts...Lab 3 CAD Challenge

The following are isometric views of the parts that you are to create for the LAB 3 CAD challenge. I had mentioned to some students that I would post my solutions so that they could double check their work...

Part 1 - Done in Lab

Part 2

Part 3

Part 4 

Part 5 (duplicate of Part 1)

Part 6

Another option....

Amazon Prime

You may or may not be aware that Amazon provides students with a six-month free trail for Amazon Prime - this service provides free two-day shipping on many items

If you do this you can order an Arduino kit via Amazon and have it in hand sometime on Tuesday.

Sign up for the free student trial of Amazon Prime

Then order one of the following...note that you can order the actual Sparkfun kit

SparkFun Inventor's Kit for Arduino with Retail Case

Arduino Uno Ultimate Starter Kit -- Includes 72 page Instruction Book

The Arduino Starter Kit (Official Kit from Arduino with 170-page Arduino Projects Book)

SainSmart UNO R3 Starter Kit With 16 Basic Arduino Tutorial Projects for Beginner (1602 LCD included)

Arduino Pre-Lab for Lab 4

Arduino Pre-Lab

The past two lab meetings have provided an introduction to the Arduino Board. By this time you should be relatively comfortable with 

1. Connecting the Arduino board to the PC, selecting the correct board type and selecting the correct COM port.
2. Using the digitalWrite function to "blink" an LED
3. Using the digitalRead function to accept input from a push button

(this of course assumes that you actually have a board - if you don't have one, please read the previous post, and try to get together with someone who has a kit to go through the following exercises)

Pre-Lab Task 1 - SIK Circuits

The Sparkfun Inventors Kit Guide provides instructions for 15 circuits. You should set up and run the following circuits...

Circuit 1 - Blinking a LED .... we have already done this
Circuit 2 - Potentiometer   .... introduction to AnalogRead function
Circuit 3 - RGB LED        .... introduction to Pulse Width Modulation (PWM)
Circuit 4 - Multiple LEDs  .... this has been demonstrated in lab - see blog post on LED Array
Circuit 5 - Push Buttons    .... this is a variation of what was covered in this week's lab
Circuit 8 - A Single Servo .... its time to get stuff moving...

Pre-Lab Task 2 - LED's, Buttons and functions

Set up the multiple LED circuit shown in the Lab 3 blog post. Once you have the circuit configured load the code and test the circuit. Then print out the code and examine it carefully to see how functions are used to create more readable code.

See if you can figure out how to add in a function that can be used to control the position of a servo motor as well as the indicator light. This is show in the video below...

You should have this circuit laid-out on your breadboard when you come to lab next week.

Pre-Lab Task 3 - Video Tutorials

The following three videos should complement the preceding two tasks and hopefully provide you with some additional insight on how to get the Arduino to do your bidding...

Arduino Update

Its time to look elsewhere...

I have had no luck getting Sparkfun to provide me with an estimated ship date for the kits... I am rather frustrated with the company and have told them that I am going to provide those of you who still do not have kits with a list of alternate suppliers.

So if you have already paid money to the bookstore request you money back...

If you need a kit, I would request that you order one of these kits from Adafruit Industries...

Adafruit ARDX - v1.3 Experimentation Kit for Arduino (Uno R3)

Starter Pack for Arduino (Includes Arduino Uno R3)

Arduino Starter Kit from Arduino.cc

If you want to get started even faster - you can get an Arduino board at Radio Shack. Some stores even carry kits...

Lecture 3 Materials

Examples of Cool Projects...

Project ShapeOko
Totally Awesome Sylvia Watercolor Bot
iFetch
Balanduino
Helicopter Blimpbot
Openbuilds v-slot

Funding for your projects...

Kickstarter, Quirky, etc...

Create custom parts...

Thingiverse
Ponoko
Dimension uPrint
Epilog Laser Cutter

Get motors, sensors, and other stuff...

Sparkfun
Pololu
Adafruit
Jameco
Newark/Element14
Robotshop

and let's not forget McMaster-Carr

Arduino (and C) Code Samples and Communities

GitHub
Arduino Playground
Arduino Forum
StackExchange
Sparkfun
Adafruit

Learning Code (tutorials)

Jeremy Blum YouTube series
You Tube
AdaFruit / YouTube / A cool bit of engineering...
Sparkfun
ebooks

Adding Libraries

Ken Shirriff's IR Remote Library

Lab 3 - Arduino Material - Digital Input

Microprocessors can be used to read signals from the outside environment.

The command that can be used to read the state of a digital pin is digitalRead.

A simple way to see how this works is to use a pushbutton to toggle the voltage of an I/O pin between +5V and ground.

The following circuit created using Frizting shows one possible way that this can be accomplished.

So what's happening here??

1. The Arduino board is used to supply both +5V and GND to the rails of the breadboard.
2. The left pushbutton is used to light an LED in a simple electrical circuit. 
3. The right pushbutton is used to control the voltage state of digital I/O pin 2.
• Pin 2 is connected to both one leg of the pushbutton and to +5V through a 10k resistor. So when the button is open, pin 2 is HIGH.
• The other leg of the pushbutton is connected to GND. When the button is closed the voltage of Pin 2 is "pulled-down" to GND. 
4. The state of Pin 2 is determined using digitalRead  in the program loop. When the program determines that the button has been pushed, it sends a  digitalWrite(13, HIGH)  this results in the other LED to turn on.

There a a few more things that need to be explored and these will be covered in lab.

Using the above set-up explore the behavior of the example Sketches...

Button

StateChangeDetection

Debounce

After this exploration - take a look at the following code that combines some of these ideas together.

    

	/*
	PushOnce
	Turns on and off a light emitting diode(LED) connected to digital
	pin 13, when pressing a pushbutton attached to pin 2.
	The circuit:
	* LED attached from pin 13 to ground
	* pin 2 is attached to one leg of pushbutton and to +5V through 10k resistor
	* other leg uf pushbutton is attached to ground
	* When button is pressed state of pin 2 chages from HIGH to LOW
	*/
	// constants won't change. They're used here to
	// set pin numbers:
	const int buttonPin = 2; // the number of the pushbutton pin
	const int ledPin = 13; // the number of the LED pin
	// variables will change:
	int buttonState1 = 0; // variables for reading the pushbutton status
	int buttonState2 = 0;
	int buttonState = 0;
	int buttonCount = 0; // variable to record number of times button has been pushed
	boolean lastButton = HIGH; // Boolean variable to hold last state of button
	void setup() {
	// initialize the LED pin as an output:
	pinMode(ledPin, OUTPUT);
	// initialize the pushbutton pin as an input:
	pinMode(buttonPin, INPUT);
	// Begin serial communication
	Serial.begin(9600);
	}
	void loop(){
	/*
	The loop processes so fast that it can read the state of the button many times during the
	time interval it takes to physically push the button. The button can "bounce" during the
	physical change and produce transients that the digital input can interpret as a
	series of state changes from HIGH to LOW.
	The button can be software "debounced" by checking the button state, waiting a short
	amount of time, say 50 milliseconds, and then checking the state once again. If the state
	hasn't changed then the reading of the button state can be consisdered valid.
	*/
	buttonState1 = digitalRead(buttonPin);
	delay(50);
	buttonState2 = digitalRead(buttonPin);
	if (buttonState1 == buttonState2){ // if a valid button state is detected proceed...
	buttonState = buttonState2;
	// check if the pushbutton is pressed.
	// if it is, the buttonState is LOW:
	if (buttonState == LOW) {
	// turn LED on:
	digitalWrite(ledPin, HIGH);
	}
	else {
	// turn LED off:
	digitalWrite(ledPin, LOW);
	}
	// check to see if button has changed state since last pass through loop
	if (buttonState != lastButton) {
	if (buttonState == LOW){ // if the state has changed and is now LOW
	buttonCount++; // increment by 1
	Serial.println(buttonCount); // send count to serial monitor
	}
	}
	lastButton = buttonState; // update value of lastButton
	}
	}

view raw PushOnce hosted with ❤ by GitHub

Next steps...

Modify the circuit such that indicator LED's are connected to pins 9, 10, 11, and 12.

The following code is a variation of the above code where functions are used to better define what is happening.

The Loop section only contains calls to a series of user defined functions and then updates to loop variables. The functions called are

debounceButton - this checks the current state of the button
checkForChange - this checks to see if the button has switched state (HIGH to LOW or LOW to HIGH)
getButtonNumber - this will increment the button counter it a change from a HIGH to LOW button state has been detected
indicatorLight - this turns on the LED associated with the button value. Either LED 1, 2, 3, or 4, on the 5th button push all LED's are tunred off.

The code for this setup is shown below the video...

	/*
	Arduino code - Example of how to use a single push-button to cycle through a number of choices. This example code uses functions to:
	** debounce the button
	** check the state of the button
	** keep track of the current selection of the push button (in this case 1, 2, 3, 4, or 5)
	** turn on an LED on the board that corresponds to the button selection
	** a dummy function is included that can be used to set the condition of some device (motor speed, servo position, etc...) that corresponds to the button choice.
	*/
	// global variables
	const int buttonPin = 2;
	boolean currentState = LOW;
	boolean lastState = LOW;
	boolean stateChange = false;
	int currentButton = 0;
	int lastButton = 4;
	int ledArray[] = {9, 10, 11, 12};
	// setup
	void setup() {
	pinMode(buttonPin, INPUT);
	for (int i=0; i<5; i++){
	pinMode(ledArray[i],OUTPUT);
	}
	Serial.begin(9600);
	}
	// main loop
	void loop(){
	currentState = debounceButton();
	stateChange = checkForChange(currentState, lastState);
	currentButton = getButtonNumber(lastButton, currentState, stateChange);
	indicatorLight(currentButton);
	lastState = currentState;
	lastButton = currentButton;
	}
	// function debounceButton
	boolean debounceButton()
	{
	boolean firstCheck = LOW;
	boolean secondCheck = LOW;
	boolean current = LOW;
	firstCheck = digitalRead(buttonPin);
	delay(50);
	secondCheck = digitalRead(buttonPin);
	if (firstCheck == secondCheck){
	current = firstCheck;
	}
	return current;
	}
	// function checkForChange
	boolean checkForChange(boolean current, boolean last)
	{
	boolean change;
	if (current != last){
	change = true;
	}
	else {
	change = false;
	}
	return change;
	}
	// function getButtonNumber
	int getButtonNumber(int button, boolean state, boolean change)
	{
	if (change == true && state == LOW){
	button++;
	if (button > 4){
	button = 0;
	}
	Serial.println(button);
	}
	return button;
	}
	// function indicatorLight
	void indicatorLight(int button)
	{
	for (int i=0; i<5; i++) {
	digitalWrite(ledArray[i], LOW);
	}
	digitalWrite(ledArray[button], HIGH);
	}
	// function itemControl

view raw button with functions hosted with ❤ by GitHub

Going even further...

One of the students in the class created a project that uses a sine wave to control an array of LED's. A pushbutton allows the user to toggle between different input modes and a potentiometer is used to adjust the parameter in each mode - phase, wave speed and brightness.

This project introduces two new functions, analogWrite and analogRead. The analogWrite function names use of pulse-width modulation (PWM) to control the brightness of the LED's. The analogRead function is used to read the value of the potentiometer. You can explore these two functions using the Arduino Example sketches...

analogWrite: File... Examples... Analog... Fading
analogRead: File... Examples... Analog... AnalogInput

The code is also a very nice example of both how to use functions to make your code easier to read and the proper use of comments to provide clarity.

Here is a video of the system in action. The code used to create this set-up is listed after the video.

	void setup(){
	//sets pins to OUTPUT
	pinMode(11,OUTPUT);pinMode(10,OUTPUT);pinMode(9,OUTPUT);
	pinMode(6,OUTPUT);pinMode(5,OUTPUT);pinMode(3,OUTPUT);}
	// extern creates global variables
	extern float p = 1; // phase shift constant
	extern float s = .005; // angular velocity constant
	extern float g = 1; // brightness threshold
	extern int mode = 0 ; // operation mode
	extern float x = 0 ; // clock variable
	extern int lock = 0 ; // button lock
	// analogWrite can only be used on pins 11,10,9,6,5,3
	// these pins contain pulse-width modulated output
	void led1(){analogWrite(11,bright(0));} // led1() sets pin 11 to value returned by function bright()
	void led2(){analogWrite(10,bright(p));} // p inputs phase shift
	void led3(){analogWrite(9,bright(2*p));}
	void led4(){analogWrite(6,bright(3*p));}
	void led5(){analogWrite(5,bright(4*p));}
	void led6(){analogWrite(3,bright(5*p));}
	int bright(int xx){ // returns the sine of global x scaled between 0 and 255
	float b;
	b = sin(x+xx)+g; // sin() input is in radians output is a float
	b = (b )*(255/2);
	if(b > 255){b = 255;}
	else if(b < 0){b = 0;} // keeps output between 0 and 255
	return b;}
	void tick(){
	if(x < 6.283){x = x + s;} // increments x variable from 0 to 2*pi
	else{x = 0;}} // zeroes x variable
	float phase(){if(mode == 0){p = analogRead(A0)/170; return p;};} // sets p = to analog input value if mode == 0
	float velocity(){if(mode == 1){s = (analogRead(A0)/10333.3)+.001; return s;};} // sets s = to analog input value if mode == 1
	float threshold(){if(mode == 2){g = (analogRead(A0)/341)-1; return g;};} // sets g = to analog input value if mode == 2
	void run(){led1(); led2(); led3(); led4(); led5(); led6();} //run function sets the brightness of the all LED's based on state of global variables
	void test(){ // checks if button is pushed and increments mode by 1
	if(digitalRead(12)==LOW && lock == 0){mode = mode + 1; lock = 2;} // increments mode when pin goes LOW and sets lock to 2
	if(digitalRead(12)==HIGH && lock == 2){lock = 3;} // sets lock to 3 when pin goes high
	if(digitalRead(12)==HIGH && lock == 3){lock = 0;} // sets lock back to 0 if pin is still high
	if(mode >= 3){mode = 0;}} // keeps mode between 0 and 2
	void loop(){ // anything inside loop is run forever
	run(); // set led brightness
	tick(); // increment clock
	phase(); // set global p if mode 0
	velocity(); // set global s if mode 1
	threshold(); // set global g if mode 2
	test();} // check button state, increment mode

view raw LED Wave hosted with ❤ by GitHub

Solid Professor Pre-Labs - Are you sure that you have completed everything??

A few students have inquired if there is any way to make certain that they have completed 100% of the Solid Professor Pre-Lab material. At the present time, Solid Professor does not provide any indication on the Home Tab as to the percentage of an assignment that has been completed. You can only see the list of te assignments and the total duration of the video tutorials.

In order to verify that you have completed all the sections of each Pre-Lab assignment, you need to verify that each section of the assignment is followed by the icon that looks like an eye. As you complete each video or download the hands-on exercise, you should notice that the icon appears for that portion of the assignment. If the eye icon does not appear, you may need to reload the page.

LED Array Circuit

Blink and Current Limiting Resistors

In lab this week we got started with the Sparkfun kit and hopefully you all got acquainted the Sparkfun RedBoard (a.k.a. the Arduino Uno).

I believe that all the groups working with the board got the Blink program to work and were able to "blink" the on-board blue LED that is connected to Pin 13. Some groups were able to progress to setting up multiple LED's on the breadboard.

I noticed that some groups were doing this without using a current limiting resistor. Hooking up the LED without the resistor results in a maximum current from the I/O pin and this situation can end up "killing" the pin and can also burn out the whole ATmega328 chip.

You can read about this on the web - google "arduino max current", here is a summary...

LED Array and other circuits

I would encourage those of you with kits to go ahead and explore the kit and create a bunch of the test circuits. I would also like to share a couple circuits and sketches with you.

The first of these is and LED array. The following images show both the actual circuit on the breadboard and then three diagrams of the same circuit that I created using the Fritzing utility.

LED Array setup on Sparkfun breadboard

Diagram of circuit created using Fritzing

Schematic of circuit created using Fritzing

PCB layout for LED Array using Fritzing

Code samples

If you construct this circuit you can use it to run a number of test programs that you can use to explore some elements of C coding.

The Arduino sketches are below.

BlinkTwo - as the name implies, this program demonstrates how to set the sketch to blink two LEDs in unison.

	/*
	BlinkTwo
	Turns two LEDs on and off in unison.
	The delay times are controlled by two variables
	that are defined at the beginning of the program.
	This example code is in the public domain.
	*/
	// Use the LEDs that are connected to I/O pins 12 and 13
	int led1 = 12;
	int led2 = 13;
	// Set delay values for the amount of time the LEDs
	// are on and the amount of time they are off.
	int onTime = 100;
	int offTime = 250;
	// the setup routine runs once when you press reset:
	void setup() {
	// initialize the digital pins as outputs.
	pinMode(led1, OUTPUT);
	pinMode(led2, OUTPUT);
	}
	// the loop routine runs over and over again forever:
	void loop() {
	digitalWrite(led1, HIGH); // turn the LED on
	digitalWrite(led2, HIGH);
	delay(onTime); // wait for a bit
	digitalWrite(led1, LOW); // turn the LED off
	digitalWrite(led2, LOW);
	delay(offTime); // wait for a bit
	}

view raw BlinkTwo hosted with ❤ by GitHub

BlinkTwoAlternate - as the name implies, this program demonstrates how to set the sketch to blink two LEDs in an alternating pattern.

	/*
	BlinkTwo
	Turns two LEDs on and off in unison.
	The delay times are controlled by two variables that are defined at the
	beginning of the program.
	This example code is in the public domain.
	*/
	// Use the LEDs that are connected to I/O pins 12 and 13
	int led1 = 12;
	int led2 = 13;
	// Set delay values for the amount of time the LEDs are on and the amount of time they are off.
	int onTime = 100;
	int offTime = 250;
	// the setup routine runs once when you press reset:
	void setup() {
	// initialize the digital pins as outputs.
	pinMode(led1, OUTPUT);
	pinMode(led2, OUTPUT);
	}
	// the loop routine runs over and over again forever:
	void loop() {
	digitalWrite(led1, HIGH); // turn the LED on (HIGH is the voltage level)
	delay(onTime); // wait for a bit
	digitalWrite(led1, LOW); // turn the LED off by making the voltage LOW
	delay(offTime); // wait for a bit
	digitalWrite(led2, HIGH); // turn the LED on (HIGH is the voltage level)
	delay(onTime); // wait for a bit
	digitalWrite(led2, LOW); // turn the LED off by making the voltage LOW
	delay(offTime);
	}

view raw BlinkTwoAlternate hosted with ❤ by GitHub

LEDarray - this sketch uses the C array construct to simplify the process of setting up and running multiple LEDs. This code also introduces the use of the For Loop and IF and IF-Else constructs. Use this program o create the Knight-Rider effect.

	/*
	BlinkArray
	Usses and Array structure and For and If loops to create an LED chase effect
	This example code is in the public domain.
	*/
	/* Intialize an array of LED pins
	Define a delay called "rate"
	Define a multiple of the delay "pause" to be used after one pass through
	array
	*/
	int ledArray[] = {9, 10, 11, 12, 13};
	int rate = 50;
	int pause = 1;
	/* Use a For Loop to set the LED array pins to output
	The counter i is a local variable within the setup function
	*/
	void setup() {
	for (int i=0; i<5; i++){
	pinMode(ledArray[i], OUTPUT);
	}
	}
	/* Use a For loop to blink each LED in the array.
	The If-Else statment checks to see if the fifth LED has been
	blinked and then sets a longer delay as defined by the integer "pause."
	*/
	void loop() {
	/* Use a For loop to blink each LED in the array.
	The If-Else statment checks to see if the fifth LED has been
	blinked and then sets a longer delay as defined by the integer "pause."
	*/
	for (int i=0; i<5; i++){
	digitalWrite(ledArray[i], HIGH);
	delay(rate);
	digitalWrite(ledArray[i], LOW);
	if (i == 4) delay(pause*rate);
	else delay(rate);
	}
	/* Use a variation of the previous For Loop to race the LED's backwards.
	If "pause" is set to 1 then the LEDs create the Knight Rider effect.
	*/
	for (int j=1; j<4; j++){
	int k = 4-j;
	digitalWrite(ledArray[k], HIGH);
	delay(rate);
	digitalWrite(ledArray[k], LOW);
	delay(rate);
	}
	}

view raw Knight Rider hosted with ❤ by GitHub

Sparkfun Update, Lecture Optimization and Fritzing...

Sparkfun 

I called Sparkfun today to check on the status on the next (and final) shipment of Arduino kits. When I spoke to the customer service representative, I learned that Sparkfun is located in Boulder, CO. You may have heard that they have had a bit of rain in the past week...

Well - their Boulder facility had to close for four days due to the flooding and they fell a bit behind schedule. The UML order is a priority item for them and the order will ship overnight on Monday, so the remainder of the boards should be in by mid-afternoon on Tuesday.

Fingers crossed!!

Lecture

In order to accommodate the 180+ students in 22.201, there are two lecture sections - one on Monday at 10:00 AM (-201) and the other on Wednesday at 10:00 AM (-202).

In a perfect world the students that attend the Monday lecture would then attend the lab sections that meet on Monday (-804, -806) and Tuesday (-801, -807, -803) and the students who attend the Wednesday lecture would then attend the lab sections that meet on Wednesday (-805, -808) and Thursday (-802, -809). But of course we don't live in a perfect world...

However...we can make it a little bit better by allowing you to attend the lecture session that will maximize your lab experience. So if you attend a Monday or Tuesday lab and are scheduled for the Wednesday lecture, please feel free to attend the Monday lecture if it fits into your schedule. And likewise if you attend a Wednesday or Thursday lab, feel free to attend the Wednesday lecture.

If you wish to do this, there is no need to make it "official" by switching sections in ISIS. Just show up....

Fritzing

Many of the following posts that deal with the Arduino board will contain images created using the open-source program called Fritzing.

It is a great program for documenting your projects and providing you the necessary tools to create custom PCB's (printed circuit boards) that are based on your designs. I recommend that you check it out at Fritzing.org

  

Sparkfun...

I was informed yesterday that the bookstore had received another shipment of the Sparkfun Kits. I don't know how many but please make and effort to get yourself one before lab this week.

Also...please, please, please, play with these kits. you do not need to wait until you come to lab to start using these things. They are FUN....

Solid Professor Pre-Labs

As stated on the course syllabus - the grading for the Solid Professor Pre-Labs is binary. If you have completed all the materials (16/16 for Pre-Lab 1) and (18/18 for Pre-Lab 2) you receive credit - a grade of 1. If you have not completed all the materials you do not get credit - a grade of 0.

Also - in order to receive credit for a Pre-Lab you must complete all the previous exercises...

If you complete all 18 modules of Pre-Lab 2 but have skipped some of the modules of Pre-Lab 1, you will not receive credit for either Pre-Lab. The reason for this is that the tracking software only reports a cummulative effort. The figure shows an example of the output from the reporting utility

ASME Student Meeting and free pizza...

All of you should plan on joining at least one of the main engineering societies. We will be discussing this during one of the lectures. This Thursday there is an informational session about the UML student chapter of the American Society of Mechanical Engineering.

Course Folder and Practice Parts

Course documents and supplemental materials will be placed into a Google Drive folder.

The course syllabus and schedule is located in the Course Documents subfolder.

Copies of the Powerpoints I use during the course lectures are contained in the Lectures subfolder.

Practice material is located in the SolidWorks Practice Material subfolder.

I have uploaded a PDF document to the Practice Material Folder that contains many parts that you can use to challenge yourself. I have put a couple examples below.

Course Syllabus

22.201                                     Mechanical Design Lab 1                               Fall 2013

 

 

Instructors
					Lecture Sections		Lab Sections
	Daniel J. Sullivan, PhD Perry Hall 328 daniel_sullivan@uml.edu				201, 202		802, 804, 805, 809
	Lawrence Thompson, PhD Perry Hall 328 lawrence_thompson@uml.edu						801, 803, 806, 807, 808
Office hours:	As posted by instructor
Course Blog:	http://sullivan-22-201-fall2013.blogspot.com/
Required Course Materials	Subscription to SolidProfessor (see blog for details)
	Sparkfun Inventor’s Kit (see blog for details)
Grading	Completion of Pre-Labs				5%
	Lab Quizzes				20%
	SolidWorks mini-projects				15%
	Arduino mini-projects				15%
	Group Design Project				20%
	SolidWorks Final Exam				25%
	Scale
	A	94% - 100%	B-	80% - 82%		D+		66% - 69%
	A-	90% - 93%	C+	76% - 79%		D		60% - 65%
	B+	86% - 89%	C	73% - 75%		F		< 60%
	B	83% - 85%	C-	70% - 72%

 

Lecture Topics:

 

Lecture 1	Course Overview Introduction to “Makers”, Resources
Lecture 2	Arduino Introduction Hand drawing: free sketching, using a straightedge, isometric projections)
Lecture 3	Arduino Tutorials / Arduino Libraries / The C programming language Hand drawing: orthographic projections
Lecture 4	Introduction to rapid prototyping 3D printing, laser cutting, CNC routers, STL files, feature resolution, use in industry
Lecture 5	Topics in circuits: Digital input and output, Using a microcontroller to read analog input, Pulsed width modulation, Pull-up and pull-down resistors, Ohms law, batteries
Lecture 6	The Group Design Project
Lecture 7	Communicating with a skilled machinist. Creation of a basic 2D machine drawing Title block, Revision block
Lecture 8	Creating motion: DC motor, servo motors, stepper motors, brushless electric motors
Lecture 9	Dimensioning standards and best practices, ASME dimensioning codes Dimensioning of holes, thread callouts
Lecture 10	Engineering Notes, Engineering Change Notices
Lecture 11	Tolerance considerations Dollar cost of over specifying tolerances Tolerance stack-up calculations Machining set-ups / dollar cost of a machined part
Lecture 12	Professional Societies Overview and sign-up for both ASME and SAE

 

SolidProfessor Pre-Labs

Each lab session has an associated Pre-Lab assignment that consists of a specified set of material from the SolidProfessor site. You are expected to complete all of the Pre-Lab with a focus on learning and becoming competent in the concepts and techniques that are introduced in the video tutorials. Each Pre-lab includes a set of exercises that you are expected to complete. These exercises will not be collected.

Most Pre-labs will have supplemental materials in the form of extra modeling suggestions that you can use to gain more practice in the concepts covered in the Pre-lab. These materials will be located under the Assignment Add-ons tab in the Solid Professor interface.

The Pre-lab grade is based upon your completion of the Pre-lab. The percentage of each Pre-lab that is completed is available to the course instructors through a SolidProfessor reporting tool. The Pre-lab grade is “all or nothing” – you must complete the entire Pre-lab assignment prior to your weekly lab meeting for you to receive any credit for this work.

The Pre-labs will include materials from the SolidProfessor SolidWorks 2013 Course List the primary modules to be covered are:

·         2013 SolidWorks 101 – Academic

·         2013 Core Concepts

·         2013 Drawings

·         2013 Advanced Parts

Arduino Pre-Labs

The Sparkfun Inventor’s kit includes a Guide book that contains 15 exercises. Prior to each lab session you will be assigned one or more of these exercises to complete. You will also be assigned a number of video tutorials to watch. This Pre-lab information will be listed on the course blog.

Lab Quizzes

Each lab session will begin with a short quiz that allows you to demonstrate competency in the concepts and techniques that have been introduced in the Pre-Lab. This will typically include both a SolidWorks exercise and some questions that cover the Arduino topics.

 

 

 

Mini-Projects

Most lab sessions will introduce mini-projects that are meant to provide you with a means to expand your ability to both create solid models and use a microcontroller. These projects will also provide you with the ability to create a physical object using a 3D printer. Some of these mini-projects will be individual efforts and some will be collaborative. 

Group Design Project

The group design project is an opportunity to work in a team environment to design, build and test a device. The device will be designed in SolidWorks, contain parts that have been 3D printed (and possibly laser-cut) and be designed to interact with its environment via sensors and actuators.