Voici les étapes à suivre pour arriver à notre état d'avancement.

== Outils nécessaires ==
 
- Arduino Yun :
[[Fichier:IMAG0453.jpg|400px]]
[[Fichier:YunParts.png|400px]]
 
- Kit Grove :
[[Fichier:IMAG0454.jpg|400px]]
 
- Cable d'alimentation :
[[Fichier:IMAG0461.jpg|400px]]
 
- Logiciel Arduino :
[[Fichier:Arduino logiciel.jpg|400px]]
 
- Boitier :
[[Fichier:IMAG0455.jpg|400px]]
[[Fichier:IMAG0457.jpg|400px]]
[[Fichier:IMAG0456.jpg|200px]]
 

== Manipulations ==
 

'''Étape 1 : Matériel'''
 
Nous avons choisi la carte électronique Arduino Yun qui intègre un microcontrôleur afin de pouvoir gérer les interactions entre les capteurs et l'environnement du WatchCare. 
Le kit Grove nous fournit un ensemble de capteurs ainsi qu'une extension de la carte afin d'y connecter les capteurs.

[[Fichier:Grove.jpeg|400px]] 
Cette extension de carte est à brancher directement sur la carte Arduino Yun.
 
Comme affiché, le kit Grove possède des sorties analogiques (jaune), des sorties numériques (rouge) et des sorties séries I2C (vert). 
Parmi les éléments de ce kit, nous utiliserons 2 LEDs, le capteur de mouvement PIR, le microphone et les support à LEDs.
 

'''Étape 2 : Logiciel'''
 
Afin de configurer la carte Arduino Yun, il faut utiliser le logiciel de développement Arduino, à partir de la version 1.5 (nous utilisons personnellement la version 1.6.4). Nous avons fait le choix d'utiliser ce logiciel sous Linux, car sous Windows l'installation nécessite des librairies et pilotes. 
[[Fichier:Arduino logiciel.jpg|300px]] 
C'est dans cette fenêtre que nous taperont le code informatique afin que le système puisse l’exécuter. C'est l'interface entre l'Homme et la machine, elle vérifie, compile et charge le programme sur la carte.
 
La première chose à faire sur le logiciel est de sélectionner le type de carte et le port USB auquel la carte est reliée comme illustré sur ces captures d'écrans.
 
[[Fichier:board.jpg|400px]]
[[Fichier:port.jpg|400px]]
 

'''Étape 3 : Câblage'''
 
Voici le câblage réalisé sur la carte. 
[[Fichier:IMAG0459.jpg|400px]] 
Nous avons relié les supports à LEDs et le capteur de mouvement respectivement sur les ports numériques 2, 3 et 4, ainsi que le microphone sur le port analogique 1. 
Notez que vous devez obstruer la partie inférieure du champ de vision du capteur de mouvement (à l'aide d'un scotch opaque par exemple) afin de servir les besoins de l'algorigramme (voir partie suivante). 
Pour continuer, il faut alimenter la carte en branchant le câble d'alimentation sur le port micro USB.
 

'''Étape 4 : Implémentation du code'''
 
Voici l'algorigramme proposé pour répondre aux exigences du cahier des charges.
 
[[Fichier:Algorigramme WatchCare 2.jpg|400px]] 
Et voici le code adapté à intégrer dans le logiciel de développement Arduino. A noter que ce code ne traite pas de l'intégralité de l'algorigramme, mais plutôt de certaines parties. Concrètement, le code proposé permet de détecter le bruit d'une chute en allumant la LED sur D2, puis détecter un mouvement en allumant la LED sur D3. 
<pre>
#define SOUND_SENSOR A0
#define LED 2
#define THRESHOLD_VALUE 670

//the time we give the sensor to calibrate (10-60 secs according to the datasheet)
int calibrationTime = 10;

//the time when the sensor outputs a low impulse
long unsigned int lowIn;

//the amount of milliseconds the sensor has to be low
//before we assume all motion has stopped
long unsigned int pause = 5000;

int pirPin = 4; //the digital pin connected to the PIR sensor's output
int ledPin = 3;
int ledVerte = 8;

/////////////////////////////
//SETUP
void setup(){
Serial.begin(9600);
pinMode(LED, OUTPUT);
pinMode(SOUND_SENSOR, INPUT);
pinMode(pirPin, INPUT);
pinMode(ledPin, OUTPUT);
pinMode(ledVerte, OUTPUT);
digitalWrite(pirPin, LOW);

//give the sensor some time to calibrate
Serial.print("calibrating sensor ");
for(int i = 0; i < calibrationTime; i++){
Serial.print(".");
delay(1000);
}
Serial.println(" done");
Serial.println("SENSOR ACTIVE");
delay(50);
}

