Khruschov réfrigérateur

Total de 200 roubles pour acheter une bonne base pour un travail simple. Le projet a été réalisé avec des collègues étrangers Adruino Arts. Pour sa mise en œuvre doit connaître les principes de base de la robotique, de l'électronique et de comprendre un peu de programmation.
Dans le clip vidéo auteur de raconte et montre que nous devrions obtenir un résultat.
En plus de la lampes nous avons besoin d'un ensemble de Grove - Kit de Toy. Commandez en ligne vous pouvez acheter par prix 79,9 $.
L'idée principale - définition de l'état statique ou dynamique de l'objet par détection de mouvement. Si la réponse est positive, puis exécutez l'un des actionneurs et la lecture de message pré-enregistré. Dans le cas contraire, activé deuxième servo, et un enregistrement sonore différente.
Détermination de passer par une certaine forme de l'entrée. Ainsi, nous obtenons le résultat en code binaire 0 ou 1.
Recorder peut lire le son enregistré seulement 4 via un signal externe. Pour enregistrer (chaque 15 sec.), Il est nécessaire de passer sur le bouton «jouer» à «dossier». Après l'enregistrement nouveau bouton devrait passer. Cela peut être fait dans le code (jeu de fonction ()). Dans servo câble est de 3 "plus", "moins" et les données numériques. Le premier deux fournissent de la nourriture pour servo (max 7) et 3e se connecte à une sortie numérique, qui reçoit des informations sur l'état de l'interrupteur et par code.
Première analysé lampe. Nous ne avons pas besoin des composants électriques, mais devons travailler fondement même. Vous devez également quelques accessoires et éléments de soutien.
Faire un trou dans le tube pour connecter notre conception.
Le prototype de robot est prêt!

Étape 1: Glow
Utilisation de la lampe LED IKEA OLEBY (Food solaire).
L'interrupteur ne fonctionne que dans un appareil numérique, et donc il dépend sur le réseau actuel. Si nous passons podsoedynym Pay Seeeduino, vous pouvez définir le BAS de sortie numérique, puis il y aura cours. Lors de la mise HAUTE, il réapparaît.
Même au sein de la lampe et on branche une résistance pour protéger la LED.
Réglez l'élément lumière dans la base métallique.

Étape 2: Principe
Nous avons la lampe attachée servo contrôle du détecteur, triple axe accéléromètre, enregistreur et jouons quatre sons différents.
Le principe de base de la lampe est la suivante:

Il se avère que le bruit (son)
Lampe incluse
Fonctionne fiche №3
Lampe main fournit mouvement (gauche-droite-gauche)
Servo reste à 90 °
Transaction terminée

Si il ya du bruit, alors:

Lampe incluse
Servo avec lampe déplacer vers la gauche
Fonctionne fiche №2
La lampe en position 90 °
Transaction terminée

Si le bras de métal atteint une certaine position (haute), puis en jouant fiche №4.

Étape 3: Amélioration
Dans le travail de conception peut apporter quelques améliorations comme l'intégration d'un commutateur frais Seeeduino, pour contrôler l'exécution de code en utilisant un cycle régulier SI. Si le commutateur est activé - démarrer le mode automatique, si ce ne est - en mode manuel.
Auto-mode comprend code standard lorsque la lampe réagit au son.
Mode manuel permet la gestion à distance par l'intermédiaire d'un axe accéléromètre triple, en changeant la position des axes X et Y.
Vous pouvez faire un tour sur les lumières 360 °, en y ajoutant un servo séparé. Puis-je configurer pour se connecter via Wi-Fi / Ethernet.
Étape 4: Code
Code Auteur (MrLdnr) se trouve ci-dessous.
[Spoiler]
#include
const int buttonPin = 4; // Interrupteur de position
int ButtonState = 0; // Variable pour la lecture des boutons de position
// Configuration Servo
myservo2 servo;
myservo servo; // Crée pour le contrôle de servo
int pos = 0; // Variable servant à mémoriser la position d'asservissement
int pos2 = 0; // Variable servant à mémoriser la position d'asservissement
int val1;
int val2;
// CONFIGURATION LED
const int ledPin2 = 5; // lumière principale
const int ledPin = 12; // Tube lumière
int countlamp2 = 0;
// Configuration du bruit
const int valeur de seuil = 300; // La réponse au son
// akseleometra Set
int ystate;
int xstate;
#include
#define MMA766ddr 0x4c
#define MMA7660_X 0x00
#define MMA7660_Y 0x01
#define MMA7660_Z 0x02
#define MMA7660_TILT 0x03
#define MMA7660_SRST 0x04
#define MMA7660_SPCNT 0x05
#define MMA7660_INTSU 0x06
#define MMA7660_MODE 0x07
#define MMA7660_SR 0x08
#define MMA7660_PDET 0x09
#define MMA7660_PD 0x0A
Accélération de classe
{
publique:
omble x;
carboniser y;
z omble;
};

