[FINAL] Pi Music Player

The Problem My stereo receiver is from the 70s and has a single AUX input. When we have people over, there is no simple way to let people play music without unplugging TV connection, adding an RCA -> 1/8 Stereo cable, and making people plug in directly/leave their phone by the receiver.

The Solution

Add an intermediary device that people can stream to via Bluetooth, which outputs via RCA to the receiver.

Inspiration

Old HiFi receivers! Hardwood (or veneer) + polished metal.

Design Process

Fabrication Process

   

Electronics Fabrication Process

[SKILL BUILDER] #6 -- 4-axis Mill

For my 4-axis skill builder I did a prototype version of my final project.  

I started with a foam yoga block from REI, but managed to destroy it VERY quickly. Unfortunately, I zeroed the Z axis out incorrectly--I tried to manually make it touch the grounding pole because I was clicking the wrong button in Roland's software.

I went into panic mode after I buried the bit an inch into the material and ripped a huge chunk out of it, and completely forgot to take photos of it. Fortunately, I managed to not break a bit (soft material + sharp bit = still alive) or damage the machine.

I went back the following week with a cork yoga block and was able to run the job correctly.

The majority was cut with a 1/4" upcut bit, the small holes were done with a 1/16" bit.

Compared to my wood cut done for my final project:

Final (Planning) -- The Hand

Tong and I decided to team up again for the Pcomp final. We want to continue exploring human-computer communication with robotic/humanoid arms, but in a larger context than rock, paper, scissors. Both of us are interested in how humans experience "connection" with computer devices, and how we can create that experience when users interact with these humanoid arms. UPDATE (Nov 13): We spent the week after play testing finalizing our design, integrating the leap motion, and updating the hardware. Tong posted a nice write up of our current design on her blog.

I spent the week porting/rewriting the game code in JavaScript, and wrote a node.js app that reads in frames from the leap motion and talks to the arduino via the johnny-five library. We printed new parts for a movable wrist, and will begin assembling them Wednesday when the additional servo comes in the mail.

We have a shared doc with BOM, project plan, and system diagram. Updated screenshots below:

BOM:

Project Plan:

Midterm -- Rock, Paper, Scissors Robot

For the midterm, Tong Wu and I built an interactive installation that lets a person play “Rock, Paper, Scissors” against a robotic hand by wearing a glove outfitted with flex sensors.

3D Printed Hand & Forearm

To build the hand and forearm, we used the models from InMoov, an open source project for a 3D printed life-size robot. All of the joints are connect with PLA filament or 3D printed bolts. The finger movements are controlled by high strength fishing line, which runs down through the fingers/arm like tendons to a servo bed at the end.

Flex Sensitive Glove

On the glove there are two flex sensors, a “start” button, and a “throw” button. These are all sewed into a right-hand glove and connected to a Nano mounted on a perf board. The Arduino is connected to a nRF24L01 wireless transceiver that talks to an identical transceiver on the robot hand.

To play the game, the player puts on the glove, presses the “start" button, then press the “throw” button twice, and makes a hand gesture indicating his/her choice of rock, paper, or scissors.

Robotic Hand & Forearm Assembly

Playing the game

Player code

// include SPI and radio libs
#include <SPI.h>
#include <'RF24.h>
#include <'nRF24L01.h>

// define flex sensor pins
#define sensorPointer A0
#define sensorPinkie A1

// define button pins
#define startButton 2
#define tapButton 3

// initialize button variables
int gameState = 0;
int lastGameState = 0;
int throwInput = 0;
int lastThrowInput = 0;
int throwCount = 0;
int computerStart = 4;
int playerChoice = 0;

// initialize radio and variables
RF24 radio(8, 9);
int msg[1];
const uint64_t pipe = 0xE8E8F0F0E1LL;

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

  // start radio transmitter on channel 115
  radio.begin();
  radio.setChannel(115);
  radio.openWritingPipe(pipe);
  radio.stopListening();

  // set sensor inputs
  pinMode(sensorPointer, INPUT);
  pinMode(sensorPinkie, INPUT);

  // set button inputs
  pinMode(startButton, INPUT);
  pinMode(tapButton, INPUT);

}