////////////////////////////
//LOOP
void loop(){

digitalWrite(ledVerte, HIGH);//dire systeme allume
int time = 0;

if(chute_detectee())
{
delay(2000); // le temps que la chute soit terminée
while( time < 10 ){
if(mouvement_detectee()){
time=10;
digitalWrite(ledPin, HIGH);
delay(100);
digitalWrite(ledPin, LOW);
}
else{
delay(600);
time ++;
digitalWrite(ledPin, LOW);
}

}
/*else {
digitalWrite(ledPin, LOW);
}*/

}
}
boolean chute_detectee()
{

boolean chute = false;
int sensorValue = analogRead(SOUND_SENSOR);//use A0 to read the electrical signal
Serial.print("sensorValue ");
Serial.println(sensorValue);
if(sensorValue > THRESHOLD_VALUE)
{
chute= true;
turnOnLED();//if the value read from A0 is larger than 670,then light the LED
delay(100);
}
turnOffLED();
return chute;

}

boolean mouvement_detectee()
{

//boolean lockLow = true;
boolean takeLowTime=false;

if(digitalRead(pirPin) == HIGH){
/*digitalWrite(ledPin, HIGH); //the led visualizes the sensors output pin state
if(lockLow){
//makes sure we wait for a transition to LOW before any further output is made:
lockLow = false;
delay(50);
} */
takeLowTime = true;
}

if(digitalRead(pirPin) == LOW){
//digitalWrite(ledPin, LOW); //the led visualizes the sensors output pin state

// if(takeLowTime){
// lowIn = millis(); //save the time of the transition from high to LOW
takeLowTime = false; //make sure this is only done at the start of a LOW phase
//}
//if the sensor is low for more than the given pause,
//we assume that no more motion is going to happen
/* if(!lockLow && millis() - lowIn > pause){
//makes sure this block of code is only executed again after
//a new motion sequence has been detected
lockLow = true;
Serial.print("motion ended at "); //output
Serial.print((millis() - pause)/1000);
Serial.println(" sec");
delay(50);
}*/
}

return takeLowTime;
}

void turnOnLED()
{
digitalWrite(LED,HIGH);
}
void turnOffLED()
{
digitalWrite(LED,LOW);
}
</pre>
 
Une fois le code tapé, il faut le compiler en cliquant sur "verify" en haut à gauche, puis il faut importer le programme en cliquant sur "upload" en haut à gauche comme l'illustre ces captures d'écran.
 
[[Fichier:Verify.png|400px]]
[[Fichier:Upload.png|400px]]
 

'''Étape 5 : Assemblage du boitier'''
 
Il y a plusieurs règles à pendre en compte: 
- Faire deux trous pour les LEDs de batterie faible et d'état de marche, 
- Faire des trous plus petits au niveau du capteur de son, 
- Faire en sorte que le capteur de mouvement soit à l'extérieur du boitier, 
- Choisir des dimensions suffisantes pour que la carte Arduino rentre dans le boitier. 
 
[[Fichier:IMAG0462.jpg|400px]]
[[Fichier:IMAG0463.jpg|400px]]
[[Fichier:IMAG0464.jpg|400px]]

Fichier:IMAG0464.jpg

2015-05-12T08:25:28Z

Remi :

2015-05-12T07:34:36Z

Remi :

Instructable WatchCare

2015-05-11T16:44:17Z

Remi :

Voici les étapes à suivre pour arriver à notre état d'avancement.

== Outils nécessaires ==
 
- Arduino Yun :
[[Fichier:IMAG0453.jpg|400px]]
[[Fichier:YunParts.png|400px]]
 
- Kit Grove :
[[Fichier:IMAG0454.jpg|400px]]
 
- Cable d'alimentation :
[[Fichier:IMAG0461.jpg|400px]]
 
- Logiciel Arduino :
[[Fichier:Arduino logiciel.jpg|400px]]
 
- Boitier :
[[Fichier:IMAG0455.jpg|400px]]
[[Fichier:IMAG0457.jpg|400px]]
[[Fichier:IMAG0456.jpg|200px]]
 

== Manipulations ==
 

'''Étape 1 : Matériel'''
 
Nous avons choisi la carte électronique Arduino Yun qui intègre un microcontrôleur afin de pouvoir gérer les interactions entre les capteurs et l'environnement du WatchCare.
Le kit Grove nous fournit un ensemble de capteurs ainsi qu'une extension de la carte afin d'y connecter les capteurs.

