Version actuelle datée du 15 juin 2018 à 21:44

Présentation générale

Description

Notre objectif est créer un bijou de type collier combinant art et jeu de lumières réalisé avec des LED. C’est-à-dire il faut ajouter une dimension dynamique, des capteurs pour remonter température et rythme cardiaque et harmoniser l'animation lumineuse et l'humeur du porteur. Pas seulement ça, les LED peuvent être contrôlées par un circuit basé sur un microcontrôleur, et la forme du circuit et le placement des composants doit être étudié pour s'intégrer artistiquement

Objectifs

Créer un bijou de type collier combinant art et jeu de lumières réalisé avec des LEDs.

Analyse du projet

Positionnement par rapport à l'existant

Maintenant, on a trouvé certains produits composant des LEDS. Mais il n'y pas ni de capteurs de température ni de capteurs de rythme cardiaque.

Analyse du concurrent

Bague lumineuse à LED clignotante en silicone

• Effet puissant et couleurs changeantes
• Couleurs Assorties
• Pile incluse
• Bouton on/off
• Durer de vie de la pile 20 h (changeable)

Site de la bague

La robe LED

• Télécommande robe LED Vêtements lumineux à LED Robe de mariée Mode double couche robe.
• Utilisez la télécommande pour changer les couleurs de LED : Batterie rechargeable.
• Cette robe lumineuse peut être utilisé à la fois dans la nuit de noce ou en plein jour fête de mariage. En une nuit splendide, il vous fait d'être le centre d'attention!

Site de la robe

Collier en or LED

• Collier ras du cou sur support métallique.
• Alimenté par une batterie rechargeable, il peut rester allumé du crépuscule à l’aube.
• Alumé ou éteint, il est magnifique de jour comme de nuit.
• Mini câble de charge USB inclut - batterie rechargeable minuscule.

led&ref=sr_gallery_2 Site du collier

Scénario d'usage du produit ou du concept envisagé

S’il y a une personne qui a notre produit, quand il participe une fête, il va être plus joli. Le collier va changer la luminance selon le changement de température de corps et le rythme de radique. Ce collier a plusieurs couleurs et plusieurs façons d’allumer. Donc ça va être super charment.

Si les jeunes voudraient donner un gâteau pour ses grand-parents, ce collier va être un gâteau parfait, particulièrement pour la grand-mère. Ce collier pourrait surveiller la santé tout le temps. Pace qu’il y a un capteur de température et un capteur de radique pour tester la température de corps et le rythme de radique. Les changements peuvent être trouvé par le changement de brillance de LED.

Notre collier aussi peut être utilisé pour vérifier si quelqu’un ment. Parce que si quelqu’un ment, son rythme de cœur va changer. Donc ce sera facile de trouver.

Le design de collier

Réponse à la question difficile

On a également optimisé le modèle, en utilisant la transmission Bluetooth entre le capteur et le contrôleur, afin d'atteindre l'objectif de la connectivité sans fil.

REX : Pas convaincu. Comment allez-vous implanter Bluetooth sur le capteur et sur le circuit du collier ?

Préparation du projet

Cahier des charges

Choix techniques : matériel et logiciel

Afin de porter pratique, l'ensemble des bijoux ne devrait pas être trop lourd, la puissance ne devrait pas être trop grande. En raison de ça, on a choisi des capteurs légers, des piles bouton et des LED qui ont bonne performance thermique. On a également optimisé le modèle, en utilisant la transmission Bluetooth entre le capteur et le contrôleur, afin d'atteindre l'objectif de la connectivité sans fil.

   32xLED CMS orange 
   32xLED CMS bleu 
   32xLED CMS vert 
   32xLED CMS jaune 
   1xArduino UNO & 1xAtmega328p 
   1xDS18B20
   1xBreadboard 
   1xPulsesensor 
   3xpiles de boutons de 3V 
   1xfil de fer 
   1xinterrupteur bascule
   1xtoile

Type de LED

Le courant de chaque LED cylindrique à bout arrondi est habituellement inferieur de soixante milliampère, donc la puissance n’est pas grand, son consommation d'énergie est faible, il a bonne performance thermique. Le courant de chaque LED CMS est environ de cinq milliampère à mille milliampère, donc son puissance est de zéro zéro six watt à un watt, la consommation d’énergie est plus petite que l’autre, et de plus, grace à sa forme, elle plus comfort pour le peau. En résumé, on a décidé de choisir LED SMD pour construire notre bijou. Et afin de réaliser la partie principale du collier ne comporterait pas de circuit, on veut utiliser les fils pour souder tous les LEDs.

