Blouse de laboratoire LED interactif (8 / 11 étapes)

Étape 8: Arduino Code

Votre manteau peut s’allumer en réponse à n’importe quel nombre de capteurs qui peuvent être raccordés sur un Arduino. Dans l’exemple de code, vous trouverez un accéléromètre (donc il se met à clignoter que vous marchez et dansez) un microphone (donc il se met à clignoter comme tu parles) et un capteur de distance (à briller plus lumineux comme approche des choses). Mais avec tous les capteurs différents, que vous pouvez brancher un Arduino, il n’y a vraiment aucune limite à ce que vous pourriez faire votre manteau y réagir. Vous pourriez brancher un capteur de température pour faire votre manteau devient plus rouge que vous réchauffez. Vous pourriez utiliser un capteur à effet hall pour faire un manteau qui s’allume pour vous prévenir des champs magnétiques invisibles. C’est pas comme si nous n’avons jamais câblés un détecteur d’alcool dans l’une de ces couches de transformer une personne en un ivressomètre glow-in-the-dark. Sauf qu’une fois.

Point est, nouveaux capteurs de câblage dans l’arduino est la meilleure façon de faire vos propres ce manteau. Faire preuve de créativité. Utilisez l’exemple de code ci-dessous comme un point de sauter et faire preuve de créativité, de là. Faites-nous savoir dans les commentaires ce que vous truquées votre manteau pour détecter !

====================
Le Code
====================

bibliothèques incluses
#include < Wire.h >
#include < ADXL345.h >
#include < NewPing.h >

Capteur sonar
#define TRIGGER_PIN 11 / / goupille de Arduino lié à déclencher la broche sur le capteur à ultrasons.
#define ECHO_PIN 10 / / goupille de Arduino liée à la broche sur le capteur à ultrasons d’écho.
#define MAX_DISTANCE 200 / / distance maximale que nous voulons faire un ping pour (en centimètres). Distance maximum sensor est évalué à 400-500cm.

NewPing sonar (TRIGGER_PIN, ECHO_PIN, MAX_DISTANCE) ; NewPing configuration des broches et distance maximale.
puissance int = 0 ;
distance de l’int = 0 ;

capteur micro
int micPin = A3 ;    Sélectionnez l’entrée pin pour le potentiomètre

Accel + accelRainbow + arc en ciel
double val = 0.0 ;
double valAdjustAccel = 0.0 ;
double highvalAccel = 0.0 ;
maxVal double = 0.0 ;
double, bleu, vert, rouge ;
double compteur de temps = 0 ;
double tc = 200 ;
ADXL345 adxl ; adxl variable est une instance de la bibliothèque de ADXL345

PWM LED
int redLED = 5 ;
int blueLED = 6 ;
Qu’int = 3 ;

boutons
int rouge = 7 ;
int greenButton = 4 ;
int blueButton = 2 ;
int rainbowButton = 0 ;
Bouton int = 8 ;
int distanceButton = 9 ;
int micButton = 12 ;
int accelButton = 13 ;

autres
minuterie d’int = 0 ;

modes de
mode d’int = 0 ;    0 = désactivé, 1 = rouge, 2 = bleu, 3 = vert, 4 = violet, 5 = teal, 6 = jaune, 7 = blanc, 8 = arc-en-ciel
9 = accel bleu, 10 = accel vert, 11 = accel rouge, 18 = accel arc-en-ciel
12 = micro vert, 13 = micro bleu, 14 = micro rouge
15 = distance rouge, 16 = distance bleu, 17 = distance vert

micro
int sensorValue = 0 ;  variable pour stocker la valeur provenant de la sonde
double valAdjustMic = 0.0 ;
double highvalMic = 0.0 ;

void setup() {}
Serial.Begin(115200) ; Ouvert serial monitor à 115200 bauds
pinMode (redLED, sortie) ;
pinMode (blueLED, sortie) ;
pinMode (que, sortie) ;
pinMode (rouge, entrée) ;
pinMode (greenButton, entrée) ;
pinMode (blueButton, entrée) ;
pinMode (rainbowButton, entrée) ;
pinMode (bouton, entrée) ;
pinMode (distanceButton, entrée) ;
pinMode (micButton, entrée) ;
pinMode (accelButton, entrée) ;
adxl.powerOn() ;
}

