Kit de batterie MIDI minimal avec imprimante 3D

Outils et machines nécessaires

	Imprimante 3D (générique)
	Coupe laser (générique) pas nécessaire, extra
	Fer à souder (générique)
	coupe-cercle

Applications et services en ligne

Arduino IDE

À propos de ce projet

Salut.

Il s'agit d'un kit de batterie minimal utilisant arduino UNO.

Tout d'abord, s'il vous plaît vérifier cette page instructables.

https://blog.arduino.cc/2017/01/19/a-3d-printed-e-drum-pad/

Depuis que j'ai commencé à le faire, j'ai été captivé par le piezo et la batterie électronique.

J'étais fasciné par un mécanisme très simple de batterie électronique et la grande invention appelée MIDI.

En d'autres termes, je ne pouvais pas être satisfait simplement en fabriquant des tampons.

Ce kit de batterie est grossièrement divisé en deux productions.

1.Pad réalisé avec une imprimante 3D et du papier épais.

2.Trigger midi convertisseur avec arduino UNO.

Le signal envoyé depuis le pad de " 1 " est traité par l'arduino de " 2 " et converti en signal MIDI. Et le signal MIDI est transmis de l'arduino à l'iPhone, à l'ordinateur portable, etc., et le son sort.

Vous n'avez pas besoin de préparer une alimentation autre qu'un smartphone ou un PC.

Ce dont vous aurez besoin

Outils

・Imprimante 3D

・Coupe laser (extra)

・clé hexagonale

couteau de coupe

・coupe-cercle

・Fer à souder

・ Coupe-tube

・perceuse à percussion

・foret 9mm / 10mm

Matériel

・Papier de 1 mm d'épaisseur

Filament PLA

・Feuilles de mousse éponge 5mm / 10mm

・MDF 2.5mm / 5.5mm (Extra)

・M6 - Boulon et écrous de 70 mm

・M6 - Boulon et écrous 50 mm

・M3 - Boulon et écrous de 10 mm

・M3 - Boulon et écrous de 15 mm

・M3 - Boulon et écrous de 25 mm

・Vis M2

Tuyau en acier inoxydable de 13 mm de diamètre

Matériel de batterie

・Tête de maille 10 pouces/8 pouces