[[Fichier:Grove.jpeg|400px]] 
Cette extension de carte est à brancher directement sur la carte Arduino Yun.
 
Comme affiché, le kit Grove possède des sorties analogiques (jaune), des sorties numériques (rouge) et des sorties séries I2C (vert).
Parmi les éléments de ce kit, nous utiliserons 2 leds, le capteur de mouvement PIR, et les support à leds.
 

'''Étape 2 : Logiciel'''
 
Afin de configurer la carte Arduino Yun, il faut utiliser le logiciel de développement Arduino, à partir de la version 1.5 (nous utilisons personnellement la version 1.6.4). Nous avons fait le choix d'utiliser ce logiciel sous Linux, car sous Windows l'installation nécessite des librairies et pilotes. 
[[Fichier:Arduino logiciel.jpg|300px]] 
C'est dans cette fenêtre que nous taperont le code informatique afin que le système puisse l’exécuter. C'est l'interface entre l'Homme et la machine, elle vérifie, compile et charge le programme sur la carte.
 
La première chose à faire sur le logiciel est de sélectionner le type de carte et le port USB auquel la carte est reliée comme illustré sur ces captures d'écrans.
 
[[Fichier:board.jpg|400px]]
[[Fichier:port.jpg|400px]]
 

'''Étape 3 : Câblage'''
 
Voici le câblage réalisé sur la carte. 
[[Fichier:IMAG0460.jpg|400px]] 
Nous avons relié les supports à leds et le capteur de mouvement respectivement sur les sorties numériques 2, 3 et 4. 
Pour continuer, il faut alimenter la carte en branchant le câble d'alimentation sur le port micro USB.
 

'''Étape 4 : Implémentation du code'''
 
Voici l'algorigramme proposé pour répondre aux exigences du cahier des charges.
 
[[Fichier:Algorigramme WatchCare 2.jpg|400px]] 
Et voici le code adapté à intégrer dans le logiciel de développement Arduino. A noter que ce code ne traite pas de l'intégralité de l'algorigramme, mais plutôt de certaines parties. Concrètement, le code proposé permet de détecter le bruit d'une chute en allumant la led sur D2, puis détecter un mouvement en allumant la led sur D3. 
<pre>
#define SOUND_SENSOR A0
#define LED 2
#define THRESHOLD_VALUE 670

//the time we give the sensor to calibrate (10-60 secs according to the datasheet)
int calibrationTime = 10;

//the time when the sensor outputs a low impulse
long unsigned int lowIn;

//the amount of milliseconds the sensor has to be low
//before we assume all motion has stopped
long unsigned int pause = 5000;

int pirPin = 4; //the digital pin connected to the PIR sensor's output
int ledPin = 3;
int ledVerte = 8;

/////////////////////////////
//SETUP
void setup(){
Serial.begin(9600);
pinMode(LED, OUTPUT);
pinMode(SOUND_SENSOR, INPUT);
pinMode(pirPin, INPUT);
pinMode(ledPin, OUTPUT);
pinMode(ledVerte, OUTPUT);
digitalWrite(pirPin, LOW);

//give the sensor some time to calibrate
Serial.print("calibrating sensor ");
for(int i = 0; i < calibrationTime; i++){
Serial.print(".");
delay(1000);
}
Serial.println(" done");
Serial.println("SENSOR ACTIVE");
delay(50);
}

////////////////////////////
//LOOP
void loop(){

digitalWrite(ledVerte, HIGH);//dire systeme allume
int time = 0;

if(chute_detectee())
{
delay(2000); // le temps que la chute soit terminée
while( time < 10 ){
if(mouvement_detectee()){
time=10;
digitalWrite(ledPin, HIGH);
delay(100);
digitalWrite(ledPin, LOW);
}
else{
delay(600);
time ++;
digitalWrite(ledPin, LOW);
}

}
/*else {
digitalWrite(ledPin, LOW);
}*/

}
}
boolean chute_detectee()
{

boolean chute = false;
int sensorValue = analogRead(SOUND_SENSOR);//use A0 to read the electrical signal
Serial.print("sensorValue ");
Serial.println(sensorValue);
if(sensorValue > THRESHOLD_VALUE)
{
chute= true;
turnOnLED();//if the value read from A0 is larger than 670,then light the LED
delay(100);
}
turnOffLED();
return chute;

}

