// Opciones de configuración:
	char ssid[10]		= "Arduino1";	// Nombre para el modulo Bluetooth.
	char baudios		 = '4';		   // 1=>1200 baudios, 2=>2400, 3=>4800, 4=>9600 (por defecto), 5=>19200, 6=>38400, 7=>57600, 8=>115200
	char password[10]	= "0001";		// Contraseña para el emparejamiento del modulo.


void setup()
{
	Serial.begin(9600);
	
	// Tiempo de espera:
		pinMode(13,OUTPUT);
		digitalWrite(13,HIGH);
		delay(10000);
		digitalWrite(13,LOW);
                pinMode(0, INPUT);
                digitalWrite(0, HIGH);
	
	// Ahora se procede a la configuración del modulo:
	
		// Se inicia la configuración:
			Serial.print("AT"); delay(1000);

		// Se ajusta el nombre del Bluetooth:
			Serial.print("AT+NAME"); Serial.print(ssid); delay(1000);

		// Se ajustan los baudios:
			Serial.print("AT+BAUD"); Serial.print(baudios); delay(1000);

		// Se ajusta la contraseña:
			Serial.print("AT+PIN"); Serial.print(password); delay(1000);	
}

void loop()
{
	// Al parpadear el led se habrá terminado la configuración:
	digitalWrite(13, !digitalRead(13));
	delay(500);
}

#include <Servo.h>
Servo miservo1;

int counter = 0;
int val;
void setup() {
  Serial.begin(9600);
  miservo1.attach(10);
  pinMode(0, INPUT);
  digitalWrite(0, HIGH);
}
void loop(){
  val= Serial.read();// lee el valor del puerto serie
  if(val!= -1 && val==108 || val=='l') {
    counter++;
  }
  Serial.println(counter);
  delay(100);
  if(counter%2==0){
    miservo1.write(98);
  }
  else{
    miservo1.write(79);
  }
}

import com.francisli.processing.http.*;
import codeanticode.gsvideo.*;
import processing.serial.*;
import gab.opencv.*;
import java.awt.*;

String portname = "COM12"; // Selection of communications port with Bluetooth
Serial port; 
HttpClient client;
GSCapture cam;
OpenCV opencv; 

int a;
void setup(){
  size(640, 480);
  String[] cameras = GSCapture.list();
  cam = new GSCapture(this, 640, 480,cameras[0]);
  opencv = new OpenCV(this, 640, 480);
  opencv.loadCascade(OpenCV.CASCADE_FRONTALFACE);  
  cam.start();
  port = new Serial(this, portname, 9600);
}

void draw(){
  opencv.loadImage(cam);
  image(cam, 0, 0);
  noFill();
  stroke(0, 255, 0);
  strokeWeight(3);
  Rectangle[] faces = opencv.detect();
  println(faces.length);

  for (int i = 0; i < faces.length; i++) {
    println(faces[i].x + "," + faces[i].y);
    rect(faces[i].x, faces[i].y, faces[i].width, faces[i].height);
    a=a+1;
    if (a==50){
      saveFrame("sketch.png");
      client = new HttpClient(this, "api.twitter.com");
      //// using SSL is optional, but recommended
      client.useSSL = true;
      //// turn on OAuth request signing
      client.useOAuth = true;
      //// set up OAuth signing parameters
      client.oauthConsumerKey = "ConsumerKey"; //This was obtain making an account of developer in Twitter 
      client.oauthConsumerSecret = "ConsumerSecret"; //This was obtain making an account of developer in Twitter 
      client.oauthAccessToken = "AccessToken"; //This was obtain making an account of developer in Twitter 
      client.oauthAccessTokenSecret = "AccessTokenSecret"; //This was obtain making an account of developer in Twitter 
      //// set up POST params
      HashMap params = new HashMap();
      params.put("status", "Intruso"); //Message
      HashMap files = new HashMap();
      files.put("media[]", "sketch.png"); //Image file
      client.POST("/1.1/statuses/update_with_media.json", params, files);
      a=0;
    }
  }
}

void captureEvent(GSCapture c) {
  c.read();
}

void responseReceived(HttpRequest request, HttpResponse response) {
  println(response.statusCode + ": " + response.statusMessage);
  println(response.getContentAsString());
}

void keyReleased() { //Sending the key for port
  port.write(key);
  println(key);
}

import codeanticode.gsvideo.*;
import java.awt.image.BufferedImage;
import java.io.ByteArrayOutputStream;
import javax.imageio.ImageIO;

import muthesius.net.*;
import org.webbitserver.*;
import jcifs.util.Base64;

WebSocketP5 socket;
GSCapture myCapture;

void setup() {
	size( 320, 240 );
	socket = new WebSocketP5( this, 8080 );
        String[] cameras = GSCapture.list();
        myCapture = new GSCapture(this, width, height,cameras[0]);	
        myCapture.start();
}

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;
}

void captureEvent(GSCapture myCapture) {
	myCapture.read();

	BufferedImage buffimg = new BufferedImage( width, height, BufferedImage.TYPE_INT_RGB);
	buffimg.setRGB( 0, 0, width, height, myCapture.pixels, 0, width );
  
	ByteArrayOutputStream baos = new ByteArrayOutputStream();
	try {
    	ImageIO.write( buffimg, "jpg", baos );
  	} catch( IOException ioe ) {
	}
  
	String b64image = Base64.encode( baos.toByteArray() );
	socket.broadcast( b64image );
}

void draw() {
	image(myCapture, 0, 0);
}

void stop(){
	socket.stop();
}

void websocketOnMessage(WebSocketConnection con, String msg){
	println(msg);
}

void websocketOnOpen(WebSocketConnection con){
	println("A client joined");
}