Capteurs

En raison du sujet nous dit que le collier peut aussi comporter des capteurs à même la peau pour remonter température et rythme cardiaque et harmoniser l'animation lumineuse et l'humeur du porteur. Comme le collier devrait être porté autour du cou, donc nos capteurs doivent être petits et légers.

Capteur de rythme cardiaque

On sait qu’il y a trois méthodes pour tester la fréquence cardiaque : Premièrement, extrait du signal optique ; deuxièmement, l'utilisation de capteurs de pression pour mesurer le pouls ; troisièmement, la méthode du volume photoélectrique. A cause de les deux premières méthodes sont sensibles aux perturbations du mouvement, donc on a décidé d’utiliser la capteur Pulsesensor, qui est capteur analogique à réflexion photoélectrique pour la mesure la fréquence cardiaque. On veut le mettre près de l'artère carotide, mais si le pouls de l'artère carotide est si faible qu'il ne peut pas être détecté, on veut le serrer sur le lobe de l'oreille.

Capteur de température

Pour mesurer la température, on a choisi DS18B20 CMS qui possède une résolution numérique de 12 bits avec une plage de mesure de moins cinquante-cinq dégrée à cent vingt-cinq dégrée. La précision analogique du capteur est de zéro cinq dégrée entre moins dix dégrée et quatre-vingt cinq dégrée, ce qui rend ce capteur très intéressant pour une utilisation "normale". Et le schéma du montage de pulsesensor est comme ça, il est lié directement à Arduino, un fil noir sur la pin GND, un fil rouge sur la pin +5v de l’arduino, un fil bleu sur la pin A0. Pour que le DS18B20 effectue des conversions de température précises, les lignes d'entrée /sortie doivent fournir assez d'énergie pendant la transition de température, donc on a choisi le mode d’alimentation externe, à cause de le mode d’alimentation parasitaire ne peut pas fournir assez de courant résultant en plus grande erreur de mesure de température.

Liste des tâches à effectuer

1. On étudie comment utiliser deux capteurs et les tester.
2. On constitue le circuit global. On lie les LEDs sur le collier et ajoute deux capteurs et tester le circuit.
3. On utilise l'ardunio UNO pour programmer l'Atmega328p pour contrôler les LEDs et les deux capteurs. Et on l'ajoute à circuit complet.
4. On teste le circuit complet et on fait des simulations.
5. On améliore notre circuit pour faire notre circuit plus esthétique.

Réalisation du Projet

Feuille d'heures

Prologue

Avant de commencer notre projet, d’abord, on analyse notre sujet. Selon le demande de sujet, on décide de faire un collier comme un « choker ». Et on choisit un capteur de température et un capteur de radique pour détecter le changement de température et de rythme de cœur. En considérant la longueur du cou, on va mettre 32 LEDs sur ce collier et il contient quatre couleurs. On va utiliser Atmega328p pour contrôler des LEDs.

Semaine 1 et 2

On a appris comment utiliser la contrôleur TLC5711 et TLC5947 sur internet, la website est ci-dessous:

adafruit

Et ensuite on a soudé les fils et les interfaces aux TLC5711

alors on a câblé et a connecté V+ et VCC à 5VDC

On a installé Arduino, a téléchargé la bibliothèque TLC5711, l'a ajouté au Library, et on a compilé les codes ci-dessous pour comprendre le function de chaque partie