boolean mouvement_detectee()
{

//boolean lockLow = true;
boolean takeLowTime=false;

if(digitalRead(pirPin) == HIGH){
/*digitalWrite(ledPin, HIGH); //the led visualizes the sensors output pin state
if(lockLow){
//makes sure we wait for a transition to LOW before any further output is made:
lockLow = false;
delay(50);
} */
takeLowTime = true;
}

if(digitalRead(pirPin) == LOW){
//digitalWrite(ledPin, LOW); //the led visualizes the sensors output pin state

// if(takeLowTime){
// lowIn = millis(); //save the time of the transition from high to LOW
takeLowTime = false; //make sure this is only done at the start of a LOW phase
//}
//if the sensor is low for more than the given pause,
//we assume that no more motion is going to happen
/* if(!lockLow && millis() - lowIn > pause){
//makes sure this block of code is only executed again after
//a new motion sequence has been detected
lockLow = true;
Serial.print("motion ended at "); //output
Serial.print((millis() - pause)/1000);
Serial.println(" sec");
delay(50);
}*/
}

return takeLowTime;
}

void turnOnLED()
{
digitalWrite(LED,HIGH);
}
void turnOffLED()
{
digitalWrite(LED,LOW);
}
</pre>
 
Une fois le code tapé, il faut le compiler en cliquant sur "verify" en haut à gauche, puis il faut importer le programme en cliquant sur "upload" en haut à gauche comme l'illustre ces captures d'écran.
 
[[Fichier:Verify.png|400px]]
[[Fichier:Upload.png|400px]]
 

'''Étape 5 : Assemblage du boitier'''

Instructable WatchCare

2015-05-11T16:43:51Z

Remi :

Voici les étapes à suivre pour arriver à notre état d'avancement.

== Outils nécessaires ==
 
- Arduino Yun :
[[Fichier:IMAG0453.jpg|400px]]
[[Fichier:YunParts.png|400px]]
 
- Kit Grove :
[[Fichier:IMAG0454.jpg|400px]]
 
- Cable d'alimentation :
[[Fichier:IMAG0461.jpg|400px]]
 
- Logiciel Arduino :
[[Fichier:Arduino logiciel.jpg|400px]]
 
- Boitier :
[[Fichier:IMAG0455.jpg|400px]]
[[Fichier:IMAG0457.jpg|400px]]
[[Fichier:IMAG0456.jpg|200px]]
 

== Manipulations ==
 

'''Étape 1 : Matériel'''
 
Nous avons choisi la carte électronique Arduino Yun qui intègre un microcontrôleur afin de pouvoir gérer les interactions entre les capteurs et l'environnement du WatchCare.
Le kit Grove nous fournit un ensemble de capteurs ainsi qu'une extension de la carte afin d'y connecter les capteurs.

[[Fichier:Grove.jpeg|400px]] 
Cette extension de carte est à brancher directement sur la carte Arduino Yun.
 
Comme affiché, le kit Grove possède des sorties analogiques (jaune), des sorties numériques (rouge) et des sorties séries I2C (vert).
Parmi les éléments de ce kit, nous utiliserons 2 leds, le capteur de mouvement PIR, et les support à leds.
 

'''Étape 2 : Logiciel'''
 
Afin de configurer la carte Arduino Yun, il faut utiliser le logiciel de développement Arduino, à partir de la version 1.5 (nous utilisons personnellement la version 1.6.4). Nous avons fait le choix d'utiliser ce logiciel sous Linux, car sous Windows l'installation nécessite des librairies et pilotes. 
[[Fichier:Arduino logiciel.jpg|300px]] 
C'est dans cette fenêtre que nous taperont le code informatique afin que le système puisse l’exécuter. C'est l'interface entre l'Homme et la machine, elle vérifie, compile et charge le programme sur la carte.
 
La première chose à faire sur le logiciel est de sélectionner le type de carte et le port USB auquel la carte est reliée comme illustré sur ces captures d'écrans.
 
[[Fichier:board.jpg|400px]]
[[Fichier:port.jpg|400px]]
 

'''Étape 3 : Câblage'''
 
Voici le câblage réalisé sur la carte. 
[[Fichier:IMAG0460.jpg|400px]] 
Nous avons relié les supports à leds et le capteur de mouvement respectivement sur les sorties numériques 2, 3 et 4. 
Pour continuer, il faut alimenter la carte en branchant le câble d'alimentation sur le port micro USB.
 

'''Étape 4 : Implémentation du code'''
 
Voici l'algorigramme proposé pour répondre aux exigences du cahier des charges.
 