・Stand de caisse claire (Tout est OK. J'utilise YAMAHA SS662.)

・Support de charleston (Tout est OK. J'utilise YAMAHA HS650A)

Pédale de kick (Tout va bien. J'utilise YAMAHA FP7210A)

・Bâton de tambour

Étape 1 :Impression 3D

Toutes les données sont sur Thingiverse et GitHub.

Veuillez utiliser la Ver.2 pour la jante.

J'ai imprimé des pièces avec un remplissage à 20%. L'épaisseur de la couche est de 0,3 mm.

En outre, vous pouvez utiliser un cutter laser pour fabriquer un tampon.

https://github.com/RyoKosaka/drums/tree/master/vector

Etape 2 :Assemblage

Utilisez des boulons et des écrous M3-10mm pour connecter les pièces ensemble.

Utilisez les boulons M3-15 mm ou M3-25 mm pour la partie centrale afin de fixer la partie inférieure l'une à l'autre.

Étape 3 :Fabrication de Shell

Premièrement, la hauteur de la coque est de 55 mm.

Veuillez faire trois bandes d'une largeur de 55 mm.

La longueur est légèrement plus longue que la longueur couvrant le coussin.

Puisqu'il y a un espace en bas, essayez d'insérer une bande dans cet espace.

Coupez la bande de manière à ce qu'elle soit d'une longueur de cercle parfaite.

Répétez cette opération 3 fois et superposez avec de l'adhésif.

Lorsque la coque sèche, avec la tête de maille fixée, faites un trou de 9 mm de diamètre pour la douille.

Vous pouvez utiliser des écrous papillon, mais j'ai également fabriqué des clés de réglage qui peuvent être serrées même avec des écrous ordinaires, alors utilisez-les par tous les moyens.

Pour la fixation de la tête grillagée, utilisez des boulons M6-70 mm.

Une fois que vous avez fait un trou, retirez à nouveau la tête grillagée pour mettre un piezo

Étape 4 :Fixation Piezo

COLLIER

Dans le cas d'une caisse claire, utilisez deux piezo comme indiqué sur la photo.

Connectez le câble rouge du piézo à chacun des embouts et anneaux.

Les deux câbles noirs se connectent au manchon.

N'oubliez pas de faire passer les câbles dans les trous de la plaque du capteur lors de la soudure.

Le piézo pour la tête (piezo connecté à la pointe) doit être pris en sandwich avec une mousse éponge de 10 mm d'épaisseur, comme indiqué sur l'image.

Un en bas, trois en haut. Et faites les 3 premiers cônes comme sur la photo.

Ensuite, placez-le sur la plaque du capteur.

KICK

Étant donné que le pad de grosse caisse n'utilise qu'un seul piézo, seule la pointe peut être utilisée.

Aucune plaque de détection n'est requise.Deux mousses éponge sous le piézo

Placez le capteur décalé par rapport au centre.

C'est parce que l'arduino ne peut pas juger de la force du coup si le batteur frappe directement le capteur.

CHARLET

Le circuit est le même que le pad de grosse caisse.

Mettez un morceau de mousse éponge de 10 mm d'épaisseur sous le piezo.

Le piézo est délicat. Faites attention à ne pas vous plier ou vous blesser.

Étape 5 : Pad de caisse claire de 10 pouces

Fixez d'abord le capteur pour la jante.

Fixez la plaque du capteur. Fixez-le fermement. Rendre l'extrémité du cône visible de 2-3 mm lorsqu'elle est vue de côté.

Bien entendu, la même procédure est également utilisée lors de l'utilisation d'un pad de 8 pouces comme caisse claire.

Étape 6 : 9 pouces Kick PAD

Tout d'abord, coupez un tuyau en acier inoxydable de 13 mm de diamètre.

Faites deux 200 mm et deux 365 mm.

Puisque la longueur peut être ajustée, même s'il y a une erreur dans la longueur, c'est OK.

Assemblez-les en vous référant aux images.

Afin de fixer le tuyau, il est conçu de manière à ce que l'écrou M3 puisse être chargé à l'intérieur de la pièce.

Fixez solidement le tuyau. Utilisez des boulons et des écrous M3-15 mm.

Étape 7 :Hi-Hat 12 pouces

Après avoir réalisé la coque avec du papier épais, j'ai pensé que si vous utilisez du papier épais je peux faire des cymbales.

D'abord. Découpez du papier épais en cercle de 300 mm de diamètre. Faites-en trois.

Ensuite, faites une entaille à partir du centre.

Enfin, une deuxième entaille est réalisée à partir du point distant de 10 mm parallèle à la première entaille.

De cette façon, trois pac-mans avec une petite bouche ouverte sont fabriqués.

Fermez ensuite soigneusement la bouche du Pac Man avec du ruban adhésif pour lui donner la forme d'une cymbale.

Appliquez de l'adhésif et superposez-les. N'oubliez pas d'étendre l'adhésif proprement et finement

Tenez fermement avec vos mains, puis placez le poids autour et séchez.

Pour faire taire, mettez une éponge de 5 mm d'épaisseur et percez un trou. Vous ne pouvez pas ouvrir le trou proprement, mais vous pouvez masquer le trou pour que tout aille bien.

Complétez en fixant le support de capteur et le guide-câble avec du ruban adhésif double face. Cela pourrait être plus facile si vous utilisez un pistolet à colle.

Étape 8 :Contrôleur Hi-Hat

Le contrôleur de charleston envoie l'ouverture et la fermeture du charleston à l'arduino.

Le circuit est très simple.

Il est réalisé en combinant trois parties.

Fixez le FSR à la partie inférieure et fixez la prise. FSR peut être utilisé même si un trou est ouvert.

Attachez une éponge de 10 mm au FSR comme une photo.

Fixez le couvercle avec des boulons M3 - 10 mm.

Même si ce n'est que HAUT et BAS, vous vous demandez peut-être pourquoi j'ai utilisé FSR.

J'utilise FSR pour correspondre à des modules de sons comme Roland et Yamaha.

Et dans la source sonore exclusive pour les batteries telles que EZ DRUMMER 2, il y a plusieurs étapes dans le degré d'ouverture du charleston.

S'il s'agit de FSR, il peut être possible de répondre en modifiant simplement le code. Cependant, je ne l'ai pas essayé.

Étape 9 :USB - MIDI

Que pouvons-nous faire dans cette étape ?

Avec le câble USB seul, vous pouvez envoyer un signal midi depuis arduino.

En d'autres termes, faites qu'arduino soit reconnu par iPhone, etc. en tant que périphérique midi sans aucun matériel supplémentaire.

Tout d'abord, consultez cette page.

http://morecatlab.akiba.coocan.jp/lab/index.php/aruino/midi-firmware-for-arduino-uno-moco/

https://github.com/kuwatay/mocolufa

Si vous connectez l'arduino UNO normal directement à l'iPhone, vous obtiendrez un message d'erreur du type "Arduino UNO n'est pas compatible".

Donc, vous devez réécrire la puce USB (ATmega16U2) utilisée dans arduino UNO.

https://www.arduino.cc/en/Hacking/DFUProgramming8U2

Cette instruction explique comment réécrire le fichier hexadécimal.

Veuillez procéder selon ce site jusqu'à la description ci-dessous.

sudo dfu-programmer atmega16u2 flash Arduino-usbserial-uno.hex

Remplacez simplement "Arduino-usbserial-uno.hex" par "dualMoco.hex".

Par conséquent,

sudo dfu-programmer atmega16u2 flash dualMoco.hex

Après la réécriture, votre Arduino sera reconnu comme un périphérique MIDI.

Si vous court-circuitez la broche comme indiqué sur l'image, elle sera reconnue comme un Arduino normal.

Sinon (lorsqu'il n'est pas court-circuité), l'arduino UNO sera reconnu comme un périphérique MIDI.

En d'autres termes, lors de l'écriture de code à l'aide de l'IDE Arduino, vous devez court-circuiter les broches comme indiqué sur l'image.

Étape 10 :Trigger to MIDI Converter

Il y a un arduino UNO et un shield dans la boite.

Référez-vous à l'image de frittage pour le circuit du blindage.

Les diodes sont destinées à la protection, mais j'ai vu l'information selon laquelle arduino UNO a un circuit de protection, les diodes peuvent ne pas être nécessaires. Est-ce que quelqu'un est au courant ?

Après avoir d'abord imprimé le modèle de l'étui et la couverture, il est bon de faire le bouclier en fonction de celui-ci.

Il existe également un modèle 3D de la couverture, mais j'ai réalisé une couverture avec un cutter laser. Veuillez choisir celui que vous voulez.

Étape 11 :Jouez avec GarageBand

Démarrez simplement garageband et connectez-vous. Il n'y a pas de réglage particulièrement difficile.

Il existe un certain nombre de DAW pour PC qui peuvent être utilisés sur cette batterie, y compris GarageBand.

Parmi eux, Hydrogen est gratuit et vous pouvez ajouter du son.

Étape 12 :Paramétrage

En créant le code, il était difficile de réécrire le code à chaque fois que la valeur changeait, je voulais donc pouvoir changer la valeur avec arduino seul.

En d'autres termes, ceci est fait pour le débogage du code, il y a donc des éléments qui n'ont pas besoin d'être modifiés.

Néanmoins, un réglage est nécessaire en fonction de la taille du piezo, de la taille du coussin, de la dureté de la mousse éponge.

Sélectionnez un instrument avec le bouton INC / DEC et sélectionnez l'élément de réglage avec le bouton NEXT / BACK. Lorsque le bouton EDIT est enfoncé alors que les instruments et les éléments que vous souhaitez régler sont affichés, vous pouvez modifier la valeur avec le bouton INC / DEC. Ensuite, appuyez à nouveau sur le bouton EDIT pour confirmer le changement.

Si vous regardez la dernière partie de la vidéo, vous comprendrez comment opérer.

SEUIL

La valeur la plus basse à laquelle le son sort

SENSIBILITÉ

Sensibilité du capteur. Si vous le baissez, vous gagnerez en vélocité même si vous frappez doucement.

REMARQUE

Numéro de la note. En changeant, vous pouvez changer d'instrument. Veuillez vous référer à l'image.

DRAPEAU

Une valeur pour juger que la raclée est terminée. Vous n'avez pas besoin de trop le changer. Ce serait bien de régler la valeur de 1 à 10. Si vous augmentez trop la valeur, vous obtiendrez un son deux fois avec un seul coup. Si vous le baissez trop, vous risquez de perdre le son lorsque vous frappez à plusieurs reprises.

TEMPS DE BALAYAGE

Lors de la recherche de pics, les valeurs sont prises consécutivement pendant plusieurs millisecondes après avoir dépassé le seuil. La valeur la plus élevée d'entre eux culminera. Ces quelques millisecondes correspondent à SCANTIME. Il n'est pas nécessaire de le changer.

TÊTE / JANTE

Réglez la facilité de la jante. L'élever rend difficile le son. Si vous l'abaissez trop fort, la jante sonnera lorsque vous frapperez la tête. Concernant le jugement de la tête et de la jante, il peut être nécessaire d'améliorer le code

PÉDALE VELO

Contrairement aux autres pads, la vélocité de la pédale est constante. La valeur initiale est 100. Veuillez remplacer votre valeur préférée.

TEMPS DE MASQUE

Il s'agit d'une valeur liée à FLAG. Il n'est pas nécessaire de le changer. Si vous le soulevez, vous risquez de ne pas entendre de son lorsque vous frappez en continu.

Étape 13 :Fusion 360

Certaines pièces peuvent ne pas être utilisables à moins que leurs dimensions ne soient modifiées. Il est difficile de modifier les données STL. J'ai donc téléchargé les données de fusion 360. Cependant, étant donné que je modifie des données par essais et erreurs, il vaut mieux ne pas trop dépendre de la fonction d'historique.

https://github.com/RyoKosaka/drums/tree/master/Fusion360

SUPPLÉMENT

Les étapes supplémentaires sont sur instructables.

https://www.instructables.com/id/Arduino-Minimal-Drum-Kit/

Et, le processus de production détaillé est publié sur ce blog.

Vérifiez-le si vous êtes intéressé.

N'hésitez pas à demander quoi que ce soit.

Amusez-vous bien !

Code

• Bonjour Drum v2

Bonjour Drum v2Arduino

/* Contrôleur MIDI de batterie Créé :28/06/2017 par Ryo Kosaka en tant que " HELLO DRUM " Ver.1.0 Modifié :12/05/2019 par George Brotherston*/// Bibliothèque Comprend// #include  // Bibliothèque Arduino (automatiquement incluse) // BAS (Ligne 41) // HAUT (Ligne 40) // INPUT_PULLUP (Ligne 47) // digitalRead() (Ligne 177) / / analogRead() (Ligne 178) #include  // Bibliothèque MIDI - Version :4.3.1 // inclut  // classe MIDI (ligne 30) // classe méthode 'begin' (ligne 55) #include  // LiquidCrystal - Version :1.0.7 // Objet lcd instancié (dans la section Variables ci-dessous) à partir de la classe LiquidCrystal (Ligne 45) // Variables - Declare and Initialize // Variables - Program boolean bSnareFlag =faux ; booléen bHihatFlag =false; booléen bKickFlag =false; booléen bPedalFlag =false; booléen bButtonState =vrai; booléen bButtonState_set =true ; entier iUPDOWN =0; int iNEXTBACK =0; // Tableaux - Programme // InstrumentSensor[6] ={seuil, sensibilité, note, indicateur, vélocité, iPeakValue} // 'iPeakValue' et 'velocity' doivent être à zéro pour tous les tableaux InstrumentSensor // Tous 'aHIHAT[]' et Les éléments du tableau 'aHIHAT_CLOSE[]' doivent avoir la même valeur, à l'exception de l'élément 'note'. int aSNARE[6] ={150, 950, 38, 3, 0, 0} ; int aSNARE_RIM[6] ={5, 500, 37, 3 , 0, 0} ; int aHIHAT[6] ={100, 800, 46, 1, 0, 0} ; int aHIHAT_CLOSE[6] ={100, 800, 42, 1, 0, 0} ; int aKICK[6] ={200, 700, 36, 1, 0, 0} ; // Instrument_ContinuousController[4] ={scantime, snare/rim, pedalVelocity , masktime} int aHIHAT_PEDAL[4] ={600, 0, 44, 0}; // InstrumentSensor_ParameterValue[4] ={seuil, sensibilité, note, indicateur} int aSETTING[4] ={4, 500 ,100 ,1}; // Bibliothèques // LiquidCrystal.h // Constantes (déjà définies dans la bibliothèque, toujours dans la portée ? Sinon, définissez ci-dessous) // const int rs =12, en =11, d4 =5, d5 =4, d6 =3 , d7 =2; // Objet lcd instancié à partir de la classe LiquidCrystal (LiquidCrystal.h Ligne 45) LiquidCrystal lcd(rs, en, d4, d5, d6, d7) ; // Associez les broches de l'interface LCD au numéro de broche Arduino associé // MIDI.h // Initialisez la bibliothèque MIDI_CREATE_DEFAULT_INSTANCE (); // Code du programme // Exécution du programme - Initial (configuration du programme) void setup () { MIDI.begin (10); // début (MIDI.h Ligne 55) lcd.begin(16, 2); // début (LiquidCrystal.h Ligne 62) lcd.print("INITIALISATION..."); // affiche (LiquidCrystal.h Ligne 45) lcd.setCursor(0, 1); // setCursor (LiquidCrystal.h Ligne 82) lcd.print("DRUM MIDI CONTROLLER"); pinMode (6, INPUT_PULLUP); // pinMode (Arduino.h Ligne 175); INPUT_PULLUP (Arduino.h Ligne 47) pinMode (7, INPUT_PULLUP); pinMode(8, INPUT_PULLUP); pinMode(9, INPUT_PULLUP); pinMode(10, INPUT_PULLUP); } // Exécution du programme - Steadystate (boucle continue jusqu'à ce que l'alimentation soit coupée) void loop() { // Circuit de contrôleur MIDI de batterie // Déclare et initialise les variables int iButton_set =digitalRead(6); // Définir le bouton // digitalRead() (Arduino.h Line 177) int iButton_up =digitalRead(7); // Bouton haut int iButton_down =digitalRead(8); // Bouton bas int iButton_next =digitalRead(9); // Bouton suivant int iButton_back =digitalRead(10); // Bouton Retour int iPiezoValue_A0 =analogRead(A0); // Piezo - Snare Head // analogRead() (Arduino.h Line 178) int iPiezoValue_A1 =analogRead(A1); // Piezo - Snare Rim int iPiezoValue_A2 =analogRead(A2); // Hi-hat int iPiezoValue_A3 =analogRead(A3); // Grosse caisse int iFSRValue_A4 =analogRead(A4); // Pédale de charleston // Mode d'édition int aUP[4] ={5, 50, 1,1}; // {seuil, sensibilité, note, indicateur} int aUP_ADVANCE[4] ={1, 50, 1,1} ; // {scantime, rim/head, pedal Velocity, masktime} // Remarque :le tableau aINSTRUMENT[] n'a pas été déclaré dans 'Arrays' au-dessus de char* aINSTRUMENT[] ={ "SNARE HEAD", "SNARE RIM", "HIHAT OPEN ", " HIHAT CLOSE ", " HIHAT PEDAL ", " KICK ", " ADVANCED SETTING " } ; // Remarque :le tableau aSETTING[] A ÉTÉ déclaré dans 'Arrays' au-dessus de char* aSETTING[] ={ "THRESHOLD", "SENSITIVITY", "NOTE", "FLAG" } ; // Remarque :aSETTING_ADVANCE[] n'a pas été déclaré dans 'Arrays' au-dessus du char* aSETTING_ADVANCE[] ={ "SCAN TIME", "HEAD / RIM ","PEDAL VELO", "MASK TIME" } ; if (iUPDOWN <0) { iUPDOWN =6; } si (iUPDOWN> 6) { iUPDOWN =0; } if (iNEXTBACK <0) { iNEXTBACK =3; } if (iNEXTBACK> 3) { iNEXTBACK =0; } // Bouton poussoir EDIT // LOW (Arduino.h Line 41) if (iButton_set ==LOW &&bButtonState ==true &&bButtonState_set ==true) { lcd.clear(); lcd.print("EDIT"); bButtonState =false; bButtonState_set =false ; retard (500); } if (iButton_set ==LOW &&bButtonState ==true &&bButtonState_set ==false) { lcd.clear(); lcd.print("EDIT FAIT"); bButtonState =false; bButtonState_set =vrai ; retard (500); } if (iButton_up ==LOW &&bButtonState ==true &&bButtonState_set ==false) { switch (iUPDOWN) { case 0 :aSNARE[iNEXTBACK] =aSNARE[iNEXTBACK] + aUP[iNEXTBACK]; Pause; cas 1 :unSNARE_RIM[iNEXTBACK] =unSNARE_RIM[iNEXTBACK] + aUP[iNEXTBACK] ; Pause; cas 2 :commutateur (iNEXTBACK) { cas 2 :aHIHAT[iNEXTBACK] =aHIHAT[iNEXTBACK] + aUP[iNEXTBACK] ; Pause; par défaut :aHIHAT_CLOSE[iNEXTBACK] =aHIHAT_CLOSE[iNEXTBACK] + aUP[iNEXTBACK] ; aHIHAT[iNEXTBACK] =aHIHAT[iNEXTBACK] + aUP[iNEXTBACK] ; } Pause; cas 3 :basculer (iNEXTBACK) { cas 2 :aHIHAT_CLOSE[iNEXTBACK] =aHIHAT_CLOSE[iNEXTBACK] + aUP[iNEXTBACK] ; Pause; par défaut :aHIHAT_CLOSE[iNEXTBACK] =aHIHAT_CLOSE[iNEXTBACK] + aUP[iNEXTBACK] ; aHIHAT[iNEXTBACK] =aHIHAT[iNEXTBACK] + aUP[iNEXTBACK] ; } Pause; cas 4 :commutateur (iNEXTBACK) { cas 0 :aHIHAT_PEDAL[iNEXTBACK] =aHIHAT_PEDAL[iNEXTBACK] + aUP[iNEXTBACK] ; Pause; cas 2 :aHIHAT_PEDAL[iNEXTBACK] =aHIHAT_PEDAL[iNEXTBACK] + aUP[iNEXTBACK] ; Pause; } Pause; cas 5 :aKICK[iNEXTBACK] =aKICK[iNEXTBACK] + aUP[iNEXTBACK] ; Pause; cas 6 :aSETTING[iNEXTBACK] =aSETTING[iNEXTBACK] + aUP_ADVANCE[iNEXTBACK] ; Pause; } bButtonState =false; retard(30); } if (iButton_down ==LOW &&bButtonState ==true &&bButtonState_set ==false) { switch (iUPDOWN) { case 0 :aSNARE[iNEXTBACK] =aSNARE[iNEXTBACK] - aUP[iNEXTBACK]; Pause; cas 1 :aSNARE_RIM[iNEXTBACK] =aSNARE_RIM[iNEXTBACK] - aUP[iNEXTBACK] ; Pause; case 2:switch (iNEXTBACK) { case 2:aHIHAT[iNEXTBACK] =aHIHAT[iNEXTBACK] - aUP[iNEXTBACK]; Pause; default:aHIHAT_CLOSE[iNEXTBACK] =aHIHAT_CLOSE[iNEXTBACK] - aUP[iNEXTBACK]; aHIHAT[iNEXTBACK] =aHIHAT[iNEXTBACK] - aUP[iNEXTBACK]; } Pause; case 3:switch (iNEXTBACK) { case 2:aHIHAT_CLOSE[iNEXTBACK] =aHIHAT_CLOSE[iNEXTBACK] - aUP[iNEXTBACK]; Pause; default:aHIHAT_CLOSE[iNEXTBACK] =aHIHAT_CLOSE[iNEXTBACK] - aUP[iNEXTBACK]; aHIHAT[iNEXTBACK] =aHIHAT[iNEXTBACK] - aUP[iNEXTBACK]; } Pause; case 4:switch (iNEXTBACK) { case 0:aHIHAT_PEDAL[iNEXTBACK] =aHIHAT_PEDAL[iNEXTBACK] - aUP[iNEXTBACK]; Pause; case 2:aHIHAT_PEDAL[iNEXTBACK] =aHIHAT_PEDAL[iNEXTBACK] - aUP[iNEXTBACK]; Pause; } Pause; case 5:aKICK[iNEXTBACK] =aKICK[iNEXTBACK] - aUP[iNEXTBACK]; Pause; case 6:aSETTING[iNEXTBACK] =aSETTING[iNEXTBACK] - aUP_ADVANCE[iNEXTBACK]; Pause; } bButtonState =false; delay(30); } // Pushbuttons UP; DOWN; NEXT; BACK if (iButton_up ==LOW &&bButtonState ==true &&bButtonState_set ==true) { iUPDOWN =++iUPDOWN; bButtonState =false; delay(30); } if (iButton_down ==LOW &&bButtonState ==true &&bButtonState_set ==true) { iUPDOWN =--iUPDOWN; bButtonState =false; delay(30); } if (iButton_next ==LOW &&bButtonState ==true &&bButtonState_set ==true) { iNEXTBACK =++iNEXTBACK; bButtonState =false; delay(30); } if (iButton_back ==LOW &&bButtonState ==true &&bButtonState_set ==true) { iNEXTBACK =--iNEXTBACK; bButtonState =false; delay(30); } if (bButtonState ==false &&iButton_up ==HIGH &&iButton_down ==HIGH &&iButton_next ==HIGH &&iButton_back ==HIGH &&iButton_set ==HIGH) { // HIGH is defined in Arduino.h Line 40 switch (iUPDOWN) { case 0:lcd.clear(); lcd.print(aINSTRUMENT[iUPDOWN]); lcd.setCursor(0, 1); lcd.print(aSETTING[iNEXTBACK]); lcd.setCursor(12, 1); lcd.print(aSNARE[iNEXTBACK]); Pause; case 1:lcd.clear(); lcd.print(aINSTRUMENT[iUPDOWN]); lcd.setCursor(0, 1); lcd.print(aSETTING[iNEXTBACK]); lcd.setCursor(12, 1); lcd.print(aSNARE_RIM[iNEXTBACK]); Pause; case 2:lcd.clear(); lcd.print(aINSTRUMENT[iUPDOWN]); lcd.setCursor(0, 1); lcd.print(aSETTING[iNEXTBACK]); lcd.setCursor(12, 1); lcd.print(aHIHAT[iNEXTBACK]); Pause; case 3:lcd.clear();lcd.print(aINSTRUMENT[iUPDOWN]); lcd.setCursor(0, 1); lcd.print(aSETTING[iNEXTBACK]); lcd.setCursor(12, 1); lcd.print(aHIHAT_CLOSE[iNEXTBACK]); Pause; case 4:lcd.clear(); lcd.print(aINSTRUMENT[iUPDOWN]); lcd.setCursor(0, 1); lcd.print(aSETTING[iNEXTBACK]); lcd.setCursor(12, 1); lcd.print(aHIHAT_PEDAL[iNEXTBACK]); Pause; case 5:lcd.clear(); lcd.print(aINSTRUMENT[iUPDOWN]); lcd.setCursor(0, 1); lcd.print(aSETTING[iNEXTBACK]); lcd.setCursor(12, 1); lcd.print(aKICK[iNEXTBACK]); Pause; case 6:lcd.clear(); lcd.print(aINSTRUMENT[iUPDOWN]); lcd.setCursor(0, 1); lcd.print(aSETTING_ADVANCE[iNEXTBACK]); lcd.setCursor(12, 1); lcd.print(aSETTING[iNEXTBACK]); Pause; } bButtonState =true; } // Instrument Sensors // Snare Drum if (iPiezoValue_A0> aSNARE[0] &&bSnareFlag ==false) { for (int i =0; i  aSNARE[4]) { aSNARE[4] =iPeak_A0; } if (iPeak_A1> aSNARE_RIM[4]) { aSNARE_RIM[4] =iPeak_A1; } } aSNARE[5] =aSNARE[4]; aSNARE_RIM[5] =aSNARE_RIM[4]; aSNARE[4] =map(aSNARE[4], aSNARE[0], aSNARE[1], 0, 127); aSNARE_RIM[4] =map(aSNARE_RIM[4], aSNARE_RIM[0], aSNARE_RIM[1], 0, 127); aSNARE[4] =(aSNARE[4] * aSNARE[4]) / 127; // Curve setting //aSNARE_RIM[4] =(aSNARE_RIM[4] * aSNARE_RIM[4]) / 127; if (aSNARE[4] <=1) { aSNARE[4] =1; } if (aSNARE[4]> 127) { aSNARE[4] =127; } if (aSNARE_RIM[4] <=0) { aSNARE_RIM[4] =0; } if (aSNARE_RIM[4]> 127) { aSNARE_RIM[4] =127; } if (aSNARE_RIM[5]> aSETTING[1]) { MIDI.sendNoteOn(aSNARE_RIM[2], aSNARE_RIM[4], 1); //(note, velocity, channel) MIDI.sendNoteOn(aSNARE_RIM[2], 0, 1); lcd.clear(); lcd.print("SNARE RIM"); lcd.setCursor(0, 1); lcd.print(aSNARE_RIM[4]); bSnareFlag =true; } //else if (aSNARE[5]> aSNARE_RIM[5]) else { MIDI.sendNoteOn(aSNARE[2], aSNARE[4], 1); //(note, velocity, channel) MIDI.sendNoteOn(aSNARE[2], 0, 1); lcd.clear(); lcd.print("SNARE HEAD"); lcd.setCursor(0, 1); lcd.print(aSNARE[4]); //lcd.setCursor(10, 1); //lcd.print(aSNARE_RIM[5]); bSnareFlag =true; } } // Hi-Hat Cymbal if (iPiezoValue_A2> aHIHAT[0] &&bHihatFlag ==false) { for (int i =0; i  aHIHAT[4]) { aHIHAT[4] =iPeak_A2; } } aHIHAT[5] =aHIHAT[4]; aHIHAT[4] =map(aHIHAT[4], aHIHAT[0], aHIHAT[1], 0, 127); aHIHAT[4] =(aHIHAT[4] * aHIHAT[4]) / 127; if (aHIHAT[4] <=1) { aHIHAT[4] =1; } if (aHIHAT[4]> 127) { aHIHAT[4] =127; } if (iPiezoValue_A0 =aHIHAT_PEDAL[0]) { MIDI.sendNoteOn(aHIHAT_CLOSE[2], aHIHAT[4], 1); MIDI.sendNoteOn(aHIHAT_CLOSE[2], 0, 1); lcd.clear(); lcd.print("HIHAT CLOSE"); lcd.setCursor(0, 1); lcd.print(aHIHAT[4]); bHihatFlag =true; } } // Hi-hat Pedal if (iPiezoValue_A0> aHIHAT_PEDAL[0] &&bPedalFlag ==false) { MIDI.sendNoteOn(aHIHAT_PEDAL[2], aSETTING[2], 1); // (note, velocity, channel) MIDI.sendNoteOn(aHIHAT_PEDAL[2], 0, 1); lcd.clear(); lcd.print("HIHAT PEDAL"); lcd.setCursor(0, 1); lcd.print(aSETTING[2]); bPedalFlag =true; } // Kick Drum if (iPiezoValue_A3> aKICK[0] &&bKickFlag ==false) { for (int i =0; i  aKICK[4]) { aKICK[4] =iPeak_A3; } } aKICK[5] =aKICK[4]; aKICK[4] =map(aKICK[4], aKICK[0], aKICK[1], 0, 127); aKICK[4] =(aKICK[4] * aKICK[4]) / 127; if (aKICK[4] <=1) { aKICK[4] =1; } if (aKICK[4]> 127) { aKICK[4] =127; } MIDI.sendNoteOn(aKICK[2], aKICK[4], 1); MIDI.sendNoteOn(aKICK[2], 0, 1); lcd.clear(); lcd.print("KICK"); lcd.setCursor(0, 1); lcd.print(aKICK[4]); bKickFlag =true; }// --- BEGIN 'Code in Progress' --- //// --- I could be wrong, but this is what it appears to be --- and out of curiousity what is purpose of this sequence? -- // // I=(A0); // Previous Code // -- DOES iSensorValue_A0 need to be declared as an integer? How does this relate to iPiezoValue_A0? -- // if (iSensorValue_A0 <(aSNARE[5] * (0.01 * aSNARE[3]))) { bSnareFlag =false; } if (iPiezoValue_A0 <=aHIHAT_PEDAL[0] &&iPiezoValue_A2 <(aHIHAT[5] * (0.01 * aHIHAT[3])) &&bHihatFlag ==true) { delay(aSETTING[3]); // iSensorValue_A1 is reading analogRead(A2), but this is aHIHAT_PEDAL (which is analogRead(A2) int iSensorValue_A1 =analogRead(A2); if (iSensorValue_A1 <(aHIHAT[5] * (0.01 * aHIHAT[3]))) { bHihatFlag =false; } } if (iPiezoValue_A0>=aHIHAT_PEDAL[0] &&iPiezoValue_A2 <(aHIHAT[5] *(0.01 * aHIHAT[3])) &&bHihatFlag ==true) { delay(aSETTING[3]); int iSensorValue_A2 =analogRead(A2); if (iSensorValue_A2 <(aHIHAT[5] * (0.01 * aHIHAT[3]))) { bHihatFlag =false; } } if (iPiezoValue_A3 <(aKICK[5] * (0.01 * aKICK[3])) &&bKickFlag ==true) { delay(aSETTING[3]); // -- Should declared iSensorValue_A3 be iPiezoValue_A3? iSensorValue_A3 is declared but not used anywhere?? int iSensorValue_A3 =analogRead(A3); if (iPiezoValue_A3 <(aKICK[5] * (0.01 * aKICK[3]))) { bKickFlag =false; } } if (iPiezoValue_A0 <=aHIHAT_PEDAL[0] &&bPedalFlag ==true) { bPedalFlag =false; }// --- END 'Code in Progress' --- // }

Hello Drum

Schémas