De Pee-Timer: Aansluiten van de Arduino, de Intel perceptuele Computing Camera en een Submersible waterpomp (2 / 4 stap)

Stap 2: programmeren

• Verwerking

• De kant van de verwerking van het programma wordt uitgevoerd in de 32-bits-bewerkingsomgeving voor Windows.
• Het verbindt met de Intel perceptuele Computing Camera en bijgehouden wanneer de gebruiker zit achter de laptop, of wanneer de gebruiker heeft verlaten via de gezichtsherkenning ingebouwd in de camera.
• Het communiceert deze wijzigingen aan de Arduino via een seriële verbinding.
  • We gebruikten de one-way verwerking Arduino seriële verbinding omdat we niet hoefden terug te trekken alle informatie van de Arduino. U kunt andere voorbeelden van seriële verbindingen hier vinden:
  • https://Learn.Sparkfun.com/tutorials/Connecting-AR...
• Het ook posten "gerandomiseerde" berichten om te tjirpen, met behulp van de Twitter API. Deze gerandomiseerde berichten worden uit collecties van berichten die gericht zijn op specifieke situaties of gebeurtenissen, teweeggebracht in de code opgehaald. In ons bijzondere project, we gebruiken het voorbeeld van een programma dat hoe vaak een gebruiker bijgehouden gebruik van het toilet opstaat, en vervolgens de gebruiker chastises als ze te lang zijn verdwenen.
  • Als u wilt werken via Processing verbinden met Twitter, we gebruikten deze handleiding: http://blog.blprnt.com/blog/blprnt/updated-quick-t...
  • U zal waarschijnlijk het nuttig vinden, zoals het loopt u door het proces van het opzetten van de toepassing op Twitter, het genereren van de authenticatie sleutels, enz.

De code voor beide toepassingen vindt u hieronder. Ik heb ook opmerkingen in de code om te helpen u erachter te komen wat er gebeurt voor elke sectie, en waar u zult moeten uw eigen wijzigingen aan te brengen. Naar mijn mening is de code heel moeilijk om te lezen in de indeling Instructables, vooral omdat het graag de tabs verwijderen. Als u kopieert en het Processing of Arduino plakt, zal het automatisch kleurcode eventueel en maken het makkelijker om te navigeren.

Verwerking
------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------
/**
PeeTracker32
Ontwikkeld door Austin Toombs (e-mail: altoombs indiana edu)
Concept door Austin Toombs en Shad bruto
Januari 2014
**/

/ ** importeren bibliotheken enz ** /
importeren van intel.pcsdk.*;
importeren van processing.serial.*;

/ ** Variabelen te initialiseren * /
/ ** Intel perceptuele Computing variabelen ** /
PXCUPipeline sessie;
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 = nieuwe ArrayList();
ArrayList faceBoxes = nieuwe ArrayList();

/ ** Collecties van potentiële tweets voor verious situaties
Als u uw eigen collecties van tekenreeksen te trekken uit maakt, is dit waar u hen kunt initialiseren
**/
ArrayList returnTweets = nieuwe ArrayList();
ArrayList firstThresholdTweets = nieuwe ArrayList();
ArrayList secondThresholdTweets = nieuwe ArrayList();
ArrayList thirdThresholdTweets = nieuwe ArrayList();

/ ** booleans voor Braziliaanse logica binnen het programma ** /
Boole faceState = false; wel of niet een gezicht te zien is
Boole prevFaceState = false; wel of niet een gezicht werd gezien in de vorige

/ ** variabelen voor het integreren met Twitter ** /
Twitter twitter;

/ ** variabelen voor het toezicht op hoe lang de gebruiker is al weg
stelt diverse "mijlpalen" voor terwijl de gebruiker s gegaan. Wij hebben hier 3, maar u kunt
verandert deze gemakkelijk door het toevoegen van meer hier en de rest van de code waar deze mijlpalen
wordt verwezen
**/
lange savedTime;
int minimumTime = 6000; minimale termijn alvorens een bericht te verzenden
int firstMilestone = 30000; eerste mijlpaal voor het verzenden van berichten van shameing
Boole firstMilestoneMessageSent = false; het bijhouden van als we de eerste mijlpaal boodschap
int secondMilestone = 60000; tweede mijlpaal voor het verzenden van berichten van shameing
Boole secondMilestoneMessageSent = false; het bijhouden van als we het tweede mijlpaal bericht verzonden
int thirdMilestone = 90000; derde mijlpaal voor het verzenden van beschamend berichten
Boole thirdMilestoneMessageSent = false; het bijhouden van als we het derde mijlpaal bericht verzonden

/ ** variabelen voor seriële verbinding ** /
Seriële myPort; het object van de seriële poort

