Arduino Step Sequencer (3 / 5 stap)

Stap 3: Code

/* ======================================================================
Arduino Punk Console
Een eenvoudig programmeerbare 8 stepsequencer Toon
door dano/beavisaudio.com
Toerental
-----------------------------------
15 Sept djh eerste versie
======================================================================*/
Kaart van alle de input en output pinnen
#define AnalogInFrequency 1
#define AnalogInTempo 2
#define AnalogInDuration 0
#define DigitalOutSignal 11
#define DigitalInSwitch0 2
#define DigitalInSwitch1 3
#define DigitalInSwitch2 4
#define DigitalInSwitch3 5
#define DigitalInSwitch4 6
#define DigitalInSwitch5 7
#define DigitalInSwitch6 8
#define DigitalInSwitch7 9
#define DigitalInStartStop 10
#define DigitalOutLED 12
Instellen van de matrix voor elke stap
int stappen [] = {100,120,140,160,180,200,220,240};
misc huishouding
int duur = 50;
int pitchval = 1;
int fPlayMode = true;
int lastPushedStep = -1;
Initialiseren van het tempo
int tempo = 100;
VOID Setup
{
Setup pin modi (digitale pennen worden ingevoerd door standaard, maar
Ik 'em expliciet instellen, zodat de code duidelijk is.
pinMode (DigitalInSwitch0, INPUT);
pinMode (DigitalInSwitch1, INPUT);
pinMode (DigitalInSwitch2, INPUT);
pinMode (DigitalInSwitch3, INPUT);
pinMode (DigitalInSwitch4, INPUT);
pinMode (DigitalInSwitch5, INPUT);
pinMode (DigitalInSwitch6, INPUT);
pinMode (DigitalInSwitch7, INPUT);
pinMode (DigitalInStartStop, INPUT);
pinMode (DigitalOutSignal, uitvoer);
pinMode (DigitalOutLED, uitvoer);

}

void loop
{
Hoofdreeks lus
for (int i = 0; ik < 8; i ++)
{
We spelen of stoppen?
fPlayMode = digitalRead (DigitalInStartStop);
digitalWrite (DigitalOutLED, hoge);
Controleer of de Hardware
readSwitches();
readPots();

de weergave bijwerken
updateDisplay();

Het lawaai maken
Als (fPlayMode)
{
freqout (stappen [i], duur);
}
digitalWrite (DigitalOutLED, laag);

Pauze tussen stappen
vertraging (tempo);
}
}

VOID updateDisplay()
{
Serial.Print (254, BYTE);
Serial.Print (192, BYTE);
Serial.Print ("T:");
Serial.Print (tempo);
Serial.Print ("d:");
Serial.Print (duur);
Als (lastPushedStep! = -1)
{
Serial.Print ("*");
Serial.Print (lastPushedStep);
}
}
Lees de huidige waarden van de potten, genaamd uit de lus.
VOID readPots)
{
tempo = (analogRead (AnalogInTempo) * 1.9);
duur = (analogRead (AnalogInDuration));
}
Lees de huidige waarden van de schakelaars en
Als ingedrukt, vervangt u de schakelaar de sleuf frequentie
door het lezen van de frequentie-pot.
VOID readSwitches()
{
nummer van de laatste ingedrukte knop Reset
lastPushedStep = -1;

Controleer wissel 0, wanneer ingedrukt, krijgen de huidige freq in stap 0, etc. etc.
Als (digitalRead (DigitalInSwitch0) == HIGH)
{
stappen [0] = analogRead(AnalogInFrequency);
lastPushedStep = 1;
}

anders als (digitalRead (DigitalInSwitch1) == HIGH)
{
stappen [1] = analogRead(AnalogInFrequency);
lastPushedStep = 2;
}

anders als (digitalRead (DigitalInSwitch2) == HIGH)
{
stap [2] = analogRead(AnalogInFrequency);
lastPushedStep = 3;
}
anders als (digitalRead (DigitalInSwitch3) == HIGH)
{
stappen [3] = analogRead(AnalogInFrequency);
lastPushedStep = 4;
}
anders als (digitalRead (DigitalInSwitch4) == HIGH)
{
stappen [4] = analogRead(AnalogInFrequency);
lastPushedStep = 5;
}
anders als (digitalRead (DigitalInSwitch5) == HIGH)
{
stappen [5] = analogRead(AnalogInFrequency);
lastPushedStep = 6;
}
anders als (digitalRead (DigitalInSwitch6) == HIGH)
{
stappen [6] = analogRead(AnalogInFrequency);
lastPushedStep = 7;
}
anders als (digitalRead (DigitalInSwitch7) == HIGH)
{
stappen [7] = analogRead(AnalogInFrequency);
lastPushedStep = 8;
}
}

de code van de freqout door Paul Badger
freq - frequentie waarde
t - tijdsduur van Toon
VOID freqout (int freq, int t)
{
int hperiod;     1/2 periode in ons berekenen
lange cycli, i;

aftrekken 7 Amerikaanse te maken voor digitalWrite overhead - empirisch bepaald
hperiod = (500000 / ((freq-7) * pitchval));

berekenen van cycli
cycli = ((lange) freq * (lange) t) / 1000;    berekenen van cycli
voor (ik = 0; ik < = cycli; i ++)
{/ / Opmerking voor t ms spelen
digitalWrite (DigitalOutSignal, hoge);
delayMicroseconds(hperiod);
digitalWrite (DigitalOutSignal, laag);
delayMicroseconds (hperiod - 1);     -1 te maken voor fractionele microseconde in digitaWrite overhead
}
}