Most of the time, there are already existing apps that send readily-available sensor data from your phone to your computer via OSC. But what if you have another device that connects to your phone that you want to use as an extra sensor? You might not be able to find an app that sends the information that you want. For example, you might want your phone to send information from multiple bluetooth devices to your computer (Github repository at bottom). The following steps will show you how to write an Android app that lets you send whatever you want using OSC.

Note: The following tutorial assumes that you have already downloaded Android Studio, and have a basic project set up and running. For more information on how to use Android Studio, follow the tutorials in the training section of the Android developer’s website.

OSC (Open sound control) is a protocol for communicating between different devices. The specification can be found here: OSC specification.

In order to use OSC with Android, we need an implementation in Java. The one we will be using in this tutorial can be found here: JavaOSC.

Including the Library

First, create a new project with the default settings. In your project view, open the build.gradle file in the app folder. You want to add the following lines of code to it:

repositories{
mavenCentral()
}

These few lines tell Android Studio that we will be using a library from the Maven Repository. To actually include the library, add the following line to the dependencies block:

compile 'com.illposed.osc:javaosc-core:0.3'

When you get a message telling you to sync your project, do it and Android Studio will automatically download the libraries that you need for you.

The final build.gradle file can be found here.

Using the Library

In the MainActivity.class file, insert these lines with the rest of your imports:

import java.net.*;
import java.util.*;

import com.illposed.osc.*;

Note: At this point, if you get an error about not finding “illposed,” you haven’t included the libraries properly yet.

Since networking and communication tasks can’t be done on the main thread in Android apps, we need to create a new thread, and put all relevant code there. Then just start the thread in the onCreate() method. The example code can be found here.

Tutorial Github Repository

Github Repository for Kinecontrol Modular Music

The Leap Motion is a sensor that can be used to read hand gestures. It provides spatial coordinates from each joint on each finger. If you’re interested in using the Leap Motion sensor with puredata to control sound through gesture, this tutorial will provide a guide for doing so.

Leap Motion Setup: 

Follow the instructions here: https://www.leapmotion.com/setup. You don’t need to get the developer version if you are just using it with puredata, but it could be useful for other projects.

Mac users: 

There is a pd external found here: http://puredatajapan.info/?page_id=1514 that reads the leap motion data and also provides some other useful calculations other than just spatial coordinates (velocities, palm normals, etc). This can be used in any of your own patches. Once it is compiled on your computer, copy the leapmotion-help.pd file, along with gesture.pd, hand.pd, and point.pd into the the same directory as your patch. Create a leapmotion-help object in your patch, and open it up so it is running at the same time.  You’ll notice that the leapmotion-help patch is using the puredata send objects to send data about hands/gestures/general info/tools. In your own patch, you can receive these messages using the receive object with the name of what you want. You can print these messages to see how they are formatted and then use several route and unpack objects to get the exact values you want. An example for getting the velocity of a hand is shown below, and for getting the “first” finger’s velocity.

Alternatives: 