VOID Setup
{
instellen van de grootte van het doek
size(640,480);

wekken spiegelbeeld vanuit camera informatie (niet nodig)
rgbTex = createImage(640,480,RGB);

de sessie-informatie voor de Intel perceptuele Computing Camera
sessie = nieuwe PXCUPipeline(this);
sessie. Init (PXCUPipeline.COLOR_VGA| PXCUPipeline.FACE_LOCATION| PXCUPipeline.FACE_LANDMARK);

initialiseren van de verbinding met de Twitter * compleet met verificatie!
U zult moeten uw eigen Twitter toepassing sleutels genereren en bevatten ze hier
ConfigurationBuilder cb = nieuwe ConfigurationBuilder();
cb.setOAuthConsumerKey("XXXXXXXXXXXXXXXXXXXX");
cb.setOAuthConsumerSecret("YYYYYYYYYYYYYYYYYYYYYY");
cb.setOAuthAccessToken("ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ");
cb.setOAuthAccessTokenSecret("XYZYXYZXYZYXYZXZXYZYXYZYXYZYXYZ");

twitter object initialiseren
Twitter = nieuwe TwitterFactory(cb.build()).getInstance();

Dit hoeft niet helemaal worden genoemd, maar is leuk om te zien
commentaar uit voor nu: getPreviousTweets();

initialiseren van de seriële poort en baudrate ingesteld op 9600
myPort = nieuwe Serial (dit, Serial.list() [0], 9600);

initialiseren van de collecties van tweets
initializeTweets();
}

loting standaardfunctie in elk programma van verwerking
VOID draw()
{
Gegevens ophalen uit de camera en de tekening naar de doek / / /
alvorens te spelen met de perceptuele computing camera, moeten we ervoor zorgen dat
het kan eigenlijk dingen zien. Alles in dit als verklaring moet
blijven als-is voor nu. We gebruiken om te bepalen of een gezicht is zelfs binnen
bekijken. Er is waarschijnlijk een eenvoudigere manier om dit te doen, maar wij willen zien van het gezicht
vakken zodat we vertellen kunnen wat het ziet als een gezicht en wat het niet doet
if(Session. AcquireFrame(false))
{
sessie. QueryRGB(rgbTex);
facePts.clear();
faceBoxes.clear();

for (int i = 0; ++ Ik)
{
lang [] ft = nieuwe lange [2];
if(!Session. QueryFaceID(i,ft))
breken;

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

PXCMFaceAnalysis.Landmark.LandmarkData lmark = nieuwe PXCMFaceAnalysis.Landmark.LandmarkData();
voor (int f = 0; f {}
if(Session. QueryFaceLandmarkData ((int) ft [0], faceLabels [f], 0, lmark))
{
facePts.add(lmark.position);
}
}
}
}
sessie. ReleaseFrame();
} //end van gezichtsherkenning als verklaring

Hier wordt weergegeven wat de camera ziet op het canvas
Image(rgbTex,0,0);
pushStyle();
Stroke(255);
noFill();

trekt de gezicht-vakken op het scherm
voor (int f = 0; f {}
PXCMRectU32 faceLoc = (PXCMRectU32)faceBoxes.get(f);
rect(faceLoc.x,faceLoc.y,faceLoc.w,faceLoc.h);
}
Fill(0,255,0);
voor (int g = 0; g {}
PXCMPoint3DF32 facePt = (PXCMPoint3DF32)facePts.get(g);
Ellipse(facePt.x,facePt.y,5,5);
}
popStyle();

Dat is het einde van de tekening spullen / / / /

opslaan van de vorige toestand van het gezicht (voor het bijhouden van doeleinden)
prevFaceState = faceState;

Als we zelfs niet kunt een gezicht helemaal zien
if(faceBoxes.size()==0) {}
faceState = false; We kunnen niet het zien van het gezicht, zodat de gebruiker is er niet

Als ze er een moment geleden, en ze net nu links
if(prevFaceState == True) {}
uitgang dat die camera ziet niet langer een gezicht
System.out.println ("kan niet een gezicht zien, starten timer");

beginnen met het bijhouden van de tijd. Millis() maatregel de tijd in milliseconden
Sinds het begin van het programma
savedTime = millis();

signaal afgeven aan seriële dat we een gezicht niet zien
myPort.write('2');
}

de tijd die de gebruiker is al weg is de huidige tijd in milliseconden
Sinds het begin van het programma min de tijd in milliseconden sinds
de start van het programma wanneer de gebruiker overgelaten.
lange timeAway = millis() - savedTime;

de timeAway informatie gebruiken om te bepalen wanneer om bericht te sturen
processAwayAlerts(timeAway);
}
else {}
Als we zien de gezichten, zijn niet wij hen timing
faceState = true;

Als we een gezicht waar we eerder niet zien, dan weten we
ze net terug
if(prevFaceState == false) {}
berekenen hoe lang de gebruiker zijn gegaan totale
lange timeAway = millis() - savedTime;