[[Fichier:Algorigramme WatchCare 2.jpg|400px]] 
Et voici le code adapté à intégrer dans le logiciel de développement Arduino. A noter que ce code ne traite pas de l'intégralité de l'algorigramme, mais plutôt de certaines parties. Concrètement, le code proposé permet de détecter le bruit d'une chute en allumant la led sur D2, puis détecter un mouvement en allumant la led sur D3. 
<pre>
#define SOUND_SENSOR A0
#define LED 2
#define THRESHOLD_VALUE 670

//the time we give the sensor to calibrate (10-60 secs according to the datasheet)
int calibrationTime = 10;

//the time when the sensor outputs a low impulse
long unsigned int lowIn;

//the amount of milliseconds the sensor has to be low
//before we assume all motion has stopped
long unsigned int pause = 5000;

int pirPin = 4; //the digital pin connected to the PIR sensor's output
int ledPin = 3;
int ledVerte = 8;

/////////////////////////////
//SETUP
void setup(){
Serial.begin(9600);
pinMode(LED, OUTPUT);
pinMode(SOUND_SENSOR, INPUT);
pinMode(pirPin, INPUT);
pinMode(ledPin, OUTPUT);
pinMode(ledVerte, OUTPUT);
digitalWrite(pirPin, LOW);

//give the sensor some time to calibrate
Serial.print("calibrating sensor ");
for(int i = 0; i < calibrationTime; i++){
Serial.print(".");
delay(1000);
}
Serial.println(" done");
Serial.println("SENSOR ACTIVE");
delay(50);
}

////////////////////////////
//LOOP
void loop(){

digitalWrite(ledVerte, HIGH);//dire systeme allume
int time = 0;

if(chute_detectee())
{
delay(2000); // le temps que la chute soit terminée
while( time < 10 ){
if(mouvement_detectee()){
time=10;
digitalWrite(ledPin, HIGH);
delay(100);
digitalWrite(ledPin, LOW);
}
else{
delay(600);
time ++;
digitalWrite(ledPin, LOW);
}

}
/*else {
digitalWrite(ledPin, LOW);
}*/

}
}
boolean chute_detectee()
{

boolean chute = false;
int sensorValue = analogRead(SOUND_SENSOR);//use A0 to read the electrical signal
Serial.print("sensorValue ");
Serial.println(sensorValue);
if(sensorValue > THRESHOLD_VALUE)
{
chute= true;
turnOnLED();//if the value read from A0 is larger than 670,then light the LED
delay(100);
}
turnOffLED();
return chute;

}

boolean mouvement_detectee()
{

//boolean lockLow = true;
boolean takeLowTime=false;

if(digitalRead(pirPin) == HIGH){
/*digitalWrite(ledPin, HIGH); //the led visualizes the sensors output pin state
if(lockLow){
//makes sure we wait for a transition to LOW before any further output is made:
lockLow = false;
delay(50);
} */
takeLowTime = true;
}

if(digitalRead(pirPin) == LOW){
//digitalWrite(ledPin, LOW); //the led visualizes the sensors output pin state

// if(takeLowTime){
// lowIn = millis(); //save the time of the transition from high to LOW
takeLowTime = false; //make sure this is only done at the start of a LOW phase
//}
//if the sensor is low for more than the given pause,
//we assume that no more motion is going to happen
/* if(!lockLow && millis() - lowIn > pause){
//makes sure this block of code is only executed again after
//a new motion sequence has been detected
lockLow = true;
Serial.print("motion ended at "); //output
Serial.print((millis() - pause)/1000);
Serial.println(" sec");
delay(50);
}*/
}

return takeLowTime;
}

void turnOnLED()
{
digitalWrite(LED,HIGH);
}
void turnOffLED()
{
digitalWrite(LED,LOW);
}
</pre>
 
Une fois le code tapé, il faut le compiler en cliquant sur "verify" en haut à gauche, puis il faut importer le programme en cliquant sur "upload" en haut à gauche comme l'illustre ces captures d'écran.
 
[[Fichier:Verify.png|400px]]
[[Fichier:Upload.png|400px]]
 

'''Étape 5 : Assemblage du boitier'''

Instructable WatchCare

2015-05-11T16:42:10Z

Remi : /* Manipulations */

Voici les étapes à suivre pour arriver à notre état d'avancement.

== Outils nécessaires ==
 
- Arduino Yun :
[[Fichier:IMAG0453.jpg|400px]]
[[Fichier:YunParts.png|400px]]
 