Indice de carbonisation;
omble commande;
état de carbonisation;
int audiodelay = 1000;
mma7660_init (void)
{
Wire.begin ();
Wire.beginTransmission (MMA766ddr);
Wire.send (MMA7660_MODE);
Wire.send (0x00);
Wire.endTransmission ();
Wire.beginTransmission (MMA766ddr);
Wire.send (MMA7660_SR);
Wire.send (0x07); // Échantillons / seconde mode actif et Auto-Sleep
Wire.endTransmission ();
Wire.beginTransmission (MMA766ddr);
Wire.send (MMA7660_MODE);
Wire.send (0x01); // mode actif
Wire.endTransmission ();
}

void setup ()
{
mma7660_init (); // Rejoignez bus i2c (adresse sélective du device master)
Serial.begin (9600);
// Capteur De Mouvement
pinMode (6 entrées); // utilisé deux pieds pour le signal externe
// La lumière et la base de la lampe de lumière
pinMode (ledPin, SORTIE);
pinMode (ledPin2 SORTIE);
// SERVOS
// AUDIO
DDRD | = 0x0C; // D2 et D3 en mode écriture;
PORTD & = 0xF3; // D2 et D3 réglés sur un faible;
// Capteur de bruit sur analogique 0
// INTERRUPTEUR
pinMode (buttonPin, INPUT);
}
rec_2_begin void ()
{
PORTD = (PORTD | 0b00000100) & 0b11110111;
}
rec_2_stop void ()
{
PORTD & = 0xF3;
}
play_2 void ()
{
PORTD = (PORTD | 0b00000100) & 0b11110111;
retard (audiodelay);
PORTD & = 0xF3;
}
////////////////////////////////////////////////// ////////////////////
////////////////////////////////////////////////// /////
// Fonction de contrôler la segment_3
rec_3_begin void ()
{
PORTD = (PORTD | 0b00001000) & 0b11111011;
}
rec_3_stop void ()
{
PORTD & = 0xF3;
}
play_3 void ()
{
PORTD = (PORTD | 0b00001000) & 0b11111011;
retard (audiodelay);
PORTD & = 0xF3;
}
////////////////////////////////////////////////// ///
////////////////////////////////////////////////
// Fonction de contrôler la segment_4;
rec_4_begin void ()
{
PORTD = PORTD | 0b00001100;
}
rec_4_stop void ()
{
PORTD & = 0xF3;
}
play_4 void ()
{
PORTD = PORTD | 0b00001100;
retard (audiodelay);
PORTD & = 0xF3;
}
//////////////////////