I used the ManosOSC  app available on the leap motion app store (https://apps.leapmotion.com/apps/manososc). This app streams OpenSoundControl data that pd can get through a UDP connection. This uses the mrpeach library just like the tutorials on using the smartphone apps to send OSC data. Just make sure to change the port to port to the same one that the ManosOSC app is sending on. The default is 7110.The example below is for getting the xyz coordinates of the tips of the first two fingers the leapmotion recognizes.

The actual pd file with the code in the screenshots can be found here: https://github.com/aditisar/oobleck/blob/master/leappdtutorial.pd

My final project used ManosOSC and tried to track a finger’s direction to control frequency/amplitude of a speaker. The code for that can be found here: https://github.com/aditisar/oobleck/blob/master/finalproject.pd

In Intro to Physical Computing, many projects require a skill of soldering. For those who don’t know, soldering is the practice of conjoining two metal materials together by the melting of a third material (solder) that melts and bridges the two metals together. Soldering is used in almost every project in the class. Examples of where soldering is applicable to this class is the joining of wires on a circuit board, of wires to a module, or wires to other wires, to name a few. However, this class having no prerequisites, it is not guaranteed that everyone knows how to solder, or solder properly. This tutorial is to show a beginner how to via soldering two wires together.

Materials

The first thing is to make sure you have all the materials needed to solder. This includes:

Safety Goggles:

Soldering Iron:

60/40 Rosin Core Solder Spool:

Fan:

Third Hand Soldering Stand with Magnifying Glass & Sponge:

Wire Stripper:

Wires:

Safety goggles are important as soldering involves melting metals at a high temperature, so it is imperative to protect your eyes when in the process of soldering. Solder comes in various shapes, lengths, and sizes, for many different applications. It is very important that the solder you are using Rosin Core Solder as it has rosin flux which is used to help the metals from oxidizing, which tends to happen at high temperatures. With oxidation, it is almost impossible for you to be able to solder properly. It is also ideal to use 60/40 solder, which is used commonly in applications that are used in Physical Computing such as soldering electronics. The one I am using is Rosin Core Solder from Radioshack® There are many versions of soldering irons out there that have different Power requirements for different applications. The soldering iron tool from Weller®, is a 25 Watt single temperature soldering iron that heats up to 750 degrees Fahrenheit. This is the typical power needed for a soldering iron to melt solder that is used for applications such as electronics and circuitry work. Although it only heats to a single temperature, it is effective in melting the Rosin Core Solder. Offered in class is the Hakko® FX888d soldering station, that gives the user a wider range of temperatures, allowing the user to heat up the soldering iron up to almost 900 degrees, although it isn’t recommended to.

The third hand station can be very useful when Soldering. It can hold the soldering iron as well as up to two metal parts (be it wires or circuit boards) through its two alligator clips. (Note: be careful if using the alligator clips to hold a circuit board, as it is possible to damage the board doing so). The sponge at the bottom is necessary to clean off the soldering iron after soldering so it can be used again. The magnifying glass, is also important so one can have a close up view when soldering for better accuracy. I got mine also from Radioshack® Some stations, such as the Hakko used in Physical Computing, have flux installed into the station as well, this way after soldering, the user can simply rub the soldering iron tip into the flux so it can be used again with less fear of the tip oxidizing. It is also recommended to have either a Fume Extractor (provided in Physical Computing) or a fan when soldering. The fumes made from the melting of solder can be very dangerous if inhaled for extended periods of time.

Soldering Tip(s):

Almost all soldering irons have removable tips so that the user can use which soldering tip that bets suits them. I personally use the round cone tip when soldering, however, especially for beginners, it is heavily recommended to use a flat head tip for soldering. It gives the user more surface area on the soldering iron, when soldering.

Setting Up:

It is important to remember to wet the sponge on the soldering base, although it’s easy to remember, it is also easy to forget to wet the sponge, as placing the soldering iron on a dry sponge will cause the sponge to burn and shorten its lifespan.

No:

Yes!:

The next step is to take the two wires we want to solder together, and strip them using a wire stripper. This will give us more space to put solder on the wire, thus creating a larger bond between the two wires

Now simply place the wires into the two alligator clips of the third hand stand, one wire to each alligator clip. Then adjust the third hand stand such that the wires are touching each other. Before soldering, an important step is the process called tinning. Contrary to the name, the only time solder is actually placed on the soldering iron, is this step. In the process of tinning, you want to turn on your soldering iron, in this case plug it in, and wait 60 seconds for it to reach the target temperature. Then, you want to take some solder from your spool of solder, and gently rub the solder onto the soldering iron, but only enough to cover the tip, you do not want globs of solder to form onto the soldering iron. The process of tinning is to reduce the chance of oxidation when soldering as well as to help make the soldering process quicker. Then, once this is done, Place the soldering iron below the exposed section of the wires and the solder above. This will create a heat bridge in which from the soldering iron heating up the wires, the wires will then cause the solder to melt on them. Then move both the soldering iron and solder slowly from left to right to completely cover the exposed section in solder. Use the magnifying glass as help if necessary for a closeup view. It should go as seen in the video below:

If done correctly, the result will look like this:

As an added bonus, I also added how to solder on a circuit board. This circuit board being the Personal Portable Server Prototype of my Father and I’s startup, Toyz Electronics. This video is a demonstration of me (re)soldering the battery onto the board using the steps above. (for more information on the Personal Portable Server: https://www.youtube.com/watch?v=hbpiUyZQ3nM  or go to tngl.biz)

Final Product:

Thank you:
Video recorded on my Wifi Smart Glasses, a product of Toyz Electronics

Set-Up

Powering the Pixy

Ideal:

Pixy can be powered through the Arduino cable provided, just plug in the cable and your pixy should be good to go!

Alternatives:

If, for some reason you decide to power the Pixy through the Vin and GND pins, be careful, these are not reverse polarity protected so you can kill the Pixy if you get the pins backwards.

Other options for powering Pixy are detailed here.

Starting up the Pixy

Apply power to Pixy to start it up.  After this one two things will happen:

If the pixy is configured to “recognize” an object, it will flash red every time that object is recognized and the pixy will send this data to the Arduino.

If the pixy wasn’t configured to recognize any object it will just go into an idle state. If you want to set a new signature, see “Programming” the Pixy.

“Programming” the Pixy

Ideal:

Unless you’re trying to recognize extremely complex objects and patterns, I recommend just configuring the pixy without the use of a computer.

Once the pixy is on, press and hold the button until the RGB led starts blinking in different colors. Once the seizure session stops, place the object that you want the pixy to recognize right in front of the camera (the led should be the color of the object at this point) and press the button (don’t hold it down). If the LED stops flashing, pixy has recognized your object and is now configured to recognize that object! If not, try again.

Alternative:

The pixy can also be loaded with signatures to recognize using the CMUcam5 software. This method may or may not work properly, depending on the firmware you have installed on the pixy. Open up pixymon, plug in the pixy, and highlight the object you want your pixy to recognize. If you want to clear or set new signatures, you can do this all through pixymon.

Configuring the Arduino

Once you have hooked up the pixy to the Arduino and configured the pixy to recognize an object, all you have to do is write the proper code to interpret the data from the pixy.

Install the Pixy Library

Download the pixy library from this link:

http://www.cmucam.org/attachments/download/1054/arduino_pixy-0.1.3.zip

In the Arduino IDE, import the newly downloaded library from Sketch->Import Library.

Writing Code

We will be using the pixy API to work with the data sent over from the pixy. The pixy API makes it extremely convenient to parse the data sent over from the pixy to the Arduino.

Data is received in “blocks”, where each block represents properties of an object that was detected. Blocks can tell you how big the object is on the screen, where it is and other useful information.

Here’s a quick guide to get you started:

Start by including the headers for pixy and SPI libraries:

#include <SPI.h>

#include <Pixy.h>

Declare a pixy global like so:

Pixy pixy;

In your setup function, initialize the pixy global:

pixy.init();

In your loop function you’re going to want to poll the pixy for recognized objects like so:

  uint16_t blocks; //size of array pixy sends

  blocks = pixy.getBlocks();

  if (blocks) // if there were any recognized objects

  {

    //finds the largest object that fits the signature

    for (j = 0; j < blocks; j++){

      prod = pixy.blocks[j].width * pixy.blocks[j].height;

      if (prod > maxProd) //save the new largest obj

          maxJ = j;

    }

This sample code goes through all the “blocks” (which represent objects that are found) and finds the largest block that fits the signature. This is done by checking the blocks area by multiplying the width and height. Blocks also hold more information that you can check, here’s a full list:

• pixy.blocks[i].signature
  • signature of the object, from 1 to 7
• pixy.blocks[i].x
  • x coordinate of the object, from 0 to 319
• pixy.blocks[i].y
  • y coordinate of the object, from 0 to 199
• pixy.blocks[i].width
  • width of the object, from 1 to 320
• pixy.blocks[i].height
  • height of the object, from 1 to 200
• pixy.blocks[i].print()
  • prints the objects received, to the serial port makes debugging easy

If all went well, your arduino should be correctly finding the proper largest object that was picked up by the pixy. To investigate code that was written for Bull, just go to the link:

https://github.com/kaandog/Bull/blob/master/Bull.ino

The nrf24l01+ is often the best solution for close range communication between arduino based devices. They are extraordinarily cheap, do not require a wireless network, and any number of them can talk to eachother at once. However, there are limitations that should be considered when using them. They have a range of around 300 feet and should always be under that to ensure good use. They can send more complex signals, but there is no api for using them, so anything more than just sending numbers between them will take more time. If these limitations fit your project, however, the nrf24l01+ is a great option.
For more information about this component, here is a datasheet

Set Up

To connect the nrf24l01+ to an arduino, there are very specific pins that are required. This is due to the serial communications that are required. Fortunately, most of the serial is abstracted away during code, but the following pins must be hooked up to the same pins on your arduino; MOSI, SCK and MISO. Vcc and Gnd are connected to 3.3v and ground, CE and CSN can be attached to any pin (we will default to 9 and 10 respectively) and IRQ is not used when communicating with arduinos. For this tutorial we will be using an arduino uno, so the pins we connect will be based on that, but remember you will need to look at your specific arduino’s pinout if you wish to use a different arduino

Gnd-Gnd

Vcc-3.3v

CE-d9

CS-d10

SCK-d13

MOSI-d11

MISO-d12

You will also need to download and install the following library https://github.com/jscrane/RF24

Test it out

To test this project, simply set up two different arduino’s with nrf24l01+s and run the pingpair code found in the github repository. You will need two different computers to read the different serial lines, and if done right one should be pinging and one should be ponging. (One of the arduinos should have their 7th pin ground to set it to a different mode than the other one).

Go further

Included is more sample code, created for a final project for Physical Computing. This code is easier to edit, and involves two different sections. The servoin code waits for a number between 0 and 180 and sets a servo to that value, and also waits for a number between 1000 and 1180 and sets a second servo to that value. The servoout code waits for a number to be written to its serial and sends that number to the other arduino. This allows for remote access of an arduino from a computer (which can be expanded to include python code controlling a remote arduino, for example.)

Note: This code also requires printf.h, found in the pingpong example used earlier

ServoIn

#include <SPI.h>
#include <RF24.h>
#include "printf.h"
#include <Servo.h>
#define CE 9
#define CS 10
#define ROLE 7
#define BAUD 57600
RF24 radio(CE, CS);
const uint64_t pipes[2] = { 0xF0F0F0F0E1LL, 0xF0F0F0F0D2LL };
Servo myServo1;
Servo myServo2;
unsigned int leftLight=0;
unsigned int rightLight=0;
void setup(void)
{
  myServo1.attach(2);
  myServo1.write(0);
  myServo2.attach(3);
  myServo2.write(0);
  Serial.begin(BAUD);
  printf_begin();
  printf("ServoIn\n\r");
  radio.begin();
  radio.openWritingPipe(pipes[1]);
  radio.openReadingPipe(1,pipes[0]);
  radio.enableDynamicPayloads() ;
  radio.setAutoAck( true ) ;
  radio.powerUp() ;
  radio.startListening();
  radio.printDetails();
}
void loop(void)
{
  if ( radio.available() )
  {
    unsigned long got_time;
    bool done = false;
    while (!done)
    {
      done = radio.read( &got_time, sizeof(unsigned long) );
    }
    Serial.println(got_time,DEC);
    radio.stopListening();
    if(got_time<181)
    {
      if(got_time==0)
        myServo1.write(1);
      if(got_time==180)
        myServo1.write(179);
      else
        myServo1.write(got_time);
      analogWrite(5,(got_time*255)/180);
    }
    if(got_time>999 && got_time<1181)
    {
      if(got_time==1000)
        myServo1.write(1);
      if(got_time==1180)
        myServo1.write(179);
      else
        myServo2.write(got_time-1000);
      analogWrite(6,((got_time-1000)*255)/180);
    }
  radio.startListening();
  }
}
// vim:cin:ai:sts=2 sw=2 ft=cpp

ServoOut

#include <SPI.h>
#include <RF24.h>
#include "printf.h"
#define CE	9
#define CS	10
#define ROLE	7
#define BAUD	57600
RF24 radio(CE, CS);
unsigned long integerValue;
unsigned long incomingByte;
const uint64_t pipes[2] = { 0xF0F0F0F0E1LL, 0xF0F0F0F0D2LL };
void setup(void)
{
  Serial.begin(BAUD);
  printf_begin();
  radio.begin();
  radio.openWritingPipe(pipes[0]);
  radio.openReadingPipe(1,pipes[1]);
  radio.enableDynamicPayloads() ;
  radio.setAutoAck( true ) ;
  radio.powerUp() ;
  radio.startListening();
  radio.printDetails();
}
void loop(void)
{ 
    radio.stopListening();
    if (Serial.available() > 0) {   
    integerValue = 0;         
    while(1) {            
      incomingByte = Serial.read();
      if (incomingByte == '\n') break;   
      if (incomingByte == -1) continue;  
      integerValue *= 10;  
      integerValue = ((incomingByte - 48) + integerValue);
    }
    }
   radio.write( &integerValue, sizeof(unsigned long) );
}
// vim:cin:ai:sts=2 sw=2 ft=cpp

2. Power on Team Tenergy charger station; hit Esc (the leftmost button) coming to the top menu. Choose “LiPo BATT” for PROGRAM SELECT. The screen should show something like this:

3. Hit enter and choose “LiPo CHARGE” using the middle two navigation buttons. The screen should show something like this:

4. Hit enter and the amperage section should be flashing then. Usually most LiPo should be charged at 1C or less but no higher. So a 2200ma battery would be charged no higher than 2.2 amps and a 1800ma battery would be charged no higher than 1.8 amps. Check your battery, set it to an appropriate value using the middle two navigation buttons.

5. Hit enter and the voltage section should be flashing now. Check your battery and set it to the correct cell value for your battery using the middle two navigation buttons.

6. After set up amperage and voltage, long press the Start button and a confirmation window will pop up. The screen would indicate something like this:

7. Hit enter when the screen shows CONFIRM. Now your battery is being charged. The screen would show something like this then:

As a reminder, CMU Computing Policy requires maintaining the confidentiality of your Andrew account credentials.  As such, it is not acceptable to store your Andrew ID and password on embedded devices such as Raspberry Pis.

For these devices, rather than using the “CMU-SECURE” network, which requires your credentials be stored in your network configuration, we recommend you use the Network Registration System (NetReg) to register the MAC address of your device and connect via the “CMU” network instead.

Getting Started with Rhino

COMPANY

• McNeel: The company that makes Rhino3D
• Rhino3D: The main website
• Rhino3D Tutorials: The official documentation

COMMUNITY

• The Rhino3d wiki: community developed site with all things Rhino
• Rhino3d newsgroup: people asking/answering questions

COMMANDS

• Thingiverse: “MakerBot’s Thingiverse is a thriving design community for discovering, making, and sharing 3D printable things. “
• SketchFab: “Sketchfab is the leading platform to publish, share and embed interactive 3D content, anywhere online. “
• Google 3d Warehouse: The Google company’s database of 3d models
• 3D Content Central Free 2D and 3D CAD Models run by the makers of SolidWorks

Online tools for CAD/CAM:

• BoxMaker: designing laser cut finger joint boxes made easy
• AutoDesk 123 Make: “3D meets DIY.  Turn your amazing 3D models into even more amazing do-it-yourself projects. “
• GearMaker: Online tool for designing Gears
• Involute Spur Gear Builder: can generate DXF files to import into SolidWorks or Rhino

References for designers:

• CNC Joinery: Read all about it
• Curved/Bending hard materials with Laser Cutter: Read all about it
• Google Books: 507 Mechanical Movements
• Google Books: The Engineer’s Sketch-book of Mechanical Movements, Devices, Appliances, Contrivances, and Details

Awesome Little Free (or almost free) Programs:

• Pepakura: Origami tool; unfold complex 3d objects and cut out of flat material
• Meshlab: Opensource/Multiplatform mesh manipulator
• SketchUp: “The easiest way to draw in 3D”
• Grasshopper: Parametric design for Rhino