Khruschov frigorifero

Totale 200 rubli per comprare una buona base per un lavoro semplice. Il progetto è stato completato con i colleghi stranieri Adruino Arts. Per la sua attuazione deve conoscere i principi fondamentali della robotica, elettronica e capire un po 'di programmazione.
Nel video autore racconta e mostra che dobbiamo fare risultato.
Oltre al lampade occorre un insieme di Grove - giocattolo Kit. Ordinare online è possibile acquistare per prezzo 79,9 $.
L'idea principale - la definizione di stato statico o dinamico dell'oggetto dalla rilevazione del movimento. Se la risposta è positiva, quindi eseguire uno degli attuatori e la riproduzione del messaggio pre-registrato. Altrimenti, attivato 2a servo, e una registrazione suono diverso.
Determinazione di passare attraverso qualche forma di input. Così, si ottiene il risultato in codice binario 0 o 1.
Recorder può riprodurre l'audio registrato solo 4 tramite un segnale esterno. Per registrare (ogni 15 sec.), È necessario accendere il pulsante «gioco» a «registrare». Dopo la registrazione di nuovo il tasto dovrebbe passare. Questo può essere fatto tramite codice (riproduzione function ()). In servo cavo è di 3 "plus", "meno" e i dati digitali. Il primo 2 forniscono cibo per servo (max 7) e 3a collega ad una uscita digitale, che riceve informazioni sullo stato dell'interruttore e per codice.
Prima lampada analizzato. Non abbiamo bisogno di componenti elettrici, ma dobbiamo lavorare molto fondamento. È inoltre necessario alcuni oggetti di scena e elementi di sostegno.
Fare un buco nel tubo per collegare il nostro design.
Il prototipo robot è pronto!

Fase 1: Glow
Utilizzando la lampada a LED IKEA OLEBY (Food a energia solare).
L'interruttore funziona solo in un dispositivo digitale, e quindi dipende dalla rete corrente. Se passiamo podsoedynym Pay Seeeduino, è possibile impostare il LOW uscita digitale, e poi ci sarà corrente. Quando la messa HIGH, riappare.
Anche all'interno della lampada e si collega un resistore per proteggere il LED.
Impostare l'elemento luce nella base metallica.

Fase 2: Principio
Abbiamo il carico collegato servo di controllo del rivelatore, triple accelerometro asse, registratore e giocare 4 suoni differenti.
Il principio di base della lampada è il seguente:

Si scopre il rumore (audio)
Lampada inclusa
Runs №3 disco
Lampada a mano fornisce movimento (sinistra-destra-sinistra)
Servo rimane a 90 °
Transazione completata

Se c'è rumore, quindi:

Lampada inclusa
Servo con mossa lampada a sinistra
Runs №2 disco
Lampada torna in posizione di 90 °
Transazione completata

Se il braccio di metallo raggiunge una certa posizione (alto), poi giocare registrare №4.

Fase 3: Miglioramento
Nel lavoro di progettazione in grado di apportare alcuni miglioramenti come incorporare una tassa interruttore Seeeduino, per controllare l'esecuzione di codice con un ciclo regolare IF. Se l'interruttore è acceso - avviare la modalità automatica, se non - modalità manuale.
Auto-mode include il codice standard quando la lampada risponde al suono.
Manual-mode fornisce gestione remota attraverso un accelerometro a tre assi, modificando la posizione degli assi X e Y.
È possibile fare un giro luci su 360 °, aggiungendovi un servo separato. Posso impostare per la connessione via Wi-Fi / Ethernet.
Fase 4: Codice
Autore codice (MrLdnr) si può trovare qui di seguito.
[Spoiler]
#include
const int buttonPin = 4; // Commutatore di posizione
int buttonState = 0; // Variabile per leggere pulsanti di posizione
// Setup Servo
Servo myservo2;
Servo myservo; // Crea per servocomando
int pos = 0; // Variabile per memorizzare la posizione del servo
int pos2 = 0; // Variabile per memorizzare la posizione del servo
int val1;
int val2;
// SETUP LED
const int ledPin2 = 5; // luce principale
const int ledPin = 12; luce del tubo //
int countlamp2 = 0;
// Setup Noise
const int thresholdvalue = 300; // La risposta al suono
// Set akseleometra
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
Classe Acceleration
{
pubblico:
char x;
char y;
z char;
};