void loop() {}
readColorButtons() ;
readAccelButton() ;
readMicButton() ;
readDistanceButton() ;
readOffButton() ;

modes: 0 = désactivé, 1 = rouge, 2 = bleu, 3 = vert, 4 = violet, 5 = teal, 6 = jaune, 7 = blanc, 8 = arc-en-ciel
9 = accel bleu, 10 = accel vert, 11 = accel rouge, 18 = accel arc-en-ciel
12 = micro vert, 13 = micro bleu, 14 = micro rouge
15 = distance rouge, 16 = distance bleu, 17 = distance vert

Si (mode == 0) / / off
{
digitalWrite (redLED, basse) ;
digitalWrite (que, faible) ;
digitalWrite (blueLED, basse) ;
}

Si (mode == 1) //red
{
digitalWrite (redLED, HIGH) ;
digitalWrite (que, faible) ;
digitalWrite (blueLED, basse) ;
}
Si (mode == 2) //blue
{
digitalWrite (redLED, basse) ;
digitalWrite (que, faible) ;
digitalWrite (blueLED, HIGH) ;
}
Si (mode == 3) / / vert
{
digitalWrite (redLED, basse) ;
digitalWrite (que, HIGH) ;
digitalWrite (blueLED, basse) ;
}
Si (mode == 4) / / violet
{
digitalWrite (redLED, HIGH) ;
digitalWrite (que, faible) ;
analogWrite (blueLED, 50) ;
}
Si (mode == 5) / / teal
{
digitalWrite (redLED, basse) ;
digitalWrite (que, HIGH) ;
analogWrite (blueLED, 50) ;
}
Si (mode == 6) / / jaune
{
digitalWrite (redLED, HIGH) ;
digitalWrite (que, HIGH) ;
digitalWrite (blueLED, basse) ;
}
Si (mode == 7) / / blanc
{
digitalWrite (redLED, HIGH) ;
digitalWrite (que, HIGH) ;
digitalWrite (blueLED, HIGH) ;
}
Si (mode == 8) / / arc-en-ciel
{
Rainbow() ;
}
Si (mode == 9 || mode == 10 || mode == 11) / / accel bleu, vert, rouge
{
Accel() ;
}
Si (mode == 12 || mode == 13 || mode == 14) / / mic vert, de bleu, de rouge
{
MIC() ;
}
Si (mode == 15 || mode == 16 || mode == 17) / / distance rouge, bleu, vert
{
distanceSensor() ;
}
Si (mode == 18) / / accel arc-en-ciel
{
accelRainbow() ;
}

}

void mic() {}
lire la valeur de la sonde :
sensorValue = analogRead(micPin) ;

Serial.println(highvalMic) ;
valAdjustMic = sensorValue-390 ;
Si (valAdjustMic > highvalMic)
{
highvalMic = valAdjustMic ;
}
d’autre
{
highvalMic = highvalMic*.90 ;
}
Si (highvalMic > maxVal)
//  {
maxVal = highvalMic ;
//  }
if(highvalMic < 100)
{
highvalMic = 0 ;
}
Si (mode == 14)
{
analogWrite(greenLED,highvalMic) ;
digitalWrite (blueLED, basse) ;
digitalWrite (redLED, basse) ;
}
Si (mode == 13)
{
analogWrite(blueLED,highvalMic) ;
digitalWrite (redLED, basse) ;
digitalWrite (que, faible) ;
}
Si (mode == 12)
{
analogWrite(redLED,highvalMic) ;
digitalWrite (blueLED, basse) ;
digitalWrite (que, faible) ;
}
Delay(1) ;
}

void distanceSensor() {}
Delay(50) ;                      Attendre 50ms entre les pings (environ 20 pings/sec). 29ms devrait être le délai le plus court entre les pings.
unsigned int nous = sonar.ping() ; Envoyer des ping, ping temps en microsecondes (nous).
distance = uS / US_ROUNDTRIP_CM ;
Serial.Print ("Ping:") ;
Serial.Print(US / US_ROUNDTRIP_CM) ; Convertir les temps de ping à distance en cm et résultat d’impression (0 = distance définie hors plage)
Serial.println("cm") ;

