El temporizador de Pee: Conectar el Arduino, la cámara de computación perceptiva de Intel y una bomba de agua sumergible (2 / 4 paso)

Paso 2: programación

• Procesamiento de

• El lado de proceso del programa se ejecuta en el entorno de procesamiento de 32 bits para Windows.
• Se conecta a la cámara de computación perceptiva de Intel y pistas cuando el usuario está sentado frente a la computadora portátil o cuando el usuario ha dejado a través de la detección de la cara en la cámara.
• Comunica estos cambios para el Arduino a través de una conexión en serie.
  • Utilizamos el proceso unidireccional a Arduino serial conexión puesto que no necesitamos extraer cualquier información detrás de Arduino. Puede encontrar otros ejemplos de conexiones serie aquí:
  • https://Learn.Sparkfun.com/tutorials/Connecting-ar...
• También envía mensajes "al azar" a Twitter, usando la API de Twitter. Estos mensajes aleatorios se tiran de colecciones de mensajes dirigidos a situaciones específicas o eventos, activados en todo el código. En nuestro proyecto en particular, estamos usando el ejemplo de un programa que rastrea cuantas veces un usuario levanta a utilizar el baño y luego castiga el usuario si se han ido demasiados.
  • Para trabajar a través del proceso de conexión a Twitter, hemos utilizado esta guía: http://blog.blprnt.com/blog/blprnt/updated-quick-t...
  • Probablemente lo encontrará útil, como le guía a través del proceso de configuración de la aplicación en Twitter, generando las claves de autenticación, etc..

El código de estas aplicaciones se proporciona a continuación. He incluido comentarios en el código para ayudar a usted averiguar lo que está sucediendo en cada sección, y donde tendrá que hacer sus propios cambios. En mi opinión, el código es bastante difícil de leer en el formato de Instructables, sobre todo porque le gusta quitar las pestañas. Si copia y pegar para procesamiento o Arduino, automáticamente color-código cuando proceda y hacer más fácil navegar.

Procesamiento de
------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------
/**
PeeTracker32
Desarrollado por Austin Toombs (correo electrónico: altoombs indiana edu)
Concepto de Austin Toombs y Shad Gross
Enero de 2014
**/

/ ** importar bibliotecas etc. ** /
Import intel.pcsdk.*;
Import processing.serial.*;

/ ** Inicializar las variables ** /
/ ** Intel Perceptual Computing Variables ** /
PXCUPipeline período de sesiones;
PImage rgbTex;

int [] faceLabels = {PXCMFaceAnalysis.Landmark.LABEL_LEFT_EYE_OUTER_CORNER,
PXCMFaceAnalysis.Landmark.LABEL_LEFT_EYE_INNER_CORNER,
PXCMFaceAnalysis.Landmark.LABEL_RIGHT_EYE_OUTER_CORNER,
PXCMFaceAnalysis.Landmark.LABEL_RIGHT_EYE_INNER_CORNER,
PXCMFaceAnalysis.Landmark.LABEL_MOUTH_LEFT_CORNER,
PXCMFaceAnalysis.Landmark.LABEL_MOUTH_RIGHT_CORNER};

ArrayList facePts = new ArrayList();
ArrayList faceBoxes = new ArrayList();

/ ** Colecciones de tweets posibles para situaciones de verious
Si crea sus propias colecciones de cadenas para tirar de, esto es donde usted puede inicializarlos
**/
ArrayList returnTweets = new ArrayList();
ArrayList firstThresholdTweets = new ArrayList();
ArrayList secondThresholdTweets = new ArrayList();
ArrayList thirdThresholdTweets = new ArrayList();

/ ** booleanos para la lógica de estado dentro del programa ** /
Boolean faceState = false; Si no se ve una cara
Boolean prevFaceState = false; sea o no un rostro fue visto en el anterior

/ ** las variables para la integración con Twitter ** /
Twitter twitter;

/ ** las variables para el control de cuánto tiempo el usuario ha desaparecido
hemos creado varios "hitos" para mientras el usuario s ido. Aquí tenemos 3, pero se puede
cambia estos fácilmente mediante la adición de más aquí y en el código donde estos hitos
se hace referencia a
**/
largo savedTime;
int minimumTime = 6000; límite de tiempo mínimo antes de enviar un mensaje
int firstMilestone = 30000; primer hito para enviar mensajes de shameing
Boolean firstMilestoneMessageSent = false; realizar un seguimiento de si envió el primer mensaje de hito
int secondMilestone = 60000; segundo hito para enviar mensajes de shameing
Boolean secondMilestoneMessageSent = false; realizar un seguimiento de si envió el segundo mensaje de hito
int thirdMilestone = 90000; tercer hito para el envío de mensajes de shaming
Boolean thirdMilestoneMessageSent = false; realizar un seguimiento de si nos envía el tercer mensaje de hito