void loop() {
  // has the player triggered the game to start
  gameState = digitalRead(startButton);
  if (gameState == HIGH && lastGameState == LOW) {
    Serial.println("Game started!");

    // tell computer to start game
    msg[0] = computerStart;
    radio.write(msg, 1);
    Serial.println("Sent start game to computer");
    computerStart++;

    // wait till player throws 2 times
    while (throwCount != 2) {
      throwInput = digitalRead(tapButton);
      delay(100);

      // increase the count after each tap
      if (throwInput == HIGH) {
        throwCount++;
        Serial.print("Throw count: ");
        Serial.println(throwCount);

        // send update to computer
        msg[0] = computerStart++;
        radio.write(msg, 1);

        delay(100);
      }
    }
    delay(10);

    // reset throw variables
    throwCount = 0;
    computerStart = 4;

    // get user input
    userChoice();
    Serial.print("Player choice: ");
    Serial.println(playerChoice);
    Serial.println("paper = 1, scissors = 2, rock = 3");
    Serial.println();

    msg[0] = playerChoice;
    radio.write(msg, 1);
  }

  // reset game state
  lastGameState = gameState;

}

void userChoice() {
  // get player choice based on sensors
  int pinkieSensor = analogRead(sensorPinkie);
  pinkieSensor = map(pinkieSensor, 650, 460, 0, 100);   // map values 0-100
  Serial.print("Pinkie sensor: ");
  Serial.println(pinkieSensor);
  if ( pinkieSensor > 40) {   // finger is bent
    pinkieSensor = 1;
  } else {
    pinkieSensor = 0;
  }
  int pointerSensor = analogRead(sensorPointer);
  pointerSensor = map(pointerSensor, 550, 400, 0, 100);   // map values 0-100
  Serial.print("Pointer sensor: ");
  Serial.println(pointerSensor);
  if ( pointerSensor > 40) {  // finger is bent
    pointerSensor = 1;
  } else {
    pointerSensor = 0;
  }

  // no sensors flex = paper, pinkie flexed = scisors, both flexed = rock
  if (pinkieSensor == 1 && pointerSensor == 1) {    //rock
    playerChoice = 3;
  } else if (pinkieSensor == 1 & pointerSensor == 0) {   //scisors
    playerChoice = 2;
  } else {    // paper
    playerChoice = 1;
  }
}

Rrobot hand code:

// include SPI, radio, and servo libs
#include <SPI.h>
#include <'RF24.h>
#include <'nRF24L01.h>
#include <'Servo.h>

// define servo finger pins
#define servoThumb 6
#define servoPointer 5
#define servoMiddle 4
#define servoRing 3
#define servoPinkie 2

// setup radio
RF24 radio(7, 8);

// initialize servo fingers
Servo thumbFinger, pointerFinger, middleFinger, ringFinger, pinkieFinger;

// initialize game variables
int aiChoice = 0;
int playerChoice = 0;

// initialize radio variables
int msg[1];
const uint64_t pipe = 0xE8E8F0F0E1LL;

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

  // attach the servos
  thumbFinger.attach(servoThumb);
  pointerFinger.attach(servoPointer);
  middleFinger.attach(servoMiddle);
  ringFinger.attach(servoRing);
  pinkieFinger.attach(servoPinkie);

  // set fingers straight
  thumbFinger.write(0);
  pointerFinger.write(0);
  middleFinger.write(0);
  ringFinger.write(0);
  pinkieFinger.write(0);

  // start the radio receiver on channel 115
  radio.begin();
  radio.setChannel(115);
  radio.openReadingPipe(1, pipe);
  radio.startListening();

  // generate seed for random function via floating pin
  randomSeed(analogRead(A2));
}