Si (distance > 29 & & distance < 131)
{
puissance = (distance - 30) * 2,55 ;
}
Si (distance < 30 || > 150 à distance)
{
puissance = 0 ;
}
Si (distance > 130)
{
puissance = 255 ;
}
Si (mode == 17)
{
analogWrite(greenLED,power) ;
digitalWrite (blueLED, basse) ;
digitalWrite (redLED, basse) ;
}
Si (mode == 16)
{
analogWrite(blueLED,power) ;
digitalWrite (que, faible) ;
digitalWrite (redLED, basse) ;
}
Si (mode == 15)
{
analogWrite(redLED,power) ;
digitalWrite (blueLED, basse) ;
digitalWrite (que, faible) ;
}
}

void accel() {}
Ennuyeux les trucs de l’accéléromètre
int x, y, z ;
adxl.readAccel (x, y & z) ; lire les valeurs de l’accéléromètre et les stocker dans des variables x, y, z
double dx, dy, dz ;
DX = abs (double) (x) / 100 ;
DY = abs (double) (y) / 100 ;
DZ = abs (double) (z) / 100 ;
Val = sqrt((dx*dx)+(dy*dy)+(dz*dz)) ;
Val = sqrt((x*x)+(y*y)+(z*z)) ;
Sortie x, y, les valeurs de z - commentées
Serial.Print(Val) ;
valAdjustAccel = val-3 ;
Si (valAdjustAccel > highvalAccel)
{
highvalAccel = valAdjustAccel ;
}
d’autre
{
highvalAccel = highvalAccel*.83 ;
}
Si (highvalAccel > maxVal)
//  {
maxVal = highvalAccel ;
//  }
Si (highvalAccel * 57 < 4)
{
highvalAccel = 4/57 ;
}
Si (mode == 10)
{
bleu = 1 ;
rouge = 0 ;
vert = 0 ;
}
Si (mode == 9)
{
bleu = 0 ;
rouge = 0 ;
vert = 1 ;
}
Si (mode == 11)
{
bleu = 0 ;
rouge = 1 ;
vert = 0 ;
}
analogWrite(blueLED,highvalAccel*57*blue) ;
analogWrite(greenLED,highvalAccel*57*green) ;
analogWrite(redLED,highvalAccel*57*red) ;
Delay(30) ;
}

void accelRainbow() {}
Ennuyeux les trucs de l’accéléromètre
int x, y, z ;
adxl.readAccel (x, y & z) ; lire les valeurs de l’accéléromètre et les stocker dans des variables x, y, z
double dx, dy, dz ;
DX = abs (double) (x) / 100 ;
DY = abs (double) (y) / 100 ;
DZ = abs (double) (z) / 100 ;
Val = sqrt((dx*dx)+(dy*dy)+(dz*dz)) ;
Val = sqrt((x*x)+(y*y)+(z*z)) ;
Sortie x, y, les valeurs de z - commentées
Serial.Print(Val) ;
valAdjustAccel = val-3 ;
Si (valAdjustAccel > highvalAccel)
{
highvalAccel = valAdjustAccel ;
}
d’autre
{
highvalAccel = highvalAccel*.83 ;
}
Si (highvalAccel > maxVal)
//  {
maxVal = highvalAccel ;
//  }
Si (highvalAccel * 57 < 4)
{
highvalAccel = 4/57 ;
}

analogWrite(blueLED,highvalAccel*57*blue) ;
analogWrite(greenLED,highvalAccel*57*green) ;
analogWrite(redLED,highvalAccel*57*red) ;
Delay(30) ;
compteur de temps = compteur de temps + 30 ;