/ ** las variables para la conexión serial ** /
Serie myPort; el objeto de puerto serie

void setup()
{
establecer el tamaño del lienzo
Size(640,480);

crear imagen de información sobre la cámara (no es necesario)
rgbTex = createImage(640,480,RGB);

la información de la sesión de la cámara de computación perceptiva de Intel
sesión = nuevo PXCUPipeline(this);
período de sesiones. Init (PXCUPipeline.COLOR_VGA| PXCUPipeline.FACE_LOCATION| PXCUPipeline.FACE_LANDMARK);

inicialización de la conexión con Twitter * con autenticación!
Se necesita generar sus propias llaves de uso de Twitter e incluirlos aquí
ConfigurationBuilder cb = new ConfigurationBuilder();
cb.setOAuthConsumerKey("XXXXXXXXXXXXXXXXXXXX");
cb.setOAuthConsumerSecret("YYYYYYYYYYYYYYYYYYYYYY");
cb.setOAuthAccessToken("ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ");
cb.setOAuthAccessTokenSecret("XYZYXYZXYZYXYZXZXYZYXYZYXYZYXYZ");

inicializar el objeto twitter
Twitter = nuevo TwitterFactory(cb.build()).getInstance();

Esto no tiene que ser llamado en todo, pero es divertido ver
comentado por ahora: getPreviousTweets();

inicializar el puerto serie y velocidad en baudios en 9600
myPort = serie nueva (este, Serial.list() [0], 9600);

inicializar las colecciones de tweets
initializeTweets();
}

función de drenaje por defecto en cada programa de tratamiento de
void draw()
{
Obtener datos de la cámara y el dibujo en el lienzo / / /
antes de jugar con la cámara computación perceptiva, tenemos que asegurarnos de
pueden ver las cosas. Todo en esta si la declaración debe
siguen siendo-por el momento. Lo usamos para determinar si una cara es incluso dentro de
vista. Probablemente existe una manera más fácil de hacer esto, pero nos gustaría ver la cara
cajas por lo que podemos decir lo que ve como una cara y lo que no hace
if(Session. AcquireFrame(false))
{
período de sesiones. QueryRGB(rgbTex);
facePts.clear();
faceBoxes.clear();

para (int i = 0; ++ i)
{
tiempo [] ft = nuevo largo [2];
if(!Session. QueryFaceID(i,ft))
rotura;

PXCMFaceAnalysis.Detection.Data fdata = nuevo PXCMFaceAnalysis.Detection.Data();
if(Session. QueryFaceLocationData ((int) ft [0], fdata))
{
faceBoxes.add(fdata.rectangle);

PXCMFaceAnalysis.Landmark.LandmarkData lmark = new PXCMFaceAnalysis.Landmark.LandmarkData();
para (int f = 0; f {}
if(Session. QueryFaceLandmarkData ((int) ft [0], faceLabels [f], 0, lmark))
{
facePts.add(lmark.position);
}
}
}
}
período de sesiones. ReleaseFrame();
} //end de detección de la cara si declaración

muestra lo que ve la cámara sobre el lienzo
Image(rgbTex,0,0);
pushStyle();
Stroke(255);
noFill();

dibuja las cajas de la cara en la pantalla
para (int f = 0; f {}
PXCMRectU32 faceLoc = (PXCMRectU32)faceBoxes.get(f);
Rect(faceLoc.x,faceLoc.y,faceLoc.w,faceLoc.h);
}
Fill(0,255,0);
para (int g = 0; {g}
FacePt PXCMPoint3DF32 = (PXCMPoint3DF32)facePts.get(g);
Ellipse(facePt.x,facePt.y,5,5);
}
popStyle();

Es el fin del dibujo cosas / / /

Guarde el estado anterior de la cara (para propósitos de seguimiento)
prevFaceState = faceState;

Si aún no podemos ver una cara en absoluto
{if(faceBoxes.Size()==0)}
faceState = false; no podemos ver la cara, por lo que el usuario no está allí

Si estaban allí hace un momento y ahora
if(prevFaceState == true) {}
que la cámara ya no ve una cara de salida
System.out.println ("no se puede ver una cara, a partir de temporizador");

Inicio tiempo de seguimiento. Millis() medida el tiempo en milisegundos
desde el inicio del programa
savedTime = millis();

Enviar mensaje a serie que no podemos ver una cara
myPort.write('2');
}

el tiempo que el usuario ha desaparecido es la hora actual en milisegundos
desde el inicio del programa menos el tiempo en milisegundos desde
el inicio del programa cuando el usuario.
timeAway largo = millis() - savedTime;