processJustReturnedAlerts(timeAway);

resetMessageBooleans();
}
}
einde van de draw methode / / / /
}

instellen naar elk van de collecties van tweets dat kunnen worden gebruikt voor
specifieke situaties
ongeldig initializeTweets() {}
returnTweets.add was ("niet achter zijn Bureau voor XXX seconden");
returnTweets.add ("geplast XXX seconden");
returnTweets.add was ("onproductieve XXX seconden");
returnTweets.add ("kunnen uitstellen voor XXX seconden");
returnTweets.add ("gebluste af voor XXX seconden");
returnTweets.add was ("volledig nutteloos voor XXX seconden");

firstThresholdTweets.add ("is waarschijnlijk plassen nu, dus als je iets nodig hebt snel comprobar");
firstThresholdTweets.add ("is niet achter zijn Bureau voor geruime tijd nu. Niet maak er een gewoonte van dit ");
firstThresholdTweets.add ("will be back soon. Of hij beter worden.");
firstThresholdTweets.add ("niet komen naar de telefoon nu. Tenzij hij het met hem heeft. In de badkamer.");

secondThresholdTweets.add ("... waar ben je? Waarom ben je al weg voor zo lang?");
secondThresholdTweets.add ("wat je nu doet beter worden belangrijke freaking.");
secondThresholdTweets.add ("als u niet gaat om te werken vandaag u misschien net zo goed go home");
secondThresholdTweets.add ("zou hebben een medisch probleem. Het moet niet dit lang duren om te plassen.");

thirdThresholdTweets.add ("duurt eeuwig te plassen. Hij beter snel eindigen of risico weg verspillen van zijn leven");
thirdThresholdTweets.add ("is verspilling van zijn tijd. Iedereen moet druk hem om terug te gaan naar zijn Bureau");
thirdThresholdTweets.add ("we sturen uit de zoektocht. U zijn gegaan te lang.");
thirdThresholdTweets.add is ("niet een model voor hoe u zich dient te gedragen op het werk.");
}

bepalen welke berichten u wilt verzenden en wanneer terwijl de gebruiker is verdwenen
gebaseerd op de tijd dat ze weg zijn
VOID processAwayAlerts(long timeAway) {}
Als de tijd die zij hebben al weg langer dan de minimum is
tijd we maken ons zorgen over, dan schakelt de LED
if(timeAway > minimumTime) {}
myPort.write('1');
}

Als de tijd die zij hebben al weg langer dan de eerste is
tijd van mijlpaal en passende maatregelen nemen
Als (timeAway > firstMilestone & &! firstMilestoneMessageSent) {}
Verzend het bericht (hetzij via twitter of aan console)
sendMessage(randomTweet(firstThresholdTweets));

teken dat de eerste mijlpaal bericht is verstuurd
firstMilestoneMessageSent = true;
}

Als de tijd die zij hebben al weg langer dan de tweede is
tijd van mijlpaal en passende maatregelen nemen
Als (timeAway > secondMilestone & &! secondMilestoneMessageSent) {}
Verzend het bericht (hetzij via twitter of aan console)
sendMessage(randomTweet(secondThresholdTweets));

teken dat de tweede mijlpaal bericht is verstuurd
secondMilestoneMessageSent = true;
}

Als de tijd die zij hebben al weg langer dan de derde is
tijd van mijlpaal en passende maatregelen nemen
Als (timeAway > thirdMilestone & &! thirdMilestoneMessageSent) {}
Verzend het bericht (hetzij via twitter of aan console)
sendMessage(randomTweet(thirdThresholdTweets));

teken dat de tweede mijlpaal bericht is verstuurd
thirdMilestoneMessageSent = true;
}
}

bepalen wat u moet doen wanneer de gebruiker terugkeert
VOID processJustReturnedAlerts(long timeAway) {}
alleen bericht weergeven als zij gegaan waren de minimale hoeveelheid
tijd. Anders waren zij waarschijnlijk gewoon weg op zoek of krassen
hun gezicht of hun haar vaststelling of... krijg je het
if(timeAway > minimumTime) {}
verslag aan de console hoe lang de gebruiker was gegaan
System.out.println ("User net terug na:" + timeAway + "miliseconden.");

Stuur bericht via twitter of via de console
sendMessage (randomTweet (returnTweets) .replace ("XXX", "" + timeAway/1000));
}

een signaal over serieel naar de Arduino te vertellen dat de gebruiker
voorkant van de computer is
myPort.write('0');
}

Kies een willekeurige tweet uit de collectie van bepaalde tweet en
die boodschap als een tekenreeks retourneren
String randomTweet(ArrayList tweetList) {}
Kies een willekeurig getal op basis van de lengte van de collectie
int. tweetIndex = (int) random(tweetList.size());