Si (compteur de temps < tc)
{
rouge = 1 ;
bleu = 0 + (compteur de temps) / TC ;
}
Si (compteur de temps > 2 * tc & & compteur de temps < 3 * tc)
{
rouge = 1 - (compteur de temps-2 * tc) / TC ;
}
Si (compteur de temps > 4 * tc & & compteur de temps < 5 * tc)
{
vert = 0 + (compteur de temps-4 * tc) / TC ;
}
Si (compteur de temps > 6 * tc & & compteur de temps < 7 * tc)
{
bleu = 1 - (compteur de temps-6 * tc) / TC ;
}
Si (compteur de temps > 8 * tc & & compteur de temps < 9 * tc)
{
rouge = 0 + (compteur de temps-8 * tc) / TC ;
}
Si (compteur de temps > 10 * tc & & compteur de temps < 11 * tc)
{
vert = 1-(compteur de temps-10 * tc) / TC ;
}
Si (compteur de temps > 12 * tc)
{
compteur de temps = 0 ;
}
Serial.Print(Red) ;
Serial.Print("") ;
Serial.Print(Blue) ;
Serial.Print("") ;
Serial.Print(Green) ;
Serial.Print("") ;
Serial.println(timecounter) ;

}

void rainbow() {}

analogWrite(blueLED,255*blue) ;
analogWrite(greenLED,255*green) ;
analogWrite(redLED,255*red) ;
Delay(30) ;
compteur de temps = compteur de temps + 30 ;




Si (compteur de temps < tc)
{
rouge = 1 ;
bleu = 0 + (compteur de temps) / TC ;
}
Si (compteur de temps > 2 * tc & & compteur de temps < 3 * tc)
{
rouge = 1 - (compteur de temps-2 * tc) / TC ;
}
Si (compteur de temps > 4 * tc & & compteur de temps < 5 * tc)
{
vert = 0 + (compteur de temps-4 * tc) / TC ;
}
Si (compteur de temps > 6 * tc & & compteur de temps < 7 * tc)
{
bleu = 1 - (compteur de temps-6 * tc) / TC ;
}
Si (compteur de temps > 8 * tc & & compteur de temps < 9 * tc)
{
rouge = 0 + (compteur de temps-8 * tc) / TC ;
}
Si (compteur de temps > 10 * tc & & compteur de temps < 11 * tc)
{
vert = 1-(compteur de temps-10 * tc) / TC ;
}
Si (compteur de temps > 12 * tc)
{
compteur de temps = 0 ;
}
Serial.Print(Red) ;
Serial.Print("") ;
Serial.Print(Blue) ;
Serial.Print("") ;
Serial.Print(Green) ;
Serial.Print("") ;
Serial.println(timecounter) ;
}

void readColorButtons() {}
Si (digitalRead (rouge) == HIGH & & digitalRead (greenButton) == LOW & & digitalRead(blueButton)==LOW)
{
mode = 1 ; rouge
Timer = 0 ;
}
Si (digitalRead (rouge) == LOW & & digitalRead (greenButton) == LOW & & digitalRead(blueButton)==HIGH)
{
mode = 2 ; bleu
Timer = 0 ;
}
Si (digitalRead (rouge) == LOW & & digitalRead (greenButton) == HIGH & & digitalRead(blueButton)==LOW)
{
mode = 3 ; vert
Timer = 0 ;
}
Si (digitalRead (rouge) == HIGH & & digitalRead (greenButton) == LOW & & digitalRead(blueButton)==HIGH)
{
mode = 4 ; Purple
digitalWrite (redLED, HIGH) ;
digitalWrite (que, faible) ;
analogWrite (blueLED, 50) ;
retard (250) ;
Timer = 0 ;
}
Si (digitalRead (rouge) == LOW & & digitalRead (greenButton) == HIGH & & digitalRead(blueButton)==HIGH)
{
mode = 5 ; Teal
digitalWrite (redLED, basse) ;
digitalWrite (que, HIGH) ;
analogWrite (blueLED, 50) ;
retard (250) ;
Timer = 0 ;
}
Si (digitalRead (rouge) == HIGH & & digitalRead (greenButton) == HIGH & & digitalRead(blueButton)==LOW)
{
mode = 6 ; jaune
digitalWrite (redLED, HIGH) ;
digitalWrite (que, HIGH) ;
digitalWrite (blueLED, basse) ;
Delay(250) ;
Timer = 0 ;
}
Si (digitalRead (rouge) == HIGH & & digitalRead (greenButton) == HIGH & & digitalRead(blueButton)==HIGH)
{
mode = 8 ; arc en ciel
digitalWrite(redLED,LOW) ;
digitalWrite(blueLED,LOW) ;
digitalWrite(greenLED,LOW) ;
retard (250) ;
Timer = timer + 250 ;
}
Si (minuterie == 1500)
//  {
mode = 8 ; couleurs de l’arc-en-ciel
digitalWrite (redLED, basse) ;
digitalWrite (blueLED, basse) ;
digitalWrite (que, faible) ;
retard (500) ;
Timer = 0 ;
//  }
Si (minuterie == 3000) ;
//  {
mode = 0 ;
digitalWrite (redLED, basse) ;
digitalWrite (blueLED, HIGH) ;
digitalWrite (que, faible) ;
Delay(500) ;
digitalWrite (redLED, basse) ;
digitalWrite (blueLED, basse) ;
digitalWrite (que, vif ;
Delay(500) ;
digitalWrite (redLED, HIGH) ;
digitalWrite (blueLED, basse) ;
digitalWrite (que, faible) ;
Delay(500) ;
digitalWrite (redLED, basse) ;
digitalWrite (blueLED, basse) ;
digitalWrite (que, faible) ;
Timer = 0 ;
//  }
//
}