#include "Adafruit_TLC59711.h"
#include <SPI.h>
#define NUM_TLC59711 2
#define data   11
#define clock  13
Adafruit_TLC59711 tlc = Adafruit_TLC59711(NUM_TLC59711, clock, data);
void setup() {
 Serial.begin(9600);  
 Serial.println("TLC59711 test");
 pinMode(10, OUTPUT);
 tlc.begin();
 tlc.write();
}
void loop() {
 colorWipe(65535, 0, 0, 100); // "Red" (depending on your LED wiring)
 delay(200);
 colorWipe(0, 65535, 0, 100); // "Green" (depending on your LED wiring)
 delay(200);
 colorWipe(0, 0, 65535, 100); // "Blue" (depending on your LED wiring)
 delay(200); 
 rainbowCycle(5);
}
// Fill the dots one after the other with a color
void colorWipe(uint16_t r, uint16_t g, uint16_t b, uint8_t wait) {
 for(uint16_t i=0; i<8*NUM_TLC59711; i++) {
     tlc.setLED(i, r, g, b);
     tlc.write();
     delay(wait);
 }
}
// Slightly different, this makes the rainbow equally distributed throughout
void rainbowCycle(uint8_t wait) {
 uint32_t i, j;
 for(j=0; j<65535; j+=10) { // 1 cycle of all colors on wheel
   for(i=0; i < 4*NUM_TLC59711; i++) {
     Wheel(i, ((i * 65535 / (4*NUM_TLC59711)) + j) & 65535);
   }
   tlc.write();
   delay(wait);
 }
}
// Input a value 0 to 4095 to get a color value.
// The colours are a transition r - g - b - back to r.
void Wheel(uint8_t ledn, uint16_t WheelPos) {
 if(WheelPos < 21845) {
   tlc.setLED(ledn, 3*WheelPos, 65535 - 3*WheelPos, 0);
 } else if(WheelPos < 43690) {
   WheelPos -= 21845;
   tlc.setLED(ledn, 65535 - 3*WheelPos, 0, 3*WheelPos);
 } else {
   WheelPos -= 43690;
   tlc.setLED(ledn, 0, 3*WheelPos, 65535 - 3*WheelPos);
 }
}

On a connecté les LEDs en serie et puis téléchargé les codes, le résultat est comme ci-dessous:

Semaine 3 et 4

Dans ces deux semaines, on a programmé un code du LED selon le code de Adafruit TLC59711. En groupe de deux LEDs, les LEDs qui dans la même groupe sont liés en série, les connexions entre les différents groupes sont en parallèle. Notre LEDs sont rouges, donc chaque groupe a été connecté à la broche Ri. Dans notre code, les LEDs peuvent allumer et éteindre progressivement, mais pas seulement ça, les groupes peut circuler un par un en même temps.

Le code ci-dessous:

#include "TLC59711.h"
#include <SPI.h>
#define NUM_TLC59711 1
#define data   11
#define clock  13
Adafruit_TLC59711 tlc = Adafruit_TLC59711(NUM_TLC59711, clock, data);
void setup() {
  Serial.begin(9600);
  Serial.println("test led");
  pinMode(10, OUTPUT);
  tlc.begin();
  tlc.write();
}
uint8_t i=0;
void loop() {
    rise(i);
    down(i);
    i=i+3;
    if(i>9) i=0;
    Serial.println(i);
    delay(200);
}
void rise(uint8_t chan) {
 uint32_t j;
 Serial.println("rise");
 for(j=0; j<65535; j+=100){
   tlc.setPWM(chan,j); 
   tlc.write();
  }
}
void down(uint8_t chan) {
  int32_t j;
  Serial.println("down");
  for(j=65535; j>=0; j-=100){ 
    tlc.setPWM(chan,j);
    tlc.write();
  }
}
// "100" c'est la vitesse de variation de la luminance. Donc on peut accélérer la  variation par augmenter "100" à "1000" ou ralentir la  variation par diminuer "100" à "10".

En suite on a compilé notre codes et les a téléchargé à Arduino UNO pour les tester.

Le résultat est ci-dessous:

Média:TestLED2.mp4

Un autre façon de connexions utilisant la batterie pour l'alimenter est comme ça:

A cause de la puissance de LED qu'on choisissait est très grande et la luminance est trop forcée, on a changé notre désigne de colis et a choisi nouveaux types de LEDs. Mais les nouveaux types de LEDs sont plus petit que les précédents, donc on a augmenté le nombre de LED à 200.

Semaine 5-8

Dans notre premier dessin: On a décidé utiliser deux contrôleurs TLC59711 pour contrôler 48 groups des LEDs et deux boutons de piles à trois volt pour fournir notre coli. Chaque group contient trois LEDs(orange, vert, jaune) ou deux LEDs(bleu), à cause de la tension nominale entre les LEDs bleu est environ trois volt, mais la tension nominale entre les LEDs orange vert ou jaune est environ deux volt. Et on a fait 24 groups de LEDs en série et les deux 24 groups de LEDs en parallèle, ils partagent la même broche. Mais comme le courant maximale de TLC59711 est 0.6A, on ne peut pas mettre deux série de LEDs en parallèle, 1.2A est très grand pour le contrôleur TLC59711