utilizar la información de timeAway para determinar cuándo enviar mensaje
processAwayAlerts(timeAway);
}
Else {}
Si vemos caras, no tiempo les
faceState = true;

Si vemos un rostro donde antes no, entonces sabemos
acaban de volver
if(prevFaceState == false) {}
calcular cuánto tiempo se han pasado al usuario total
timeAway largo = millis() - savedTime;

processJustReturnedAlerts(timeAway);

resetMessageBooleans();
}
}
fin del sorteo método / / /
}

cada una de las colecciones de tweets que pueden utilizarse para establecer
situaciones específicas
void initializeTweets() {}
returnTweets.add ("estaba lejos de su escritorio para segundos XXX");
returnTweets.add ("hizo pis por segundos XXX");
returnTweets.add ("quedaba improductiva por XXX segundos");
returnTweets.add ("podido posponer durante segundos XXX");
returnTweets.add ("magnésica segundos XXX");
returnTweets.add ("fue completamente inútil para segundos XXX");

firstThresholdTweets.add ("es probablemente orinar ahora, así que si necesitas algo comprobar atrás pronto");
firstThresholdTweets.add ("ha sido lejos de su escritorio por algún tiempo. No hagas un hábito de esto");
firstThresholdTweets.add ("regresará pronto. O mejor.");
firstThresholdTweets.add ("no puede venir al teléfono ahora mismo. A menos que tenga con él. En el baño.");

secondThresholdTweets.add ("... ¿Dónde estás? ¿Por qué has estado lejos por tanto tiempo?");
secondThresholdTweets.add ("lo que estás haciendo ahora mismo mejor ser freaking importante.");
secondThresholdTweets.add ("si no vas a trabajar hoy en día usted podría así a ir a casa");
secondThresholdTweets.add ("tenga un problema médico. No debe tomar esto mucho a orinar.");

thirdThresholdTweets.add ("se lleva para siempre a orinar. Mejor acabar rápido o el riesgo de perder su vida lejos");
thirdThresholdTweets.add ("está perdiendo su tiempo". Todo el mundo debe presionarlo para volver a su escritorio");
thirdThresholdTweets.add ("estamos enviando al grupo de búsqueda. Ha sido ido demasiado largo.");
thirdThresholdTweets.add ("no es un modelo de cómo deben comportarse en el trabajo.");
}

determinar los mensajes a enviar y cuando mientras que el usuario se ha ido
en base al tiempo que han estado ausente
void processAwayAlerts(long timeAway) {}
Si el tiempo que se han idos es mayor que el mínimo
tiempo nos preocupa, entonces enciende el LED
if(timeAway > minimumTime) {}
myPort.write('1');
}

Si el tiempo se han idos es más largo que el primero
tiempo de hito, después adoptará las medidas adecuadas
Si (timeAway > firstMilestone & &! firstMilestoneMessageSent) {}
enviar el mensaje (ya sea en twitter o en consola)
sendMessage(randomTweet(firstThresholdTweets));

marca que se ha enviado el primer mensaje de hito
firstMilestoneMessageSent = true;
}

Si el tiempo se han idos es más largo que el segundo
tiempo de hito, después adoptará las medidas adecuadas
Si (timeAway > secondMilestone & &! secondMilestoneMessageSent) {}
enviar el mensaje (ya sea en twitter o en consola)
sendMessage(randomTweet(secondThresholdTweets));

marca que ha llegado el segundo mensaje de hito
secondMilestoneMessageSent = true;
}

Si el tiempo que se han idos más de la tercera
tiempo de hito, después adoptará las medidas adecuadas
Si (timeAway > thirdMilestone & &! thirdMilestoneMessageSent) {}
enviar el mensaje (ya sea en twitter o en consola)
sendMessage(randomTweet(thirdThresholdTweets));

marca que ha llegado el segundo mensaje de hito
thirdMilestoneMessageSent = true;
}
}

determinar qué hacer cuando el usuario devuelve
void processJustReturnedAlerts(long timeAway) {}
sólo mostrar mensaje si se habían ido la cantidad mínima de
tiempo. De lo contrario probablemente fueron mirando lejos o rayar
su cara o arreglar su cabello o te lo dan
if(timeAway > minimumTime) {}
Informe a tiempo al usuario de la consola se había ido
System.out.println ("usuario de regresar después de:" + timeAway + "milisegundos.");

Enviar mensaje en twitter o en consola
sendMessage (randomTweet (returnTweets) .replace ("XXX", "" + timeAway/1000));
}

enviar una señal en serie a Arduino que el usuario
es frente a la computadora
myPort.write('0');
}

