iDatoBato Laboratories

Processing Class 6: 3D and Libraries

2011-10-09T14:09:00.006-04:00

Hello Class! I hope you all had a great week. Here is a brief of what I want to cover today:

3D in Processing

- How to change the Processing rendering engine to handle 3D graphics: MODE in size()

- Using the 3D Primitives: box() and sphere()

- Using pushMatrix() and popMatrix() to adjust placement of 2D shapes in 3D: translate(), rotateX(), rotateY(), rotateZ()

Libraries

- What is a library in Processing

- Where to find available libraries and how to find their reference

- How to include a library in a sketch

- How to download and setup a library to work with the Processing application

3D in Processing

While it is important to learn how to draw in Processing using 2D shapes, at some point you are going to want to break into the z-axis. The z-axis represents depth or distance from the user, assuming the user is facing the display. Many of the commands we have been using for 2D shapes such as line() and point() include ways of handling the z-coordinate along with the x and y. Before you can utilize any z-coordinate, you will need to set the render engine in Processing to understand and handle 3D. You set the render engine inside the call to size() inside of setup(). Normally, when sketching in 2D, you only need to use size() to set the width and height of the sketch. When wanting to incorporate 3D, you need to set another 3rd parameter, MODE. The MODE allows you to choose P3D, a Processing based 3D render engine, or OPENGL, a render engine that utilizes calls directly to the graphics card. You will need to look closely at the differences each render engine creates in the look and function of your sketch. Each has a different look and feel and some 2D elements, such as stroke and lines, do not always appear as you might expect.

Lets all take a look at what 3D looks like in Processing by first checking out the examples. Open Examples/3D/Camera and take a look at the 3 sketches inside. These 3 sketches point out how the camera works inside your sketch.

Now open Examples/3D/Image, these sketches show how image data can be used in a 3D environment. Extrusion is especially nice as it moves the position of points based on the brightness of the pixel in the reference image. It is possible to do this with a webcam as well.

Make sure to also take a quick look at the Textures folder and as well as the Transform folder. Rotate1 and Rotate2 examples in Transform show how pushMatrix and popMatrix can be used to create 3D images.

Most of these examples use the P3D render native to the Processing language. However, a few utilize the OPENGL library. Next we are going to learn how to use libraries to add functionality to your sketches.

Libraries

Simply put, Libraries add things your sketch can do. A library is code that was written to work within Processing, and is specific to a certain task, such as: talking to an Arduino, evaluating sound or creating sound, robust typography control, exotic file type export.

The Processing download includes several libraries which are available upon install. Any other libraries will need to be downloaded and saved into a libraries directory. The libraries directory(folder) needs to be located inside of your sketch folder, the folder where Processing looks to find your sketches(by default it is located in your documents folder). Download the library from the web and place the library folder inside of your libraries folder. Make sure and support Examples files are stored inside the library folder in a folder named "examples".

When you want to include a library in your sketch, simply mouse over the "Sketch" drop down menu item at the top of the screen, and select "Import Library…". This will in turn open another drop down menu, listing all of the available libraries. When you click a desired library, a bit of code is added to the top of your sketch on to what ever tab is open. For example, when I choose to include the OpenGL library, the code looks like this:

import processing.opengl.*;

Now lets take a look at some of the examples included with the libraries included in Processing.

Processing Class 5: Images, Video and Saving

2011-10-02T20:21:00.005-04:00

Hello Class. This week we are going to revisit nested for loops to move through images and grab data. We are also going to explore how to use video, both local files and a webcam. After we get through that we will learn how to save out versions of our sketches for others to see.

Images:

Processing has a native data type specific to images called PImage. Anytime you want to work with an image you need to use a PImage. The PImage object has multiple properties. Some of them are an array of pixel color value, width, and height. Images that are made up of a grid of pixels are called raster graphics.

Video:

Video requires using the video library from processing. We will explore basic use so that we have a better understanding of how to use libraries for next weeks class.

Class 4: Arrays, Functions and using Images

2011-09-25T18:41:00.005-04:00

Today's class will cover two very important concepts: Arrays and Functions. Afterwards, I will show you how use images in your sketches.

Arrays

An array is a list or group of data. You can have an array of any type of data. For example, you want to move 10 rectangles around the screen using random incremental movements between -1 and 1(brownian motion). Instead of creating 10 variables for the x location and 10 for the y location, you can use two arrays, one for the x locations and 1 for the y locations. All of the variables are the same type and their purpose is the same.

Each variable(variables in an array are referred to as elements) in an array is associated with an index number that describes in position in the array. The first element in an array is [0] and the second is [1] and so on. When you create an array you must identify the length or number of elements in the array. You cannot access a value higher than the length of an array. If you try you will receive the Null Pointer error.

Arrays are a little different to create than normal variables. Here are a few ways to create them:

int[] numbers = new int[3];// creates an int array of 3 empty elements

int[] numbers = {10,20,30};// creates an int array of 3 elements and sets values

The power of arrays really comes to life when you use them in combination with for loops. A for loop can increment which element is being accessed/used and you can set the 'test' of the for loop to the length of the array. Every array has a variable that stores its length, the total number of elements. It can be accessed like this, arrayName.length.

int[] numbers = {10,20,30};// creates an int array of 3 elements and sets values