void loop() {

  // wait to receive start code from player
  while (msg[0] != 4) {
    radio.read(msg, 1);
    Serial.println("Waiting to start game...");
  }

  Serial.println();
  Serial.println("----------------------------------");
  Serial.println("Game started!");
  aiChoice = random(300); // generate psuedo-random number 0-300
  aiChoice = map(aiChoice, 0, 300, 1, 3);

  while (msg[0] != 5) {
    radio.read(msg, 1);
  }
  // count to one
  Serial.println("Moving fingers to 1...");
  pinkieFinger.write(180);
  ringFinger.write(180);
  middleFinger.write(180);
  thumbFinger.write(180);
  delay(100);

  while (msg[0] != 6) {
    radio.read(msg, 1);
  }
  // count to two
  Serial.println("Moving fingers to 2...");
  Serial.println();
  delay(100);

  // move robot hand per computer choice
  switch (aiChoice) {
    case 1:   // paper
      // leave all fingers open
      delay(2000);
      Serial.println("Computer choice: paper");
      break;
    case 2:   // scissors
      // move thumb, ring, and pinkie fingers
      pinkieFinger.write(180);
      ringFinger.write(180);
      thumbFinger.write(180);
      delay(2000);
      Serial.println("Computer choice: scissors");
      break;
    case 3:   // rock
      // move all fingers
      pinkieFinger.write(180);
      ringFinger.write(180);
      middleFinger.write(180);
      pointerFinger.write(180);
      thumbFinger.write(180);
      delay(2000);
      Serial.println("Computer choice: rock");
      break;
  }
  Serial.println();

  // wait for choice from player
  while (msg[0] != 1 && msg[0] != 2 && msg[0] != 3) {
    radio.read(msg, 1);
    Serial.println("Waiting for player choice");
  }
  playerChoice = msg[0];
  Serial.println();
  Serial.print("Player choice: ");
  Serial.println(playerChoice);
  Serial.println("paper = 1, scissors = 2, rock = 3");
  Serial.println();

  // compare choices to see who wins
  if (playerChoice == aiChoice) {   // tie game
    // countdown code and throw again code here
    //break;
    Serial.println("Tie game!");

  } else {
    switch (aiChoice) {

      // computer chooses paper
      case 1:
        switch (playerChoice) {
          case 2: // player chooses scissors
            // player wins!
            Serial.println("Player wins!");
            // scissors cuts paper
            break;
          case 3: //player chooses rock
            // computer wins!
            Serial.println("Computer wins!");
            // paper wraps rock
            break;
        }
        break;

      // computer chooses scissors
      case 2:
        switch (playerChoice) {
          case 1: // player chooses paper
            // computer wins!
            Serial.println("Computer wins!");
            // scissors cuts paper
            break;
          case 3: // player chooses rock
            // player wins!
            Serial.println("Player wins!");
            // rock crushes scissors
            break;
        }
        break;

      // computer chooses rock
      case 3:
        switch (playerChoice) {
          case 1: // player chooses paper
            // player wins!
            Serial.println("Player wins!");
            // paper covers rock
            break;
          case 2: // player chooses scissors
            // computer wins!
            Serial.println("Computer wins!");
            // rock crushes scissors
            break;
        }
        break;
    }
  }
  Serial.println("----------------------------------");
  Serial.println();

  // reset game variables
  playerChoice = 0;
  aiChoice = 0;

  // reset servos
  thumbFinger.write(0);
  pointerFinger.write(0);
  middleFinger.write(0);
  ringFinger.write(0);
  pinkieFinger.write(0);

 delay(1000); 
}

Final -- RAIN-MKR

[video width="640" height="360" m4v="http://www.nickwallace.us/blog/wp-content/uploads/2017/10/IMG_0139.m4v"][/video] Our intro to fab assignment this week was to mount a motor, and after realizing that I could essentially buy a DC motor that pumps water (a peristaltic pump) I decided to make a physical interface for my pcomp project. Basically, make a device with a control panel that rains water onto an analog sensor, which feeds into p5 and creates rain within the sketch based on the amount of water you control.

This turned out to be more challenging from the design side than I initially anticipated, and during my office hours with Tom on Monday I had a few aha moments with regards to the whole process. At the end of the day,  my current design is fundamentally flawed in that it isn't possible to accurately gauge the rate of water flow to draw rain in p5, and because the sensor doesn't magically dry out when you stop the "rain" from the control panel.