retourneert de tekenreeks op die locatie
Return tweetList.get(tweetIndex);
}

Stuur een bericht via twitter of aan console
VOID sendMessage(String message) {}
verzenden van het bericht via twitter (commentaar uit tijdens het testen)
/ ** Probeer {}
twitter.updateStatus(message);
}
vangst (TwitterException te) {}
println ("kon geen verbinding maken:" + te);
};**/

Stuur het bericht naar de console
System.out.println(Message);
}

Reset de bericht booleans. Anders kunnen de berichten van de drempel slechts
eenmaal tijdens elke uitvoering van het programma worden verzonden
ongeldig resetMessageBooleans() {}
firstMilestoneMessageSent = false;
secondMilestoneMessageSent = false;
thirdMilestoneMessageSent = false;
}

/**
* Deze methode vindt alleen de eerdere tweets gemaakt door dit apparaat en
* print ze aan de console. Het kan worden verwijderd en gewoon niet
* genoemd en alle andere functies van dit programma zal niet veranderen
**/
ongeldig getPreviousTweets() {}
Query query = nieuwe Query("#peeTimer");
query.setRpp(100); werkt niet w/meest recente Twitter4j

Proberen het maken van de query-verzoek.
Probeer {}
de volgende regel wordt de twitter status bijgewerkt
QueryResult resultaat = twitter.search(query);
ArrayList tweets = (ArrayList) result.getTweets();

for (int i = 0; ik < tweets.size(); i ++) {}
Status t = (Status) tweets.get(i);
Gebruiker u = t.getUser() (gebruiker);
Tekenreeks user = u.getName();
Koord msg = t.getText();
println ("Tweet door" + user + ":" + msg);
};
}
vangst (TwitterException te) {}
println ("kon geen verbinding maken:" + te);
};
}
------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------

Arduino
------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------
/**
peetimerArduinoSketch
Ontwikkeld door Austin Toombs (e-mail: altoombs indiana edu)
Concept door Austin Toombs en Shad bruto
Januari 2014
**/

variabelen voor lezing en naar serieel
char val; Gegevens ontvangen van de seriële poort

Pin-toewijzingen
int ledPin = 13; De PIN-code ingesteld op digitale i/o-13
int waterPumpPin = 10; Deze pin eigenlijk besturingselementen de PowerSwitch staart, draaien in- en uitschakelen

Tijdregistratie voor waterpomp
lange previousMillis = 0;
lange offInterval = 4000; Hoe lang moeten we het af per interval
lange onInterval = 2000; Hoe lang moeten we het op per interval
Boole timeStarted = false;

het bijhouden van de status van de waterpomp
int waterPumpState = laag;

VOID Setup
{
pinMode (ledPin, OUTPUT); Set pin als OUTPUT
pinMode (waterPumpPin, OUTPUT); pincode instellen als OUTPUT
initialiseren van seriële communicatie met een snelheid van 9600 baud
Serial.begin(9600);
}

void loop {}
Als (Serial.available())
{/ / Indien gegevens beschikbaar om te lezen,
Val = Serial.read(); Lees het en sla het in de val
}
Als (val == '1')
{/ / Als 1 werd ontvangen
digitalWrite (ledPin, hoge); de LED inschakelen

Als de timer is niet nog begonnen, starten
if(!timeStarted) {timeStarted = true;}

beslissen wat te doen met de waterpomp, op basis van tijd
manageWaterPump();
} else {/ / als iets anders dan een 1 wordt ontvangen
digitalWrite (ledPin, laag); uitschakelen van de LED
digitalWrite (waterPumpPin, laag); uitschakelen van de waterpomp
timeStarted = false; uitschakelen van de timer
}
delay(10); Wacht 10 milliseconden voor volgende lezing
}

beslissen hoe u het beheren van de waterpomp
ongeldig manageWaterPump() {}
de huidige hoeveelheid tijd die is verstreken sinds we de 1 in seriële ontvangen
unsigned long currentMillis = millis();

Als de waterpomp is al weg
if(waterPumpState == low) {}
en het is al uit lang genoeg, opnieuw in te schakelen het op
Als (currentMillis - previousMillis > offInterval) {}
de laatste tijd u de LED knipperde besparen
previousMillis = currentMillis;
waterPumpState = hoog;

de LED met de ledState van de variabele instellen
digitalWrite (waterPumpPin, waterPumpState);
}
}
else {//if die de waterpomp is al op
en het heeft reeds lang genoeg, opnieuw in te schakelen het uit
Als (currentMillis - previousMillis > onInterval) {}
de laatste tijd u de LED knipperde besparen
previousMillis = currentMillis;
waterPumpState = laag;

de LED met de ledState van de variabele instellen
digitalWrite (waterPumpPin, waterPumpState);
}
}
}
------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------