La minuterie Pee : Brancher l’Arduino, la caméra de calcul perceptuelle d’Intel et une pompe à eau Submersible (2 / 4 étapes)

Étape 2: programmation

• Traitement

• Le côté de la transformation du programme s’exécute dans l’environnement de traitement 32 bits pour Windows.
• Il se connecte à la caméra de calcul perceptuelle Intel et effectue le suivi lorsque l’utilisateur est assis devant l’ordinateur portable, ou lorsque l’utilisateur a laissé par le biais de la détection de visage, intégrée dans la caméra.
• Il communique ces changements à l’Arduino via une connexion série.
  • Nous avons utilisé le traitement unidirectionnel à connexion serial Arduino comme on n’avait pas besoin de retirer toute information de l’Arduino. Vous pouvez trouver d’autres exemples de connexions série ici :
  • https://Learn.Sparkfun.com/tutorials/Connecting-AR...
• Il publie également messages « aléatoires » sur Twitter, en utilisant l’API de Twitter. Ces messages aléatoires sont tirés des collections de messages qui visent des situations ou des événements, a déclenché dans tout le code. Dans notre projet, nous utilisons l’exemple d’un programme qui effectue le suivi combien de fois un utilisateur se lève pour utiliser les toilettes et puis châtie l’utilisateur, si ils sont allés trop longs.
  • Pour travailler par traitement de branchement à Twitter, nous avons utilisé ce guide : http://blog.blprnt.com/blog/blprnt/updated-quick-t...
  • Vous trouverez probablement il utile, car elle vous guide dans le processus de mise en place de l’application sur Twitter, la génération de clés d’authentification, etc..

Le code pour que ces deux demandes est fourni ci-dessous. J’ai inclus des commentaires dans le code pour aider à vous comprendre ce qui se passe pour chaque section, et où vous aurez besoin d’apporter vos propres modifications. À mon avis, le code est assez difficile à lire au format Instructables, autant qu’il veut enlever les cales. Si vous copiez et collez dans le traitement ou l’Arduino, il sera automatiquement code couleur le cas échéant et rendent plus facile à naviguer.

Traitement
------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------
/**
PeeTracker32
Développée par Austin Toombs (Courriel : altoombs indiana edu)
Concept par Austin Toombs et Shad Gross
Janvier 2014
**/

/ ** importer des bibliothèques etc. ** /
Import intel.pcsdk.* ;
Import processing.serial.* ;

/ ** Initialiser des variables ** /
/ ** Intel perceptuelle de calcul Variables ** /
PXCUPipeline session ;
RgbTex Byte ;

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() ;

/ ** Collections de tweets potentiels pour les situations verious
Si vous créez vos propres collections de chaînes pour tirer, c’est où vous pouvez initialiser les
**/
ArrayList returnTweets = new ArrayList() ;
ArrayList firstThresholdTweets = new ArrayList() ;
ArrayList secondThresholdTweets = new ArrayList() ;
ArrayList thirdThresholdTweets = new ArrayList() ;

/ ** valeurs booléennes pour la logique de l’État au sein du programme ** /
faceState booléen = false ; Si un visage est vu
prevFaceState booléen = false ; Si oui ou non un visage a été vu dans le précédent

/ ** variables pour l’intégration avec Twitter ** /
Twitter twitter ;

/ ** variables pour surveiller combien de temps l’utilisateur a été disparu
Nous avons mis en place diverses « jalons » pour tandis que l’utilisateur est parti. Nous avons 3 ici, mais vous pouvez
change facilement en ajoutant plus ici et partout dans le code où ces jalons
sont référencés
**/
long savedTime ;
int minimumTime = 6000 ; délai minimum avant d’envoyer un message
int firstMilestone = 30000 ; première étape pour l’envoi de messages de shameing
firstMilestoneMessageSent booléen = false ; suivi de si nous avons envoyé le premier message de jalon
int secondMilestone = 60000 ; deuxième étape pour l’envoi de messages de shameing
secondMilestoneMessageSent booléen = false ; suivi de si nous avons envoyé le deuxième message de jalon
int thirdMilestone = 90000 ; troisième étape pour envoyer des messages humiliation
thirdMilestoneMessageSent booléen = false ; suivi de si nous avons envoyé le troisième message de jalon

/ ** variables pour connexion série ** /
Serial myPort ; l’objet de port série