void readAccelButton() {}
Si (digitalRead(accelButton)) / / 9 = accel bleu, 10 = accel vert, 11 = accel rouge, 18 = accel arc-en-ciel
{
Si (mode == 9) / / déjà accel bleu
{
mode = 10 ; faire l’accel vert
Delay(500) ;
}
ElseIf (mode == 10) / / déjà accel vert
{
mode = 11 ;  faire l’accel rouge
Delay(500) ;
}
ElseIf (mode == 11) / / déjà accel rouge
{
mode = 18 ; faire accel arc-en-ciel
Delay(500) ;
}
ElseIf (mode == 18) / / déjà accel arc-en-ciel
{
mode = 9 ; faire l’accel bleu
Delay(500) ;
}
d’autre
{
mode = 9 ; faire l’accel bleu
Delay(500) ;
}
}
}

void readMicButton() {}
Si (digitalRead(micButton)) / / 12 = micro vert, 13 = micro bleu, 14 = micro rouge
{
Si (mode == 12) / / déjà micro vert
{
mode = 13 ; faire micro bleu
Delay(500) ;
}
ElseIf (mode == 13) / / déjà micro bleu
{
mode = 14 ;  faire micro rouge
Delay(500) ;
}
ElseIf (mode == 14) / / déjà micro rouge
{
mode = 12 ; faire micro vert
Delay(500) ;
}
d’autre
{
mode = 12 ; faire micro vert
Delay(500) ;
}
}
}

void readDistanceButton() {}

Si (digitalRead(distanceButton)) / / 15 = distance rouge, 16 = distance bleu, 17 = distance vert
{
Si (mode == 15) / / distance déjà rouge
{
mode = 16 ; faire la distance bleu
Delay(500) ;
}
ElseIf (mode == 16) / / distance déjà bleu
{
mode = 17 ;  faire la distance vert
Delay(500) ;
}
ElseIf (mode == 17) / / distance déjà vert
{
mode = 15 ; faire la distance rouge
Delay(500) ;
}
d’autre
{
mode = 15 ; faire la distance rouge
Delay(500) ;
}
}
}
void readOffButton() {}
Si (digitalRead(offButton))
{
mode = 0 ;
}
}

Articles Liés

Faire une LED interactif iPad contrôlée mur

Faire une LED interactif iPad contrôlée mur

Me montrer la vidéo d'youtube de la paroi en action !Tout le monde veut faire des afficheurs à LED géants pour montrer leurs vagues LED cool, géométriques ou floue rose Elvis art. Toutefois, afin de répondre à un immense mur de LED, vous devrez trouv
Chaussures LED interactif - Arduino

Chaussures LED interactif - Arduino

Démarquez-vous de la foule avec ces chaussures de LED Interactive cool qui sont activées par le mouvement. Choisissez parmi six différents effets, pour mélanger les choses un peu la prochaine fois que vous êtes dehors sur la ville !Étape 1: vue d'ens
Système de LED interactif pour tout-petits (en cours)