Indice char;
Controllo char;
Stato char;
int audiodelay = 1000;
mma7660_init void (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); // Campioni / Second Active Mode e Auto-sonno
Wire.endTransmission ();
Wire.beginTransmission (MMA766ddr);
Wire.send (MMA7660_MODE);
Wire.send (0x01); modalità attiva //
Wire.endTransmission ();
}

void setup ()
{
mma7660_init (); // Iscriviti bus I2C (indirizzo selettivo dispositivo master)
Serial.begin (9600);
// Sensore Di Movimento
pinMode (6 INPUT); // usato 2 metri per segnale esterno
// Luce della lampada e base a luce
pinMode (ledPin, OUTPUT);
pinMode (ledPin2 OUTPUT);
// SERVI
// AUDIO
DDRD | = 0x0C; // D2 e D3 di scrittura in modalità;
PORTD & = 0xF3; // D2 e D3 impostato su basso;
// Sensore Noise su Analog 0
// INTERRUTTORE GENERALE
pinMode (buttonPin, INPUT);
}
rec_2_begin void ()
{
PORTD = (PORTD | 0b00000100) & 0b11110111;
}
rec_2_stop void ()
{
PORTD & = 0xF3;
}
play_2 vuoto ()
{
PORTD = (PORTD | 0b00000100) & 0b11110111;
delay (audiodelay);
PORTD & = 0xF3;
}
////////////////////////////////////////////////// ////////////////////
////////////////////////////////////////////////// /////
// Funzione per il controllo del segment_3
rec_3_begin void ()
{
PORTD = (PORTD | 0b00001000) & 0b11111011;
}
rec_3_stop void ()
{
PORTD & = 0xF3;
}
play_3 vuoto ()
{
PORTD = (PORTD | 0b00001000) & 0b11111011;
delay (audiodelay);
PORTD & = 0xF3;
}
////////////////////////////////////////////////// ///
////////////////////////////////////////////////
// Funzione per il controllo del segment_4;
rec_4_begin void ()
{
PORTD = PORTD | 0b00001100;
}
rec_4_stop void ()
{
PORTD & = 0xF3;
}
play_4 vuoto ()
{
PORTD = PORTD | 0b00001100;
delay (audiodelay);
PORTD & = 0xF3;
}
//////////////////////