- Kit Grove :
[[Fichier:IMAG0454.jpg|400px]]
 
- Cable d'alimentation :
[[Fichier:IMAG0461.jpg|400px]]
 
- Logiciel Arduino :
[[Fichier:Arduino logiciel.jpg|400px]]
 
- Boitier :
[[Fichier:IMAG0455.jpg|400px]]
[[Fichier:IMAG0457.jpg|400px]]
[[Fichier:IMAG0456.jpg|200px]]
 

== Manipulations ==
 

'''Étape 1 : Matériel'''
 
Nous avons choisi la carte électronique Arduino Yun qui intègre un microcontrôleur afin de pouvoir gérer les interactions entre les capteurs et l'environnement du WatchCare.
Le kit Grove nous fournit un ensemble de capteurs ainsi qu'une extension de la carte afin d'y connecter les capteurs.

[[Fichier:Grove.jpeg|400px]] 
Cette extension de carte est à brancher directement sur la carte Arduino Yun.
 
Comme affiché, le kit Grove possède des sorties analogiques (jaune), des sorties numériques (rouge) et des sorties séries I2C (vert).
Parmi les éléments de ce kit, nous utiliserons 2 leds, le capteur de mouvement PIR, et les support à leds.
 

'''Étape 2 : Logiciel'''
 
Afin de configurer la carte Arduino Yun, il faut utiliser le logiciel de développement Arduino, à partir de la version 1.5 (nous utilisons personnellement la version 1.6.4). Nous avons fait le choix d'utiliser ce logiciel sous Linux, car sous Windows l'installation nécessite des librairies et pilotes. 
[[Fichier:Arduino logiciel.jpg|300px]] 
C'est dans cette fenêtre que nous taperont le code informatique afin que le système puisse l’exécuter. C'est l'interface entre l'Homme et la machine, elle vérifie, compile et charge le programme sur la carte.
 
La première chose à faire sur le logiciel est de sélectionner le type de carte et le port USB auquel la carte est reliée comme illustré sur ces captures d'écrans.
 
[[Fichier:board.jpg|400px]]
[[Fichier:port.jpg|400px]]
 

'''Étape 3 : Câblage'''
 
Voici le câblage réalisé sur la carte. 
[[Fichier:IMAG0460.jpg|400px]] 
Nous avons relié les supports à leds et le capteur de mouvement respectivement sur les sorties numériques 2, 3 et 4. 
Pour continuer, il faut alimenter la carte en branchant le câble d'alimentation sur le port micro USB.
 

'''Étape 4 : Implémentation du code'''
 
Voici l'algorigramme proposé pour répondre aux exigences du cahier des charges.
 
[[Fichier:Algorigramme WatchCare 2.jpg|400px]] 
Et voici le code adapté à intégrer dans le logiciel de développement Arduino. A noter que ce code ne traite pas de l'intégralité de l'algorigramme, mais plutôt de certaines parties. Concrètement, le code proposé permet de détecter le bruit d'une chute en allumant la led sur D2, puis détecter un mouvement en allumant la led sur D3. 
<pre>
#define SOUND_SENSOR A0
#define LED 2
#define THRESHOLD_VALUE 670

//the time we give the sensor to calibrate (10-60 secs according to the datasheet)
int calibrationTime = 10;

//the time when the sensor outputs a low impulse
long unsigned int lowIn;

//the amount of milliseconds the sensor has to be low
//before we assume all motion has stopped
long unsigned int pause = 5000;

int pirPin = 4; //the digital pin connected to the PIR sensor's output
int ledPin = 3;
int ledVerte = 8;

/////////////////////////////
//SETUP
void setup(){
Serial.begin(9600);
pinMode(LED, OUTPUT);
pinMode(SOUND_SENSOR, INPUT);
pinMode(pirPin, INPUT);
pinMode(ledPin, OUTPUT);
pinMode(ledVerte, OUTPUT);
digitalWrite(pirPin, LOW);

//give the sensor some time to calibrate
Serial.print("calibrating sensor ");
for(int i = 0; i < calibrationTime; i++){
Serial.print(".");
delay(1000);
}
Serial.println(" done");
Serial.println("SENSOR ACTIVE");
delay(50);
}

