Arduino baserad leksak för barn (4 / 6 steg)

Steg 4: Arudino kod

#include "pitches.h" / / innehåller anteckningar refereras i denna kod.

int tonepin = 3; att spela musikaliska toner
int loadpin = 9;
int clockpin = 7.
int SOpin = 8.

osignerade långa idle_time;

byte registerContent = 0;
byte registerContent2 = 0;
lång loWord; tidigare var ett heltal
int bitContent = 0;
lång idle_millseconds = 0;

PIN ansluten till spärren stift (ST_CP) 74HC595
CONST int latchPin_595 = 10; tidigare 10
PIN ansluten till klockan stift (SH_CP) 74HC595
CONST int clockPin_595 = 12; tidigare 12
PIN ansluten till Data i (DS) av 74HC595
CONST int dataPin_595 = 11; tidigare 11
int bitToSet; bit på 595 SKIFT register att ställa

int button_Switch1 = 2;

int melodi [] = {
NOTE_C4, NOTE_G3, NOTE_E7, NOTE_A3, NOTE_G3, NOTE_A4, NOTE_D8, NOTE_B6};

#define white_button 8
#define yellow_button 32
#define blue_button 1
#define red_button 2
#define green_button 16

#define red_led 0 / / bitars för att skriva på 595 register
#define white_led 4
#define blue_led 1
#define green_led 2
#define yellow_led 3

lång joy1_up = 32768;
lång joy1_down = 2048;
lång joy1_left = 8192;
lång joy1_right = 512;

lång joy2_up = 4096;
lång joy2_down = 1024;
lång joy2_left = 16384;
lång joy2_right = 256;

Ogiltiga inställningar)
{
pinMode (loadpin, produktionen);
pinMode (clockpin, produktionen);
pinMode (SOpin, indata);

ställa in stift att produktionen eftersom de behandlas i de viktigaste loopen
pinMode (latchPin_595, produktionen);
pinMode (dataPin_595, produktionen);
pinMode (clockPin_595, produktionen);

pinMode (button_Switch1, ingång); 5 knappen växlar med lysdioder

digitalWrite (loadpin, låg);
digitalWrite (clockpin, hög);
digitalWrite (button_Switch1, låg);

led_check(1); tänds lysdioderna och spela en enda ton... Random

Serial.BEGIN(9600);

idle_time=Millis();
}

Ogiltig loop)
{
för (int idx = 0; idx < 16; idx ++)
{
om (idx == 0)
{
pulseload();
}
bitContent = digitalRead (SOpin);

om (bitContent == 1 & & idx < 8)
{
bitWrite(registerContent,idx,1);
}
annat if (bitContent == 1 & & idx > = 8)
{
bitWrite (registerContent2, idx-8,1);
}
annat if (bitContent == 0 & & idx < 8)
{
bitWrite (registerContent, idx, 0);
}
annat if (bitContent == 0 & & idx > = 8)
{
bitWrite (registerContent2, idx-8,0);
}

pulseclock();
}
slutet av klockcykel för 2 SKIFT register.

loWord = ord (registerContent, registerContent2); konvertera två byte i ett ord
Serial.Print ("Output värde:");
Serial.println(loWord,dec); skriva ut ordet som ett decimaltal

Switch(loWord) {
fall 36864:
Serial.println ("båda upp");
bitToSet = red_led;
registerWrite (bitToSet, hög);
Playtone(2);
bryta;
fall 3072:
Serial.println ("båda ned");
bitToSet = green_led;
registerWrite (bitToSet, hög);
Playtone(2);
bryta;
fall 24576:
Serial.println ("båda vänster");
bitToSet = white_led;
registerWrite (bitToSet, hög);
Playtone(2);
bryta;
fall 768:
Serial.println ("båda rätt").
bitToSet = blue_led;
registerWrite (bitToSet, hög);
Playtone(2);
bryta;
mål 8:
Serial.println ("vita knappen");
bitToSet = white_led;
registerWrite (bitToSet, hög);
Playtone(1);
bryta;
fall 32:
Serial.println ("gula knappen");
bitToSet = yellow_led;
registerWrite (bitToSet, hög);
Playtone(1);
bryta;
fall 1:
Serial.println ("blå knapp");
bitToSet = blue_led;
registerWrite (bitToSet, hög);
Playtone(1);
bryta;
fall 2:
Serial.println ("röd knapp");
bitToSet = red_led;
registerWrite (bitToSet, hög);
Playtone(1);
bryta;
fall 16:
Serial.println ("gröna knappen");
bitToSet = green_led;
registerWrite (bitToSet, hög);
Playtone(1);
bryta;

standard:
ingenting skjutet eller okänt sekvens
för (int thisPin = 0; thisPin < 16; thisPin ++) {
registerWrite (thisPin, låg);
}
registerContent = 0;
registerContent2 = 0;

} / / end fall / växla

fånga in aktuell tid

check_idle_time(); Kolla inaktivitet tid

Serial.Print ("registrera 1:");
Serial.println (registerContent, BIN);
Serial.Print ("registrera 2:");
Serial.println (registerContent2, BIN);
Serial.println (byte(10));
registerContent = 0;

fördröjning (250);
}

void pulseload)
{
digitalWrite (loadpin, hög);
fördröjning (5).
digitalWrite (loadpin, låg);
}

void pulseclock)
{
digitalWrite (clockpin, låg);
fördröjning (5).
digitalWrite (clockpin, hög);
}

void registerWrite (int whichPin, int whichState) {
de bitar som du vill skicka
byte bitsToSend = 0;

stänga av utdata så att stiften inte tänds
medan du skiftande bitar:
digitalWrite (latchPin_595, låg);

Aktivera den nästa högsta biten i bitsToSend:
bitWrite (bitsToSend, whichPin, whichState);

flytta bitarna ut:
shiftOut (dataPin_595, clockPin_595, MSBFIRST, bitsToSend);

Aktivera utdata så att lamporna kan lysa upp:
digitalWrite (latchPin_595, hög);

}

Annullera playtone (int num_of_tones) {
spela ett slumpmässigt meddelande från melodi
för (int jag = 0; jag < num_of_tones; i ++) {
int rand_note = random(0,7); Välj en anteckning från melody array
int rand_duration = (random(1,2)) * 4. antingen 4 eller 8
för att beräkna noterar varaktighet, ta en sekund
dividerat med Noteringstyp.
e.g. fjärdedelsnot = 1000 / 4, åttondelen noterar = 1000/8, etc.
int noteDuration = 1000/rand_duration;
tonen (tonepin, melody[rand_note],noteDuration);

Ange en minsta tid mellan dem för att skilja anteckningar.
tonens längd + 30% verkar fungera bra:
int pauseBetweenNotes = noteDuration * 1,30;
Delay(pauseBetweenNotes);
stoppa tonen uppspelningen:
noTone(tonepin);
idle_time=Millis();
}
}

void led_check(int tone_count)
{

för (int led_bit = 0; led_bit < 5; led_bit ++) {
registerWrite (led_bit, hög);
Playtone (tone_count);
fördröjning (250);
registerWrite (led_bit, låg);
idle_time=Millis(); återställa inaktiv timer
}
}

void check_idle_time() {

om (millis() > idle_time + 600000) {
10 minuters inaktivitet
led_check(2); Light lysdioder spela 2 toner
idle_time=Millis();
}
}