elegir un tweet al azar de la colección de tweet dado y
devolver ese mensaje como una cadena
String randomTweet(ArrayList tweetList) {}
elegir un número aleatorio basado en la longitud de la colección
int tweetIndex = (int) random(tweetList.size());

Devuelve la cadena en ese lugar
volver tweetList.get(tweetIndex);
}

Enviar un mensaje en twitter o en consola
void sendMessage(String message) {}
Enviar un mensaje por twitter (comente durante la prueba)
/ ** prueba {}
twitter.updateStatus(message);
}
{} catch (TwitterException te)
println ("no pudo conectarse:" + te);
};**/

Enviar un mensaje a consola
System.out.println(Message);
}

restablecer los valores booleanos de mensaje. De lo contrario los mensajes de umbral podrían sólo
enviarse una vez durante cada ejecución del programa
void resetMessageBooleans() {}
firstMilestoneMessageSent = false;
secondMilestoneMessageSent = false;
thirdMilestoneMessageSent = false;
}

/**
* Este método sólo encuentra los tweets anteriores hechos por este dispositivo y
* Imprima hacia fuera a la consola. Se puede quitar y no
* llama y no va a cambiar cualquier otra funcionalidad de este programa
**/
void getPreviousTweets() {}
Query Query = new Query("#peeTimer");
query.setRpp(100); no funciona Twitter4j w/más recientes

Trate de hacer la solicitud de consulta.
trate de {}
la siguiente línea actualiza el estado de twitter
QueryResult resultado = twitter.search(query);
ArrayList tweets = (ArrayList) result.getTweets();

para (int i = 0; i < tweets.size(); i ++) {}
Estado t = tweets.get(i) (estado);
U usuario = (usuario) t.getUser();
Usuario de la cadena = u.getName();
String msg = t.getText();
println ("Tweet a" + usuario + ":" + msg);
};
}
{} catch (TwitterException te)
println ("no pudo conectarse:" + te);
};
}
------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------

Arduino
------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------
/**
peetimerArduinoSketch
Desarrollado por Austin Toombs (correo electrónico: altoombs indiana edu)
Concepto de Austin Toombs y Shad Gross
Enero de 2014
**/

variables para la lectura a y de serie
char val; Datos recibidos del puerto serial

asignaciones de pines
int ledPin = 13; Configurar el pin digital 13 de entrada-salida
int waterPumpPin = 10; Este pin controla realmente la cola de PowerSwitch para encender y apagar

tiempo de seguimiento para bomba de agua
previousMillis largo = 0;
offInterval largo = 4000; Cuánto tiempo necesitamos apagado por intervalo
onInterval largo = 2000; Cuánto tiempo necesitamos en por intervalo
Boolean timeStarted = false;

seguimiento del estado de la bomba de agua
int waterPumpState = bajo;

void setup()
{
pinMode (ledPin, salida); Conjunto pin como salida
pinMode (waterPumpPin, salida); configurar pin como salida
inicializar la comunicación serial a una velocidad de 9600 baudios
Serial.Begin(9600);
}

void loop() {}
Si (Serial.available())
{/ / Si hay datos disponibles para leer,
Val = Serial.read(); leerla y guardarla en val
}
Si (val == '1')
{/ / Si se recibió 1
digitalWrite (ledPin, HIGH); Encienda el LED

Si el temporizador no ha comenzado aún, iniciar
if(!timeStarted) {timeStarted = true;}

decidir qué hacer con la bomba de agua, en base al tiempo
manageWaterPump();
} else {/ / si se recibe otra cosa que un 1
digitalWrite (ledPin, LOW); Apagar el LED
digitalWrite (waterPumpPin, bajo); Apague la bomba de agua
timeStarted = false; desactivar el temporizador
}
Delay(10); Esperar 10 milisegundos para la siguiente lectura
}

decidir cómo manejar la bomba de agua
void manageWaterPump() {}
la actual cantidad de tiempo que ha pasado desde que recibimos el 1 en la serie
unsigned currentMillis largo = millis();

Si la bomba de agua ya está apagada
if(waterPumpState == Low) {}
y ha sido de largo suficiente, girar a la en
Si (currentMillis - previousMillis > offInterval) {}
guardar la última vez que titilaba el LED
previousMillis = currentMillis;
waterPumpState = alto;

Set el LED con la ledState de la variable:
digitalWrite (waterPumpPin, waterPumpState);
}
}
else {//if en que la bomba de agua ya está
y ha sido el tiempo suficiente, girar a la fuera
Si (currentMillis - previousMillis > onInterval) {}
guardar la última vez que titilaba el LED
previousMillis = currentMillis;
waterPumpState = bajo;

Set el LED con la ledState de la variable:
digitalWrite (waterPumpPin, waterPumpState);
}
}
}
------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------