void setup()
{
définir la taille de la toile
Size(640,480) ;

créer image à partir d’informations caméra (pas nécessaire)
rgbTex = createImage(640,480,RGB) ;

les informations de session pour la caméra de calcul perceptuelle Intel
session = new PXCUPipeline(this) ;
session. Init (PXCUPipeline.COLOR_VGA| PXCUPipeline.FACE_LOCATION| PXCUPipeline.FACE_LANDMARK) ;

l’initialisation de la connexion à Twitter * complet avec authentification !
Vous aurez besoin générer votre propre Twitter application clés et les inclure ici
ConfigurationBuilder cb = new ConfigurationBuilder() ;
cb.setOAuthConsumerKey("XXXXXXXXXXXXXXXXXXXX") ;
cb.setOAuthConsumerSecret("YYYYYYYYYYYYYYYYYYYYYY") ;
cb.setOAuthAccessToken("ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ") ;
cb.setOAuthAccessTokenSecret("XYZYXYZXYZYXYZXZXYZYXYZYXYZYXYZ") ;

initialiser objet twitter
Twitter = new TwitterFactory(cb.build()).getInstance() ;

Cela ne doit pas être appelée à tout, mais il est amusant de voir
Commentaires pour l’instant : getPreviousTweets() ;

initialiser le port série et affectez bauds 9600
myPort = nouvelle série (ce, Serial.list() [0], 9600) ;

initialiser les collections de tweets
initializeTweets() ;
}

fonction de tirage au sort par défaut dans chaque programme de traitement
void draw()
{
Obtention de données de l’appareil photo et dessin de la toile / / /
avant de jouer avec la caméra informatique perceptuelle, il faut s’assurer que
Il peut en fait voir les choses. Tout dans ce cas énoncé devrait
rester en tant que-est pour l’instant. Nous l’utilisons pour déterminer si un visage est même à l’intérieur
vue. Il y a probablement un moyen plus facile de le faire, mais nous aimerions voir le visage
boîtes, donc nous pouvons dire ce qu’il considère comme un visage et ce qu’il ne fonctionne pas
if(session. AcquireFrame(false))
{
session. QueryRGB(rgbTex) ;
facePts.clear() ;
faceBoxes.clear() ;

pour (int i = 0; ++ J’ai)
{
depuis longtemps [] ft = nouvelle longue [2] ;
if(!session. QueryFaceID(i,ft))
rupture ;

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

PXCMFaceAnalysis.Landmark.LandmarkData lmark = new PXCMFaceAnalysis.Landmark.LandmarkData() ;
pour (int f = 0; f {}
if(session. QueryFaceLandmarkData ((int) ft [0], faceLabels [f], 0, lmark))
{
facePts.add(lmark.position) ;
}
}
}
}
session. ReleaseFrame() ;
} //end de détection de visage si Déclaration

affiche ce que la caméra voit sur la toile
image(rgbTex,0,0) ;
pushStyle() ;
Stroke(255) ;
noFill() ;

dessine les zones du visage sur l’écran
pour (int f = 0; f {}
PXCMRectU32 faceLoc = (PXCMRectU32)faceBoxes.get(f) ;
Rect(faceLoc.x,faceLoc.y,faceLoc.w,faceLoc.h) ;
}
Fill(0,255,0) ;
pour (g int = 0; g {}
PXCMPoint3DF32 facePt = (PXCMPoint3DF32)facePts.get(g) ;
ellipse(facePt.x,facePt.y,5,5) ;
}
popStyle() ;

C’est la fin du dessin des choses / / /

Enregistrez l’état antérieur de la face (aux fins de suivi)
prevFaceState = faceState ;

Si nous ne pouvons pas voir même un visage à tous les
{if(faceBoxes.Size()==0)}
faceState = false ; Nous ne pouvons pas voir le visage, afin que l’utilisateur n’est pas là

Si ils étaient là il y a un instant et ils ont tout à l’heure à gauche
if(prevFaceState == true) {}
sortie que la caméra ne voit plus un visage
System.out.println ("ne peut pas voir un visage, à partir de minuterie") ;

commencer le suivi des temps. Millis() mesure le temps en millisecondes
depuis le début du programme
savedTime = millis() ;

Envoyer le signal à série que nous ne pouvons pas voir un visage
myPort.write('2') ;
}

le temps que l’utilisateur a été disparu est le temps courant en millisecondes
depuis le début du programme moins le temps en millisecondes depuis le
le début du programme lorsque l’utilisateur a quitté.
timeAway long = millis() - savedTime ;

Utilisez les informations de timeAway pour déterminer quand envoyer message
processAwayAlerts(timeAway) ;
}
else {}
Si nous voyons les visages, nous ne sommes pas leur calendrier
faceState = true ;

Si nous voyons un visage où nous n’avons déjà pas, alors nous savons
ils vient de rentrer
if(prevFaceState == false) {}
calculer combien de temps l’utilisateur a été allé total
timeAway long = millis() - savedTime ;

processJustReturnedAlerts(timeAway) ;

resetMessageBooleans() ;
}
}
fin du tirage au sort méthode / / /
}