Although I wasn't able to get this quite to the level of completion that I wanted in 1 week, I'm fairly pleased with the results as a starting point. If nothing else, I learned a lot on both the physical and computing sides.

I plan to update this post a bit more this week when it's not 3:30am.

I went through a few panel designs before settling on a 2 button, 1 knob finish (bottom right):

Test fitting:

Final template cut in acrylic and sharpie-ed. This worked OK, but I definitely think it's best to use paint in the future:

I drilled a couple of holes in the box to run cables in/out:

Wired up a tiny pushbutton switch to hide under the box for an easter egg:

I cut a small block of plywood to act as a backstop for the breadboard, serving two purposes: keeping the breadboard in place and insuring the usb plug remains in the same place. Forgot to take a photo of the usb hole cut, but I did that freehand with a dremel:

With the box finished (minus wiring), I started to build the frame for the physical rain device. I glued + screwed some plywood I ripped on the panel saw to form the base:

While that was drying, I used a film canister from the junk shelf to cover the motor. This was sealed with hot glue:

I used a small piece of scrap plywood to create a raised motor mount:

I mounted this to the frame with two wood screws. Also pictured are the counter balance boards I mounted to the back of the frame with wood screws:

Testing the motor functionality with a bench power supply:

[video width="272" height="480" m4v="http://www.nickwallace.us/blog/wp-content/uploads/2017/10/IMG_0129.m4v"][/video]

To attach the wires to the back of the frame I went with the copious amounts of hot glue method. I connected the (+) rail of the motor to a DC barrel jack:

I drilled a hole for the raindrop sensor in the middle of the frame and glued the crap out of it as well:

Testing the functionality:

[video width="272" height="480" m4v="http://www.nickwallace.us/blog/wp-content/uploads/2017/10/testing_rainflow.m4v"][/video]

Unfortunately, I ran out of time to do much more. I originally planned to laser cut a "front" panel for the frame that had engraved clouds, cut out rain lines, and engraved grass/trees. Hopefully I'll have time to work on this more after the midterm.

[video width="640" height="360" m4v="http://www.nickwallace.us/blog/wp-content/uploads/2017/10/IMG_0139.m4v"][/video]

[video width="352" height="288" m4v="http://www.nickwallace.us/blog/wp-content/uploads/2017/10/IMG_0144.m4v"][/video]

Arduino code:

// define i/o pins
#define WATER_PUMP  3
#define PUMP_POT A6
#define RAIN_SENSOR A7
#define RAIN_BUTTON 8
#define THUNDER_BUTTON 10
#define EE_BUTTON 9

// define global vars
int lastRainState = 0;
boolean raining = false;
boolean thunderPress = false;
boolean eePress = false;
int potVal = 0;

void setup() {
  // setup i/o pins
  pinMode(WATER_PUMP, OUTPUT);
  pinMode(RAIN_SENSOR, INPUT);
  pinMode(RAIN_BUTTON, INPUT);
  pinMode(THUNDER_BUTTON, INPUT);
  pinMode(EE_BUTTON, INPUT);

  analogWrite(WATER_PUMP, 0);

  // turn on serial
  Serial.begin(9600);
  while (!Serial) {
  }
}

void loop() {
  // call thunder and easter egg functions
  thunder();
  ee();

  // toggle rainState on/off
  int rainState = digitalRead(RAIN_BUTTON);
  if (rainState == HIGH && lastRainState == LOW) {
    raining = !raining;

    if (raining) {
      // read pot value and remap
      potVal = analogRead(PUMP_POT);
      potVal = map(potVal, 0, 1023, 150, 255);

      // write to motor
      analogWrite(WATER_PUMP, potVal);
    } else {
      // motor is off
      analogWrite(WATER_PUMP, 0);
    }
  }
  lastRainState = rainState;

  if (raining) {
    // read pot value and remap
    int potVal = analogRead(PUMP_POT);
    potVal = map(potVal, 0, 1023, 150, 255);

    // write to motor
    analogWrite(WATER_PUMP, potVal);
  }

  // print rain sensor values
  int rainValue = analogRead(RAIN_SENSOR);
  rainValue = map(rainValue, 0, 1023, 50, 0); // map sensor pot val on 0-50 scale
  Serial.print(rainValue);

  if (thunderPress) { // print true if thunder button is pressed
    Serial.print(",");
    Serial.print("1");
    Serial.println();
    thunderPress = false;
    delay(5);
  } else if (eePress) { // print true if ee button is pressed
    Serial.print(",");
    Serial.print("2");
    Serial.println();
    eePress = false;
    delay(5);
  } else {  // otherwise just end the line
    Serial.println();
  }

  delay(50);
}