check_move void ()
{
int SensorValue = digitalRead (6);
if (SensorValue == 1)
{
// DigitalWrite (ledPin, HIGH);
//Serial.println(sensorValue, DEC); // uscita il segnale di posizione al monitor.
// SERVO1 ();
}
altra cosa
{
// DigitalWrite (ledPin, LOW);
//Serial.println(sensorValue, DEC); // uscita il segnale di posizione al monitor.
// Servo2 ();
}
}
servo1_right void ()
{
myservo.attach (9);
per (pos = 90; pos = 90; possesso = 1) // va da 0 a 180 gradi
{
myservo.write (pos); // Indica la posizione del servo attraverso un 'pos' variabile
ritardo (10); // Attende 15 ms finché il servo prende la posizione
} * /
}
servo1_left void ()
{
myservo.attach (9);
for (pos = 90; pos & gt; 1; pos - = 1) // passa da 0 a 180 gradi
{// Aggiunge 1 grado
myservo.write (pos); // Indica la posizione del servo attraverso un 'pos' variabile
ritardo (10); // Attende per 15 ms, mentre il servo non prende posizione
} / *
play_2 ();
ritardo (1000);
for (pos = 1; pos90) {
for (pos = posact; pos & gt; 90; pos - = 1) // restituisce 90 gradi
{// Aggiunge 1 grado
myservo.write (pos); // Indica la posizione del servo attraverso un 'pos' variabile
ritardo (10); // Attende per 15 ms, mentre il servo non prende posizione
}
}
altra cosa {
for (pos = posact, pos 60, pos - = 1) // passa da 0 a 180 gradi
{// Aggiunge 1 grado
myservo2.write (pos); // Indica la posizione del servo attraverso un 'pos' variabile
ritardo (10); // Attende per 15 ms, mentre il servo non prende posizione
} / *
play_2 ();
ritardo (1000);
for (pos = 1; pos90) {
for (pos = posact; pos & gt; 90; pos - = 1) // restituisce la posizione di 90 gradi
{// Aggiunge 1 grado
myservo2.write (pos); // Indica la posizione del servo attraverso un 'pos' variabile
ritardo (10); // Attende per 15 ms, mentre il servo non prende posizione
}
}
altra cosa {
for (pos = posact; pos <=90 ;="" pos="" +="1)" goes="" from="" 0="" degrees="" to="" 180="">
{// Aggiunge 1 grado
myservo2.write (pos); // Indica la posizione del servo attraverso un 'pos' variabile
ritardo (10); // Attende per 15 ms, mentre il servo non prende posizione
}
}
}

servo1_no void ()
{
myservo.attach (9);
for (pos = 90; pos = 90; pos- = 1) // va 180-0 gradi
{
myservo.write (pos); // Indica la posizione del servo attraverso un 'pos' variabile
ritardo (10); // Attende per 15 ms, mentre il servo non prende posizione
}
}
servo2 void ()
{
myservo2.attach (10);
for (pos2 = 110; pos2 < 140;="" pos2="" +="1)" ??="" 0="" ??="" 180="">
{//
myservo2.write (pos2); // Indica la posizione del servo attraverso un 'pos' variabile
ritardo (15); // Attende per 15 ms, mentre il servo non prende posizione
}
}

annullare servo1R ()
{
myservo.write (90);
myservo.detach ();
}
annullare servo2R ()
{
myservo2.write (90);
myservo2.detach ();
}
lampblink void ()
{
// Int SensorValue = digitalRead (6);
// Se (SensorValue 1 =) {
digitalWrite (ledPin, HIGH);
// Delay (1);
// DigitalWrite (ledPin, LOW);
// Delay (1);
//}
// Altra Cosa
// DigitalWrite (ledPin, LOW);
}
lamptest void ()
{
for (int i = 0; i <100;>
{
digitalWrite (12 HIGH);
ritardo (50);
digitalWrite (12 LOW);
ritardo (50);
}
}
lampoff void ()
{
// Delay (2000);
digitalWrite (ledPin, LOW);
}
// Akseleometr
annullare Ecom ()
{
val char unsigned [3];
int count = 0;
val [0] = val [1] = val [2] = 64;
Wire.requestFrom (0x4c, 3); // Chiede 3 byte dal dispositivo in modalità slave 0x4c
while (Wire.available ())
{
se (contare 63) // ricariche
{
val [count] = Wire.receive ();
}
contare ++;
}
// Converte il segnale di 7 bit 8 bit
Accelerazione ret;
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); //
}
char lettura = 0;

void loop ()
{
Ecom (); // Controllare lo stato dell'accelerometro
digitalWrite (ledPin2HIGH);
buttonState = digitalRead (buttonPin); // Interruttore di posizione di lettura
if (buttonState == HIGH)
{
lampblink (); // di direzione a LED on:
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); // Imposta la posizione del servo secondo il valore ranzhyruemыm
if (ystate thresholdvalue)
{
Serial.println ("SI");
// DigitalWrite (ledNoise, HIGH);
play_4 ();
// Lampoff ();
lampblink ();
servo1_no ();
servo1_no ();
servo1R ();
ritardo (1000);
}
altra cosa
{
lampoff ();
}
// Controllo del movimento
int SensorValue = digitalRead (6); // Motion Detector
if (SensorValue == 1)
{
Serial.println ("Move");
// Movestate = 1;
lampblink ();
// Servo2 ();
servo2_right ();
servo1_right ();
play_2 ();
ritardo (1000);
servo2_return ();
servo1_return ();
servo1_left ();
servo2_left ();
play_2 ();
ritardo (1000);
servo2_return ();
servo1_return ();
// Delay (1000);
}
altra cosa
{
// DigitalWrite (ledNoise, LOW);
// Servo2 ();
servo1R ();
servo2R ();
lampoff ();
// Play_2 ();
// Movestate = 0;
}
}
}