for(int i = 0; i < numbers.length; i++){

    println(numbers[i]);

// prints 10 20 30 each on their own line

Functions

Functions are a way of compartmentalizing code. Functions allow you to reuse code without having to copy and paste lines in multiple areas of your code. For example, switching back and forth from a white stroke and black fill to a black stroke and white fill.

stroke(255);

fill(0);

// to…

stroke(0);

fill(255);

Instead of having to copy and paste two lines of code each time, you could write two functions and call those commands in one line of code.

void whiteStrokeBlackFill(){

stroke(255);

fill(0);

// and…

void blackStrokeWhiteFill(){

stroke(0);

fill(255);

// to execute the functions…

whiteStrokeBlackFill();// turns the stroke to white and the fill to black

blackStrokeWhiteFill();// turns the stroke to black and the fill to white

();// turns the stroke to white and the fill to black

You can increase the usefulness of a function by setting values when you run the function. These values are called parameters. Parameters can be any data type. Here is an example:

void printNumber(int num){

println("number = " + num);

Class 3: For Loops, new Shapes and more Math!!!

2011-09-18T19:41:00.006-04:00

Hello 3rdWard! I hope you had a great week and are ready of another action packed class of Processing.

Today we are going to be focusing on a very important concept: For Loops.

What is a for loop? A for loop is a way of repeating the same commands a specified number of times.

What does it look like? It looks like this:

for(init; test; update){

statements

}

How does a for loop work? The parenthesis setup the structure of a for loop by defining the init, test, and update. The statements inside the block(a block is defined as the arguments inside curly braces{}) run continously as long as the test evaluates as true. The init assigns the initial value of the variable used in the test. The update is used to modify the variable after each iteration of the block. A for loop works like this:

1. The init statement is run

2. The test is evaluated to true or false

3. If the test is true, continue to step 4. If the test is false, jump to step 6

4. Run the statements within the block

5. Run the update statement and jump to step 2

6. Exit the structure and continue running the program

For Loops are very useful in programming graphics as they allow you to make many many iterations very easily.

Shapes:

Here are some cheat sheets that will break down the order in which you need to state your vertices to create a shape the way you want to.

Processing Class 2: Variables, Math, and Logic

2011-09-11T18:02:00.016-04:00

Hello everybody. I want to start off this week by taking a look at the awesome self portraits and monsters you all made. Congratulations, you are officially programmers now :) You successfully created compositions using the shape primitives, changing both the stroke(outline) and fill(shape) colors and mastered the idea of the coordinate system that is in place in Processing. This is not trivial, you have created meaning and subject with math as your tools. The reason I wanted all of you to create an annoyingly tedious character is so you develop an understanding of the coordinate system as well as the way in which order of commands changes composition and a familiarity with the shape building blocks. Next weeks homework will be to add a level of interaction to your monster/self portrait. I will go into this in more detail later….muwahhhahh.

Break down for what you will understand at the end of this class:

You will understand how to setup your sketches to allow for animation and interaction.

You will understand how to create variables, assign values to them and recall those values.

You will understand how to use mathematical operators(+,-,/,*,%, and more) allowing you to use math to arrive at values.

You will understand how to use conditional structures to control the flow of your programs.

As with last week, we are going to take a look at examples that come with Processing. This way you will be able to review when you are home as well as follow along on your machine in class.

Setting up your sketch

Last week we learned how to create a basic sketch in Processing. These sketches only display one frame that never changes. From now on we are going to be interested in multiple frames, because that way we can create animation and interaction.

Here is how I want you to setup your sketches from now on:

/*****************************************

* Header Title: elaborate the title here

* more details of sketch here

* include any credits to other people

* Your Name - date when created

*****************************************/

// declare your variables here

// setup() only happens once at the beginning of the sketch

void setup(){

// this is where you set the initial properties

size( 400, 400 );// size() should always go inside setup()

smooth();// smooth() usually only needs to go here

}

// draw() happens over and over and over

void draw(){

background(0);// apply the background first

// now draw or evaluate anything you want

}

* note: blogger lost the rest of lesson so I will be borrowing from Ben and Casey for the short term. I will go back and change this so as to not be directly using there words. But for now...

Data and Variables

What is data? Data often consists of measurements of physical characteristics. For example, Casey’s California driver’s license states his sex is M, his hair is BRN, and his eyes are HZL. The values M, BRN, and HZL are items of data associated with Casey. Data can be the population of a country, the average annual rainfall in Los Angeles, or your current heart rate. In software, data is stored as numbers and characters. Examples of digital data include a photograph of a friend stored on your hard drive, a song downloaded from the Internet, and a news article loaded through a web browser. Less obvious is the data continually created and exchanged between computers and other devices. For example, computers are continually receiving data from the mouse and keyboard. When writing a program, you might create a data element to save the location of a shape, to store a color for later use, or to continuously measure changes in cursor position.

Data types

Processing can store and modify many different kinds of data, including numbers, letters, words, colors, images, fonts, and boolean values (true, false). The computer stores each in a different way, so it has to know which type of data is being used to know how to manage it. For example, storing a word takes more room than storing one letter; therefore, storing the word Cincinnati requires more space than storing the letter C. If space has been allocated for only one letter, trying to store a word in the same space will cause an error. Every data element is represented as sequences of bits (0s and 1s) in the computer’s memory. For example, 01000001 can be interpreted as the letter A, and it can also be interpreted as the number 65. It’s necessary to specify the type of data so the computer knows how to correctly interpret the bits.

Numeric data is the first type of data encountered in the following sections of this book. There are two types of numeric data used in Processing: integer and floating- point. Integers are whole numbers such as 12, -120, 8, and 934. Processing represents integer data with the int data type. Floating-point numbers have a decimal point for creating fractions of whole numbers such as 12.8, -120.75, 8.125, and 934.82736. Processing represents floating-point data with the float data type. Floating-point numbers are often used to approximate analog or continuous values because they have decimal

37resolution. For example, using integer values, there is only one number between 3 and 5, but floating-point numbers allow us to express myriad numbers between such as 4.0, 4.5, 4.75, 4.825, etc. Both int and float values may be positive, negative, or zero.

The simplest data element in Processing is a boolean variable. Variables of this type can have only one of two values—true or false. The name boolean refers to the mathematician George Boole (b. 1815), the inventor of Boolean algebra—the foundation for how digital computers work. A boolean variable is often used to make decisions about which lines of code are run and which are ignored.

The following table compares the capacities of the data types mentioned above with other common data types:

Name Size Value Range

boolean 1 bit true or false

byte 8 bits -128 to 127

char 16 bits 0 to 65535

int 32 bits -2,147,483,648 to 2,147,483,647

float 32 bits 3.40282347E+38 to -3.40282347E+38

color 32 bits 16,777,216 colors

Variables

A variable is a container for storing data. Variables allow a data element to be reused many times within a program. Every variable has two parts, a name and a value. If the number 21 is stored in the variable called age, every time the word age appears in the program, it will be replaced with the value 21 when the code is run. In addition to its name and value, every variable has a data type that defines the category of data it can hold.

A variable must be declared before it is used. A variable declaration states the data type and variable name. The following lines declare variables and then assign values to the variables:

int x;// Declare the variable x of type int

float y;// Declare the variable y of type float

boolean b;// Declare the variable b of type boolean

x = 50;// Assign the value 50 to x

y = 12.6;// Assign the value 12.6 to y

b = true;// Assign the value true to b

As a shortcut, a variable can be declared and assigned on the same line:

int x = 50;

float y = 12.6;

boolean b = true;

More than one variable can be declared in one line, and the variables can then be assigned separately:

float x, y, z;

x = -3.9;

y = 10.1;

z = 124.23;

When a variable is declared, it is necessary to state the data type before its name; but after it’s declared, the data type cannot be changed or restated. If the data type is included again for the same variable, the computer will interpret this as an attempt to make a new variable with the same name, and this will cause an error:

int x = 69; // Assign 69 to x

x = 70; // Assign 70 to x

int x = 71; // ERROR! The data type for x is duplicated

The = symbol is called the assignment operator. It assigns the value from the right side of the = to the variable on its left. Values can be assigned only to variables. Trying to assign a constant to another constant produces an error:

// Error! The left side of an assignment must be a variable

5 = 12;

When working with variables of different types in the same program, be careful not to mix types in a way that causes an error. For example, it’s not possible to fit a floating- point number into an integer variable:

// Error! It’s not possible to fit a floating-point number into an int

int x = 24.8;

float f = 12.5;

// Error! It’s not possible to fit a floating-point number into an int

int y = f;

Variables should have names that describe their content. This makes programs easier to read and can reduce the need for verbose commenting. It’s up to the programmer to decide how she will name variables. For example, a variable storing the room temperature could logically have the following names:

temp

temperature

roomTemp

roomTemperature

Processing also includes a few variables that are specific to the sketch. Two we will be using are width and height. Width stores the value of the width of the sketch and height stores the height of the sketch.

Math: Arithmetic

In programming, the visual properties of an image on the screen are defined by numbers, which means that the image can be controlled mathematically. For example, a rectangle might have a horizontal position of 10, a vertical position of 10, a width and height of 55, and a gray value of 153. If the gray value is stored in the variable grayVal and 102 is added to this variable, the gray value will become 255 and the shape will appear white on screen.

The +, -, *, /, and = symbols are probably familiar, but the % is more exotic. The % operator calculates the remainder when one number is divided by another. The %, the code notation for modulus, returns the integer remainder after dividing the number to the left of the symbol by the number to the right.

Modulus can be explained with an anecdote. After a hard day of work, Casey and Ben were hungry. They went to a restaurant to eat dumplings, but there were only 9 dumplings left so they had to share. If they share equally, how many dumplings can they each eat and how many will remain? It’s obvious each can have 4 dumplings and 1 will remain. If there are 4 people and 35 dumplings, each can eat 8 and 3 will remain. In these examples, the modulus value is the number of remaining dumplings.

The modulus operator is often used to keep numbers within a desired range. For example, if a variable is continually increasing (0, 1, 2, 3, 4, 5, 6, 7, etc.), applying the modulus operator can transform this sequence. A continually increasing number can be made to cycle continuously between 0 and 3 by applying %4:

x 0 1 2 3 4 5 6 7 8 9 10

x%4 0 1 2 3 0 1 2 3 0 1 2

When working with mathematical operators and variables, it’s important to be

aware of the data types of the variables you’re using. The combination of two integers will always result in an int. The combination of two floating-point numbers will always result in a float, but when an int and float are operated on, the result is a float.

Integer values can be assigned to floating-point variables, but not vice versa. Assigning a float to an int makes the number less accurate, so Processing requires that you do so explicitly. Working with an int and a float will upgrade the int and treat both numbers as floating-point values, but the result won’t fit into an int variable.

Operator precedence, Grouping

The order of operations determines which math operators perform their calculations before others. For example, multiplication is always evaluated before addition regardless of the sequence of the elements. The expression 3 + 4 * 5 evaluates to 23 because 4 is first multiplied by 5 to yield 20 and then 3 is added to yield 23. The order of operations specifies that multiplication always precedes addition regardless of the order in which they appear in the expression. The order of operations for evaluating expressions may be changed by adding parentheses. For example, if an addition operation appears in parentheses, it will be performed prior to multiplication. The expression (3 + 4) * 5 evaluates to 35 because 3 is first added to 4 to yield 7, which is then multiplied by 5 to yield 35. This is more concisely expressed in code:

x = 3 + 4 * 5; // Assign 23 to x

y = (3 + 4) * 5; // Assign 35 to y

In many cases, parentheses are necessary to force elements of an expression to evaluate before others, but sometimes they are used only to clarify the order of operations. The following lines calculate the same result because multiplication always happens before addition, but you may find the second line more clear.

x = 10 * 20 + 5; // Assign 205 to x

y = (10 * 20) + 5; // Assign 205 to y

The following table shows the operator precedence for the operators introduced so far. Items at the top precede those toward the bottom.

Multiplicative * / %

Additive + -

Assignment =

Decisions and Controlling Flow of Programs

The programs we’ve seen so far run each line of code in sequence. They run the first line, then the second, then the third, etc. The program stops when the last line is run. It’s often beneficial to change this order—sometimes skipping lines or repeating lines many times to perform a repetitive action. Although the lines of code that comprise a program are always positioned in an order from top to bottom on the page, this doesn’t necessarily define the order in which each line is run. This order is called the flow of the program. Flow can be changed by adding elements of code called control structures.

Relational expressions

What is truth? It’s easy to answer this difficult philosophical question in the context of programming because the logical notions of true and false are well defined. Code elements called relational expressions evaluate to true and false. A relational expression is made up of two values that are compared with a relational operator. In Processing, two values can be compared with relational operators as follows:

Expression Evaluation

3> 5 false

3< 5 true

5< 3 false

5> 3 true

Each of these statements can be converted to English. Using the first row as an example, we can say, “Is three greater than five?” The answer “no” is expressed with the value false. The next row can be converted to “Is three less than five?” The answer is “yes” and is expressed with the value true. A relational expression, two values compared with a relational operator, evaluates to true or false—there are no other possible values. The relational operators are defined as follows:

Operator Meaning

> greater than

< less than

>= greater than or equal to

<= less than or equal to

== equivalent to

!= not equivalent to

The following lines of code show the results of comparing the same group of numbers with different relational operators:

println(3 > 5); // Prints "false"

println(5 > 3); // Prints "true"

println(5 > 5); // Prints "false"

println(3 < 5); // Prints "true"

println(5 < 3); // Prints "false"

println(5 < 5); // Prints "false"

println(3 >= 5); // Prints "false"

println(5 >= 3); // Prints "true"

println(5 >= 5); // Prints "true"

println(3 <= 5); // Prints "true"

println(5 <= 3); // Prints "false"

println(5 <= 5); // Prints "true"

The equality operator, the == symbol, determines whether two values are equivalent. It is different from the = symbol, which assigns a value, but the two are often used erroneously in place of each other. The only way to avoid this mistake is to be careful. It’s similar to using “their” instead of “there” when writing in English—a mistake that even experienced writers sometimes make. The != symbol is the opposite of == and determines whether two values are not equivalent.

println(3 == 5); // Prints "false"

println(5 == 3); // Prints "false"

println(5 == 5); // Prints "true"

println(3 != 5); // Prints "true"

println(5 != 3); // Prints "true"

println(5 != 5); // Prints "false"

Conditionals

Conditionals allow a program to make decisions about which lines of code run and which do not. They let actions take place only when a specific condition is met. Conditionals allow a program to behave differently depending on the values of their variables. For example, the program may draw a line or an ellipse depending on the value of a variable. The if structure is used in Processing to make these decisions:

if (test) { statements

}

The test must be an expression that resolves to true or false. When the test expression evaluates to true, the code inside the { (left brace) and } (right brace) is run. If the expression is false, the code is ignored. Code inside a set of braces is called a block.

Logical operators

Logical operators are used to combine two or more relational expressions and to invert logical values. They allow for more than one condition to be considered simultaneously. The logical operators are symbols for the logical concepts of AND, OR, and NOT:

Operator Meaning

&& AND

|| OR

! NOT

The following table outlines all possible combinations and the results.

Expression Evaluation

true && true true

true && false false

false && false false

true || true true

true || false true

false || false false

!true false

!false true

Processing Class 1: Hello World!

2011-09-04T20:07:00.002-04:00

Let me start off by saying I am super excited to teach you all Processing. I have been wanting to teach Processing to a group for awhile now and I am finally getting the chance. That said, lets get to it.

Getting Started:
What is Processing? Processing is an environment for programming graphics that was designed to be friendly to non programmers, yet still offer power to advanced users. It was originally created by Ben Fry and Casey Reas but has been contributed to by hundreds of users world wide. Under the hood, Processing is based on Java and any Java code can be implemented along with Processing code. In fact, Processing handles wrapping a ton of Java to make it super easy for you to get up and running without a lot of hassle. For this reason Processing files are called sketches, to relay the ideology of a quick coding attempt at a problem or idea. Don't let the term sketch fool you, a Processing sketch can be a full fledged application written in thousands of lines of code, but it can also only be one line.

What are we going to cover today:
Get to know the Processing Website and all it has to offer.

After we review the website we will get to know the Processing development environment. This is where you will create your Processing sketches.

Then we will get our hands wet with Processing by going over the examples that are included in Processing. The examples can be found in Examples/Books/Processing Handbook/Units00-17/. For this class we will be covering chapters 01 Structure and 02 Shape 1. I highly recommend the book that goes along with these examples, Processing: A Programming Handbook for Visual Designers and Artists.

For homework, please post at least one sketch to the class group on OpenProcessing.org. The requirements are to make a self portrait or a monster. Here is the class group.

Final Class: Arduino and Physical Computing

2011-04-02T01:31:00.018-04:00

Hello class! Time sure has flown by, much like how fast this class will go by with all of the cool things we are going to learn today.

Here is a brief break down of the things to do:

Review array code from last week and discuss in depth what arrays are and how they are to be used.
Learn how to solder.
Use your body as a sensor to control a group of LEDs.
Use a potentiometer attached to the Arduino to adjust the speed of a movie playing in Processing.
Control a drawing program with values sent from Arduino.

Let us start by reviewing Arrays from last week.

Arrays and For Loops:

Arrays are a way of declaring multiple of the same type of variable in a row in memory. Usually they are used with the idea that the values are multiples of the same type of object. What I mean is while the value of the photocell is an integer it doesn't make sense to include it in an array of integers that represent the digital pins used to power LEDs. Arrays are declared a little differently then other variables. Here are a few ways to declare an array:

int myInts[6];// this creates an array that has 6 places but does not define what the values are

int myPins[] = {2, 4, 8, 3, 6};// this creates an array of 5 places and defines the values

int mySensVals[6] = {2, 4, -8, 3, 2};// this creates an array of 6 places but only defines the first 5 values

This is how you access the values that are store in the arrays above:

myPins[0], where the value would equal 2.

The number inside of the square brackets [ ] indicates which element to access. Arrays are 0 based, meaning the first element is considered the 0 place not the 1st place.

Here is how you change the value of an element of an array:

myPins[1] = 9;// now the values for myPins look like this: {2, 9, 8, 3, 6}

The real power of arrays is unleashed when combined with for loops. The structure of a for loop is a little confusing at first, but once you understand how to use them they are essential. Basically a for loop is a way of repeating a command a determined number of times. You can use an array to count from any number by any number to any number. This makes it perfect for working with arrays because instead of manually putting 0-4 inside of the [ ] to access the values of myPins array, you can use a variable.

Here is a for loop that prints the values of myPins array to the serial monitor:

for(int i = 0; i < 5; i++){

Serial.print(myPins[i]);

Serial.print(", ");

}

Serial.println();

This snippet of code will display the values with a comma and space between each value and then a line break after the last element has been printed. I recommend that you take a look at the for loop link above. The guys at Arduino have a wonderful description of how the mechanics work.

Soldering:

Soldering is simple in concept but takes some practice to become proficient. Before you begin soldering you will first need the necessary tools: soldering iron, solder and a copper scrubber. Some additional tools to mention are: solder flux, helping hands, and a solder vacuum. Out of all of the tools, having great solder and a nice clean tip on your iron will be the biggest help.

Soldering breaks down to a few simple steps. First, apply a beat of solder to the tip of a hot iron. This is called tinning the tip and will allow for easier transfer of heat between the tip and the metals to be soldered together. Next, apply the tip to the contacts(metal part of the component/wire to be soldered) and allow the metals to heat for a second or three. Now place the solder onto the contacts and wait for the solder to flow onto the metal. If done properly the solder will hug close to the contacts, you will know when it happens and it is spectacular. It took me a few hours of soldering to really get the hang of the it.

By far the most difficult part of soldering is juggling all of the components and tools. Two ways to help with this problem are to use a breadboard to hold the components or use helping hands. Using the breadboard is perfect for soldering breakout boards, boards made to have a component interface with a breadboard, but not as good as helping hands at most other soldering applications. One trick my friend Paul Rothman taught me was to use the helping hands to hold the solder instead of holding the components. This works if you can easily hold both components with one hand and the iron with the other.

There are tons of tutorials online that show you detailed examples of all types of soldering. I have embedded a great beginner video for reference.

So now that we understand how to solder, we are going to give it a try. We want to solder two separate wires to two separate shiny pennies. We will then use the pennies to measure the conductivity of our skin, but only after they have cooled :)

Now lets use a similar circuit to the one we used last week with all of our LEDs. Make the circuit in the diagram.

So far we have been adjusting the values of the min and max for calibrating using the serial window to manually monitor for the lowest and highest values. This time we are going to use an example sketch to have the Arduino do the calibration for us. Open the calibration sketch, it can be found inside of /Examples/Analog/Calibration. ( or copy and paste the code below )

/*
Calibration

Demonstrates one technique for calibrating sensor input. The
sensor readings during the first five seconds of the sketch
execution define the minimum and maximum of expected values
attached to the sensor pin.

The sensor minimum and maximum initial values may seem backwards.
Initially, you set the minimum high and listen for anything
lower, saving it as the new minimum. Likewise, you set the
maximum low and listen for anything higher as the new maximum.

The circuit:
* Analog sensor (potentiometer will do) attached to analog input 0
* LED attached from digital pin 9 to ground

created 29 Oct 2008
By David A Mellis
Modified 4 Sep 2010
By Tom Igoe

http://arduino.cc/en/Tutorial/Calibration

This example code is in the public domain.

*/

// These constants won't change:
const int sensorPin = A0; // pin that the sensor is attached to
const int ledPin = 9; // pin that the LED is attached to

// variables:
int sensorValue = 0; // the sensor value
int sensorMin = 1023; // minimum sensor value
int sensorMax = 0; // maximum sensor value

void setup() {
// turn on LED to signal the start of the calibration period:
pinMode(13, OUTPUT);
digitalWrite(13, HIGH);

// calibrate during the first five seconds
while (millis() < 5000) {
sensorValue = analogRead(sensorPin);

// record the maximum sensor value
if (sensorValue > sensorMax) {
sensorMax = sensorValue;
}

// record the minimum sensor value
if (sensorValue < sensorMin) {
sensorMin = sensorValue;
}
}

// signal the end of the calibration period
digitalWrite(13, LOW);
}

void loop() {
// read the sensor:
sensorValue = analogRead(sensorPin);

// apply the calibration to the sensor reading
sensorValue = map(sensorValue, sensorMin, sensorMax, 0, 255);

// in case the sensor value is outside the range seen during calibration
sensorValue = constrain(sensorValue, 0, 255);

// fade the LED using the calibrated value:
analogWrite(ledPin, sensorValue);
}

When you upload the code you will notice that only the LED attached to pin 9 seems to light up. To make all of the LEDs work similar to last weeks photo resistor circuit copy and paste the following code.

/*
Using an array of digital pins and a for loop to easily contol LEDs
with a mapped value from a photocell

As you can see, using arrays and for loops makes your code a lot smaller
and easy to change.

Matt Richard
http://idblab.blogspot.com
*/

int sensorPin = A0; // select the input pin for the potentiometer
int ledPins[] = {
2, 3, 4, 5, 6, 7, 8, 9, 10, 11};

int sensorValue = 0; // variable to store the value coming from the sensor
int minThresh = 1023;
int maxThresh = 0;

void setup() {
Serial.begin(9600);
for(int i = 0; i < 10; i++){
pinMode(ledPins[i], OUTPUT);
}

// turn on LED to signal the start of the calibration period:
pinMode(13, OUTPUT);
digitalWrite(13, HIGH);

// calibrate during the first five seconds
while (millis() < 5000) {
sensorValue = analogRead(sensorPin);

// record the maximum sensor value
if (sensorValue > maxThresh) {
maxThresh = sensorValue;
}

// record the minimum sensor value
if (sensorValue < minThresh) {
minThresh = sensorValue;
}
}

// signal the end of the calibration period
digitalWrite(13, LOW);
}

void loop() {
// read the value from the sensor:
sensorValue = analogRead(sensorPin);
Serial.println(sensorValue);

controlLEDs();
}

void controlLEDs(){
int numLEDsOn = map(sensorValue, minThresh, maxThresh, 0, 10);
for(int i = 0; i < numLEDsOn; i++){
digitalWrite(ledPins[i], HIGH);
}
for(int j = numLEDsOn; j < 10; j++){
digitalWrite(ledPins[j], LOW);
}
}

Using Arduino and Processing together:

First off, what is Processing? From the processing website:

Processing is a programming language, development environment, and online community that since 2001 has promoted software literacy within the visual arts. Initially created to serve as a software sketchbook and to teach fundamentals of computer programming within a visual context, Processing quickly developed into a tool for creating finished professional work as well.

As a programming language, Processing is built from Java and has a strong visual output capability. When we open up the Processing IDE you will notice a strong resemblance to the Arduino IDE. This is because they were meant to work together and the founders of both languages worked together to make them look and work similar. The similarities are greater than skin deep, with Processing having a huge community following offering up tons of code resources.

There are a few ways to work with Arduino and Processing, but I am going to demonstrate only one way today. If you are interested you can check out the Arduino library available in Processing. The library allows you to make Arduino calls directly from Processing.

Today we are going to send a byte through serial to Processing and use that value to adjust the speed of a looping movie. Let's start off by making a simple circuit with the Arduino using a potentiometer and 2 different colored LEDs. The potentiometer will give us a value and the LEDs will give us an idea of what that value is before it gets to Processing. Go ahead and make the circuit in the following image. In your ladyada kit you have 3 clear LEDs, one red, one green, and pen blue. The diagram shows 2 clear LEDs wired to different PWM pins, any 2 of the clear will do because we know they will different. This is to help differentiate between when the video will be playing forwards and backwards.

Now lets throw the following code into Arduino and upload it to your board.

/**
* Send a byte through Serial to be used by Processing
* I am pretty sure the original code was written by Tom Igoe
*/

int analogPin = 0;
int analogValue = 0;
int forwardLedPin = 3;
int backwardLedPin = 11;
int pwmValue = 0;

void setup()
{
// start serial port at 9600 bps:
Serial.begin(9600);
}

void loop()
{
// read analog input, divide by 4 to make the range 0-255:
analogValue = analogRead(analogPin);
analogValue = analogValue / 4;
Serial.print(analogValue, BYTE);
// figure out which LED should be on
// if the values are between 0-127, then the backwardLed should be lit
if(analogValue <= 127){
pwmValue = map(analogValue, 127, 0, 0, 255);
analogWrite(backwardLedPin, pwmValue);
analogWrite(forwardLedPin, 0);// this will make sure the other LED is off
}
// if the values are between 128-255, then the forwardLed should be lit
// pwm an led to show that the pot is working
if(analogValue >= 128){
pwmValue = map(analogValue, 128, 255, 0, 255);
analogWrite(forwardLedPin, pwmValue);
analogWrite(backwardLedPin, 0);// this will make sure the other LED is off
}
// pause for 10 milliseconds:
delay(10);
}

The code maps the value of your potentiometer to light up one LED with one half of the values and light tup the other with the other half of values. The center position of the potentiometer will render both LEDs off. These results mimic how the Processing will react to the values of the potentiometer.

Lets open up Processing and load the loop example for the video library. You can find the sketch by looking in the following folders /Examples/Library/Video(movie)/Loop. Now press the play button in the upper left of the Processing IDE. You will see a transparent video playing and leaving trails where ever your mouse is. This is neat but not what we are after. Go ahead and paste the code I have below into Processing replacing all of the code for the Loop sketch.

/**
* Loop Video with values sent from Arduino.
*
* Using an Arduino and Potentiometer, contro the playback speed of a video
* Recieve values using Serial I/O library
*/

import processing.video.*;// import video library
import processing.serial.*;// import serial library

Movie myMovie; // The movie object
float timeJump = 0.0; // amount of time that is displaced when scrubbing the movie in reverse
float timePrevious = 0.0; // the last position of the playhead
float timeFuture = 0.0; // the future position of the playhead

float videoSpeed = 0.0; // the speed at which the video plays
float maxSpeed = 5.0;
float minSpeed = -5.0;

Serial myPort; // The serial port

void setup() {
size(640, 480, P2D);
background(0);
// Load and play the video in a loop
myMovie = new Movie(this, "station.mov");
myMovie.loop();

println(Serial.list());
myPort = new Serial(this, Serial.list()[0], 9600);
}

void movieEvent(Movie myMovie) {
myMovie.read();
}

void draw() {
// tint(255, 30);

if(videoSpeed < 0) {
timeJump = myMovie.time() - timePrevious;
timeFuture = myMovie.time() + timeJump;
if(timeFuture <= 0) {
// we only need to ajust the playhead if the playhead goes past
// the beginning of the movie in reverse
float newBackwardsTime = myMovie.duration() + timeFuture;
myMovie.jump(newBackwardsTime);
}
}
myMovie.speed(videoSpeed);
image(myMovie, 0, 0, width, height);

timePrevious = myMovie.time();
}
/**
* serialEvent
*
* This function access the values coming in from the serial port
* It assigns the values to the play speed of the video, called videoSpeed
* The videoSpeed has a range of -5x to +5x normal playing speed
* These values are determined by the minSpeed and maxSpeed variables
* If you alter them you can change the range of speed the video will play
* For this to work, an Arduino must be sending one byte through the serial port
*/
void serialEvent (Serial myPort) {
// get the byte:
int inByte = myPort.read();
videoSpeed = map(inByte, 0, 255, minSpeed, maxSpeed);
// print it:
println(inByte);
}

// This can be tested with using the keys if you are unable to access and Arduino and potentiometer
// The UP key increases the speed and the DOWN key decreases the speed
void keyPressed() {
if(keyCode == UP) {
videoSpeed += 0.1;
videoSpeed = constrain(videoSpeed, minSpeed, maxSpeed);
}
if(keyCode == DOWN) {
videoSpeed -= 0.1;
videoSpeed = constrain(videoSpeed, minSpeed, maxSpeed);
}
println("adjusted videoSpeed with keys to: " + videoSpeed);
}

Now with the Arduino plugged into the usb slot, go ahead and press the play button in Processing. You will notice that when you change the potentiometer, the speed at which the movie is playing will change. It is a lot of fun to manipulate computer programs with physical objects!

/**
* Loop Video with values sent from Arduino.
*
* Using an Arduino and Potentiometer, contro the playback speed of a video
* Recieve values using Serial I/O library
*/

import processing.serial.*;// import serial library

float diameter = 0.0; // the speed at which the video plays
float maxSpeed = 200.0;
float minSpeed = 1.0;

Serial myPort; // The serial port

void setup() {
size(600, 600);
background(0);
println(Serial.list());
myPort = new Serial(this, Serial.list()[0], 9600);
}

void draw() {

ellipse(mouseX, mouseY, diameter, diameter);
}
/**
* serialEvent
*
* This function access the values coming in from the serial port
* It assigns the values to the play speed of the video, called videoSpeed
* The videoSpeed has a range of -5x to +5x normal playing speed
* These values are determined by the minSpeed and maxSpeed variables
* If you alter them you can change the range of speed the video will play
* For this to work, an Arduino must be sending one byte through the serial port
*/
void serialEvent (Serial myPort) {
// get the byte:
int inByte = myPort.read();
diameter = map(inByte, 0, 255, minSpeed, maxSpeed);
// print it:
println(inByte);
}

// This can be tested with using the keys if you are unable to access and Arduino and potentiometer
// The UP key increases the speed and the DOWN key decreases the speed
void keyPressed() {
if(keyCode == UP) {
diameter += 0.1;
diameter = constrain(diameter, minSpeed, maxSpeed);
}
if(keyCode == DOWN) {
diameter -= 0.1;
diameter = constrain(diameter, minSpeed, maxSpeed);
}
println("adjusted diameter with keys to: " + diameter);
}

Here we are able to adjust a sketch created by Dan Shiffman to allow interaction with a webcam and the arduino. We are also saving out a .mov file when you press spacebar.

/**
* Mirror
* by Daniel Shiffman.
*
* Each pixel from the video source is drawn as a rectangle with rotation based on brightness.
*/

import processing.video.*;
import processing.serial.*;// import serial library

float diameter = 0.0; // the speed at which the video plays
float maxSpeed = 200.0;
float minSpeed = 1.0;

MovieMaker mm; // Declare MovieMaker object

Serial myPort; // The serial port

// Size of each cell in the grid
int cellSize = 20;
// Number of columns and rows in our system
int cols, rows;
// Variable for capture device
Capture video;

void setup() {
size(640, 480, P2D);
frameRate(30);
cols = width / cellSize;
rows = height / cellSize;
colorMode(RGB, 255, 255, 255, 100);

// Uses the default video input, see the reference if this causes an error
video = new Capture(this, width, height, 12);

println(Serial.list());
myPort = new Serial(this, Serial.list()[0], 9600);
mm = new MovieMaker(this, width, height, "drawing.mov",
30, MovieMaker.ANIMATION, MovieMaker.MEDIUM);

background(0);
}

void draw() {
if (video.available()) {
video.read();
video.loadPixels();

// Not bothering to clear background
// background(0);

// Begin loop for columns
for (int i = 0; i < cols; i++) {
// Begin loop for rows
for (int j = 0; j < rows; j++) {

// Where are we, pixel-wise?
int x = i*cellSize;
int y = j*cellSize;
int loc = (video.width - x - 1) + y*video.width; // Reversing x to mirror the image

float r = red(video.pixels[loc]);
float g = green(video.pixels[loc]);
float b = blue(video.pixels[loc]);
// Make a new color with an alpha component
color c = color(r, g, b, 75);

// Code for drawing a single rect
// Using translate in order for rotation to work properly
pushMatrix();
translate(x+cellSize/2, y+cellSize/2);
// Rotation formula based on brightness
rotate((2 * PI * brightness(c) / 255.0));
rectMode(CENTER);
fill(c);
noStroke();
// Rects are larger than the cell for some overlap
rect(0, 0, diameter, diameter);
popMatrix();
}
}

// want to record video into movie file
mm.addFrame(); // Add window's pixels to movie
}
}

/**
* serialEvent
*
* This function access the values coming in from the serial port
* It assigns the values to the play speed of the video, called videoSpeed
* The videoSpeed has a range of -5x to +5x normal playing speed
* These values are determined by the minSpeed and maxSpeed variables
* If you alter them you can change the range of speed the video will play
* For this to work, an Arduino must be sending one byte through the serial port
*/
void serialEvent (Serial myPort) {
// get the byte:
int inByte = myPort.read();
diameter = map(inByte, 0, 255, minSpeed, maxSpeed);
// print it:
println(inByte);
}

void keyPressed() {
if (key == ' ') {
mm.finish(); // Finish the movie if space bar is pressed!
exit();
}
}

Class 3

2011-03-26T10:45:00.026-04:00

Today's class is going to be an exciting one. We have some new concepts to work with that are a little hard at first to understand but are very powerful. Here is a look at what we are going to learn today:

Analog Input: Potentiometer (lab)
Thresholds and calibration: Brightness sensor (lab)
Arrays and for loops
Add movement 2: Servo Motors (group lab)

Analog Input:

The Arduino has 6 pins that allow you to receive analog values from sensors attached to those pins. The Arduino determines the value by reading the voltage coming into those pins and comparing it to the Arduino standard voltage of 5volts dc. We are going to discover how this works by using a potentiometer. Create the circuit below and then upload the following code onto the Arduino.

/*
Analog Input with Potentiometer(pot)
using the arduinos analog input pins
Matt Richard
http://idblabs.blogspot.com
*/

int potPin = A0; // the pin which the middle pin of the potentiometer is attached
int potValue = 0; // the value that is sent from the potentimeter to the analog pin

void setup() {
// create a serial connection
Serial.begin(9600);
}

void loop() {
// read the value from the potentiometer
potValue = analogRead(potPin);

// display the value of the potentiometer in the serial monitor Serial.println(potValue);
}

Now that we have used a potentiometer lets use the value to vary the delay between turning an LED on and off. Create the circuit below and then upload the following code onto the Arduino. The code is an example available with the Arduino ide found under 3.Analog/AnalogInput.

/*
Analog Input
Demonstrates analog input by reading an analog sensor on analog pin 0 and
turning on and off a light emitting diode(LED) connected to digital pin 13.
The amount of time the LED will be on and off depends on
the value obtained by analogRead().
The circuit:
* Potentiometer attached to analog input 0
* center pin of the potentiometer to the analog pin
* one side pin (either one) to ground
* the other side pin to +5V
* LED anode (long leg) attached to digital output 13
* LED cathode (short leg) attached to ground
* Note: because most Arduinos have a built-in LED attached
to pin 13 on the board, the LED is optional.
Created by David Cuartielles
Modified 4 Sep 2010
By Tom Igoe
This example code is in the public domain.
http://arduino.cc/en/Tutorial/AnalogInput
*/

int sensorPin = A0; // select the input pin for the potentiometer
int ledPin = 13; // select the pin for the LED
int sensorValue = 0; // variable to store the value coming from the sensor

void setup() {
// declare the ledPin as an OUTPUT:
pinMode(ledPin, OUTPUT);
}

void loop() {
// read the value from the sensor:
sensorValue = analogRead(sensorPin);
// turn the ledPin on
digitalWrite(ledPin, HIGH);
// stop the program for milliseconds:
delay(sensorValue);
// turn the ledPin off:
digitalWrite(ledPin, LOW);
// stop the program for for milliseconds:
delay(sensorValue);
}

We can also use a potentiometer to control PWM signals to control an LED. Follow the diagram and then paste the following code. This circuit is almost identical to the last one, other than the LED is changed from pin 13 to pin 6.

Analog input, analog output, serial output

Reads an analog input pin, maps the result to a range from 0 to 255

and uses the result to set the pulsewidth modulation (PWM) of an output pin.

Also prints the results to the serial monitor.

The circuit:

* potentiometer connected to analog pin 0.

Center pin of the potentiometer goes to the analog pin.

side pins of the potentiometer go to +5V and ground

* LED connected from digital pin 6 to ground

created 29 Dec. 2008

Modified 4 Sep 2010

by Tom Igoe

This example code is in the public domain.

// These constants won't change. They're used to give names

// to the pins used:

const int analogInPin = A0; // Analog input pin that the potentiometer is attached to

const int analogOutPin = 6; // Analog output pin that the LED is attached to

int sensorValue = 0; // value read from the pot

int outputValue = 0; // value output to the PWM (analog out)

void setup() {

// initialize serial communications at 9600 bps:

Serial.begin(9600);

}

void loop() {

// read the analog in value:

sensorValue = analogRead(analogInPin);

// map it to the range of the analog out:

outputValue = map(sensorValue, 0, 1023, 0, 255);

// change the analog out value:

analogWrite(analogOutPin, outputValue);

// print the results to the serial monitor:

Serial.print("sensor = " );

Serial.print(sensorValue);

Serial.print("\t output = ");

Serial.println(outputValue);

// wait 10 milliseconds before the next loop

// for the analog-to-digital converter to settle

// after the last reading:

delay(10);

}

Thresholds and Calibration:

The potentiometer generated a value from 0-1024, an even range to use as an input. Most sensors do not generate such a nice range of values under normal working conditions. To accurately map a sensor you need to now what the thresholds of the sensor. Each sensor will have a minimum and maximum threshold. Let's use a photocell to change the brightness of an LED. To do this first we will need to determine the minimum and maximum threshold of the photocell. Create the circuit below and then upload the following code onto the Arduino.

/*
Analog input from photocell to determine LED brightness
Matt Richard
http://idblab.blogspot.com
*/

int sensorPin = A0; // select the input pin for the potentiometer
int ledPin = 6; // select the pin for the LED
int sensorValue = 0; // variable to store the value coming from the sensor
int minThresh = 0;// replace this number with a lowest number from the serial monitor
int maxThresh = 1000;// replace this number with a highest number from the serial monitor

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

void loop() {
// read the value from the sensor:
sensorValue = analogRead(sensorPin);
Serial.println(sensorValue);
analogWrite(ledPin, map(sensorValue, minThresh, maxThresh, 0, 255));
}

Once the program has been uploaded, open the serial monitor to view the incoming values from the photocell. Make note of the value of the photocell in ambient light, this is your maximum threshold. Now cover the photocell with your hand or an object to make it as dark as you can. This value is your minimum threshold. I like to add a small buffer of +-20 to insure that the photocell values do not go out of range under normal conditions, but make sure not to have a number less than 0. This is a simple way to calibrate your sensor. By replacing the values for minThresh and maxThresh with values from the serial monitor the effect of dimming the LED by placing your hand over the photocell has a greater effect on the brightness of the LED.

Arrays and For Loops:

int myInts[6];// this creates an array that has 6 places but does not define what the values are

int myPins[] = {2, 4, 8, 3, 6};// this creates an array of 5 places and defines the values

int mySensVals[6] = {2, 4, -8, 3, 2};// this creates an array of 6 places but only defines the first 5 values

This is how you access the values that are store in the arrays above:

myPins[0], where the value would equal 2.

The number inside of the square brackets [ ] indicates which element to access. Arrays are 0 based, meaning the first element is considered the 0 place not the 1st place.

Here is how you change the value of an element of an array:

myPins[1] = 9;// now the values for myPins look like this: {2, 9, 8, 3, 6}

Here is a for loop that prints the values of myPins array to the serial monitor:

for(int i = 0; i < 5; i++){

Serial.print(myPins[i]);

Serial.print(", ");

}

Serial.println();

Let's put it into action so you can see how easy they are to use. Create the circuit below and then upload the following code onto the Arduino.

Working with Motors

The arduino can allow you to control much more than LEDs. In fact you can use the arduino to physically change your environment by using motors. There are many different types of motors, but the most common are brush DC motors, servo motors, and stepper motors.

Brush DC motors : These are the most common motors. You will find them inside of toys, fans, blenders, printers, drills… the list goes on and on. The motor has two terminals, a positive and negative terminal. Simply apply power to one terminal and ground to the other and the motor will spin. Reverse which terminal gets power and ground and the direction reverses. An easy way to control the direction and power source of a motor is to use and H-Bridge.

Stepper Motor : Stepper motors break down a full rotation into a number of steps. Rather than continually rotating like a DC motor, the stepper increments in steps or fractions of a rotation. While you can also use an H-Bridge to control a stepper it is easiest to use the EasyDriver stepper controller.

Servo Motor : Servos are similar to Steppers, in that you tell it to go to a certain angle and it will stop at that angle. The difference is that most packages only have a rotational range of 180 degrees. Servos are used a lot in RC cars, boats and planes to control the steering mechanisms. At its heart a servo is a DC motor with circuitry to understand how far it has rotated. It also usually has gearing to increase its torque.

Servos are incredible easy to use with the arduino. They have three wires, power, ground, and signal. A PWM signal is sent down the signal line and the servo uses that to determine where to rotate to. Arduino has a library that makes this all very easy for us. Build the circuit below and we will control the servo with a potentiometer.

// Controlling a servo position using a potentiometer (variable resistor)
// by Michal Rinott

#include

Servo myservo; // create servo object to control a servo

int potpin = 2; // analog pin used to connect the potentiometer
int val; // variable to read the value from the analog pin

void setup()
{
myservo.attach(9); // attaches the servo on pin 9 to the servo object
}

void loop()
{
val = analogRead(potpin); // reads the value of the potentiometer (value between 0 and 1023)
val = map(val, 0, 1023, 0, 179); // scale it to use it with the servo (value between 0 and 180)
myservo.write(val); // sets the servo position according to the scaled value
delay(15); // waits for the servo to get there
}

More fun with Arduino! PComp with Arduino Class 2

2011-03-19T09:53:00.024-04:00

Here is a short list of the topics we will cover for class 2:

Commenting (review)

Basic Programming Structure

Pulse Width Modulation(pwm)

Where to find components/tools/cool stuff

Commenting (code):

Commenting code is an important part of making sense of what is going on in the code, especially when you come back to your program at a later date. Using comments, you can leave descriptions of the processes and variables used in your program. There are two kinds of commenting, line commenting(//...) and block comments(/.../).

Line commenting occurs each time you place two forward slashes in your code. The rest of the text on the line with the slashes is disregarded by the compiler. This is a great way to turn off one line of code but still have it available for a later time. Block comments use a combination of / to begin the comment and / to end the comment. Anything inside of those characters will be disregarded by the compiler. This allows you to turn off big chunks of code and create proper code descriptions.

/*

This is a block comment. Everything inside of the "/" and "/" is commented out.

*/

// this is also a comment

Variables (code):

Variables are a way of storing and accessing values in a program. There are many different types of variables, each type has a limit to how big of a number or even what type of number can be stored inside.

The standard variables available to us through Arduino are:

boolean: A boolean holds one of two values, true or false. (Each boolean variable occupies one byte of memory.)

char: A data type that takes up 1 byte of memory that stores a character value. Character literals are written in single quotes, like this: 'A' (for multiple characters - strings - use double quotes: "ABC").

byte: A byte stores an 8-bit unsigned number, from 0 to 255.

int: Integers are your primary datatype for number storage, and store a 2 byte value. This yields a range of -32,768 to 32,767 (minimum value of -2^15 and a maximum value of (2^15) - 1).

word: A word stores a 16-bit unsigned number, from 0 to 65535. Same as an unsigned int.

long: Long variables are extended size variables for number storage, and store 32 bits (4 bytes), from -2,147,483,648 to 2,147,483,647.

float: Datatype for floating-point numbers, a number that has a decimal point. Floating-point numbers are often used to approximate analog and continuous values because they have greater resolution than integers. Floating-point numbers can be as large as 3.4028235E+38 and as low as -3.4028235E+38. They are stored as 32 bits (4 bytes) of information.

double: Double precision floating point number. Occupies 4 bytes. Same thing as a float.

string: Strings are represented as arrays of type char.

array: An array is a collection of variables that are accessed with an index number. Arrays in the C programming language, on which Arduino is based, can be complicated, but using simple arrays is relatively straightforward.

Program Structure (code):

It is important to have a standard structure when writing a program. A structure will make it easy for you and others to locate all of the components of your program.

The first part of the program should be a description of what the program is using block comments.

The second section is where you place all of your variables. Start with constants first and then group them according to their purpose. Don't forget to leave detailed comments.

The third section is for the setup() function. Void setup() is where you initialize your digital pins and communication lines.

The fourth section is for the loop() function. Void loop() is what gets executed by the microcontroller on every loop or frame. This will get repeated over and over until the microcontroller is turned off.

The fifth section(not depicted) is used for functions you create.

PWM - introduction to Pulse Width Modulation:

Pulse Width Modulation is a process of taking a digital pin(on/off) and creating a gradient value or change. By pulsing the pin on and off in varying square waves you can achieve a range of values which can be used to "dim" an LED. I say "dim" because really the LED is being turned on and off so fast that our eyes perceive it as dim.

Fading using delay(lab):

/*

Fade

This example shows how to fade an LED on pin 9

using the analogWrite() function.

This example code is in the public domain.

*/

int brightness = 0; // how bright the LED is

int fadeAmount = 5; // how many points to fade the LED by

void setup() {

// declare pin 6 to be an output:

pinMode(6, OUTPUT);

}

void loop() {

// set the brightness of pin 6:

analogWrite(6, brightness);

// change the brightness for next time through the loop:

brightness = brightness + fadeAmount;

// reverse the direction of the fading at the ends of the fade:

if (brightness == 0 || brightness == 255) {

fadeAmount = -fadeAmount ;

}

// wait for 30 milliseconds to see the dimming effect

delay(30);

}

Fading using timer(lab):

Fade RGB LEDs

This example shows how to fade an LED on pin 3,5,6

using the analogWrite() function.

This example code is in the public domain.

int brightnessBlue = 0; // how bright the BLUE LED is

int fadeAmountBlue = 5; // how many points to fade the BLUE LED by

int brightnessGreen = 85; // how bright the GREEN LED is

int fadeAmountGreen = 5; // how many points to fade the BLUE LED by

int brightnessRed = 170; // how bright the RED LED is

int fadeAmountRed = 5; // how many points to fade the BLUE LED by

void setup() {

// declare pin 9 to be an output:

pinMode(3, OUTPUT);

pinMode(5, OUTPUT);

pinMode(6, OUTPUT);

}

void loop() {

// set the brightness of pin 3, 5, and 6:

analogWrite(3, brightnessBlue);

analogWrite(5, brightnessGreen);

analogWrite(6, brightnessRed);

// BLUE LED LOGIC BEGIN

// change the brightness for next time through the loop:

brightnessBlue = brightnessBlue + fadeAmountBlue;

// reverse the direction of the fading at the ends of the fade:

if (brightnessBlue == 0 || brightnessBlue == 255) {

fadeAmountBlue = -fadeAmountBlue ;

}

// BLUE LED LOGIC END

// GREEN LED LOGIC BEGIN

// change the brightness for next time through the loop:

brightnessGreen = brightnessGreen + fadeAmountGreen;

// reverse the direction of the fading at the ends of the fade:

if (brightnessGreen == 0 || brightnessGreen == 255) {

fadeAmountGreen = -fadeAmountGreen ;

}

// GREEN LED LOGIC END

// RED LED LOGIC BEGIN

// change the brightness for next time through the loop:

brightnessRed = brightnessRed + fadeAmountRed;

// reverse the direction of the fading at the ends of the fade:

if (brightnessRed == 0 || brightnessRed == 255) {

fadeAmountRed = -fadeAmountRed ;

}

// RED LED LOGIC END

// wait for 30 milliseconds to see the dimming effect

delay(30);

}

Where to find components/tools/cool stuff:

At some point you are going to need to add to your project. If you need it local your only options are a RadioShack or a small electronics seller in China Town. The address is 269 Canal Street and the store is located in the back. If you don't need it today, then you have a much wider option for price and availability online. I have included some of my most frequented online stores along with what they stock.

Local:

RadioShack - common components, wires and tools

269 Canal Electronics - rarer components, call and ask, not cheap, in China Town

Electronics:

SparkFun Electronics - Hacker/Hobbyist Electronics and Arduino

Adafruit
- Hacker/Hobbyist Electronics and Arduino

Evil Mad Science - Arduino and cheap LEDs

MaceTech - LED control for Arduino

Electronics Goldmine - Close out prices on electronic parts and tools, mostly older

All Electronics - Close out prices on electronic parts and tools, mostly new

Jameco - Professional Electronic Parts and ICs

Mouser - Professional Electronic Parts and ICs

Robotics:

Pololu - Motor controllers and sensors

LynxMotion - Servo housings and metal robot kits

Hardware/Materials:

SmallParts - small mechanic components and hand tools

McMaster Carr - all sorts of awesome building materials and tools, delivers fast

Welcome to Arduino! PComp with Arduino Class 1

2011-03-11T19:33:00.013-05:00

Hello everyone, I hope your day has been well and that you ate a big breakfast because we are going to have a lot of fun.

Names and Introductions

Just a quick introduction so we can find out your name and why you are interested in the class and what your experience with programming and circuits is.

What to expect form the class

Here is a brief look at the run down of the class:
Day 1
A definition of what Physical computing is and how and why it is used.
Information about the Arduino and why it is a great platform for physical computing.
Overview of the Arduino website.
How to install and run Arduino.
Overview of the kit.
What tools you need and where to get them.
Blink (lab)
Input & Output
Digital & Analog

Day 2
Soldering (lab)
Multimeter
Comment (code)
Variables (code)
Program structure (code)
Functions (code)
PWM
Fading using timer (lab)
Where to find components

Day 3
Fade timing: modulo (lab)
Multiple LEDs: arrays and for loops (lab)
Potentiometer: serial output (lab)
Control LED with pot: mapping (lab)
Brightness sensor: thresholds and calibration(lab)
Button counter w/state change (lab)

Day 4
Handling alternative power sources
Smoothing sensor values
Projects (color mixer, chandelier)

What is Physical Computing?

Physical Computing, or Pcomp for short, refers to the practice of using a computer to interfacing with the natural physical world. The process can include receiving data from the natural world and/or creating an output outside of the computer that effects the world. We will learn how to use microcontrollers as an intermediary between the physical world and your computer.

Intro to Arduino, Welcome to the club

The Arduino is a wonderful prototyping platform for a number of reasons. The Arduino uses an open source hardware business model. What this means is that they give away for free exactly how to make their product and they also allow you to take those plans and make their product and sell it, I believe as long as you do the same. This breeds an environment where everyone shares and everyone succeeds together growing together as the collective knowledge grows. This means that there are tons of code lying around the web waiting for you to search for them and throw them onto your arduino, making simple work of simple projects. This also means that many people have designed add-ons to the original platform that interface flawlessly and add a great deal of functionality. So welcome to the club, have fun and enjoy the life.

How to Install Arduino

The people at Arduino have put together a wonderful intro to the arduino for any of the major platforms. Check out the link and follow along to install get started when you get back to your house.

Arduino web resources

There are a ton of web resources available for the Arduino. Here are a few of my go to places to look for help:
The Arduino website includes an entire run down of the arduino language.
The website also includes a ton on how to get started including examples, foundations, and links to other resources.
Along with the code that comes with Arduino, you can use code people have created to work with Arduino. These are called libraries and they can be found here. Most libraries will have links to more information on how to use the code they provide.
While you might think that you have a unique idea, this is almost certainly not the case. Check the forums at Arduino (old forum) to see if anyone has already solved the problem you are trying to figure out.

What are our materials

Here is a run down of the parts in the kit:

1 Arduino Uno

1 breadboard

1 USB cable (A to B)

2 momentary(or biased) switches

2 potentiometers

1 photoresistor

5 red LEDs

3 superbrite LEDs

5 100 ohm resistors

5 1000 ohm resistors

5 10000 ohm resistors

1 bundle of jumper wires

Lets make something blink!

For startes we are going to use the basic Arduino introduction sketch, the blinking LED. Now while this is a basic sketch, it is an amazing experience, I remember my first blinking LED well. Lets jump to the Arduino site to take a look at the sketch.

The difference between input and output

This is pretty simple, inputs are values and processes associated with things coming into the Arduino, while an output is a value that is sent out from the Arduino. Human inputs are our five senses and our outputs are using our body in any way to effect the outside world for example talking.

Physical Computing with Arduino: class 3

2011-01-22T19:55:00.028-05:00

modulo: Fade timing (lab)
analog input: Potentiometer (lab)
mapping: control LED with a Pot(lab)
thresholds and calibration: Brightness sensor (lab)
arrays and for loops: Multiple LEDs (lab)
Button counter w/state change (lab)

Modulo:

Modulo is an mathematical operator that calculates the remainder when one integer is divided by another. It is very useful for keeping a number with in a set of numbers, or counting to a certain number over and over. Lets take a look at how it works:

0 % 4 = 0

1 % 4 = 1

2 % 4 = 2

3 % 4 = 3

4 % 4 = 0

5 % 4 = 1

6 % 4 = 2

7 % 4 = 3

8 % 4 = 0

The first number can keep growing but the result will only be a number between 0-3. If you modulo by 255, instead of 4, you have a great number to throw into the analogWrite() command to PWM a digital pin. Thats just what we are going to do. In fact lets make a simple "clock" and then a metronome.

Using the function millis() returns the number of milliseconds since the Arduino has begun running a program. We can visualize the length of time the Arduino has been running a way that we recognize by chunking it into blocks of seconds, or fractions of seconds. Make the following circuit and then upload the corresponding code to make a simple clock.

Simple Clock

Using % (modulo) and millis() to make a simple clock that

PWMs an LED to fractions of a second

Matt Richard

http://idblab.blogspot.com

int pwmPin = 6;// digital pin to connect to LED

int pwmVal = 0;// variable that represents the PWM value for the LED to be placed in the analogWrite(pin, value) command.

int maxPWM = 256;// used with % to keep pwmVal between 0-255

int divisor = 2;// used to keep the increment of light and time relative

int pwmValIncrement = maxPWM / divisor;// if this # is a factor of 256 then the brightness steps will be even

int second = 1000;// number of milliseconds in one second

int time = second / divisor;// the increment in time that will trigger a change in the pwmVal

void setup() {

Serial.begin(115200);// begin a serial communication so we can see the millis count up.

}

void loop() {

// if the amount of time has passed then...

if(millis() % time == 0){

pwmVal = pwmVal + pwmValIncrement;// the value of the LED equals itself plus the LED light increment

pwmVal = pwmVal % maxPWM;// make sure the value of the LED is not greater than 255, if it is loop it back to 0

analogWrite(pwmPin, pwmVal);// PWM the led

Serial.println("time");// displays the change in light along side the change in millis

}

Serial.println(millis() % 1000);// displays the change in millis

}

Analog Input:

Analog Input with Potentiometer(pot)

using the arduinos analog input pins

Matt Richard

http://idblabs.blogspot.com

int potPin = A0; // the pin which the middle pin of the potentiometer is attached

int potValue = 0; // the value that is sent from the potentimeter to the analog input pin

void setup() {

// create a serial connection so we can view the potentiometer readings in the serial monitor

Serial.begin(9600);

}

void loop() {

// read the value from the potentiometer

potValue = analogRead(potPin);

// display the value of the potentiometer in the serial monitor

Serial.println(potValue);

}

Analog Input

Demonstrates analog input by reading an analog sensor on analog pin 0 and

turning on and off a light emitting diode(LED) connected to digital pin 13.

The amount of time the LED will be on and off depends on

the value obtained by analogRead().

The circuit:

* Potentiometer attached to analog input 0

* center pin of the potentiometer to the analog pin

* one side pin (either one) to ground

* the other side pin to +5V

* LED anode (long leg) attached to digital output 13

* LED cathode (short leg) attached to ground

* Note: because most Arduinos have a built-in LED attached

to pin 13 on the board, the LED is optional.

Created by David Cuartielles

Modified 4 Sep 2010

By Tom Igoe

This example code is in the public domain.

http://arduino.cc/en/Tutorial/AnalogInput

int sensorPin = A0; // select the input pin for the potentiometer

int ledPin = 13; // select the pin for the LED

int sensorValue = 0; // variable to store the value coming from the sensor

void setup() {

// declare the ledPin as an OUTPUT:

pinMode(ledPin, OUTPUT);

}

void loop() {

// read the value from the sensor:

sensorValue = analogRead(sensorPin);

// turn the ledPin on

digitalWrite(ledPin, HIGH);

// stop the program for milliseconds:

delay(sensorValue);

// turn the ledPin off:

digitalWrite(ledPin, LOW);

// stop the program for for milliseconds:

delay(sensorValue);

}

Thresholds and Calibration:

The potentiometer generated a value from 0-1024 a even range to use as an input. Most sensors do not generate such a nice range of values under normal working conditions. To accurately map a sensor you need to now what the thresholds of the sensor. Each sensor will have a minimum and maximum threshold. Lets use a photocell to change the brightness of an LED. To do this first we will need to determine the minimum and maximum threshold of the photocell. Create the circuit below and then upload the following code onto the Arduino.

Analog input from photocell to determine LED brightness

Matt Richard

http://idblab.blogspot.com

int sensorPin = A0; // select the input pin for the potentiometer

int ledPin = 6; // select the pin for the LED

int sensorValue = 0; // variable to store the value coming from the sensor

int minThresh = 0;// replace this number with a lowest number from the serial monitor

int maxThresh = 1000;// replace this number with a highest number from the serial monitor

void setup() {

Serial.begin(9600);

}

void loop() {

// read the value from the sensor:

sensorValue = analogRead(sensorPin);

Serial.println(sensorValue);

analogWrite(ledPin, map(sensorValue, minThresh, maxThresh, 0, 255));

}

Arrays and For Loops:

int myInts[6];// this creates an array that has 6 places but does not define what the values are

int myPins[] = {2, 4, 8, 3, 6};// this creates an array of 5 places and defines the values

int mySensVals[6] = {2, 4, -8, 3, 2};// this creates an array of 6 places but only defines the first 5 values

This is how you access the values that are store in the arrays above:

myPins[0] + 1 = 3

The number inside of the square brackets [ ] indicates which value to access. Arrays are 0 based, meaning the first value is considered the 0 place not the 1st place.

Here is how you change the value of an element of an array:

myPins[1] = 9;// now the values for myPins look like this: {2, 9, 8, 3, 6}

Here is a for loop that prints the values of myPins array to the serial monitor:

for(int i = 0; i <>

Serial.print(myPins[i]);

Serial.print(", ");

}

Serial.println();

Lets put it into action so you can see how easy they are to use. Create the circuit below and then upload the following code onto the Arduino.

contains code to allow me to not mess styles

Using an array of digital pins and a for loop to easily contol LEDs

with a mapped value from a photocell

As you can see, using arrays and for loops makes your code a lot smaller

and easy to change.

Matt Richard

http://idblab.blogspot.com

int sensorPin = A0; // select the input pin for the potentiometer

int ledPins[] = {

2, 3, 4, 5, 6, 7, 8, 9, 10, 11};

//how to write with out an array

int ledPin1 = 2;

int ledPin2 = 3;

int ledPin3 = 4;

int ledPin4 = 5;

int ledPin5 = 6;

int ledPin6 = 7;

int ledPin7 = 8;

int ledPin8 = 9;

int ledPin9 = 10;

int ledPin10 = 11;

int sensorValue = 0; // variable to store the value coming from the sensor

int minThresh = 580;

int maxThresh = 870;

void setup() {

Serial.begin(9600);

for(int i = 0; i <>

pinMode(ledPins[i], OUTPUT);

}

//how to write with out for loop

pinMode(ledPin1,OUTPUT);

pinMode(ledPin2,OUTPUT);

pinMode(ledPin3,OUTPUT);

pinMode(ledPin4,OUTPUT);

pinMode(ledPin5,OUTPUT);

pinMode(ledPin6,OUTPUT);

pinMode(ledPin7,OUTPUT);

pinMode(ledPin8,OUTPUT);

pinMode(ledPin9,OUTPUT);

pinMode(ledPin10,OUTPUT);

}

void loop() {

// read the value from the sensor:

sensorValue = analogRead(sensorPin);

Serial.println(sensorValue);

controlLEDs();

}

void controlLEDs(){

int numLEDsOn = map(sensorValue, minThresh, maxThresh, 0, 10);

for(int i = 0; i <>

digitalWrite(ledPins[i], HIGH);

}

for(int j = numLEDsOn; j <>

digitalWrite(ledPins[j], LOW);

}

// how to write without for loops and arrays

if(numLEDsOn == 0){

digitalWrite(ledPins1, LOW);

digitalWrite(ledPins2, LOW);

digitalWrite(ledPins3, LOW);

digitalWrite(ledPins4, LOW);

digitalWrite(ledPins5, LOW);

digitalWrite(ledPins6, LOW);

digitalWrite(ledPins7, LOW);

digitalWrite(ledPins8, LOW);

digitalWrite(ledPins9, LOW);

digitalWrite(ledPins10, LOW);

}

if(numLEDsOn == 1){

digitalWrite(ledPins1, HIGH);

digitalWrite(ledPins2, LOW);

digitalWrite(ledPins3, LOW);

digitalWrite(ledPins4, LOW);

digitalWrite(ledPins5, LOW);

digitalWrite(ledPins6, LOW);

digitalWrite(ledPins7, LOW);

digitalWrite(ledPins8, LOW);

digitalWrite(ledPins9, LOW);

digitalWrite(ledPins10, LOW);

}

if(numLEDsOn == 2){

digitalWrite(ledPins1, HIGH);

digitalWrite(ledPins2, HIGH);

digitalWrite(ledPins3, LOW);

digitalWrite(ledPins4, LOW);

digitalWrite(ledPins5, LOW);

digitalWrite(ledPins6, LOW);

digitalWrite(ledPins7, LOW);

digitalWrite(ledPins8, LOW);

digitalWrite(ledPins9, LOW);

digitalWrite(ledPins10, LOW);

}

if(numLEDsOn == 0){

digitalWrite(ledPins1, LOW);

digitalWrite(ledPins2, LOW);

digitalWrite(ledPins3, LOW);

digitalWrite(ledPins4, LOW);

digitalWrite(ledPins5, LOW);

digitalWrite(ledPins6, LOW);

digitalWrite(ledPins7, LOW);

digitalWrite(ledPins8, LOW);

digitalWrite(ledPins9, LOW);

digitalWrite(ledPins10, LOW);

}

if(numLEDsOn == 3){

digitalWrite(ledPins1, HIGH);

digitalWrite(ledPins2, HIGH);

digitalWrite(ledPins3, HIGH);

digitalWrite(ledPins4, LOW);

digitalWrite(ledPins5, LOW);

digitalWrite(ledPins6, LOW);

digitalWrite(ledPins7, LOW);

digitalWrite(ledPins8, LOW);

digitalWrite(ledPins9, LOW);

digitalWrite(ledPins10, LOW);

}

if(numLEDsOn == 4){

digitalWrite(ledPins1, HIGH);

digitalWrite(ledPins2, HIGH);

digitalWrite(ledPins3, HIGH);

digitalWrite(ledPins4, HIGH);

digitalWrite(ledPins5, LOW);

digitalWrite(ledPins6, LOW);

digitalWrite(ledPins7, LOW);

digitalWrite(ledPins8, LOW);

digitalWrite(ledPins9, LOW);

digitalWrite(ledPins10, LOW);

}

if(numLEDsOn == 5){

digitalWrite(ledPins1, HIGH);

digitalWrite(ledPins2, HIGH);

digitalWrite(ledPins3, HIGH);

digitalWrite(ledPins4, HIGH);

digitalWrite(ledPins5, HIGH);

digitalWrite(ledPins6, LOW);

digitalWrite(ledPins7, LOW);

digitalWrite(ledPins8, LOW);

digitalWrite(ledPins9, LOW);

digitalWrite(ledPins10, LOW);

}

if(numLEDsOn == 6){

digitalWrite(ledPins1, HIGH);

digitalWrite(ledPins2, HIGH);

digitalWrite(ledPins3, HIGH);

digitalWrite(ledPins4, HIGH);

digitalWrite(ledPins5, HIGH);

digitalWrite(ledPins6, HIGH);

digitalWrite(ledPins7, LOW);

digitalWrite(ledPins8, LOW);

digitalWrite(ledPins9, LOW);

digitalWrite(ledPins10, LOW);

}

if(numLEDsOn == 7){

digitalWrite(ledPins1, HIGH);

digitalWrite(ledPins2, HIGH);

digitalWrite(ledPins3, HIGH);

digitalWrite(ledPins4, HIGH);

digitalWrite(ledPins5, HIGH);

digitalWrite(ledPins6, HIGH);

digitalWrite(ledPins7, HIGH);

digitalWrite(ledPins8, LOW);

digitalWrite(ledPins9, LOW);

digitalWrite(ledPins10, LOW);

}

if(numLEDsOn == 8){

digitalWrite(ledPins1, HIGH);

digitalWrite(ledPins2, HIGH);

digitalWrite(ledPins3, HIGH);

digitalWrite(ledPins4, HIGH);

digitalWrite(ledPins5, HIGH);

digitalWrite(ledPins6, HIGH);

digitalWrite(ledPins7, HIGH);

digitalWrite(ledPins8, HIGH);

digitalWrite(ledPins9, LOW);

digitalWrite(ledPins10, LOW);

}

if(numLEDsOn == 9){

digitalWrite(ledPins1, HIGH);

digitalWrite(ledPins2, HIGH);

digitalWrite(ledPins3, HIGH);

digitalWrite(ledPins4, HIGH);

digitalWrite(ledPins5, HIGH);

digitalWrite(ledPins6, HIGH);

digitalWrite(ledPins7, HIGH);

digitalWrite(ledPins8, HIGH);

digitalWrite(ledPins9, HIGH);

digitalWrite(ledPins10, LOW);

}

if(numLEDsOn == 10){

digitalWrite(ledPins1, HIGH);

digitalWrite(ledPins2, HIGH);

digitalWrite(ledPins3, HIGH);

digitalWrite(ledPins4, HIGH);

digitalWrite(ledPins5, HIGH);

digitalWrite(ledPins6, HIGH);

digitalWrite(ledPins7, HIGH);

digitalWrite(ledPins8, HIGH);

digitalWrite(ledPins9, HIGH);

digitalWrite(ledPins10, HIGH);

}

unless the resulting number would be less than 0.

2011-01-15T17:53:00.026-05:00

Here is the agenda for class 2:

1. Soldering (lab)

2. Comment (code) - review from last week

3. Variables (code) - add to what we learned last week

4. Program structure (code) - add to what we learned last week

5. PWM - introduction to Pulse Width Modulation

6. Fading using timer (lab)

7. Where to find components/tools/cool stuff

Soldering:

There are tons of tutorials online that show you detailed examples of all types of soldering. I have embedded a great beginner video for reference.

Commenting (code):

Commenting code is an important part of making sense of what is going on in the code, especially when you come back to your program at a later date. Using comments, you can leave descriptions of the processes and variables used in your program. There are two kinds of commenting, line commenting(//...) and block comments(/*...*/).

Line commenting occurs each time you place two forward slashes in your code. The rest of the text on the line with the slashes is disregarded by the compiler. This is a great way to turn off one line of code but still have it available for a later time. Block comments use a combination of */ to begin the comment and */ to end the comment. Anything inside of those characters will be disregarded by the compiler. This allows you to turn off big chunks of code and create proper code descriptions.

Blink

Turns on an LED on for one second, then off for one second, repeatedly.

This example code is in the public domain.

void setup() {

// initialize the digital pin as an output.

// Pin 13 has an LED connected on most Arduino boards:

pinMode(13, OUTPUT);

}

void loop() {

digitalWrite(13, HIGH); // set the LED on

delay(1000); // wait for a second

digitalWrite(13, LOW); // set the LED off

delay(1000); // wait for a second

}

Variables (code):

Variables are a way of storing and accessing values in programming. There are many different types of variables, each type has a limit to how big of a number or even what type of number can be stored inside. So far we have only used integers(int) in our code. An integer is a whole number with a range from -32,768 to 32,767. Today we will learn about floats, a number with a floating point or decimal. Floats are great for fine detail in rate of change as they allow us to have access to the numbers between whole numbers.

As we progress in class we will learn and use more variable types. If you want to learn more ahead of time you can check out the variables column on the Arduino website.

Program Structure (code):

Smoothing

Reads repeatedly from an analog input, calculating a running average

and printing it to the computer. Keeps ten readings in an array and

continually averages them.

The circuit:

* Analog sensor (potentiometer will do) attached to analog input 0

Created 22 April 2007

By David A. Mellis

http://www.arduino.cc/en/Tutorial/Smoothing

This example code is in the public domain.

// Define the number of samples to keep track of. The higher the number,

// the more the readings will be smoothed, but the slower the output will

// respond to the input. Using a constant rather than a normal variable lets

// use this value to determine the size of the readings array.

const int numReadings = 10;

int readings[numReadings]; // the readings from the analog input

int index = 0; // the index of the current reading

int total = 0; // the running total

int average = 0; // the average

int inputPin = A0;

void setup()

{

// initialize serial communication with computer:

Serial.begin(9600);

// initialize all the readings to 0:

for (int thisReading = 0; thisReading <>

readings[thisReading] = 0;

}

void loop() {

// subtract the last reading:

total= total - readings[index];

// read from the sensor:

readings[index] = analogRead(inputPin);

// add the reading to the total:

total= total + readings[index];

// advance to the next position in the array:

index = index + 1;

// if we're at the end of the array...

if (index >= numReadings)

// ...wrap around to the beginning:

index = 0;

// calculate the average:

average = total / numReadings;

// send it to the computer (as ASCII digits)

Serial.println(average, DEC);

}

It is important to have a standard structure when writing a program. A structure will make it easy for you and others to locate all of the components of your program.

The first part of the program should be a description of what the program is using block comments.

The second section is where you place all of your variables. Start with constants first and then group them according to their purpose. Don't forget to leave detailed comments.

The third section is for the setup() function. Void setup() is where you initialize your digital pins and communication lines.

The fourth section is for the loop() function. Void loop() is what gets executed by the microcontroller on every loop or frame. This will get repeated over and over until the microcontroller is turned off.

The fifth section(not depicted) is used for functions you create.

PWM - introduction to Pulse Width Modulation:

Pulse Width Modulation is a process of taking a digital pin(on/off) and creating a gradient value or change. By pulsing the pin on and off in varying square waves you can achieve a range of values which can be used to "dim" an LED. I say "dim" because really the LED is being turned on and off so fast that our eyes perceive it as dim.

Fading using timer (lab):

PWM LED

dim an led using analogWrite

code by Matt Richard

int pinRed = 11;

int pwmValueRed = 0;

int pwmIncrementRed = 1;

int pinGreen = 3;

int pwmValueGreen = 0;

int pwmIncrementGreen = 2;

int pinBlue = 6;

int pwmValueBlue = 0;

int pwmIncrementBlue = 3;

int pwmMin = 0;// the lowest pwm value - 0 = off

int pwmMax = 255;// the highest pwm value - 255 = full on

void setup(){

Serial.begin(9600);

}

void loop(){

red();

green();

blue();

delay(20);

}

void red(){

pwmValueRed = pwmValueRed + pwmIncrementRed;

Serial.println(pwmValueRed);

// pwmValue += pwmIncrement;

// this takes care of the pwmValue being smaller than pwmMin

if(pwmValueRed <= pwmMin){

Serial.println("we reached red's bottom!");

pwmIncrementRed = pwmIncrementRed * -1;

pwmValueRed = pwmValueRed + pwmIncrementRed;

}

// this takes care of the pwmValue being larger than pwmMax

if(pwmValueRed >= pwmMax){

Serial.println("we reached red's top!");

pwmIncrementRed = pwmIncrementRed * -1;

pwmValueRed = pwmValueRed + pwmIncrementRed;

}

analogWrite(pinRed, pwmValueRed);

}

void green(){

pwmValueGreen = pwmValueGreen + pwmIncrementGreen;

Serial.println(pwmValueGreen);

// pwmValue += pwmIncrement;

// this takes care of the pwmValue being smaller than pwmMin

if(pwmValueGreen <= pwmMin){

Serial.println("we reached Green's bottom!");

pwmIncrementGreen = pwmIncrementGreen * -1;

pwmValueGreen = pwmValueGreen + pwmIncrementGreen;

}

// this takes care of the pwmValue being larger than pwmMax

if(pwmValueGreen >= pwmMax){

Serial.println("we reached Green's top!");

pwmIncrementGreen = pwmIncrementGreen * -1;

pwmValueGreen = pwmValueGreen + pwmIncrementGreen;

}

analogWrite(pinGreen, pwmValueGreen);

}

void blue(){

pwmValueBlue = pwmValueBlue + pwmIncrementBlue;

Serial.println(pwmValueBlue);

// pwmValue += pwmIncrement;

// this takes care of the pwmValue being smaller than pwmMin

if(pwmValueBlue <= pwmMin){

Serial.println("we reached Blue's bottom!");

pwmIncrementBlue = pwmIncrementBlue * -1;

pwmValueBlue = pwmValueBlue + pwmIncrementBlue;

}

// this takes care of the pwmValue being larger than pwmMax

if(pwmValueBlue >= pwmMax){

Serial.println("we reached Blue's top!");

pwmIncrementBlue = pwmIncrementBlue * -1;

pwmValueBlue = pwmValueBlue + pwmIncrementBlue;

}

analogWrite(pinBlue, pwmValueBlue);

}

Where to find components/tools/cool stuff:

Do to the change in culture here in America, hobbyist electronics is not as common as it once was. If you want to walk to a store to purchase electronic components your only option is likely to be Radio Shack. Radio Shack has an assortment of resistors and capacitors as well as a few IC(intergraded circuits). If you want a much better selection and lower cost, you will need to look online. Here is a list of some great electronics suppliers that I like.

Electronics:

Robotics:

Hardware/Materials:

Physical Computing with Arduino: class 1

2011-01-15T15:47:00.003-05:00

A friend of mine recommended that I use my blog to post class information instead of using google docs. For now I will just include a link to the google presentation for class 1 and will port it over to the blog in the next few days.

Class 1 presentation

Cute/Monstrous: an exploration into the Fly

2010-03-30T14:39:00.004-04:00

I have chosen the fly as my animal to research and create works with for the rest of the semester in Animals, People, and those in between. Each student is required to select an animal from Reaktion's animal series. The books offer a unique look into the lives of familiar, albeit misunderstood, animals. It was a hard choice between crocodiles, which feature prominently in my anxiety dreams, and flies, which I think are very beautiful when seen up close. I chose the fly because, well, they are such close partners to humans yet we rarely think of them as pets except for maybe Pigpen in "Peanuts" or that crazy character from "Midnight in the Garden of Good and Evil" who had flies on strings as companions. We consider them to be harbingers of disease, but really they are just moving our own germs between us. Long story short, I found them fascinating and close to home.

For our first assignment we had to portray our animal in two contrasting ways: monstrous and cute. For cute I used the principles of anthropomorphication to liken a fly to a child. I increased the size of the head, gave it humanesque hands with thumbs and a baseball cap and boots. A button nose, small smile, big eyes and a coy wave topped it off.

For the monstrous image I played more with the horror of a human body being decomposed by flies. When I was a child I found my neighbors dead cat in the woods behind my house. For a moment I believed the creature was still alive because the chest cavity was still in motion. That was when I noticed that the belly had burst open and maggots were roiling inside causing the carcass to undulate rhythmically. I immediately grasped my chest throat with the tips of my fingers pressing deep and hard into my skin, so as to cause pain and make me realize I was alive. But I couldn't help feel like I would eventually end up like that, one day I would be as that cat. The drawing I created focussed on overly defined form as a way to introduce darkness into the piece and also detail, thus keeping the viewers eyes moving. The human form has been warped and skewed to suggest internal changes due to internal decomposition. A hole has been placed in the chest from which flies are being born, quiet similar to our own birth except, flies seem to be born from death and decay which has likely added to there stigma. I even added the beginning of fly wings where the human arm should be to illustrate the change in domain and repurposing of the flesh.

Conductive Liquid

2010-03-11T17:43:00.002-05:00

Elie Zananiri and I decided to make a fluid that would allow us to create liquid circuits. We tried many different combinations of the materials: water, oil, salt, powder graphite, and glue. The best combination was water, salt, and graphite, which resulted in a mixture that gave a steady reading of about 100 ohms. We used the liquid to create both a drawn circuit and an irrigation circuit.

Conductive Fluid Drawing from Matt Richard on Vimeo.

Conductive fluid irrigation LED circuit from Matt Richard on Vimeo.

Teach-Shirt

2010-03-04T16:07:00.004-05:00

A concern of mine for the developing world is how to deliver teaching materials. I had an idea for t-shirts that have information printed on them in a way that makes it viewable while being worn. This way the person could study randomly through out the day. The shirts could have printing on all 4 sides: front, back, inside front, inside back. Each side would have a different subject matter, perhaps mathematics, science, history, and art. The teachings would be designed for each specific area to which they were distributed.

The faces of pigs in human representation

2010-02-09T15:58:00.010-05:00

"...to Freyr he gave the boar, saying that it could run through air and water better than any horse, and it could never become so dark with night or gloom of the Murky Regions that there should not be sufficient light where he went, such was the glow from its mane and bristles..."

In Norse mythology the boar Gullinbursti, is a magical creature created in a blacksmiths furnace as a bet that it could not be done. He is a symbol of strength, intelligence, and courage. He is shown in the illustration behind his owner Freyr, god of farming, peace, and sexual pleasure.

Here is a Belgian children's cartoon depicting a pig as a gross and funny farting pig. The pig is full of life, full of humor, and seems to be a help, but ends up just causing a mess. This is the typical western depiction of a pig, not very bright and full of smelly farts. This depiction is most likely a result of the way pigs are raised/farmed in our culture. Many pigs are kept in small areas, resulting in huge amounts of animal waste and a putrid smell to boot. They are often portrayed rolling in there own waste or mud which only adds to our image of them as a dirty and stupid animal.

This pig is depicted as a monster that needed to be cruelly shot down by an 11 year old boy. The alleged giant was from the the back woods of South Georgia, and was shot 8 times with a 50-caliber hand gun!

Gullinbursti is a depiction of a pig that is very different from how I was raised to think of a pig, so much so that I find the illustration rather bizarre. The idea of a sacred powerful pig defies the idea of a dirty, smelly pig that I was raised to have as an idea. The last depiction of the monster pig is just sad to me. To me this is an honorable champion of the woods, most likely a stray pig that survived very well, and a giant of the world. I guess the part that truly saddens me is that people feel proud to destroy the giants of the world.

My animal self portrait

2010-01-26T14:53:00.003-05:00

For my first assignment in Animals, People and those in between I was instructed to create a portrait of my animal self, or spirit animal. By this I mean, an animal to which I feel a certain kinship or that we share similar traits in both habit, habitat, and personality. I happen to have always loved animals, and have a large knowledge of many species both foreign and domestic, so this was a bit of a daunting task, or so I thought. Frankly, the American Beaver (Castor canadensis) came to me rather quickly and while I would like to think we do not share a lot of physical characteristics, I do think we are quite similar in many ways.

Well for starters I feel that I am a builder at heart and at practice and the beaver is undeniably a prolific builder. The beaver also has a larger than body personality, which is reflected in the effects his/her building has on the world around it. I would like to think that my creations influence those around me in mostly positive ways, similar to the way the beaver can create new bodies of water for new life to grow( a little sappy ). I have always felt at home in the water in a way that makes me dream in swimming, and I love splashing. I also associate myself with the fact the beaver can be prey. What I mean by this is that the beaver is a very alert individual and I have always been alert of my surroundings, relying more on my awareness than on my strength.

I chose to place the beaver in the environment of the Strip Mall construction site by the road for a lot of reasons that relate to how I feel and how I relate to my past. No matter how hard I try, I still feel like I am a transient New Yorker and that my true home is Northern Virginia. Recently I have come to the opinion that "NoVa would be a great place, if you would just get rid of the people", but that is not entirely true. I grew up with constant construction and remodeling in NoVa, whether it was roads or shopping malls, it was always changing, and so I felt it was appropriate to include some sort of construction in a self portrait. But everyone knows that a construction site is not the ideal place for a beaver, and this relates to how I feel about the lack of nature I experience in New York. Yet, I can't help but feel a similarity between the beaver and its damn and the construction site and its shopping mall. Both are considered pests and blights on the landscape but they do a lot to bring life to an area.

Stress Computing: Keeping track of stress before it tracks YOU down and KILLS you!

2009-11-16T10:26:00.011-05:00

Stress is big business these days. Whether you are concerned with relieving stress, preventing stress, or monitoring stress you are sure to find plenty of products that claim to help you get to the bottom of the whole stressful stress stuff. But what exactly is stress and why are so many people concerned with it?

Stress is a biological term for the consequences of the failure of a human or animal to respond appropriately to emotional or physical threats to the organism, whether actual or imagined. It includes a state of alarm and adrenaline production, short-term resistance as a coping mechanism, and exhaustion. Common stress symptoms include irritability, muscular tension, inability to concentrate and a variety of physical reactions, such as headaches and elevated heart rate.

It covers a huge range of phenomena from mild irritation to the kind of severe problems that might result in a real breakdown of health. Signs of stress may be cognitive, emotional, physical or behavioral. Signs include poor judgment, a general negative outlook, excessive worrying, moodiness, irritability, agitation, inability to relax, feeling lonely or isolated, depressed, aches and pains, diarrhea or constipation, nausea, dizziness, chest pain, rapid heartbeat, eating too much or not enough, sleeping too much or not enough, withdrawing from others, procrastinating or neglecting responsibilities, using alcohol, cigarettes, or drugs to relax, and nervous habits (e.g. nail biting or pacing).

This is how stress effects the body in the relative short term, but what about common causes of stress and long term stress exposure?

So, here’s the top 7 Greatest Stress-creating behaviors. Find the ones that apply to you, and get to eliminating them, because these you can control.

1. Not saying “no”:
This is a particular problem for the female of the species, but men, now even you're doing it. It’s OK, in fact it’s healthy to turn down a request from family or friends, or not volunteer for that PTA project when you’re already looking for time on your schedule to eat... Take Nancy Reagan’s advice and…”just say NO” – nicely and with a brief, honest explanation (“I’m just too booked right now” or “my kids come first and I’m not spending enough time with them as it is…”) Only you can prevent over-load fires.

2. Inefficient time/task management:
Set a schedule for checking/responding to emails and voice messages, vs. doing so extensively throughout the day; this technique is used by the top business leaders. When scheduling an appointment, rather than asking “what time’s good for you?” which gives away control of your schedule, start by giving them some good times for you. Pay attention to the amount of time it takes you to complete a task, get to/from a meeting etc; you’ll be amazed by how much longer these things take than you thought, and now you can arrange your schedule more realistically.

3. Being a perpetual “fixer”:
Take off the Knight suit and stop rescuing people. It’s an unhealthy way to get attention, and, honestly, you’re really helping yourself more than actually helping them (it’s called “enabling”). If it is your responsibility, know what is in and out of your control so you don’t spin your wheels working on things that you cannot possibly influence.

4. Not scheduling time for rejuvenation:
Burn out is guaranteed when you don’t make taking time to rest/rejuvenate as much a part of your schedule as getting the laundry done. It is not something that you can take or leave – it is a mandatory requirement for both your body and your mind, and ignoring that law of physics will not change it.

5. No exercise:
The human body requires regular physical movement much like an automobile requires regular running to maintain it in good working order. You cannot remain sedentary and expect to feel good. Change your daily habits from using the least amount of physical exertion to using the most (taking the stairs whenever possible, walking into the bank vs. using the drive-thru, etc.), or you purchase one a large work-out ball to use at home, particularly while watching TV (good for everything from sit-ups to leg strengthening), But, keep your personal “vehicle” sitting in the proverbial driveway and you will soon be taking it to the salvage lot….

6. Making “mountains out of molehills”:
Otherwise and more currently known as “sweating the small stuff”, This behavior is quite toxic for you, and a real relationship buster with those you love. Learn to discern the difference between what’s truly important and worthy of concern, and what’s worthy of a smile, a shrug, and moving on. Begin by getting feed-back (from people whose opinion you trust) on when you tend to do this most often, and start with those and similar situations.

7. “Should’ing” all over yourself (and others…):
I think “should” shouldn’t be in the dictionary… I mean, really, what does “should” actually indicate? “I should be better at that….” Huh?! Either you can be better at that or you can’t (for whatever clear reason); you will be better at that or you won’t (depending on your level of motivation or present capabilities). Thinking “should” is a set-up for a no-win; an expectation with no clear determination of whether the desired outcome is doable in actuality. Be clear about what you or others actually “can” or “won’t” do vs. what they “should” do, and you’ll be on much more solid ground.

As for the long term effects of stress...

Stress can significantly affect many of the body's immune systems, as can an individual's perceptions of, and reactions to, stress. The term psychoneuroimmunology is used to describe the interactions between the mental state, nervous and immune systems, as well as research on the interconnections of these systems. Immune system changes can create more vulnerability to infection, and have been observed to increase the potential for an outbreak of psoriasis for people with that skin disorder.

Chronic stress has also been shown to impair developmental growth in children by lowering the pituitary gland's production of growth hormone, as in children associated with a home environment involving serious marital discord, alcoholism, or child abuse.

Studies of female monkeys at Wake Forest University (2009) discovered that individuals suffering from higher stress have higher levels of visceral fat in their bodies. This suggests a possible cause-and-effect link between the two, wherein stress promotes the accumulation of visceral fat, which in turn causes hormonal and metabolic changes that contribute to heart disease and other health problems.

Over the long term, distress can lead to diminished health and/or increased propensity to illness; to avoid this, stress must be managed.

Great! We already have so many things to worry about these days(ever increasing our stress levels), now we have to worry about too much stress. How much of stress monitoring can be done autonomously by a wearable device, or does the psychological nature of stress require a higher self awareness for effective monitoring/management? Quite a few companies tout wonder devices that aim to monitor and then help alleviate stress, but what exactly do they monitor and do they work at relieving stress?

Full Body Stress Monitor
Firstbeat HEALTH: heartbeat monitor
Bio-Q Ring

An Argument for Existential Computing

2009-11-09T11:27:00.004-05:00

I think the dedication of attention to details of ones person is good for humanity. I do not think that the integration of computers is necessary to do so. However, I do think that computers allow for us to capture the data we want to pay attention to while not needing to actively participate in the actual logging and sensing of data. That said, the logging of self data should lead the individual to some conclusion about priorities, at which point the person is required to spend time reflecting on the outcome of the data, and ultimately change themselves in a way that better positions them in life. For example, one could log stress data(galvanic skin response and heart rate) while commuting to and from work, trying out different routes and departure times. But if once the data is collected and the person refuses to look at the data or respond appropriately then the logging of data has served no purpose. But this is obvious, I suppose what I am trying to say is that the active participation of the person in reviewing the data is as, if not more, important than the logging of the data. The active participation in reviewing the data conveys a willingness to change ones habits, or a fluidity in the brains make up for change. Why do I think that paying attention to self data is good for humanity? I don't really, what I do think is good is the repositioning of priorities to facilitate happiness in yourself and others. The decision to change ones priorities from quickness of commute to least stressful of commute has implications that will cascade down past the individual. The fundamental decision to value ones personal mental health over ones ability to pack as much into one day as possible also has the effect of restructuring values in other areas of a persons life. Good uses for data logging include times in which the person is under the assumption that an activity is inherently something, and so executes the activity because of the desired outcome, ie. I watch TV when I get home at night to relax. If one were to log data while watching TV after coming home and then log data while doing other activities, one could get a better idea of what is actually relaxing and not just sedating. To a certain extent, paying close attention to data logging allows us as individuals to create new values and let go of old ones given to us by our family, or at least the possibility could arise. But why, what is the reason to spend time reviewing details of your life? From my examples I immediately think of health reasons, less stress has been proven to better on your body and mind. Also, if some how we are all connected and a collective conscious does exists, then I think it is better to have a happy, calm, and caring collective conscious over an angry, nervous, and apathetic collective conscious.

Processing Maquette for my light sculpture

2009-10-25T18:06:00.006-04:00

I am currently working on a 4x4 ft light sculpture for Danny Rozin's "Project Studio" class. The sculpture uses 40 servos to move 40 arms that each have 2 RGB LEDs at the tips. I am most interested in the way the light from the LEDs will mix together on the canvas, especially since I can control both the color of the light and it position. I uploaded a Processing sketch I made to visualize patterns and color sequences. This version focuses on movement patterns and not color. Drag the mouse on the screen to change the viewing angle.

Estrella Intersects the Plane from Matt Richard on Vimeo.

Foot Sensors for Longboarding Data

2009-10-12T12:50:00.002-04:00

This week the goal was to make our data logging devises mobile if not wearable. I was unable to become fully detached from my computer for the data logging. However, I was able to make it mobile by using a small netbook to log the data, and keep it stored in my backpack while I went for a nice ride around Washington Square Park. The values were sent from the Arduino via serial communication, and Processing listened for the values and wrote them to a CSV(comma separated values) file. Next, I stuck the file into a program written by Dan O'Sullivan that graphs that data and allows the viewer to scroll through the data. If you look closely, you will see that my right foot makes more jumps than my left foot. This is because I push my longboard with my right foot :) Moving forward, I would like to find a better sensor for a more stable and wider range values. I found that the FSRs that I used were almost maxed out even when standing.

Depth Time: adventures in finger painting

2009-10-09T13:07:00.003-04:00

Sue Syn and I collaborated on a project for Dan O'Sullivan's "The Rest of You" class, in which we wore ultra sonic range finders on our wrists while we painted with our hands. The values that were recorded from the sensors were then used to render information that was captured from a camera that was recording our movements. Both the actual footage and the data augmented video were displayed together. The result is a time lapse record of our movements and color choices, allowing the user to watch the painting develop and time pass. The idea was to make the artist and viewer aware of spatial relationships that are not considered important or taken for granted. The hope being that a greater understanding of one's subconscious might come to light. While I was pleased with the result, I have been making strides toward a better mapping of the depth data than just value. The next iteration of this idea will have the painting pushed and pulled in 3D space based on the values from the range finder.

Depth Time from Matt Richard on Vimeo.

Herpes a la Face Tracking

2009-05-15T01:18:00.004-04:00

For my final in Nature of Code and Computational Cameras, I worked on creating an app that would allow users to take pictures of themselves or their friends. The image is scanned for a face. If a face is detected, simple rules of proportion are used to determine the basic location of the mouth. After the mouth is found, a script that mimics the look and feel of oral herpes is applied to that area of the picture. The resultant image is gross and funny. I also created another version that turns a portrait picture into a mugshot, includes criminal information and a lone teardrop tattoo. Recently I have been doing a lot of image augmentation. I think that it could prove to be very popular if I could only get it out to the masses. Further ideas include, fake family vacation pictures and fake historical pictures. It seems that everyone loves neat pictures of themselves, and frankly, they don't even have to be real.

Camera Futura

2009-04-13T01:30:00.003-04:00

I was asked to think about the future of cameras and how they will impact or lives. I came up with a few ideas, some more distant then others.

Short Term
I think image stabilization could easily be improved by allowing the user to hold the shutter button down, but only firing the shutter when an accelerometer in the camera says that the camera is appropriately stable.

Medium Term
Through advances in image pattern recognition and optimization, new picture taking modes could exist that search for classical balance and proportion. Only when a composition presents itself that includes 20 golden rectangles can an image be captured. This would help amateur photographers better understand the principles of composition.

Long Term
The ability to compare dimensions, specifically in relation to your body, seems like a useful piece of information to be included in the photo. Which makes me wonder of the future of the photograph itself. In the future cameras will most assuredly capture information in a three dimensional format. Probably through the use of stereoscopic vision like our own eyes. This would weave the extra information into the display rather than simply including it in the Metadata.

Color Tracking Fun! part 3

2009-04-02T00:05:00.005-04:00

Back at it with color tracking and the gang. This time are sights are set on driving the streets of NYC in a virtual car. We had several immediate problems that made it impossible to work outside. It began raining and we were using an auto gain webcam which was making our lovely neon pink squares appear white.

We grabbed a better camera and headed to upper floors of Tisch to shoot in a larger location. The code was riddled with problems and made it nearly impossible to get satisfactory shots. Nevertheless, Winslow had an idea brewing and was able to stitch together a story of a class field trip.

Wicked Awesome!!! from Winslow Porter on Vimeo.

Elffervescence made a debut in the space scene, this time wearing a black background.

Angela's awesome documentation again.

Color Tracking Fun! part 2

2009-04-01T23:39:00.004-04:00

The following week we all met again and decided to have a dance party. We invited some of our friends and danced in front of a short throw projector projecting party videos from amongst the ISH. Music by Mylo, "I'm back".

MASKPARTY featuring Coconut Horse, ODB, Lemonhead, and Mario from Winslow Porter on Vimeo.

This time the code was changed to calculate the angle between the two green squares and display the images of various heads onto our bodies. We created a make shift head gear device out of black foam and rubber bands, to which the green squares were attached.

Another inside look by Angela Chen.

Color Tracking Fun!

2009-04-01T22:21:00.007-04:00

After working with blobs and the OpenCV library to create "Granpa Loves Valentine's Day", Winslow Porter and I combined forces with Meredith Hasson and Angela Chen to tackle color tracking.

Using Dan O’Sullivan's color tracking code as a starting point, we began to develop a simple and sometimes reliable way of determining the location of two green squares from the pixel data of a webcam. From the location of each square we can then determine the distance between the squares and even the angle of a line drawn between the two squares.

Gone Fishing Debugging from Matt Richard on Vimeo.

But what to do with such a thing? After a quick brainstorm, the act of fish-story telling, specifically the phrase, "a [fish] this big!" would be captured in augmented video and a simple story would be told.

Catch of the Day from Winslow Porter on Vimeo.

The code can be found here along with an awesome inside look from Angela Chen.

Rainbow Waves et wake

2009-04-01T18:47:00.010-04:00

Awhile ago I played around with Dan Shiffman's SineWave processing applet. I only adjusted a few lines of code but was able to create complex patterns. I added a fade by drawing a rectangle over everything at a low transparency. I changed the color mode to HSB(Hue Saturation Brightness). The warping effect of all of the ellipses is because their positions determine their size and color. The striation was created using modulus.

When I want to show a Processing sketch online I always upload it to OpenProcessing. This sketch became popular very quickly, which I attribute to an awesome thumbnail. A few weeks after I uploaded Rainbow Waves it was added to the "featured ones", a goal I wanted to achieve since September of 2008.

I then created two other sketches shortly thereafter that were inspired by a combination of Rainbow Waves with a classmates homework and color sequencing from the color_tile series I worked on last November.

Marios Color Wave

Elfervescence

Generative Disease: Cold Sores II

2009-02-26T12:59:00.020-05:00

For midterm in Dan Shiffman's Nature of Code, I chose to create generative cold sores. Currently the sores are distributed using Perlin noise. My next step is to incorporate hierarchy into the distribution.

Generative Disease: Cold Sores

2009-02-19T12:35:00.020-05:00

*Test image in photoshop

For my midterm in Nature of Code I am going to attempt to simulate the look of cold sores on pictures of my friends. Here is a break down of the steps I think will be necessary to create a realistic effect:

1. Create a father point and assign an amount of energy. The amount of energy will determine how large it will be and how many children it can have.

2. Create children points that surround the father point. Children points energy levels should be smaller than the fathers energy level. Some children can have children of their own if they are large enough.

3. The energy level of each point will determine the size of a circle like shape that emanates from the point. The circles of all the points will be averaged together and a blob shape will be drawn.

4. Repeat step 3 but decrease the energy level each time. At the same time, change the color so that the resultant shape defines the form of a blister.

5. Determine the direction of the light source in the image and use that vector to add shadow and then highlights.

Worm Boarding at Cottontail Hill

2009-02-11T17:15:00.004-05:00

Worm Boarding at Cottontail Hill from Matt Richard on Vimeo.

This video has been sitting on my computer for far too long. It was recorded in January of 2006, and the sport of Worm Boarding lasted only for two days.

Upon finding a water heater box in a suburb of Washington DC, Adam Colton and I attempted to ride inside the box down hills. The first night we had no clue how to balance together and we were only able to travel 20 feet before crashing into a curb, rolling over, or just laughing too hard to continue. This did not deter us from understanding the mechanics of what would become known as "Worm Boarding".

On the second day of trial runs we made a breakthrough in balance technique. Undoubtedly Adam was better at steering, so he would lead. I was pretty good I being still and didn't mind not seeing where I was going, so I was a natural for the rear of the "Worm". A few more runs on lesser neighborhood hills and it was time to do what we knew we must, attempt to ride down Cottontail Hill from the top! This hill is so steep that when it snows it is well-nigh impossible to drive up. Adam C. being who he is, grabbed his camera and Adam S. provided a steady hand in filming.

We tried several times to no avail. Sadly, the box did not live past that day and no one has ever "Worm Boarded" since. I encourage all of you in trying to ride down a hill in a box. Since you are sitting, you have less distance to fall which means that it doesn't hurt, plus the box does a lot to save your skin. Be sure to wear clothes that cover, and always wear a helmet.

Granpa looks for OpenCV in the kitchen

2009-02-09T11:04:00.011-05:00

Winslow Porter and I played with the new OpenCV library for Processing. Thankfully Granpa was around in the kitchen for us to Capture.

Grandpa Loves Valentines Day from Winslow Porter on Vimeo.

We also found footage from 1969 of a van making an illegal U-turn in San Francisco.

Rainbow Image Detection from Winslow Porter on Vimeo.
This effect was created by Andy Best in a tutorial he wrote for processing's OpenCV library. You can check out the tutorial here.

Then I stayed up playing with the sketch until I went to class. I did capture an amazing smile though.

All-nighter smile from Matt Richard on Vimeo.

Pictures from early on in the evening.

Nature of Code week 3: Vectors and Forces

2009-02-05T12:38:00.015-05:00

Created a simple simulation of fish swimming in a circle. Then I worked on adjusting the look and feel to create a nicer looking visualization. Click the links to see them in action.

Fish Tornado
Fish Tornado 2
Fish Tornado 3

Hue is New York?

2009-02-02T11:03:00.007-05:00

I am interested in using cameras to gather color data about New Yorkers' wardrobes. The information could be used to create the ideal outfit for a specific part of town or to create a wonderful portrait of the city.

iDatoBato Laboratories

Processing Class 6: 3D and Libraries

Processing Class 5: Images, Video and Saving

Class 4: Arrays, Functions and using Images

Class 3: For Loops, new Shapes and more Math!!!

Processing Class 2: Variables, Math, and Logic

Processing Class 1: Hello World!

Final Class: Arduino and Physical Computing

Class 3

More fun with Arduino! PComp with Arduino Class 2

Commenting (review)

Basic Programming Structure

Basic Programming Structure

Pulse Width Modulation(pwm)

Where to find components/tools/cool stuff

Commenting (code):

/*

This is a block comment. Everything inside of the "/*" and "*/" is commented out.

This is a block comment. Everything inside of the "/*" and "*/" is commented out.

*/

*/

// this is also a comment

Variables (code):

Variables (code):

Variables are a way of storing and accessing values in a program. There are many different types of variables, each type has a limit to how big of a number or even what type of number can be stored inside.

The standard variables available to us through Arduino are:

boolean: A boolean holds one of two values, true or false. (Each boolean variable occupies one byte of memory.)

boolean: A boolean holds one of two values, true or false. (Each boolean variable occupies one byte of memory.)

char: A data type that takes up 1 byte of memory that stores a character value. Character literals are written in single quotes, like this: 'A' (for multiple characters - strings - use double quotes: "ABC").

byte: A byte stores an 8-bit unsigned number, from 0 to 255.

int: Integers are your primary datatype for number storage, and store a 2 byte value. This yields a range of -32,768 to 32,767 (minimum value of -2^15 and a maximum value of (2^15) - 1).

word: A word stores a 16-bit unsigned number, from 0 to 65535. Same as an unsigned int.

long: Long variables are extended size variables for number storage, and store 32 bits (4 bytes), from -2,147,483,648 to 2,147,483,647.

double: Double precision floating point number. Occupies 4 bytes. Same thing as a float.

string: Strings are represented as arrays of type char.

array: An array is a collection of variables that are accessed with an index number. Arrays in the C programming language, on which Arduino is based, can be complicated, but using simple arrays is relatively straightforward.

Program Structure (code):

It is important to have a standard structure when writing a program. A structure will make it easy for you and others to locate all of the components of your program.

It is important to have a standard structure when writing a program. A structure will make it easy for you and others to locate all of the components of your program.

The first part of the program should be a description of what the program is using block comments.

The second section is where you place all of your variables. Start with constants first and then group them according to their purpose. Don't forget to leave detailed comments.

The third section is for the setup() function. Void setup() is where you initialize your digital pins and communication lines.

The fourth section is for the loop() function. Void loop() is what gets executed by the microcontroller on every loop or frame. This will get repeated over and over until the microcontroller is turned off.

The fifth section(not depicted) is used for functions you create.

PWM - introduction to Pulse Width Modulation:

Fading using delay(lab):

/*

/*

Fade

This example shows how to fade an LED on pin 9

using the analogWrite() function.

*/

int brightness = 0; // how bright the LED is

int fadeAmount = 5; // how many points to fade the LED by

void setup() {

// declare pin 6 to be an output:

pinMode(6, OUTPUT);

}

void loop() {

// set the brightness of pin 6:

analogWrite(6, brightness);

// change the brightness for next time through the loop:

brightness = brightness + fadeAmount;

// reverse the direction of the fading at the ends of the fade:

if (brightness == 0 || brightness == 255) {

fadeAmount = -fadeAmount ;

}

// wait for 30 milliseconds to see the dimming effect

delay(30);

}

Fading using timer(lab):

Where to find components/tools/cool stuff:

Electronics:

SparkFun Electronics - Hacker/Hobbyist Electronics and Arduino

Adafruit - Hacker/Hobbyist Electronics and Arduino

- Hacker/Hobbyist Electronics and Arduino

Evil Mad Science - Arduino and cheap LEDs

MaceTech - LED control for Arduino

Electronics Goldmine - Close out prices on electronic parts and tools, mostly older

Jameco - Professional Electronic Parts and ICs

This is a block comment. Everything inside of the "/" and "/" is commented out.

This is a block comment. Everything inside of the "/" and "/" is commented out.

Adafruit
- Hacker/Hobbyist Electronics and Arduino