Dans notre deuxième dessin: On a décidé utiliser seulement un contrôleur TLC5947 pour contrôler 24 groups des LEDs et deux bouton de piles à trois volt pour fournir notre coli. Parce que le contrôleur TLC5947 a 24 chanel et puis on peut contrôler toues les LEDs avec un contrôleur, ça c'est propice à diminuer la dimension de la carte PCB. Mais la luminance de ce dessin n'est pas suffisant, et on a deux capteur aussi, donc six volt n'est pas suffisant pour fournir le coli quand même.

Dans notre troisième dessin: On a décidé utiliser deux contrôleur TLC5947 pour contrôler 48 groups des LEDs et trois bouton de piles à trois volt pour fournir notre coli. Chaque group est liée à une broche. Pour diminuer la dimension de notre carte PCB, on a utilise un LilyPad Arduino et une carte USB comme l'interface périphérique USB. Et quand on a désigné la carte PCB, on a choisi les deux couches, on a mis une partie de fil sur le devant et une autre partie de fil est à l'opposé, on a met les trois bouton de piles à l'opposé aussi.

Le schéma du LilyPad Arduino et Carte USB sont comme ci-dessous:

Notre plan final sont comme ci-dessous:

Semaine 9

Dans cette séance de Projet, on redésigne notre collier. Il y a 16 groups de LEDs dans notre collier, et une type de groupe comme [orange vert jeune; bleu bleu; orange vert jeune], une autre type de groupe comme [bleu bleu; orange vert jeune; bleu bleu], les position de capteurs sont à gauche et à droite de 8 centrales groups des LEDs, entre les deux LEDs, on veut utilise les résistance à 0 ohm pour liaison. Le face de collier est comme ci-dessous:

Pour lier les LEDs avec notre PCB, on veut utilise les fils très fines, leurs largeur sont environ 1mm, et on veut les mettre comme trois couches, 16 des fils côte à côte dans une couche. A la position des capteurs, on veut les mettre sur le dessus des capteurs, en raison de les deux capteurs doivent être près du cou pour mesurer la température et la palpitation. Pour les autres positions, on veut les mettre derrière les LEDs, et on veut utilise le tissu ou quelques choses pour séparer les LEDs et les fils. Le verso et le côté de collier sont comme ci-dessous:

Semaine 10

Après le redésigne de notre collier, on soude l'Atmega328p,un reset, deux capacités, des résistances, un LED testé, un connecteur et des fils dans un circuit pour tester le circuit. Le connecteur est lié avec FTDI qui va relier avec la partie USB pour transmettre le programme d'Atmega328p. Quand on finit la soudure, on utilise l'arduino pour le tester. Si le LED testé allume, le circuit est correct. Après on teste l'Atmega328p, on soude autre composants. Par ailleurs, parce que si on soude les LEDs directement, c'est un peu difficile. Donc on fait un PCB pour mettre des LEDs ensemble.

Semaine 11

En raison de mauvais circuit, on refait le circuit et le PCB.

On change le schéma de piles dans un autre PCB. Pour mieux connecter les PCB avec le collier, on ajoute deux parties vides. Du coup, on peut passer le collier par la partie vide.

Semaine 12

On étudie les deux capteurs, DS18B20U et PulseSensor.

PulseSensor est un capteur simple, il n'a pas besoin de circuit de conduite.

On utilise les codes après pour tester notre capteur, il peut réaliser la fonction d'allumer le LED selon le rythme de cœur. Et après on essayera de changer la façon d'allumer pour montrer la changement de rythme de cœur.

On teste le rythme de cœur par mettre le capteur au bout des doigts

Et puis on teste le rythme de cœur par mettre le capteur à la lobe de l'oreille

Le capteur de température DS18B20U est trop petit, donc on fait un PCB pour le souder. Et son circuit de conduite compose par un resistance qui est 42 kohm.

Et son circuit de conduite compose par un resistance qui est 4.7 kohm.

Mais on ne trouve pas sa symbol dans l'application Fritzing. Donc on fait sa symbol nous même. D'abord, on trouve sa daille. Et on cherche un composant dans l'application Fritzing qui a la même daille. Ensuite, on export le schéma de ce composant pour le modifier. Finalement, on obtient un symbol qui a la même forme que DS18B20U. Le dernier chose à faire est de modifier les interfaces de ce composant. Selon le datasheet de DS18B20U, on remet toutes les interfaces. Du coup, on obtient le vraiment symbol de DS18B20U.

Le capteur de température DS18B20U réalise la fonction de détecter la température et puis la transporter à l'ordinateur. Il est un capteur numérique, donc on voit la valeur de température directement dans la fenêtre virtualisée.