mettre en place chacun des collections de tweets qui peuvent être utilisés pour
situations particulières
void initializeTweets() {}
returnTweets.add ("a été éloigné de son bureau pour XXX secondes") ;
returnTweets.add ("pipi pour XXX secondes") ;
returnTweets.add ("était improductif pour XXX secondes") ;
returnTweets.add ("réussi à remettre à plus tard pour XXX secondes") ;
returnTweets.add ("relâchiez pour XXX secondes") ;
returnTweets.add ("était complètement inutile pour XXX secondes") ;

firstThresholdTweets.add ("est probablement pipi dès maintenant, donc si vous avez besoin de quelque chose revenez bientôt ») ;
firstThresholdTweets.add ("a été éloigné de son bureau depuis un certain temps. Ne faites pas une habitude de cette") ;
firstThresholdTweets.add ("sera de retour bientôt. Ou il vaut mieux être.") ;
firstThresholdTweets.add ("ne peut pas venir au téléphone dès maintenant. À moins qu’il a avec lui. Dans la salle de bain.") ;

secondThresholdTweets.add ("... où es-tu ? Pourquoi avez-vous été loin pour si longtemps?") ;
secondThresholdTweets.add ("tout ce que vous faites maintenant mieux être freaking important.") ;
secondThresholdTweets.add ("si vous n’allez pas au travail aujourd'hui vous pourriez aussi bien juste rentrer à la maison") ;
secondThresholdTweets.add ("pourrait avoir un problème médical. Il ne devrait pas prendre ce long faire pipi.") ;

thirdThresholdTweets.add ("il faut toujours faire pipi. Il mieux finir rapide ou risquer dépérir sa vie ») ;
thirdThresholdTweets.add ("perd son temps. Tout le monde devrait la pression lui de revenir à son bureau") ;
thirdThresholdTweets.add ("nous envoyons sur le groupe de recherche. Vous avez disparu trop longue.") ;
thirdThresholdTweets.add ("n’est pas un modèle pour comment vous devez se comporter au travail.") ;
}

déterminer les messages à envoyer et quand pendant que l’utilisateur a disparu
basé sur le temps qu’ils ont été absent
void processAwayAlerts(long timeAway) {}
Si le temps qu’ils ont été allés est plus long que le minimum
temps, nous sommes préoccupés par, puis allumer la LED
if(timeAway > minimumTime) {}
myPort.write('1') ;
}

Si le temps qu’ils ont été allés est plus long que le premier
durée de l’étape, puis prendre les mesures voulues
Si (timeAway > firstMilestone & &! firstMilestoneMessageSent) {}
Envoyer le message (que ce soit sur twitter ou sur console)
sendMessage(randomTweet(firstThresholdTweets)) ;

marquer que le premier message de jalon a été envoyé
firstMilestoneMessageSent = true ;
}

Si le temps qu’ils ont été allés est plus long que la seconde
durée de l’étape, puis prendre les mesures voulues
Si (timeAway > secondMilestone & &! secondMilestoneMessageSent) {}
Envoyer le message (que ce soit sur twitter ou sur console)
sendMessage(randomTweet(secondThresholdTweets)) ;

marquer que le deuxième message de jalon a été envoyé
secondMilestoneMessageSent = true ;
}

Si le temps qu’ils ont été allés est plus long que le troisième
durée de l’étape, puis prendre les mesures voulues
Si (timeAway > thirdMilestone & &! thirdMilestoneMessageSent) {}
Envoyer le message (que ce soit sur twitter ou sur console)
sendMessage(randomTweet(thirdThresholdTweets)) ;

marquer que le deuxième message de jalon a été envoyé
thirdMilestoneMessageSent = true ;
}
}

déterminer ce qu’il faut faire lorsque l’utilisateur retourne
void processJustReturnedAlerts(long timeAway) {}
seulement afficher message si ils étaient partis le montant minimal de
temps. Sinon ils étaient probablement juste à la recherche de suite ou grattage
leur visage ou la fixation de leurs cheveux ou... vous l’obtenez
if(timeAway > minimumTime) {}
rapport à la console pendant combien de temps l’utilisateur avait disparu
System.out.println ("l’utilisateur vient de rentrer après:" + timeAway + « milisecondes. ») ;

Envoyer message sur twitter ou sur console
sendMessage (remplacer randomTweet (returnTweets) (« XXX », "" + timeAway/1000)) ;
}

Envoyer un signal au cours de la série de dire l’Arduino qui l’utilisateur
se trouve en face de l’ordinateur
myPort.write('0') ;
}

Choisissez un tweet au hasard dans la collection donnée tweet et
retourner ce message sous forme de chaîne
String randomTweet(ArrayList tweetList) {}
choisir un nombre aléatoire basé sur la longueur de la collection
int tweetIndex = (int) random(tweetList.size()) ;