////////////////////////////
//LOOP
void loop(){

digitalWrite(ledVerte, HIGH);//dire systeme allume
int time = 0;

if(chute_detectee())
{
delay(2000); // le temps que la chute soit terminée
while( time < 10 ){
if(mouvement_detectee()){
time=10;
digitalWrite(ledPin, HIGH);
delay(100);
digitalWrite(ledPin, LOW);
}
else{
delay(600);
time ++;
digitalWrite(ledPin, LOW);
}

}
/*else {
digitalWrite(ledPin, LOW);
}*/

}
}
boolean chute_detectee()
{

boolean chute = false;
int sensorValue = analogRead(SOUND_SENSOR);//use A0 to read the electrical signal
Serial.print("sensorValue ");
Serial.println(sensorValue);
if(sensorValue > THRESHOLD_VALUE)
{
chute= true;
turnOnLED();//if the value read from A0 is larger than 670,then light the LED
delay(100);
}
turnOffLED();
return chute;

}

boolean mouvement_detectee()
{

//boolean lockLow = true;
boolean takeLowTime=false;

if(digitalRead(pirPin) == HIGH){
/*digitalWrite(ledPin, HIGH); //the led visualizes the sensors output pin state
if(lockLow){
//makes sure we wait for a transition to LOW before any further output is made:
lockLow = false;
delay(50);
} */
takeLowTime = true;
}

if(digitalRead(pirPin) == LOW){
//digitalWrite(ledPin, LOW); //the led visualizes the sensors output pin state

// if(takeLowTime){
// lowIn = millis(); //save the time of the transition from high to LOW
takeLowTime = false; //make sure this is only done at the start of a LOW phase
//}
//if the sensor is low for more than the given pause,
//we assume that no more motion is going to happen
/* if(!lockLow && millis() - lowIn > pause){
//makes sure this block of code is only executed again after
//a new motion sequence has been detected
lockLow = true;
Serial.print("motion ended at "); //output
Serial.print((millis() - pause)/1000);
Serial.println(" sec");
delay(50);
}*/
}

return takeLowTime;
}

void turnOnLED()
{
digitalWrite(LED,HIGH);
}
void turnOffLED()
{
digitalWrite(LED,LOW);
}
</pre>
 
Une fois le code tapé, il faut le compiler en cliquant sur "verify" en haut à gauche, puis il faut importer le programme en cliquant sur "upload" en haut à gauche comme l'illustre ces captures d'écran.
 
[[Fichier:Verify.jpg|400px]]
[[Fichier:Upload.jpg|400px]]
 

'''Étape 5 : Assemblage du boitier'''

Fichier:Upload.png

2015-05-11T16:41:34Z

Remi :

2015-05-11T16:34:00Z

Remi :

Fichier:Board.jpg

2015-05-11T16:33:48Z

Remi :

Instructable WatchCare

2015-05-11T16:04:06Z

Remi :

Voici les étapes à suivre pour arriver à notre état d'avancement.

== Outils nécessaires ==
 
- Arduino Yun :
[[Fichier:IMAG0453.jpg|400px]]
[[Fichier:YunParts.png|400px]]
 
- Kit Grove :
[[Fichier:IMAG0454.jpg|400px]]
 
- Cable d'alimentation :
[[Fichier:IMAG0461.jpg|400px]]
 
- Logiciel Arduino :
[[Fichier:Arduino logiciel.jpg|400px]]
 
- Boitier :
[[Fichier:IMAG0455.jpg|400px]]
[[Fichier:IMAG0457.jpg|400px]]
[[Fichier:IMAG0456.jpg|200px]]
 

== Manipulations ==
 

'''Étape 1 : Matériel'''
 
Nous avons choisi la carte électronique Arduino Yun qui intègre un microcontrôleur afin de pouvoir gérer les interactions entre les capteurs et l'environnement du WatchCare.
Le kit Grove nous fournit un ensemble de capteurs ainsi qu'une extension de la carte afin d'y connecter les capteurs.

[[Fichier:Grove.jpeg|400px]] 
Cette extension de carte est à brancher directement sur la carte Arduino Yun.
 
Comme affiché, le kit Grove possède des sorties analogiques (jaune), des sorties numériques (rouge) et des sorties séries I2C (vert).
Parmi les éléments de ce kit, nous utiliserons 2 leds, le capteur de mouvement PIR, et les support à leds.
 

'''Étape 2 : Logiciel'''
 
Afin de configurer la carte Arduino Yun, il faut utiliser le logiciel de développement Arduino, à partir de la version 1.5 (nous utilisons personnellement la version 1.6.4). Nous avons fait le choix d'utiliser ce logiciel sous Linux, car sous Windows l'installation nécessite des librairies et pilotes. 
[[Fichier:Arduino logiciel.jpg|300px]] 
C'est dans cette fenêtre que nous taperont le code informatique afin que le système puisse l’exécuter. C'est l'interface entre l'Homme et la machine, elle vérifie, compile et charge le programme sur la carte.
 