Le code pour PulseSensor et DS18B20 ensemble est suivant:

 #define LED_PIN     6   //led_pin
 #define ONE_WIRE_BUS 2  // ds18b20_pin
 #define HEART_PIN   A0  //pulse_pin
 OneWire oneWire(ONE_WIRE_BUS); //define_ds18b20
 DallasTemperature sensors(&oneWire); //pass_reference_to_sensor
 void setup() {
   Serial.begin(9600);
   sensors.begin();
 }
 void loop() {
   //get_pulse_value
   int heartValue = analogRead(HEART_PIN);
   //get_temp_value
   sensors.requestTemperatures();
   int tempCValue=sensors.getTempCByIndex(0);
   //filter
   int filterValue = filter(heartValue);
   Serial.println(filterValue);
   //trans_value_to_rgb_value(0-255)
   //On n'a pas besoin de cette partie dans la finale code parce que nos LEDs sur la collier sont monocouleur, on le changera par les codes pour monocouleur LEDs qui sont contrôlés par TLC5947
   int maphValue = map(constrain(filterValue, 940, 1024), 940, 1024, 0, 255);
   int maptValue = map(constrain(tempCValue, 35, 40), 35, 40, 0, 255);
   delay(20);
 }
 //filtre
 int filter (int input) {
   #define FILTER_SIZE 10
   static int filterArray[FILTER_SIZE] = {0};
   static int fi = 0;
   filterArray[fi++] = input;
   if (fi >= FILTER_SIZE) {
     fi = 0;
   }
   int32_t output = 0;
   for (int i = 0; i < FILTER_SIZE; i++) {
     output += filterArray[i];
   }
   return int(output / FILTER_SIZE);
 }

Semaine 13

Comme les cartes de LED que on a déjà fait, on les soudés.

Pour les piles, on les met comme ci-dessous

Et puis on re-soude tous les composants de notre nouveau carte principale

Semaine 14

Le collier sur un modèle ras-du-cou est difficile à réaliser avec les circuits imprimés disponibles. Un modèle de type collerette est plus adapté avec deux rangées de barres de LEDs. Le schéma ci-dessous donne une idée d'un tel collier. Le circuit imprimé principal serait situé derrière le cou et masqué par un noeud décoratif, les piles étant fixées sur les rubans du noeud.

Démonstration du fonctionnement de la rangée inférieure du collier : Media:2018 P19 demicollier.mp4.

Zoom sur les LEDs : Media:2018 P19 demicollierzoom.mp4.

Démonstration du fonctionnement du collier avec 2 rangées : Media:2018 P19 collier.mp4.

Pour la partie de programmer ce collier avec les deux capteurs, tout d'abord, il faut reconfirmer les pins liées entre les deux contrôleurs et le microcontrôleur, et les pins liées entre les capteurs et le microcontrôleur. Et puis il faut ajouter 4 bibliothèques:

 bibliothèque de TLC5947
 bibliothèque1 du capteur de température
 bibliothèque2 du capteur de température
 bibliothèque du capteur de rythme cardiaque

pour contrôler notre capteurs et contrôleurs.

Selon de PCB de notre carte principale, on sais que le pin numéro 3 (clock) de chaque contrôleur est liée à la même pin de Atmega328p, c'est PD5. Et le numéro du pin de donée est 4 de chaque contrôleur, liée à PD4 de Atmega328p. Et le numéro du pin de registre est 30 de chaque contrôleur, liée à PD6 de Atmega328p. Donc on défini

//nombre du contrôleur
#define NUM_TLC5974 2 
//declaration de TLC5947
#define data   4
#define clock   5
#define latch   6
#define oe  -1

Pour les deux capteurs, selon les datasheets de chaque capteur et microcontrôleur.

La datasheet de Atmega328p

La datasheet de TLC5947

Et le capteur de rythme cardiaque faut lier à un pin de signal analogique de microcontrôleur, on choisi PC0.

Le capteur de température faut lier à un pin de signal numérique de microcontrôleur, on choisi PD7.

Parce qu'on a pas soudé les LEDs en fonction de l'ordre des pins de les deux contrôleurs, ils s'allument par hasarde, donc on crée un tableau pour contrôler tous les LEDs s'allumer un par un

 uint8_t iarray[48]={7,23,1,5,17,22,2,18,0,20,8,11,19,13,3,9,6,16,15,4,10,45,40,37,36,31,33,42,47,26,24,30,25,43,44,27,34,41,35,39,38,46,28,32,29,14,12,21};

