MIDI contrôlée synthétiseur FM analogique (4 / 4 étapes)

Étape 4: Temps de jeu

Voici une vidéo de démonstation de ce que mon build sonnait comme lorsque vous utilisez un amplificateur alimenté par la batterie: http://youtu.be/JzKzRq4mcdk

//____________________________________________________
/*

write_pot (0, 0) ;  Seuil de 7555car,
write_pot (1, 0) ;  Décharge de 7555car,
write_pot (2, 0) ;  7555car Volume,
write_pot (3, 0) ;  7555mod vol, effectivement les indice de modulation
write_pot (4, 0) ;  Seuil de 7555mod
write_pot (5, 0) ;  7555mod décharge

Quand seuil et décharge sont déplacés ensemble sur une seule puce (transporteur ou modulateur)
ils contrôlent la fréquence, lorsque déplacé indépendamment, ils contrôlent le terrain mais avec l’évolution
puslewidth ou devoir cicle.  Cela modifie le timbre de la sortie.

*/

Réglage des paramètres prédéfinis.
échelle de 0 à 127 en autant pour chaque pot, volume est gravie différemment des autres paramètres.
int data_scale [] = {2, 2, 1,25, 1.25, 2, 2} ;

vous devrez jouer avec ce numéro pour obtenir vos numéros de contrôleur alignés avec les 6 paramètres.
int controllerOffSet = 0 ; ce nombre est specfic au contrôleur midi novation

int DATAOUT = 11 ;
int DATAIN = 12 ;      MISO - ne pas utilisé, mais une partie de builtin SPI
int SPICLOCK = 13 ;    SCK
int SLAVESELECT = 10 ;  SS
int incomingByte = 0 ;
Remarque int = 0 ;
vel int = 0 ;
contrôleur d’int = 0 ;
valeur int = 0 ;

résistance de l’octet = 0 ;
int indice ;
int outdex ;

void setup()
{
Vitesse de transmission MIDI set :
Serial.Begin(31250) ;
débogueur, ou baud contrôle série
Serial.Begin(9600) ;

octet i = 0 ;
clr octets = 0 ;

goupilles de configuration pour fonctionner avec SPI
pinMode (DATAOUT, sortie) ;
pinMode (DATAIN, entrée) ;
pinMode(SPICLOCK,OUTPUT) ;
pinMode(SLAVESELECT,OUTPUT) ;
digitalWrite(SLAVESELECT,HIGH) ; désactiver le périphérique
SPCR = 01010000
Interrupt désactivé, spi activé, msb 1er, maître, clk faible lors de l’inactivité,
exemple sur le bord d’attaque de clk, système horloge/4 (plus rapide)
SPCR = (1 << SPE) | (1 << MSTR) ;
CLR = SPSR ;
CLR = SPDR ;
Delay(10) ;

Flash une LED et flash chaque adresse numérique pot (pour le débogage) et pour faire taire le circuit

Tous les pots la valeur minimale/maximale résistance et vice versa
pour (i = 0; i < 6; i ++)
{
digitalWrite (2, haut) ;
Delay(100) ;
write_pot(i,0) ;
digitalWrite (2, basse) ;
Delay(100) ;
}
Delay(1000) ;  Attendez une seconde


pour (i = 0; i < 6; i ++)
{
digitalWrite (2, haut) ;
Delay(100) ;
write_pot (i, 255) ;
digitalWrite (2, basse) ;
Delay(100) ;
255 = résistance totale...
}

}

programme principal
void loop()
{


Si (Serial.available() > 0) {}
incomingByte = Serial.read() ;

voir s’il y a un format de message spécifique, si un octet de statut MIDI spécifique est détecté, puis
traiter les deux prochains octets entrants sous forme d’octets de données
//
Si (incomingByte == 176) {/ / le message d’État pour le canal de midi cc 1
Delay(1) ;
l’octet suivant, noter que le numéro du contrôleur
Contrôleur = Serial.read() - controllerOffSet ;
Delay(1) ;
enregistrer le troisième octets pour les données de contrôleur ou de la valeur
valeur = Serial.read() ;

}
Si le numéro du contrôleur est dans la bonne fourchette,
le numéro du contrôleur permet de paramétrer l’adresse (1 des 6 résistances) et
la valeur de ce contrôleur permet de définir la résistance de ladite adresse

Si (contrôleur < 6 & & contrôleur > = 0) {}

certains paramètres peuvent besoin d’échelle,
write_pot (contrôleur, ((valeur * data_scale[controller]))) ;

une LED s’allume lorsque les données sont envoyées (pour le feedback utilisateur/débogage)
digitalWrite (2, haut) ;
Delay(1) ;
} / / fin si contrôleur
} / / fin si série

Delay(1) ;
digitalWrite (2, basse) ;
} / / fin de boucle principale

//-----------------------------------------------------------custom function calls--------------------

fonction pour envoyer des données à une adresse particulière
write_pot octet (adresse int, int valeur)
{
digitalWrite(SLAVESELECT,LOW) ;
2 octets opcode
spi_transfer(Address) ;
spi_transfer(value) ;
digitalWrite(SLAVESELECT,HIGH) ; puce, de sortie du signal transfert fin
}

fonction pour les données de transfert sur SPI
char spi_transfer (données char volatils)
{
SPDR = données ;                    Démarrer la transmission
while (!. (SPSR & (1 << SPIF)))     Attendez la fin de la transmission
{
};
retour SPDR ;                    retourne l’octet reçu
}