void thunder() {
  int thunderState = digitalRead(THUNDER_BUTTON);

  if (thunderState == HIGH) {
    thunderPress = true;
  }
}

void ee() {
  int eeState = digitalRead(EE_BUTTON);
  int lastEeState = 0;

  if (eeState != lastEeState) {
    if (eeState == HIGH) {
      eePress = true;
    }
  }
  lastEeState = eeState;
}

P5 code:

// drop.js code adapted from Dan Shiffman's purple rain coding challenge
// https://youtu.be/KkyIDI6rQJI

// define global vars
var drops = [];
var serial;
var portName = '/dev/cu.wchusbserial1410';

var inputData;
var sensorData = 0;
var otherPlay = 0;
var rainData = 0;

var rainSound;
var thunderSound;
var eeSound;

// preload SFX before setup
function preload(){
  rainSound = loadSound('rain.mp3');
  thunderSound = loadSound('thunder.mp3');
  eeSound = loadSound('rainmaker.mp3');
}

function setup() {
  createCanvas(640, 360);
  for (var i = 0; i < 1000; i++) { drops[i] = new Drop(); } rainSound.play(); // setup serial connection for analog sensor input serial = new p5.SerialPort(); 
serial.on('connected', serverConnected); 
serial.on('open', portOpen); 
serial.on('data', serialEvent); 
serial.list(); serial.open(portName); } 

function serverConnected() { } 
function portOpen() { } 

function serialEvent() { 
inputData = serial.readLine(); // check that the array has at least 1 element if (inputData.length > 0) {

    var sensorReadings = inputData.split(',');

    sensorData = int(sensorReadings[0]);
    otherPlay = int(sensorReadings[1]);   
  }
}

function draw() {
  background(220,220,220);

  // play thunder sound when button is pressed
  if (otherPlay == 1) {
    thunderSound.play();
    otherPlay = 0;
  } else if (otherPlay == 2) { // play matchbox 20 clip when button is pressed
    eeSound.play();
    eeSound.setVolume(.4);
    otherPlay = 0;
  }

  // smooth sensor data using linear interpolation and show as %
  rainData = lerp(rainData, sensorData, 0.04);
  text('rain percentage: ' + round((rainData /50)*100) + '%', 30, 30);

  // show rain on screen
  var rainAmount = rainData * 15; 
  for (var i = 0; i < rainAmount; i++) {
    drops[i].fall();
    drops[i].show();
  }

  // set rain sound vol based on sensor input
  var rainVol = rainData * 2
  var volume = map(rainVol, 0, 50, 0, 1);
  rainSound.setVolume(volume);
}

Do It Once - Do It Again

For my 14-week project in the Prototyping Electronic Devices class I would like to build a self-contained, remote weather station that operates via GPRS (2G). Ideally, parts will be low cost (> $20) and relatively simple. The device will be built into a waterproof enclosure with a solar panel on the outside. The solar panel will charge a battery, which will provide power to the circuit. The circuit will pull data from a variety of sensors (inputs) at a specified time interval and then transmit that data to an AWS server (outputs), which will be displayed on an HTML page, potentially with some basic data visualization or simply in a table.

Inputs:

• Tempature sensor
• Humidity sensor
• Pressure sensor
• Light sensor
• Rain sensor

Outputs:

• Sensor outputs posted to database via GPRS
• Possible data visualization overlay for database data

Presentation Tuesday, October 31st:

• What it is?
• Making process
• Thoughts and questions
• Next steps
• 5 minute presentation