Et en suite, on liée les deux capteurs avec la carte principale. On veut réaliser la fonction fondamentale de notre projet, c-t-à dire les LEDs doivent s'allumer ou s'éteindre en fonction de la température et le pouls, en fonction de différents valeurs viennent de les deux capteurs.

Quand on teste le capteur de rythme cardiaque, comme c'est un capteur qui transporte un signal analogique, on trouve que les valeurs viennent directement de capteur ne sont pas très stables, donc pour faire les valeurs plus stables, on écrit un filtre pour filtrer les valeurs

 //filtre
 int filtre (int input) {
 #define FILTER_SIZE 10
 static int filterArray[FILTER_SIZE] = {0};
 static int fi = 0;
 filterArray[fi++] = input;
 if (fi >= FILTER_SIZE) {
   fi = 0;
 }
 int32_t output = 0;
 for (int iff = 0; iff < FILTER_SIZE; iff++) {
   output += filterArray[iff];
 }
 return int(output / FILTER_SIZE);
 }

Après cette filtre, la valeur normale pour une personne saine qui a environ 23 ans(+-2 ans) vient notre capteur de rythme cardiaque est environ 900(+-50), on pose la intervalle de la valeur normale est entre 700 et 1000.

Parce que le capteur de température est un capteur numérique, donc on n'a pas filtrer ses valeurs. Mais comme il y a quelque perte d'énergie dans l'air, la valeur normale pour une personne saine n'est pas 37 dégrée, elle est inférieur de 37 dégrée, environ 32 ou 33 dégrée.

Notre idée principale est que lorsque la valeur de température est supérieur à la valeur normale, tous les LEDs s'allument durée 30 secondes pour l'alarme, et lorsque la valeur de température est normale, tous les LEDs s'allument progressivement et s'étendent progressivement un par un en fonction de la valeur rythme cardiaque. Si la valeur de rythme cardiaque est grande, les LEDs s'allument progressivement et s'étendent progressivement rapide, sinon les LEDs s'allument progressivement et s'étendent progressivement lentement. Ce programme vérifie la température 2 fois par minute(30 secondes par fois) et vérifie la rythme cardiaque chaque 0.2 secondes.

Quand la température est normale

Média:LEDs s'allument en fonction de pouls.mp4

Quand la température n'est pas normale

Média:LEDs alarme.mp4