Système de LED interactif pour tout-petits (en cours)

Je travaille sur deux projets en parallèle et je veux organiser ce que j'ai sur ce projet avant de commencer à documenter l'autre projet.Système de LED interactif pour tout-petits (en cours)Estimé : toutes les 50 %.Lorsque vous avez terminé la volont
Blouse de laboratoire steampunk et injecteur

Blouse de laboratoire steampunk et injecteur

j'ai voulu une blouse de laboratoire mais qui est un modèle original alors j'ai mis sur la création d'un Steampunk Labcoat.La tenue est de deux sections, qui sont tous deux forme ajustage de précision.La partie blanche a une fermeture éclair au centr
Matrice de LED interactif Intel Galileo

Matrice de LED interactif Intel Galileo

Créer un interactif 8 x 8 LED Matrix et envoyer photos à afficher de n'importe où dans le monde entier !Dans ce projet, nous utilisons une carte Intel Galileo qui nous a généreusement donné par Intel (ils vous donner beaucoup de ceux aux Etats-Unis d
Châle de LED interactif de mouvement

Châle de LED interactif de mouvement

Il se sent toujours très fort en hiver pour promener le chien avant et après le travail, parce qu'il est froid et sombre de l'extérieur. Ce châle est conçu pour fournir les deux chaleur et lumière pour une sécurité accrue (et amusement).Le foulard s'
PIXEL - Art LED interactif

PIXEL - Art LED interactif

Dans ce Instructable, je vais parler de PIXEL qui est actuellement sur KickStarter (Shameless Plug). Et aussi comment un mec avec un travail de jour peut prendre une idée et qu'il devienne un vrai produit.Le KickStarter pour PIXEL comprend également
Lampe led interactive | tenségrité structure + arduino

Lampe led interactive | tenségrité structure + arduino

Cette pièce est une lampe de mouvement sensible. Conçu comme une sculpture de tenségrité minime, la lampe change sa configuration de couleurs en réponse à l'orientation et les mouvements de l'ensemble de la structure.En d'autres termes, selon son ori
Toile Programmable LED interactif

Toile Programmable LED interactif

L'objectif de ce projet était d'aller un peu plus loin avec la toile personnalisée. Il en coûtera un peu plus, mais le potentiel est beaucoup plus grand pour cette conceptionÉtape 1: théorieLED blanche résistance CalcVCE = 0, 3VChute de tension LED =
Interactive Arduino alimenté LED Skis

Interactive Arduino alimenté LED Skis

Malade de la noirceur terne de skier la nuit ? N'ayez pas peur ! Arduino skis de LED interactifs programmables viendront égayer votre soirée.Ces maison construite skis ont LED incorporé sous le p-tex et la feuille du dessus. Une Arduino et accéléromè
Table de ping-pong interactif LED bière

Table de ping-pong interactif LED bière

Créer votre propre Table de ping-pong de bière LED interactif !Cette instructable vous guidera à travers toutes les étapes d'afin de créer une table de ping-pong d'one-of-a-kind bière complète avec coupe détection RGB gousses, rondelles de balle auto
Interactive floue LED ceinture

Interactive floue LED ceinture

Il s'agit d'une Instructable pour vous montrer comment faire une ceinture de LED interactive, floue ! Ceinture peut être utilisé de plusieurs façons, non seulement comme une ceinture... le porter comme une bandoulière, accrocher sur le mur, enroulez-
Tableau interactif de LED

Tableau interactif de LED

Voici un guidée instructable sur comment faire votre propre table de LED interactif à l'aide d'un des kits de Evil Mad Sciencitst.Voici une vidéo de ma table finale en action dans l'obscurité et une photo de quoi ça ressemble :Étape 1: Choisir votre
L’aventure de l’électricité : un diorama de lumière interactif

L’aventure de l’électricité : un diorama de lumière interactif

d'où provient l'électricité ? Qui a inventé l'ampoule ? Comment villes utilise cette technologie aujourd'hui ?Voici quelques-uns questions que nous espérons adresse dans ce diorama interactif, l'aventure de l'électricité!Ce projet a été conçu à des f