Category: Assignment-12C-Object-That-Tweets

Two Computers, OSC, and an Arduino

For this project, Golan gave me permission to work on communication between two computers which are remotely connected via the network (thanks Golan!).  I wanted to do this as it is a critical component in making my final project work, which is in essence a telepresent robot student (more details to come!) .  Here is a video of it working:

Primarily using Processing and Arduino, I used the oscP5 library by Andreas Schlegel for the communication between the computers, and just plain Serial to control the Arduino.  Overall, the communication pipeline looks like this:

Computer 1 -> Computer 2 -> Arduino

Lag appeared to be minimal, and the OSC interface was very fast and worked well for my needs.

Here is the Processing Code that uses OSC to communicate between two computers:(adapted from an excellent tutorial here: http://learning.codasign.com/index.php?title=Sending_and_Receiving_OSC_Data_Using_Processing)

/* --- PRE SETUP --- */
//pre setup network:
import java.net.InetAddress;
 
InetAddress inet;
 
String myIP;
 
//pre setup OSC:
import oscP5.*;
import netP5.*;
 
OscP5 oscP5;
NetAddress myRemoteLocation;
 
//pre setup Arduino:
import processing.serial.*;
Serial port;
 
/* ----- SETUP ----- */
void setup() {
  size(400,400);
 
  /* --- PREPARE NETWORK: --- */
  //get this computer's ip:
  try {
    inet = InetAddress.getLocalHost();
    myIP = inet.getHostAddress();
  }
  catch (Exception e) {
    e.printStackTrace();
    myIP = "couldnt get IP"; 
  }
  println(myIP);
 
  /* --- PREPARE OSC: --- */
  //this computer's port
  oscP5 = new OscP5(this,5001);
 
  //sender ip and port (replace with real IP:)
  myRemoteLocation = new NetAddress("127.0.0.1",6002);
 
  /* --- PREPARE ARDUINO: --- */
  println("Available serial ports:");
  println(Serial.list());
  port = new Serial(this, Serial.list()[5], 9600);  
 
}
 
/* --- MAIN LOOP --- */
void draw() { }
 
void mousePressed() {  
  // create an osc message
  OscMessage myMessage = new OscMessage("/test");
 
  myMessage.add(123); // add an int to the osc message
  myMessage.add(12.34); // add a float to the osc message 
  myMessage.add("hello other computer!"); // add a string to the osc message
 
  // send the message
  oscP5.send(myMessage, myRemoteLocation); 
}
 
 
 
 
void oscEvent(OscMessage theOscMessage) 
{  
  // get the first value as an integer
  int firstValue = theOscMessage.get(0).intValue();
 
  // get the second value as a float  
  float secondValue = theOscMessage.get(1).floatValue();
 
  // get the third value as a string
  String thirdValue = theOscMessage.get(2).stringValue();
 
  // print out the message
  print("OSC Message Recieved: ");
  print(theOscMessage.addrPattern() + " ");
  println(firstValue + " " + secondValue + " " + thirdValue);
 
  //send message to Arduino:
  port.write('a');
}

Arduino code was very simple: it just checks for input and turns led on and off. (Adapted from Dimmer example:)

/* --- PRE SETUP --- */
int ledPin = 13;
boolean on = false;
 
/* ----- SETUP ----- */
void setup() {
  // initialize the serial communication:
  Serial.begin(9600);
  // initialize the ledPin as an output:
  pinMode(ledPin, OUTPUT);
}
 
/* --- MAIN LOOP --- */
void loop() {
  byte brightness;
 
  // check if data has been sent from the computer:
  if (Serial.available()) {
    // read the most recent byte (which will be from 0 to 255):
    brightness = Serial.read();
    // set the brightness of the LED:
    if(on == true) {
      digitalWrite(ledPin, HIGH);
      on = false;
    } else {
      digitalWrite(ledPin, LOW);
      on = true;
    }
  }
 
}

The Arduino was just for testing. As such, there is just a single LED:

arduinoled

TWEETING OBJECTO

I decided to do the button that tweets.  It took me some time to figure out the code but with the help of Luca, I was able to successfully tweet with the press of a button. In my code, I decided to have the arduino Serial print an “A” when ever the button was down and then have Processing read that “A” and then post a status to twitter.

<iframe width=”560″ height=”315″ src=”//www.youtube.com/embed/7m2t1GF-ueM” frameborder=”0″ allowfullscreen></iframe>

Screen Shot 2014-11-17 at 8.38.48 PM

 

Arduino
const int buttonPin = 2;    
 
// variables will change:
int buttonState = 0;  
int buttonPressed = 0;// variable for reading the pushbutton status
 
void setup() {
  Serial.begin(9600);  // initialize serial communications   
 
}
 
void loop(){
  buttonState = digitalRead (buttonPin);
  if (buttonState==1 &amp;&amp; buttonPressed==0){
    Serial.println("A");
    buttonPressed=1;
  }
  else if (buttonState==0 &amp;&amp; buttonPressed==1) {
    buttonPressed=0;
  }
 
 
  delay (10);   // wait some number of milliseconds
 
}
 
 
Processing
import processing.serial.*;
import com.temboo.core.*;
import com.temboo.Library.Twitter.Tweets.*;
 
Serial myPort;
 
ArrayList serialChars;      // Temporary storage for received serial data
int whichValueToAccum = 0;  // Which piece of data am I currently collecting? 
boolean bJustBuilt = false; // Did I just finish collecting a datum?
 
// Create a session using your Temboo account application details
TembooSession session = new TembooSession("salexy", "myFirstApp", "111dc69fd5864a3e95ef1ed410610654");
 
void setup() {
  int nPorts = Serial.list().length; 
  for (int i=0; i &lt; nPorts; i++) {   println("Port " + i + ": " + Serial.list()[i]);   }   String portName = Serial.list()[4];    myPort = new Serial(this, portName, 9600);   serialChars = new ArrayList(); }   void draw() {   while (myPort.available () &gt;0) {
    char aChar = (char) myPort.read();
 
    if (aChar=='A') {
      //println ("hi");
      runStatusesUpdateChoreo();
    }
  }
}
 
void runStatusesUpdateChoreo() {
  // Create the Choreo object using your Temboo session
  StatusesUpdate statusesUpdateChoreo = new StatusesUpdate(session);
 
  // Set credential
  statusesUpdateChoreo.setCredential("Pawalkerology");
 
  // Set inputs
  statusesUpdateChoreo.setAccessToken("1202876874-AcWWhnbZYZHGMPhDNPRBfXHhrXfEQxIn5P3KK8W");
  statusesUpdateChoreo.setAccessTokenSecret("JN1DpjlZ6tKZ8II676KJB2cZL5kqgw7DxAOcMctj72CGZ");
  statusesUpdateChoreo.setConsumerSecret("K2jfW0ANoGzMowlHABOov3evxzI10C8HxMCuX7PFSvb5OLGb0v");
  statusesUpdateChoreo.setStatusUpdate("This Documentation Tho!");
  statusesUpdateChoreo.setConsumerKey("B6QwcUz3de2dWGcq4wzqjqwHr");
 
  // Run the Choreo and store the results
  StatusesUpdateResultSet statusesUpdateResults = statusesUpdateChoreo.run();
 
  // Print results
  println(statusesUpdateResults.getResponse());
 
}

Button that Tweets

Using arduino and processing, I made a button that will tweet the exact hour, minute, and second that it is pushed.

Screen Shot 2014-11-17 at 7.56.29 PM

 

The tweet from the video ^^^~^^~^^~^^~^^^

Arduino Code:

 
//Will Taylor - Tweeting App
 
// Create a session using your Temboo account application details
TembooSession session = new TembooSession("willtaylorvisual", "myFirstApp", "9eeb4f289ddf4ae28ab9426f0956347d");
 
import com.temboo.core.*;
import com.temboo.Library.Twitter.Tweets.*;
import processing.serial.*;
ArrayList serialChars;
Serial myPort;
 
void setup() {
// List my available serial ports
int nPorts = Serial.list().length;
for (int i=0; i < nPorts; i++) {
println("Port " + i + ": " + Serial.list()[i]);
}
 
String portName = Serial.list()[5];
myPort = new Serial(this, portName, 9600);
serialChars = new ArrayList();
}
 
void processSerial() {
 
while (myPort.available () > 0) {
char aChar = (char) myPort.read();
 
// You'll need to add a block like one of these
// if you want to add a 3rd sensor:
if (aChar == 'A') {
// Run the StatusesUpdate Choreo function
println("You did it you piece of shit! Good fucking job!");
runStatusesUpdateChoreo();
}
}
}
 
void runStatusesUpdateChoreo() {
// Create the Choreo object using your Temboo session
StatusesUpdate statusesUpdateChoreo = new StatusesUpdate(session);
 
// Set inputs
statusesUpdateChoreo.setAccessToken("2774482314-jR8gqVBzWk08Wh4SEpsmTZazMT7i4MBVHAP5fwl");
statusesUpdateChoreo.setAccessTokenSecret("2GUsUWfMBAdXLadA1XjATxHzJB8e5AMQxWtyofGRRNiTf");
statusesUpdateChoreo.setConsumerSecret("7KMu4Ky2OAFtmmDpepEeemlgozoomvd2tAIq98lrdzFAbdiuPY");
statusesUpdateChoreo.setStatusUpdate("Test tweet for status update app! Button pushed @ " + hour() + ":" + minute() + "." + second());
statusesUpdateChoreo.setConsumerKey("TSake54GKJUnG9bugX3NAhkbJ");
 
// Run the Choreo and store the results
StatusesUpdateResultSet statusesUpdateResults = statusesUpdateChoreo.run();
 
// Print results
println(statusesUpdateResults.getResponse());
 
}
 
void draw(){
processSerial();
}

 

Processing Code:

 
// Will Taylor - Tweeting App Arduino
 
const int buttonPin = 9;
int buttonValue = 0;
boolean tweet = false;
void setup() {
Serial.begin(9600);
pinMode(buttonPin, INPUT);
}
 
void loop() {
buttonValue = digitalRead(buttonPin);
if (buttonValue == HIGH && tweet == false){
Serial.println("A");
tweet = true;
} else {
Serial.println("B");
tweet = false;
}
 
delay(100);
 
}

 

 

arduino button tweets wee

tweets!: Screen Shot 2014-11-17 at 7.29.16 PM

fritzing:
Screen Shot 2014-11-17 at 7.38.11 PM

arduino pic:
IMG_4819

arduino code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
const int buttonPin = 7;     // the number of the pushbutton pin
 
int buttonState = 0;         // variable for reading the pushbutton status
 
void setup() 
{
//initialize serial communications at a 9600 baud rate
Serial.begin(9600);
 
pinMode(buttonPin, INPUT); 
}
 
void loop(){
  // read the state of the pushbutton value:
  buttonState = digitalRead(buttonPin);
  Serial.print(buttonState);
 
  delay(10);
}

processing code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
 
import com.temboo.core.*;
import com.temboo.Library.Twitter.Tweets.*;
 
// Create a session using your Temboo account application details
TembooSession session = new TembooSession("clarence", "myFirstApp", "c7192b9a881f4d4cae8bbd3c39d9f897");
 
void setup() {
  // Run the StatusesUpdate Choreo function
  runStatusesUpdateChoreo();
}
 
void runStatusesUpdateChoreo() {
  // Create the Choreo object using your Temboo session
  StatusesUpdate statusesUpdateChoreo = new StatusesUpdate(session);
 
  // Set inputs
  statusesUpdateChoreo.setAccessToken("549952908-x2iw8OJ8mvhElgoYtB8BJBCaFwSHXJh3RPbgjeZY");
  statusesUpdateChoreo.setAccessTokenSecret("XOvV1qgaO9eaqAjGsrvKvxy1oFijBSOhI3hyJOWJv6qhc");
  statusesUpdateChoreo.setConsumerSecret("Z22ucs7ArRU2c2ta81KnmKOrLvvqkC1z21Dk6hC69gNieq7iVq");
  statusesUpdateChoreo.setStatusUpdate("CLARENCE LUVS THIS BEAUTIFUL WORLD");
  statusesUpdateChoreo.setConsumerKey("3sHH6QuXsowjA2eLIkk6MVSp4");
 
  // Run the Choreo and store the results
  StatusesUpdateResultSet statusesUpdateResults = statusesUpdateChoreo.run();
 
  // Print results
  println(statusesUpdateResults.getResponse());
 
}

Object That Tweets: Ticklish Object

This is a rock that tweets its laughter when it is tickled or poked. Tickling it harder will make it laugh more.
This is more of a fun little tech demo than anything.
Apologies for the ugly code…

Screen Shot 2014-11-17 at 5.08.52 PM

Screen Shot 2014-11-17 at 5.23.15 PM

Processing code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
import processing.serial.*;
import com.temboo.core.*;
import com.temboo.Library.Twitter.Tweets.*;
 
Serial myPort;   
 
int valueA;  // Sensor Value A
int valueB;  // Sensor Value B
 
int oldValueB;
int finalPressure = 0;
boolean foundPressure = false;
int resetTimer = 0;
 
//------------------------------------
void setup() {
  size(300, 200);
 
  // List my available serial ports
  int nPorts = Serial.list().length; 
  for (int i=0; i < nPorts; i++) {
    println("Port " + i + ": " + Serial.list()[i]);
  }
 
  String portName = Serial.list()[9];
  myPort = new Serial(this, portName, 9600);
  serialChars = new ArrayList();
}
 
float round(float number, float decimal) {
  return (float)(round((number*pow(10, decimal))))/pow(10, decimal);
} 
 
//------------------------------------
void draw() {
 
  // Process the serial data. This acquires freshest values. 
  processSerial();
 
  background (150);  
 
  if(!foundPressure && valueB < oldValueB) {
    finalPressure = oldValueB;
    foundPressure = true;
    runStatusesUpdateChoreo();
  }
  if(foundPressure) {
    resetTimer++;
    if(resetTimer > 1000) {
      resetTimer = 0;
      foundPressure = false;
      finalPressure = 0;
      oldValueB = 0;
      valueB = 0;
    }
  }
 
  text ("old pressure: "+oldValueB, 80, 35);
  text ("pressure: "+valueB,        80, 55);
  text ("final pressure: "+finalPressure,  80, 75);
}
 
ArrayList serialChars;      // Temporary storage for received serial data
int whichValueToAccum = 0;  // Which piece of data am I currently collecting? 
boolean bJustBuilt = false; // Did I just finish collecting a datum?
 
void processSerial() {
 
  while (myPort.available () > 0) {
    char aChar = (char) myPort.read();
 
    // You'll need to add a block like one of these 
    // if you want to add a 3rd sensor:
    if (aChar == 'A') {
      bJustBuilt = false;
      whichValueToAccum = 0;
    } else if (aChar == 'B') {
      bJustBuilt = false;
      whichValueToAccum = 1;
    } else if (((aChar == 13) || (aChar == 10)) && (!bJustBuilt)) {
      // If we just received a return or newline character, build the number: 
      int accum = 0; 
      int nChars = serialChars.size(); 
      for (int i=0; i < nChars; i++) { 
        int n = (nChars - i) - 1; 
        int aDigit = ((Integer)(serialChars.get(i))).intValue(); 
        accum += aDigit * (int)(pow(10, n));
      }
 
      // Set the global variable to the number we captured.
      // You'll need to add another block like one of these 
      // if you want to add a 3rd sensor:
      if (whichValueToAccum == 0) {
        valueA = accum;
        // println ("A = " + valueA);
      } else if (whichValueToAccum == 1) {
        oldValueB = valueB;
        valueB = accum;
        // println ("B = " + valueB);
      }
 
      // Now clear the accumulator
      serialChars.clear();
      bJustBuilt = true;
 
    } else if ((aChar >= 48) && (aChar < = 57)) {
      // If the char is between '0' and '9', save it.
      int aDigit = (int)(aChar - '0'); 
      serialChars.add(aDigit);
    }
  }
}
 
String getLaughText(int p) {
  String result = "";
 
  p = p/75;
  for(int i = 0; i < p; i++) {
    result += "ha";
  }
  result += "!";
 
  return result;
}
 
// Create a session using your Temboo account application details
TembooSession session = new TembooSession("ticklishobject", "myFirstApp", "d6a74398d87c4963b7ce4951f8d291c9");
 
void runStatusesUpdateChoreo() {
  // Create the Choreo object using your Temboo session
  StatusesUpdate statusesUpdateChoreo = new StatusesUpdate(session);
 
  // Set inputs
  statusesUpdateChoreo.setAccessToken("2881358115-wqORtFIwM25CwVfrw7xB6ZBElOZ9wTiVDotqiwV");
  statusesUpdateChoreo.setAccessTokenSecret("lB7M7Yr08lM6wda6W2h9oOaIdXuiFiO7i3Y67owkdKHJK");
  statusesUpdateChoreo.setConsumerSecret("aDUmwJyDtIS0WuIdyq8U322FB5gxBL7GDfUfsVXP01ca8XcGTg");
  statusesUpdateChoreo.setStatusUpdate(getLaughText(finalPressure));
  statusesUpdateChoreo.setConsumerKey("eGeUwIZoaLGkhC8FlwpfaFwBZ");
 
  // Run the Choreo and store the results
  StatusesUpdateResultSet statusesUpdateResults = statusesUpdateChoreo.run();
 
  // Print results
  println(statusesUpdateResults.getResponse());
 
}

Arduino code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
// This Arduino program reads two analog signals, 
// such as from two potentiometers, and transmits 
// the digitized values over serial communication. 
 
int sensorValue0 = 0;  // variable to store the value coming from the sensor
int sensorValue1 = 0;  // variable to store the value coming from the other sensor
 
void setup() {
  Serial.begin(9600);  // initialize serial communications    
}
 
void loop() {
 
  // Read the value from the sensor(s):
  sensorValue0 = analogRead (A0);  // reads value from Analog input 0
  sensorValue1 = analogRead (A2);  // reads value from Analog input 1    
 
  Serial.print ("A"); 
  Serial.println (sensorValue0); 
  Serial.print ("B"); 
  Serial.println (sensorValue1);  
 
  delay (50);   // wait a fraction of a second, to be polite
}

internet of things

My original plan was to use a Kinect to detect if someone enters a room at a certain time, and take a picture and then post that on my twitter feed, I have all the code, its just all commented out. I was having problems with converting the PImage to Base64 code for temboo.
Instead, I fool my plant into thinking that it is daylight by turning on my desk lamp on. My plant will use my twitter and tweet a selfie and “morning!” every time I turn my lamp on. In the past 20 min my plant thinks the sun has set and rose 20 times.

IMG_0280IMG_0281

CODE:

//import org.apache.commons.codec.binary.Base64;
import processing.serial.*;
Serial myPort; 
import com.temboo.core.*;
import com.temboo.Library.Twitter.Tweets.*;
//import org.openkinect.*;
//import org.openkinect.processing.*;
//import javax.xml.bind.DatatypeConverter;
//import java.nio.*;
//import java.nio.file.Files;
// Create a session using your Temboo account application details
TembooSession session = new TembooSession("cstiles", "myFirstApp", "efd8e2eb76bb4136956b7ee28e6d12b7");
int valueA;  // Sensor Value A
boolean sendTweet = false;
int once = 1;
//Kinect kinect;
//int[] data;
//String basesixtyfourImage;
//PImage img;
void setup() {
  // Run the UpdateWithMedia Choreo function
 // kinect = new Kinect(this);
 // kinect.start();
  //img = loadImage("test.png");
 
  int nPorts = Serial.list().length; 
  for (int i=0; i < nPorts; i++) {
    println("Port " + i + ": " + Serial.list()[i]);
  } 
 
  String portName = Serial.list()[5]; 
  myPort = new Serial(this, portName, 9600);
  serialChars = new ArrayList();
}
 
 void draw(){
     // Process the serial data. This acquires freshest values. 
  processSerial();
//  if (keyPressed == true) {
//    //kinect.enableRGB(true);
//    //PImage img = kinect.getVideoImage();
//    String basesixtyfourImage = PImage2Base64(testImage);
    if (once == 1 && sendTweet==true) {
      runUpdateWithMediaChoreo();
      sendTweet=false;
      once = once+1;
 
    }// basesixtyfourImage
//  }
  println(valueA);
 if (valueA<50) sendTweet = true;
  else {
    sendTweet = false;
    once = 1;
 }
 }
 
void runUpdateWithMediaChoreo() { //back to string img
  // Create the Choreo object using your Temboo session
  UpdateWithMedia updateWithMediaChoreo = new UpdateWithMedia(session);
 
  // Set credential
  updateWithMediaChoreo.setCredential("twitter");
 
  // Set inputs
  updateWithMediaChoreo.setMediaContent("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");
  updateWithMediaChoreo.setStatusUpdate("morning!"+ millis());
 
  // Run the Choreo and store the results
  UpdateWithMediaResultSet updateWithMediaResults = updateWithMediaChoreo.run();
 
  // Print results
  println(updateWithMediaResults.getResponse());
  println(updateWithMediaResults.getLimit());
  println(updateWithMediaResults.getRemaining());
  println(updateWithMediaResults.getReset());
 
}
 
//
//
//byte[] int2byte(int[]src) {
//        int srcLength = src.length;
//        byte[]dst = new byte[srcLength << 2];
//   
//        for (int i=0; i<srcLength; i++) {
//                int x = src[i];
//                int j = i << 2; //                dst[j++] = (byte) (( x >>> 0 ) & 0xff);          
//                dst[j++] = (byte) (( x >>> 8 ) & 0xff);
//                dst[j++] = (byte) (( x >>> 16 ) & 0xff);
//                dst[j++] = (byte) (( x >>> 24 ) & 0xff);
//        }
//        return dst;
//}
//
//public String PImage2Base64(PImage i_Image)
// {  
//    i_Image.loadPixels();    
//    byte[] bytes = byte(i_Image.pixels);  
//    String b64 = DatatypeConverter.printBase64Binary(bytes);
//    byte[] origB = DatatypeConverter.parseBase64Binary(b64);
//    String orig = new String(origB);
//    println(orig);
//    return orig;
// }
// 
ArrayList serialChars;      // Temporary storage for received serial data
int whichValueToAccum = 0;  // Which piece of data am I currently collecting? 
boolean bJustBuilt = false; // Did I just finish collecting a datum?
 
void processSerial() {
 
  while (myPort.available () > 0) {
    char aChar = (char) myPort.read();
 
    // You'll need to add a block like one of these 
    // if you want to add a 3rd sensor:
    if (aChar == 'A') {
      bJustBuilt = false;
      whichValueToAccum = 0;
    } 
    else if (((aChar == 13) || (aChar == 10)) && (!bJustBuilt)) {
      // If we just received a return or newline character, build the number: 
      int accum = 0; 
      int nChars = serialChars.size(); 
      for (int i=0; i < nChars; i++) {          int n = (nChars - i) - 1;          int aDigit = ((Integer)(serialChars.get(i))).intValue();          accum += aDigit * (int)(pow(10, n));       }         // Set the global variable to the number we captured.       // You'll need to add another block like one of these        // if you want to add a 3rd sensor:       if (whichValueToAccum == 0)          valueA = accum;         // println ("A = " + valueA);         // Now clear the accumulator       serialChars.clear();       bJustBuilt = true;       } else if ((aChar >= 48) && (aChar < = 57)) {
      // If the char is between '0' and '9', save it.
      int aDigit = (int)(aChar - '0'); 
      serialChars.add(aDigit);
    }
  }
}
photoresistorw:o.led_bb

Arduino Code:

// This Arduino program reads two analog signals, 
// such as from two potentiometers, and transmits 
// the digitized values over serial communication. 
 
int sensorValue0 = 0;  // variable to store the value coming from the sensor
 
void setup() {
  Serial.begin(9600);  // initialize serial communications    
}
 
void loop() {
 
  // Read the value from the sensor(s):
  sensorValue0 = analogRead (A0);  // reads value from Analog input 0
 
 
  Serial.print ("A"); 
  Serial.println (sensorValue0); 
 
 
  delay (50);   // wait a fraction of a second, to be polite
}

					
					
			

The Switch

For this project, I wanted to do something simple in order to focus on my final project. So I came up with a simple concept of a switch replying via twitter to people who have touched it. When the switch is turned on, it lets you know. When it is turned off, it lets you know. I could see this project as being done much better with an animatronic object of some sort.

VIDEO:

SCREENSHOT:

switchTwitterScreen

SKETCHES:

switchSketch

FRITZING:

switch_bb

ARDUINO CODE:

//Arduino code for a switch
// It tells processing when it is turned on or off.
// Author: Matthew Kellogg
// Date: November 17, 2014
// Copyright 2014 Matthew Kellogg
 
//Keeps track of how long switch is in either position
// Used for debouncing
int onTime = 0;
int offTime = 0;
 
// Pin used for the switch
int switchPin = 2;
 
void setup(){
  Serial.begin(9600);
  pinMode(switchPin, INPUT);
}
 
void loop(){
  //write 'O' if switch is switched on after THRESH of off
  //write 'F' if switch is switched off after THRESH of on
  static const int DELAY = 100;
  static const int THRESH = 1000;
  bool on = digitalRead(switchPin);
  if (on){
    if (offTime &gt; THRESH){
      Serial.write('O');
    }
    onTime+=DELAY;
    offTime = 0;
  }else{
    if (onTime &gt; THRESH){
      Serial.write('F');
    }
    offTime+=DELAY;
    onTime = 0;
  }
  delay(DELAY);
}

PROCESSING:

import com.temboo.core.*;
import com.temboo.Library.Twitter.Tweets.*;
import processing.serial.*;
 
Serial myPort;
 
// Create a session using your Temboo account application details
TembooSession session = new TembooSession("kellogg92", "myFirstApp", "afd7abe943404e90b715b4b2aa9f681d");
 
void setup() {
  // connect the serial
  if (Serial.list().length &gt; 0) {
    String portName = Serial.list()[0]; 
    myPort = new Serial(this, portName, 9600);
  }
}
 
void draw(){
  readSerial();
}
 
void onTurnedOn(){
  println("ON!!!");
  runStatusesUpdateChoreo("The switch said, \"Mmm, you've turned me on.\"");
}
 
void onTurnedOff(){
  println("OFF!!!");
  runStatusesUpdateChoreo("The switch said, \"Eww, you've turned me off.\"");
}
 
//Does a status update with str
void runStatusesUpdateChoreo(String str) {
  // Create the Choreo object using your Temboo session
  StatusesUpdate statusesUpdateChoreo = new StatusesUpdate(session);
 
  // Set credential
  statusesUpdateChoreo.setCredential("Twitter");
 
  // Set inputs
  statusesUpdateChoreo.setStatusUpdate(str);
 
  // Run the Choreo and store the results
  StatusesUpdateResultSet statusesUpdateResults = statusesUpdateChoreo.run();
 
  // Print results
  println(statusesUpdateResults.getResponse());
}
 
//Reads all the characters from serial input
void readSerial() {
  while (myPort!=null &amp;&amp; myPort.available () &gt; 0) {
    char aChar = (char) myPort.read();
    if (aChar == 'O') {
      onTurnedOn();
    } else if (aChar == 'F') {
      onTurnedOff();
    }
  }
}

HEYY it works now

So with thanks to Matt, this works now:

Arduino:

const int buttonPin = 2;     // the number of the pushbutton pin
 
int buttonState = 0;         // variable for reading the pushbutton status
 
void setup() 
{
//initialize serial communications at a 9600 baud rate
Serial.begin(9600);
 
// initialize the pushbutton pin as an input:
 
pinMode(buttonPin, INPUT); 
}
 
void loop(){
  // read the state of the pushbutton value:
  buttonState = digitalRead(buttonPin);
  Serial.print(buttonState);
 
  delay(10);
}

Processing:

////with help from Miranda; thank you muchly I am still bad at serial stuff
 
import com.temboo.core.*;
import com.temboo.Library.Twitter.Tweets.*;
 
import processing.serial.*;
 
 
Serial myPort;
int currentvalue;
int previousvalue;
 
// Create a session using your Temboo account application details
TembooSession session = new TembooSession("natroze", "myFirstApp", "05001793540547fab231aefa984084c0");
 
void setup() {
  String portName =Serial.list()[2];
  myPort =new Serial(this, portName,9600);
}
 
void draw(){
  previousvalue = currentvalue;
  if (myPort.available() == 0){  //takes the available data
    currentvalue = myPort.read(); //and stores it in the current value
    myPort.clear();
  }
 
  if (currentvalue == 0){
    sendtweet();
 
  }
}
 
void sendtweet(){
  runStatusesUpdateChoreo();
}
 
 
void runStatusesUpdateChoreo() {
  // Create the Choreo object using your Temboo session
  StatusesUpdate statusesUpdateChoreo = new StatusesUpdate(session);
 
  //creds
  statusesUpdateChoreo.setCredential("twitterapp");
 
  // Set inputs
 
  statusesUpdateChoreo.setStatusUpdate("CEASE");
 
 
  // Run the Choreo and store the results
  StatusesUpdateResultSet statusesUpdateResults = statusesUpdateChoreo.run();
 
 
}

An object that tweets.

Well, for this assignment I really had a block. I din’t know what to tweet from my arduino so I… Well… I set up a simple button which completes a circuit telling my arduino to send a serial message which processing reads and thenuses to run my temboo choreo. I updated my choreo to take any string and tweet it. I then created a list of words to explain my project. I apologize for the sorry nature of it, truly.

A messy image of a simple button.

November 17, 2014 at 1027AM

Here’s a fritzing diagram.

BasicButton

My Twitter Feed.

Snap 2014-11-17 at 11.30.17

My Arduino Code.

int digPort = 8;
int buttonPushed = 0;
int buttonDown = 0;
int count = 0;
 
void setup() {
  Serial.begin(9600);
  pinMode(digPort, INPUT);
}
 
void loop() {
    buttonPushed = digitalRead(digPort);
 
    if (buttonPushed == HIGH && buttonDown == 0) {
      Serial.println("A");
      Serial.println(count);
      buttonDown = 1;
      count += 1;
    } else if (buttonPushed == LOW && buttonDown == 1) {
      buttonDown = 0;
    }
    delay(100);
 
}

My Processing Code.

import processing.serial.*;
import com.temboo.core.*;
import com.temboo.Library.Twitter.Tweets.*;
 
String not[] = {"nothing",
                "I have absolutely nothing",
                "to make"};
 
Serial myPort;
 
// Create a session using your Temboo account application details
TembooSession session = new TembooSession("luxapodular", "myFirstApp", "d731d22a81a14393a5be783117d2a8ce");
 
ArrayList serialChars;      // Temporary storage for received serial data
int whichValueToAccum = 0;  // Which piece of data am I currently collecting? 
boolean bJustBuilt = false; // Did I just finish collecting a datum?
 
int notIndex = 0;
 
void setup() {
  int nPorts = Serial.list().length; 
  for (int i=0; i < nPorts; i++) {
  println("Port " + i + ": " + Serial.list()[i]);
  }
  String portName = Serial.list()[0]; 
  myPort = new Serial(this, portName, 9600);
  serialChars = new ArrayList();
}
 
void draw() {
  doEt();
}
 
void doEt() {
   while (myPort.available () > 0) {
    char aChar = (char) myPort.read();
 
    if (aChar == 'A') {
      String thingToSay = not[notIndex];
      notIndex = (notIndex + 1) % 3;
      println(thingToSay);
      runStatusesUpdateChoreo(thingToSay);
    }
  }
}
 
void runStatusesUpdateChoreo(String string) {
  // Create the Choreo object using your Temboo session
  StatusesUpdate statusesUpdateChoreo = new StatusesUpdate(session);
 
  // Set inputs
  statusesUpdateChoreo.setAccessToken("2768964284-CkF5gMrUdhc07hXBJybfH06MVVvgUrgJfDuncfd");
  statusesUpdateChoreo.setAccessTokenSecret("5pm0mlgBuhdx2LVn5Gcj9ehldJtj8AhsI5jyffv25mphb");
  statusesUpdateChoreo.setConsumerSecret("yKVbJn9fnP2oArvBVhE94yiiyoj8FgpiqYy0NKZew3McpxACLe");
  statusesUpdateChoreo.setStatusUpdate(string);
  statusesUpdateChoreo.setConsumerKey("AlVDRqLH5OIL6XWrHyPi9Ikjf");
 
  // Run the Choreo and store the results
  StatusesUpdateResultSet statusesUpdateResults = statusesUpdateChoreo.run();
 
  // Print results
  println(statusesUpdateResults.getResponse());
}

A Button that Tweets

Full disclosure: I went for the minimal project so that I can dedicate more time to the final.

Screen Shot 2014-11-12 at 7.08.35 PMThis is my initial Temboo test, before the button was connected.

Screen Shot 2014-11-12 at 9.02.56 PMThis test has the button connection. Now we have a tweeting button!

circuittweetButton_bb

//Miranda Jacoby
//Electronic Media Studio Interactivity Section A
//majacoby@andrew@.cmu.edu
//Copyright Miranda Jacoby 2014
//Code created with help of Golan Levin
//With elements of the pushbutton example code 
   //created 2005
   //by DojoDave &lt;http://www.0j0.org&gt;
   //modified 30 Aug 2011
   //by Tom Igoe
   //http://www.arduino.cc/en/Tutorial/Button
 
 
// constants won't change. They're used here to 
// set pin numbers:
const int buttonPin = 2;     // the number of the pushbutton pin
 
// variables will change:
int buttonState = 0;         // variable for reading the pushbutton status
 
void setup() {
  Serial.begin(9600);  // initialize serial communications   
 
}
 
void loop(){
  // read the state of the pushbutton value:
  buttonState = digitalRead (buttonPin);
 
  // print if the pushbutton is pressed.
  // Serial.println (buttonState); writes the string "1" or "0"
  Serial.print (buttonState);  
 
  delay (10);   // wait some number of milliseconds
 
}
//Miranda Jacoby
//Electronic Media Studio Interactivity Section A
//majacoby@andrew@.cmu.edu
//Copyright Miranda Jacoby 2014
//Code created with help of Golan Levin and Temboo. 
 
import com.temboo.core.*;
import com.temboo.Library.Twitter.Tweets.*;
import processing.serial.*;
 
Serial myPort;  // Create object from Serial class
int currVal;      // Data received from the serial port
int prevVal;
int tweetTime;
int currentTime;
 
// Create a session using your Temboo account application details
TembooSession session = new TembooSession("pigeon", "pigeontwitter", "2289511ed75e4578a3b71a4b693fdb03");
 
void setup() {
 
  size(200, 200);
  String portName = Serial.list()[5];
  myPort = new Serial(this, portName, 9600);
 
   currentTime = millis();
}
 
void draw() {
 
  prevVal = currVal;  // swap
  if ( myPort.available() &gt; 0) {  // If data is available,
    currVal = myPort.read();         // read it and store it in val
    myPort.clear();
  }
  background(255);             // Set background to white
  if (currVal == 48) {              // If the serial value is "0",
    fill(0);                   // set fill to black
  } else if (currVal == 49) {         // If the serial value is not 0,
    fill(240);                 // set fill to whiteish
  } else {
    fill(255, 0, 0);
  }
  rect(50, 50, 100, 100);
 
  if (currVal != prevVal) {
    if (currVal == 48) {
      sendTweet();
    } else if (currVal == 49) {
      // println ("Released!");
    }
  }
}
 
void sendTweet(){
  tweetTime = millis() - currentTime;
  println ("I was pressed at " + tweetTime);  
  if (tweetTime &gt; 1000){
    println("Sucessful tweet");
    //send tweet by running the StatusesUpdate Choreo function
     runStatusesUpdateChoreo();
  } 
  else  {
    println("To soon to tweet!");
  }
  currentTime = millis();
}
 
void runStatusesUpdateChoreo() {
  // Create the Choreo object using your Temboo session
  StatusesUpdate statusesUpdateChoreo = new StatusesUpdate(session);
 
  // Set credential
  statusesUpdateChoreo.setCredential("TweetButton");
 
  // Set inputs
  statusesUpdateChoreo.setAccessToken("2769267476-rHudd8EwU7uLhkcruAwHxJtzA5AB7EH9lwPFD7s");
  statusesUpdateChoreo.setAccessTokenSecret("aIxNctSi3RXShSRn0iWfaDkE8NSN9OglhY4GgOU1gWRZy");
  statusesUpdateChoreo.setStatusUpdate("Testing, for the second time: A button that tweets when you press it.");
 
  // Run the Choreo and store the results
  StatusesUpdateResultSet statusesUpdateResults = statusesUpdateChoreo.run();
 
  // Print results
  println(statusesUpdateResults.getResponse());
 
}