Les codes pour réaliser les fonction est comme ci-dessous

 #include <OneWire.h>
 #include <DallasTemperature.h>
 #include "Adafruit_TLC5947.h"
 #define ONE_WIRE_BUS PC0  // ds18b20_pin
 #define HEART_PIN   PD7  //pulse_pin
 #define NUM_TLC5974 2    //nombre du controleur
 //declaration de TLC5947
 #define data   4
 #define clock   5
 #define latch   6
 #define oe  -1
 Adafruit_TLC5947 tlc = Adafruit_TLC5947(NUM_TLC5974, clock, data, latch);
 OneWire oneWire(ONE_WIRE_BUS); //define_ds18b20
 DallasTemperature sensors(&oneWire); //pass_reference_to_sensor
 void setup() {
   Serial.begin(9600);
   sensors.begin(); 
   tlc.begin();
   if (oe >= 0) {
     pinMode(oe, OUTPUT);
     digitalWrite(oe, LOW);
   }     
 }
 uint8_t i=0;
 //C'est le tableau pour contrôler l'ordre de LED s'allume, on peut changer l'ordre de LED s'allumer par changer ce tableau, on utilise les différents tableau pour changer après  
 uint8_t iarray[48]={7,23,1,5,17,22,2,18,0,20,8,11,19,13,3,9,6,16,15,4,10,45,40,37,36,31,33,42,47,26,24,30,25,43,44,27,34,41,35,39,38,46,28,32,29,14,12,21}; 
 //la fonction principale  
 void loop() {
 //prendre la valeur de temperature
   sensors.requestTemperatures();
   float tempCValue=sensors.getTempCByIndex(0);  
   Serial.println(tempCValue);
 //si la temperature n'est pas normale
   //La valeur de température peut-être en fonction de la demande
   //On peut aussi utiliser la valeur de pouls pour alarmer, par changer *tempCValue* à *filtervalue*
   if(tempCValue>37)
   {
     for(int ii=0;ii<48;ii++)
     {
       //La fonction de l'alarme peut être changé par la fonction alarme2 ou alarme3, pour faire plusieurs de façons possibles. alarme2 et alarme3 peuvent être trouvés après
       alarme(iarray[ii],4095);
     }
   //tous les LEDs s'allument durée 30 secondes pour l'alarme
   delay(30000);
   }
 //sinon 
   else
   {
     //Ce façon de allumer et éteindre peut être changer par les autres, les autres façons peuvent être trouvés après
     rise(iarray[i],4095);
     down(iarray[i],4095);
     i=i+1;
     if(i>47) i=0;  
     Serial.println(i);
     //On vérifie la rythme cardiaque chaque 0.2 secondes 
     delay(200); 
   } 
 }
 //LED_allumer
 void rise(uint8_t chan, uint16_t pwm) {  
 //prendre la valeur de pulse
   int heartValue = analogRead(HEART_PIN);
 //filtre la valeur de pulse
   int filterValue = filter(heartValue);
   Serial.println(filterValue);
   uint32_t j;
   Serial.println("rise");
 //On change la luminance par la valeur de rythme cardiaque
 //On peut aussi utilise la valeur *tempCValue* comme une variable pour changer la luminance de LED
   for(j=0; j<pwm; j+=filterValue) { 
     tlc.setPWM(chan,j);
     tlc.write();
   }
 }
 //LED_eteindre
 void down(uint8_t chan, uint16_t pwm) {
 //prendre la valeur de pulse
   int heartValue = analogRead(HEART_PIN);
 //filtre la valeur de pulse
   int filterValue = filter(heartValue);
   Serial.println(filterValue);
   int32_t j;
   Serial.println("down");
 //On change la luminance par la valeur de rythme cardiaque
 //On peut aussi utilise la valeur *tempCValue* comme une variable pour changer la luminance de LED
   for(j=pwm; j>=0; j-=filterValue) { 
     tlc.setPWM(chan,j);
     tlc.write();
   }
 }
 //LED_alarme
 void alarme(uint8_t chan,uint16_t pwm){
   tlc.setPWM(chan,pwm);
   tlc.write();
 }
 //filter
 int filter (int input) {
   #define FILTER_SIZE 10
   static int filterArray[FILTER_SIZE] = {0};
   static int fi = 0;
   filterArray[fi++] = input;
   if (fi >= FILTER_SIZE) {
     fi = 0;
   }
   int32_t output = 0;
   for (int iff = 0; iff < FILTER_SIZE; iff++) {
     output += filterArray[iff];
   }
   return int(output / FILTER_SIZE);
 }

Quand ce collier fonctionne normal, tous les valeurs viennent des capteurs sont normaux, il y une autre façon pour changer les états de tous les LEDs. La première ligne(au dessus) de LEDs s'allument de droite à gauche, et la deuxième ligne(au dessous) de LEDs s'allument de gauche à droite. Quand la première ligne fini, elle s'éteint et atteint jusqu'à la deuxième ligne fini aussi. Et les deux ligne recommencent ensemble.

Média:La deuxième façon pour allumer normal.mp4

On crée un nouveau tableau *jarray[]* pour noter l'ordre de LEDs de la première ligne et la deuxième ligne.

 //la première ligne
 uint8_t jarray1[21]={10,4,15,16,6,9,3,13,19,11,8,20,0,18,2,22,17,5,1,23,7};
 //la deuxième ligne
 uint8_t jarray2[27]={45,40,37,36,31,33,42,47,26,24,30,25,43,44,27,34,41,35,39,38,46,28,32,29,14,12,21};

Les codes sont comme ci-dessous:

 //Ce partie doit être ajouté dans la fonction *loop*, dans le cas tous les valeurs sont dans intervalles normaux
 //Si la première ligne est déjà fini
 if(i>20) 
   {
     //la première ligne s'éteint jusqu'à la deuxième ligne fini aussi
     for(int l=0;l<21;l++)
     {
       atteint(jarray1[l],0);
     }
     //la deuxième ligne continue
     rise(jarray2[k],4095);
     down(jarray2[k],4095);
     i=i+1;
     k=k+1;
   }
 //Si la première ligne n'est pas fini  
 else
   {
     //les deux lignes fonctionnent ensemble
     rise(jarray1[i],4095);
     rise(jarray2[k],4095);
     down(jarray1[i],4095);
     down(jarray2[k],4095);
     i=i+1;
     k=k+1;
   }
 //Si la deuxière ligne est fini aussi
 if( k>26 && i>26) 
   {
     //la deuxière ligne s'éteint
     for(int j=0;j<27;j++)
     {
       atteint(jarray2[j],0);
     }
     //les deux lignes recommencent
     k=0;
     i=0;     
   }  