'''Étape 3 : Câblage'''
 
Voici le câblage réalisé sur la carte. 
[[Fichier:IMAG0460.jpg|400px]] 
Nous avons relié les supports à leds et le capteur de mouvement respectivement sur les sorties numériques 2, 3 et 4. 
Pour continuer, il faut alimenter la carte en branchant le câble d'alimentation sur le port micro USB.
 

'''Étape 4 : Implémentation du code'''
 
Voici l'algorigramme proposé pour répondre aux exigences du cahier des charges.
 
[[Fichier:Algorigramme WatchCare 2.jpg|400px]] 
Et voici le code adapté à intégrer dans le logiciel de développement Arduino. A noter que ce code ne traite pas de l'intégralité de l'algorigramme, mais plutôt de certaines parties. Concrètement, le code proposé permet de détecter le bruit d'une chute en allumant la led sur D2, puis détecter un mouvement en allumant la led sur D3. 
<pre>
#define SOUND_SENSOR A0
#define LED 2
#define THRESHOLD_VALUE 670

//the time we give the sensor to calibrate (10-60 secs according to the datasheet)
int calibrationTime = 10;

//the time when the sensor outputs a low impulse
long unsigned int lowIn;

//the amount of milliseconds the sensor has to be low
//before we assume all motion has stopped
long unsigned int pause = 5000;

int pirPin = 4; //the digital pin connected to the PIR sensor's output
int ledPin = 3;
int ledVerte = 8;

/////////////////////////////
//SETUP
void setup(){
Serial.begin(9600);
pinMode(LED, OUTPUT);
pinMode(SOUND_SENSOR, INPUT);
pinMode(pirPin, INPUT);
pinMode(ledPin, OUTPUT);
pinMode(ledVerte, OUTPUT);
digitalWrite(pirPin, LOW);

//give the sensor some time to calibrate
Serial.print("calibrating sensor ");
for(int i = 0; i < calibrationTime; i++){
Serial.print(".");
delay(1000);
}
Serial.println(" done");
Serial.println("SENSOR ACTIVE");
delay(50);
}

////////////////////////////
//LOOP
void loop(){

digitalWrite(ledVerte, HIGH);//dire systeme allume
int time = 0;

if(chute_detectee())
{
delay(2000); // le temps que la chute soit terminée
while( time < 10 ){
if(mouvement_detectee()){
time=10;
digitalWrite(ledPin, HIGH);
delay(100);
digitalWrite(ledPin, LOW);
}
else{
delay(600);
time ++;
digitalWrite(ledPin, LOW);
}

}
/*else {
digitalWrite(ledPin, LOW);
}*/

}
}
boolean chute_detectee()
{

boolean chute = false;
int sensorValue = analogRead(SOUND_SENSOR);//use A0 to read the electrical signal
Serial.print("sensorValue ");
Serial.println(sensorValue);
if(sensorValue > THRESHOLD_VALUE)
{
chute= true;
turnOnLED();//if the value read from A0 is larger than 670,then light the LED
delay(100);
}
turnOffLED();
return chute;

}

boolean mouvement_detectee()
{

//boolean lockLow = true;
boolean takeLowTime=false;

if(digitalRead(pirPin) == HIGH){
/*digitalWrite(ledPin, HIGH); //the led visualizes the sensors output pin state
if(lockLow){
//makes sure we wait for a transition to LOW before any further output is made:
lockLow = false;
delay(50);
} */
takeLowTime = true;
}

if(digitalRead(pirPin) == LOW){
//digitalWrite(ledPin, LOW); //the led visualizes the sensors output pin state

// if(takeLowTime){
// lowIn = millis(); //save the time of the transition from high to LOW
takeLowTime = false; //make sure this is only done at the start of a LOW phase
//}
//if the sensor is low for more than the given pause,
//we assume that no more motion is going to happen
/* if(!lockLow && millis() - lowIn > pause){
//makes sure this block of code is only executed again after
//a new motion sequence has been detected
lockLow = true;
Serial.print("motion ended at "); //output
Serial.print((millis() - pause)/1000);
Serial.println(" sec");
delay(50);
}*/
}

return takeLowTime;
}

void turnOnLED()
{
digitalWrite(LED,HIGH);
}
void turnOffLED()
{
digitalWrite(LED,LOW);
}
</pre>

'''Étape 5 : Assemblage du boitier'''