retourne la chaîne à cet endroit
Return tweetList.get(tweetIndex) ;
}

Envoyer un message sur twitter ou sur console
void sendMessage(String message) {}
Envoyer le message via twitter (en commentaire lors du test)
/ ** Essayez {}
twitter.updateStatus(message) ;
}
{} catch (TwitterException te)
println ("Impossible de se connecter:" + te) ;
};**/

Envoyer un message à la console
System.out.println(message) ;
}

réinitialiser les valeurs booléennes message. Dans le cas contraire, les messages de seuil pourraient seulement
envoyée une fois pendant chaque exécution du programme
void resetMessageBooleans() {}
firstMilestoneMessageSent = false ;
secondMilestoneMessageSent = false ;
thirdMilestoneMessageSent = false ;
}

/**
* Cette méthode recherche seulement les tweets précédentes faites par ce dispositif et
* les imprime sur la console. Il peut être enlevé et tout simplement pas
* appelé et ne changera pas d’autres fonctionnalités de ce programme
**/
void getPreviousTweets() {}
Requête de la requête = new Query("#peeTimer") ;
query.setRpp(100) ; ne fonctionne pas Twitter4j w/plus récent

Essayez de faire la demande de requête.
try {}
la ligne suivante met à jour le statut de twitter
QueryResult résultat = twitter.search(query) ;
Tweets de ArrayList = result.getTweets() (ArrayList) ;

pour (int i = 0; i < tweets.size(); i ++) {}
Statut t = tweets.get(i) (Status) ;
L’utilisateur u = t.getUser() (utilisateur) ;
User String = u.getName() ;
String msg = t.getText() ;
println (« Tweet par » + user + ":" + msg) ;
};
}
{} catch (TwitterException te)
println ("Impossible de se connecter:" + te) ;
};
}
------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------

Arduino
------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------
/**
peetimerArduinoSketch
Développée par Austin Toombs (Courriel : altoombs indiana edu)
Concept par Austin Toombs et Shad Gross
Janvier 2014
**/

variables pour la lecture et de série
char de val ; Données reçues du port série

affectation des broches
int ledPin = 13 ; L’axe de la valeur numérique d’e/s 13
int waterPumpPin = 10 ; Cette broche contrôle effectivement la queue PowerSwitch, tournant sous et hors tension

temps de suivi pour pompe à eau
long previousMillis = 0 ;
offInterval long = 4000 ; Combien de temps nous en avons besoin au large par intervalle
onInterval long = 2000 ; Combien de temps nous en avons besoin sur par intervalle
timeStarted booléen = false ;

suivi de l’état de la pompe à eau
int waterPumpState = faible ;

void setup()
{
pinMode (ledPin, sortie) ; Mettre la broche en sortie
pinMode (waterPumpPin, sortie) ; broche la valeur en sortie
initialiser une communication série à une vitesse de 9600 bauds
Serial.Begin(9600) ;
}

void loop() {}
Si (Serial.available())
{/ / Si les données sont disponibles pour lire,
Val = Serial.read() ; Lisez-le et stockez-la dans le val
}
Si (val == « 1 »)
{/ / Si 1 a été reçu
digitalWrite (ledPin, HIGH) ; allumer la LED

Si la minuterie n’a pas encore démarré, démarrez-le
if(!timeStarted) {timeStarted = true;}

décider quoi faire avec la pompe à eau, basée sur le temps
manageWaterPump() ;
} else {/ / si autre chose qu’un 1 est reçu
digitalWrite (ledPin, basse) ; éteindre la LED
digitalWrite (waterPumpPin, basse) ; éteindre la pompe à eau
timeStarted = false ; désactiver la minuterie
}
Delay(10) ; Attendre 10 millisecondes pour la prochaine lecture
}

décider comment gérer la pompe à eau
void manageWaterPump() {}
le montant actuel du temps qui s’est écoulé depuis que nous avons reçu le 1 en série
unsigned long currentMillis = millis() ;

Si la pompe à eau est déjà hors de
if(waterPumpState == Low) {}
et il a été éteint assez longtemps, puis le tourner il sur
Si (currentMillis - previousMillis > offInterval) {}
enregistrer la dernière fois vous cligna des yeux la LED
previousMillis = currentMillis ;
waterPumpState = élevé ;

Définissez la LED avec la ledState de la variable :
digitalWrite (waterPumpPin, waterPumpState) ;
}
}
la pompe à eau est déjà sur d’autre {//if
et il a été assez longtemps, puis tournant il éteint
Si (currentMillis - previousMillis > onInterval) {}
enregistrer la dernière fois vous cligna des yeux la LED
previousMillis = currentMillis ;
waterPumpState = bas ;

Définissez la LED avec la ledState de la variable :
digitalWrite (waterPumpPin, waterPumpState) ;
}
}
}
------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------