Pour réaliser plusieurs de façons pour alarmer, on a deux idées. Une idée est que lorsque ce collier alarme, tous les LEDs clignotent rapidement, de gauche à droite, de la première ligne à la deuxième ligne, jusqu'à 30 fois, et puis ils s'éteignent pour 5 secondes.

Média:La deuxième façon pour Alarme.mp4

Les codes sont comme ci-dessous:

 //LED_alarme2
 void alarme2(){
   for(int nn=0;nn<48;nn++){
     tlc.setPWM(iarray[nn],4095);
     tlc.write();}  
   for(int nn=0;nn<48;nn++){
     tlc.setPWM(iarray[nn],0);
     tlc.write();} 
 }

Une autre idée est que lorsque ce collier alarme, tous les LEDs bleues et autres LEDs colorées traversent le flash jusqu'à 15 fois, et puis ils s'éteignent pour 5 secondes. Les LEDs bleues s'allument de la deuxième ligne à la première ligne, de droite à gauche, et s'éteignent de la première ligne à la deuxième ligne, de gauche à droite. Les autres LEDs colorées s'allument de la première ligne à la deuxième ligne, de gauche à droite, et s'éteignent de la deuxième ligne à la première ligne, de droite à gauche.

Média:La troisième façon pour Alarme.mp4

On crée un nouveau tableau *karray[]* pour noter l'ordre de LEDs bleues et les autres LEDs colorées.

 //les autres LEDs colorées
 uint8_t karray1[32]={7,1,5,22,2,0,20,11,19,3,9,16,15,10,45,37,36,33,42,26,24,25,43,27,34,35,39,46,28,29,14,21};
 //les LEDs bleues
 uint8_t karray2[16]={12,32,38,41,44,30,47,31,40,4,6,13,8,18,17,23};

Les codes sont comme ci-dessous, on appelle les fonction *alarme(uint8_t chan,uint16_t pwm)* et *atteint(uint8_t chan,uint16_t pwm)*

 //LED_alarme3
   void alarme3(){
     //LEDs bleues
     for(int k2=0;k2<16;k2++){
       alarme(karray2[k2],4095);}   
     for(int k2=15;k2>=0;k2--){
       atteint(karray2[k2],0);}
     //les autres LEDs colorées  
     for(int k1=0;k1<32;k1++){
       alarme(karray1[k1],4095);}
     for(int k1=31;k1>=0;k1--){
       atteint(karray1[k1],0);}
   }

Il reste à finir le collier avec des rubans (par exemple) et un système de fermeture. Il faut aussi souder les capteurs, décorer la carte principale et changer la batterie par 4 piles.

Semaine 15

On soude les deux capteur

Après la soudure, on teste ce collier avec les codes dans la document *Semaine 14*, ça c'est notre idée principale. Quand la température est supérieur de 37 dégrée(dans la teste, on utilise 30 dégrée), la fonction d'alare démarre, tous les LEDs s'allument durée 30 secondes; quand tous les valeurs sont dans l'intervalle normaux, les LEDs s'allument un par un, de la première ligne à la deuxième ligne, de gauche à droite. Cette programme va continuer avec la processus précédemment ininterrompu(après l'alarme).

Média:Démonstration_complète_1.mp4

On teste ce collier en utilisant l'alarme2 et la deuxième façon pour allumer, on met le capteur de rythme de cœur au bout des doigts, comme la température n'est pas très haute aujourd'hui, il fait un peu froid, c'est difficile de la chauffer à 33 dégrée, pour tester, donc on définit que si la température est supérieur de 30 dégrée, la fonction d'alarme démarre. Après l'alarme, si les valeurs viennent des deux capteurs sont dans l'intervalle normaux, cette programme va continuer avec la processus précédemment ininterrompu, sinon la programme va continuer d'alarmer jusqu'à des conditions normales.

Média:Démonstration_complète_2.mp4

Et puis, on teste ce collier en utilisant l'alarme3 et la deuxième façon pour allumer, on met le capteur de rythme de cœur au bout des doigts, les condition sont comme précédant

Média:Démonstration_complète_3.mp4

On change la batterie avec 4 piles

On décore le collier avec du ruban

Documents Rendus

Fichier:Rapport P19.pdf