check_move void ()
{
int = sensorValue digitalRead (6);
if (sensorValue == 1)
{
// DigitalWrite (ledPin, HIGH);
//Serial.println(sensorValue, DEC); // la sortie de signal de position à l'écran.
// Servo1 ();
}
autre
{
// DigitalWrite (ledPin, LOW);
//Serial.println(sensorValue, DEC); // la sortie de signal de position à l'écran.
// Servo2 ();
}
}
servo1_right void ()
{
myservo.attach (9);
pour (pos = 90; pos = 90; possession = 1) // va de 0 à 180 degrés
{
myservo.write (pos); // Indique la position d'asservissement à travers une «pos« variable
retard (10); // Attend 15 ms jusqu'à ce que le servo prend la position
} * /
}
servo1_left void ()
{
myservo.attach (9);
pour (pos = 90; pos & gt; 1; pos - = 1) // va de 0 à 180 degrés
{// Incréments de 1 degré
myservo.write (pos); // Indique la position d'asservissement à travers une «pos« variable
retard (10); // Attend 15 ms, tandis que le servo ne prend pas position
} / *
play_2 ();
retard (1000);
pour (pos = 1; pos90) {
pour (pos = posact; pos & gt; 90; pos - = 1) // renvoie 90 degrés
{// Incréments de 1 degré
myservo.write (pos); // Indique la position d'asservissement à travers une «pos« variable
retard (10); // Attend 15 ms, tandis que le servo ne prend pas position
}
}
else {
pour (pos = posact; pos 60; pos - = 1) // va de 0 à 180 degrés
{// Incréments de 1 degré
myservo2.write (pos); // Indique la position d'asservissement à travers une «pos« variable
retard (10); // Attend 15 ms, tandis que le servo ne prend pas position
} / *
play_2 ();
retard (1000);
pour (pos = 1; pos90) {
pour (pos = posact; pos & gt; 90; pos - = 1) // renvoie la position de 90 degrés
{// Incréments de 1 degré
myservo2.write (pos); // Indique la position d'asservissement à travers une «pos« variable
retard (10); // Attend 15 ms, tandis que le servo ne prend pas position
}
}
else {
pour (pos = posact; pos <=90 ;="" pos="" +="1)" goes="" from="" 0="" degrees="" to="" 180="">
{// Incréments de 1 degré
myservo2.write (pos); // Indique la position d'asservissement à travers une «pos« variable
retard (10); // Attend 15 ms, tandis que le servo ne prend pas position
}
}
}

servo1_no void ()
{
myservo.attach (9);
pour (pos = 90; pos = 90; possession = 1) // va 180-0 degrés
{
myservo.write (pos); // Indique la position d'asservissement à travers une «pos« variable
retard (10); // Attend 15 ms, tandis que le servo ne prend pas position
}
}
servo2 void ()
{
myservo2.attach (10);
pour (pos2 = 110; pos2 < 140;="" pos2="" +="1)" ??="" 0="" ??="" 180="">
{//
myservo2.write (pos2); // Indique la position d'asservissement à travers une «pos« variable
retard (15); // Attend 15 ms, tandis que le servo ne prend pas position
}
}

annuler servo1R ()
{
myservo.write (90);
myservo.detach ();
}
annuler servo2R ()
{
myservo2.write (90);
myservo2.detach ();
}
lampblink void ()
{
// Int sensorValue = digitalRead (6);
// Si (sensorValue = 1) {
digitalWrite (ledPin, HIGH);
// Retard (1);
// DigitalWrite (ledPin, LOW);
// Retard (1);
//}
// Else
// DigitalWrite (ledPin, LOW);
}
REALISER ESSAI LMPE void ()
{
for (int i = 0; i <100;>
{
digitalWrite (12 HIGH);
retard (50);
digitalWrite (12 LOW);
retard (50);
}
}
lampoff void ()
{
// Retard (2000);
digitalWrite (ledPin, LOW);
}
// Akseleometr
annuler Ecom ()
{
unsigned char val [3];
int count = 0;
val [0] = val [1] = val [2] = 64;
Wire.requestFrom (0x4c, 3); // Demande 3 octets de l'appareil en mode esclave 0x4c
while (Wire.available ())
{
if (compter 63) // recharge
{
val [count] = Wire.receive ();
}
compter ++;
}
// Convertit le signal de 7 bits 8 bits
ret d'accélération;
ret.x = ((char) (val [0] 2)) / 4;
ret.y = ((char) (val [1] 2)) / 4;
ret.z = ((char) (val [2] 2)) / 4;
ystate = ret.y;
xstate = ret.x;
Serial.print ("x =");
Serial.println (ret.x, DEC); //
Serial.print («y =»);
Serial.println (ret.y, DEC); //
Serial.print ("z =");
Serial.println (ret.z, DEC); //
}
omble lecture = 0;

void loop ()
{
Ecom (); // Vérifiez l'état de l'accéléromètre
digitalWrite (ledPin2HIGH);
ButtonState = digitalRead (buttonPin); // Commutateur de position de lecture
if (ButtonState == HIGH)
{
lampblink (); // clignotants à DEL sur:
myservo.attach (9);
myservo2.attach (10);
val1 = ystate;
val1 = map (val130 -300 179);
myservo2.write (val1);
val2 = xstate;
val2 = map (val2 -30 300 179);
myservo.write (val2); // Définit la position d'asservissement en fonction de la valeur ranzhyruemыm
if (ystate valeur de seuil)
{
Serial.println ("OUI");
// DigitalWrite (ledNoise, HIGH);
play_4 ();
// Lampoff ();
lampblink ();
servo1_no ();
servo1_no ();
servo1R ();
retard (1000);
}
autre
{
lampoff ();
}
// Vérification pour le mouvement
int = sensorValue digitalRead (6); // Détecteur De Mouvement
if (sensorValue == 1)
{
Serial.println ("Move");
// Movestate = 1;
lampblink ();
// Servo2 ();
servo2_right ();
servo1_right ();
play_2 ();
retard (1000);
servo2_return ();
servo1_return ();
servo1_left ();
servo2_left ();
play_2 ();
retard (1000);
servo2_return ();
servo1_return ();
// Delay (1000);
}
autre
{
// DigitalWrite (ledNoise, LOW);
// Servo2 ();
servo1R ();
servo2R ();
lampoff ();
// Play_2 ();
// Movestate = 0;
}
}
}