Étape 3: Code
/* ======================================================================
Arduino Punk Console
Un séquenceur de ton étape simple 8 programmables
par dano/beavisaudio.com
Nombre de tours
-----------------------------------
Version initiale de 15 Sept djh
======================================================================*/
Carte toutes les broches d’entrée et de sortie
#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
Mettre en place le tableau pour chaque étape
les étapes d’int [] = {100,120,140,160,180,200,220,240} ;
entretien ménager misc
durée de l’int = 50 ;
int pitchval = 1 ;
int fPlayMode = true ;
int lastPushedStep = -1 ;
Initialiser le tempo
int tempo = 100 ;
void setup()
{
broche modes d’installation (numérique broches sont d’entrée par défaut, mais
J’aime em définie explicitement juste pour que le code est clair.
pinMode (entrée, DigitalInSwitch0) ;
pinMode (entrée, DigitalInSwitch1) ;
pinMode (entrée, DigitalInSwitch2) ;
pinMode (entrée, DigitalInSwitch3) ;
pinMode (entrée, DigitalInSwitch4) ;
pinMode (entrée, DigitalInSwitch5) ;
pinMode (entrée, DigitalInSwitch6) ;
pinMode (entrée, DigitalInSwitch7) ;
pinMode (entrée, DigitalInStartStop) ;
pinMode (DigitalOutSignal, sortie) ;
pinMode (DigitalOutLED, sortie) ;
}
void loop()
{
Boucle de la séquence principale
pour (int i = 0; i < 8; i ++)
{
Allons-nous jouer ou s’arrêter ?
fPlayMode = digitalRead (DigitalInStartStop) ;
digitalWrite (DigitalOutLED, élevé) ;
Vérifier le matériel
readSwitches() ;
readPots() ;
mise à jour de l’affichage
updateDisplay() ;
Faire du bruit
Si (fPlayMode)
{
FreqOut (étapes [i], durée) ;
}
digitalWrite (DigitalOutLED, basse) ;
Faire une pause entre les étapes
retard (tempo) ;
}
}
Sub updateDisplay()
{
Serial.Print (254, BYTE) ;
Serial.Print (192, BYTE) ;
Serial.Print ("t") ;
Serial.Print (tempo) ;
Serial.Print ("d:") ;
Serial.Print (durée) ;
Si (lastPushedStep! = -1)
{
Serial.Print ("*") ;
Serial.Print (lastPushedStep) ;
}
}
Lire les valeurs actuelles des pots, appelées à partir de la boucle.
Sub readPots ()
{
tempo = (analogRead (AnalogInTempo) * 1,9) ;
durée = (analogRead (AnalogInDuration)) ;
}
Lire les valeurs actuelles des interrupteurs et
Si vous appuyez sur, remplacer fréquence de fente du switch
en lisant le pot de fréquence.
Sub readSwitches()
{
réinitialiser le dernier numéro du bouton poussé
lastPushedStep = -1 ;
Vérifiez le commutateur 0, si vous appuyez sur, entrer la freq actuelle dans étape 0, etc etc.
Si (digitalRead (DigitalInSwitch0) == HIGH)
{
mesures [0] = analogRead(AnalogInFrequency) ;
lastPushedStep = 1 ;
}
ElseIf (digitalRead (DigitalInSwitch1) == HIGH)
{
les étapes [1] = analogRead(AnalogInFrequency) ;
lastPushedStep = 2 ;
}
ElseIf (digitalRead (DigitalInSwitch2) == HIGH)
{
étapes [2] = analogRead(AnalogInFrequency) ;
lastPushedStep = 3 ;
}
ElseIf (digitalRead (DigitalInSwitch3) == HIGH)
{
mesures [3] = analogRead(AnalogInFrequency) ;
lastPushedStep = 4 ;
}
ElseIf (digitalRead (DigitalInSwitch4) == HIGH)
{
les étapes [4] = analogRead(AnalogInFrequency) ;
lastPushedStep = 5 ;
}
ElseIf (digitalRead (DigitalInSwitch5) == HIGH)
{
les étapes [5] = analogRead(AnalogInFrequency) ;
lastPushedStep = 6 ;
}
ElseIf (digitalRead (DigitalInSwitch6) == HIGH)
{
étapes [6] = analogRead(AnalogInFrequency) ;
lastPushedStep = 7 ;
}
ElseIf (digitalRead (DigitalInSwitch7) == HIGH)
{
mesures [7] = analogRead(AnalogInFrequency) ;
lastPushedStep = 8 ;
}
}
code FreqOut par Paul Badger
FREQ - valeur de la fréquence
t - durée du tonus
void freqout (int freq, int t)
{
int hperiod ; calculer la période de 1/2 en nous
cycles de temps, j’ai ;
soustraire 7 US pour compenser les frais généraux - digitalWrite déterminée empiriquement
hperiod = (500000 / ((freq-7) * pitchval)) ;
calculer les cycles
cycles = (freq (long) * t (long)) / 1000 ; calculer les cycles
pour (i = 0; i < = cycles; i ++)
{/ / Jouez note pour t ms
digitalWrite (DigitalOutSignal, élevé) ;
delayMicroseconds(hperiod) ;
digitalWrite (DigitalOutSignal, basse) ;
delayMicroseconds (hperiod - 1) ; -1 pour compenser microseconde fractionnaire à une surcharge de digitaWrite
}
}