void websocketOnClosed(WebSocketConnection con){
	println("A client left");
}

#include <Servo.h> 
 
Servo myservo; 
 
void setup() 
{ 
  Serial.begin(9600);
  myservo.attach(10);
  pinMode(0, INPUT);
  digitalWrite(0, HIGH);
} 
 
void loop() 
{ 
  byte brightness;
  if (Serial.available()>0) {
    brightness = Serial.read();
    myservo.write(brightness);                  
    delay(15);                           
  }
} 

import SimpleOpenNI.*;
import processing.serial.*;

Serial port;
/*---------------------------------------------------------------
Variables
----------------------------------------------------------------*/
// create kinect object
SimpleOpenNI  kinect;

// image storage from kinect
PImage kinectDepth;
// int of each user being  tracked
int[] userID;
// user colors
color[] userColor = new color[]{ color(255,0,0), color(0,255,0), color(0,0,255),
                                 color(255,255,0), color(255,0,255), color(0,255,255)};
 
// postion of head to draw circle
PVector headPosition = new PVector();
// turn headPosition into scalar form
float distanceScalar;
// diameter of head drawn in pixels
float headSize = 200;
  
// threshold of level of confidence
float confidenceLevel = 0.5;
// the current confidence level that the kinect is tracking
float confidence;
// vector of tracked head for confidence checking
PVector confidenceVector = new PVector();
 
float ellipseSize, ellipseSize1; 

PVector rightHand = new PVector();
PVector leftHand = new PVector();

/*---------------------------------------------------------------
Starts new kinect object and enables skeleton tracking. 
Draws window
----------------------------------------------------------------*/
void setup()
{
  
  println("Ports");
  println(Serial.list());

  // start a new kinect object
  kinect = new SimpleOpenNI(this);
  
  // enable depth sensor 
  kinect.enableDepth();
  
  // enable skeleton generation for all joints
  kinect.enableUser();
   
  // draw thickness of drawer
  strokeWeight(3);
  // smooth out drawing
  smooth();
  
  // create a window the size of the depth information
  
  size(kinect.depthWidth(), kinect.depthHeight()); 
  
  port = new Serial(this, Serial.list()[0], 9600);
} // void setup()
  
/*---------------------------------------------------------------
Updates Kinect. Gets users tracking and draws skeleton and
head if confidence of tracking is above threshold
----------------------------------------------------------------*/
void draw(){ 
  // update the camera
  kinect.update();
  // get Kinect data
  kinectDepth = kinect.depthImage();
  // draw depth image at coordinates (0,0)
  image(kinectDepth,0,0); 
  
   // get all user IDs of tracked users
  userID = kinect.getUsers();
   
  // loop through each user to see if tracking
  for(int i=0;i<userID.length;i++)
  {
    // if Kinect is tracking certain user then get joint vectors
    if(kinect.isTrackingSkeleton(userID[i]))
    {
      // get confidence level that Kinect is tracking head
      confidence = kinect.getJointPositionSkeleton(userID[i],
                          SimpleOpenNI.SKEL_HEAD,confidenceVector);
       
      // if confidence of tracking is beyond threshold, then track user
      if(confidence > confidenceLevel)
      {
        // change draw color based on hand id#
        stroke(userColor[(i)]);
        // fill the ellipse with the same color
        fill(userColor[(i)]);
        // draw the rest of the body
        drawSkeleton(userID[i]);       
      } //if(confidence > confidenceLevel)
    } //if(kinect.isTrackingSkeleton(userID[i]))
  } //for(int i=0;i<userID.length;i++)
  
  //saveFrame("frames/####.tif");
  
} // void draw()
  
/*---------------------------------------------------------------
Draw the skeleton of a tracked user.  Input is userID
----------------------------------------------------------------*/
void drawSkeleton(int userId){ 

  kinect.getJointPositionSkeleton(userId, SimpleOpenNI.SKEL_RIGHT_HAND,rightHand);
  kinect.getJointPositionSkeleton(userId, SimpleOpenNI.SKEL_LEFT_HAND,leftHand);
  
  kinect.convertRealWorldToProjective(rightHand, rightHand);
  kinect.convertRealWorldToProjective(leftHand, leftHand);
  
  ellipseSize = map(rightHand.z, 700, 2500, 50, 1); 
  ellipseSize1 = map(leftHand.z, 700, 2500, 50, 1);
   
  ellipse(rightHand.x, rightHand.y, ellipseSize, ellipseSize); //draw circle in right hand 
  ellipse(leftHand.x, leftHand.y, ellipseSize1, ellipseSize1); //draw circle in left hand
  
  port.write((int)map(rightHand.x,100,700,0,179)); //sending data
  
    
} // void drawSkeleton(int userId)
  
/*---------------------------------------------------------------
When a new user is found, print new user detected along with
userID and start pose detection.  Input is userID
----------------------------------------------------------------*/
void onNewUser(SimpleOpenNI curContext, int userId){
  println("New User Detected - userId: " + userId);
  // start tracking of user id
  curContext.startTrackingSkeleton(userId);
} //void onNewUser(SimpleOpenNI curContext, int userId)
  
/*---------------------------------------------------------------
Print when user is lost. Input is int userId of user lost
----------------------------------------------------------------*/
void onLostUser(SimpleOpenNI curContext, int userId){
  // print user lost and user id
  println("User Lost - userId: " + userId);
} //void onLostUser(SimpleOpenNI curContext, int userId)
 
/*---------------------------------------------------------------
Called when a user is tracked.
----------------------------------------------------------------*/
void onVisibleUser(SimpleOpenNI curContext, int userId){
} //void onVisibleUser(SimpleOpenNI curContext, int userId)