Guitar Hero Arduino პროექტი: 12 ნაბიჯი (სურათებით)

2024 ავტორი: John Day | [email protected]. ბოლოს შეცვლილი: 2024-01-30 10:20

Wij zijn Maarten Vrebos, Justin Cavanas en Wannes Stroobandt ჩვენ ვსწავლობთ მულტიმედიურ და საკომუნიკაციო ტექნოლოგიებს. აუდიოვიზუალური და ინფორმაციული ტექნოლოგიის პრინციპები დამტკიცებულია გიტარის გმირისა და მოთამაშეების მიერ, რომლებიც ასევე იყენებენ MIDI კონტროლერს. Het is onze bedoeling om de bestaande knoppen op de gitaar intern te vervangen. Onze კონტროლერი zala vastgehouden en bespeeld worden als een as normalale gitaar. Aangezien we iets hebben gehackt hebben we er niet veel extra materiaal in moeten verwerken.

In de afbeelding kan u onze allereerste schets op papier zien van hoe het eindproduct er zou moeten uitzien met daarnaast een foto van gitaar die als behuizing zal worden gebruikt.

Wij hebben ons voor dit პროექტი gebaseerd op volgende bronnen:

slapyak.wordpress.com/guitar-hero-midi-con…

www.instructables.com/id/Converting-a-rescu…

gizmodo.com/391834/turn-your-guitar-hero-g…

Benodigdheden voor dit პროექტი

• 6 კლავიშის ღილაკი
• 7 1kohm რეზისტორები
• 1 გელი LED 1
• blauwe LED
• 1 Arduino Uno R3
• 1 საბურავი LED
• 2 დისკიანი ები
• 1 შუიფშქელაარი
• 1 პურის დაფა
• 1 პოტენომეტრი
• 1 პროტოფორდი
• 1 გიტარა გმირი გიტარა
• ვოლდოენდის საწოლი
• Materiaal om te solderen/dremelen/
• შროვენდრააიერ

ნაბიჯი 1: ვერზამელენის კომპონენტი

Voor ons პროტოტიპი (op breadboard) hebben we volgende componenten gebruikt:

6 ღილაკი

7 1kohhm რეზისტორები

1 ყვითელი LED

1 ცისფერი LED

1 Arduino Uno R3

1 მწვანე LED

2 წითელი LED

1 შუიფშეკელარი

1 პურის დაფა

1 პოტენომეტრი

ნაბიჯი 2: ბუუენის პროტოტიპი

Om ons prototype te bouwen hebben we al onze componenten gebruikt op een breadboard, de breadboard dient dan als testobject zodat we niet meteen in de behuizing te werk moeten gaan. ეს არის პროტოტიპი hebben ჩვენ ვიმსჯელებთ gedigitaliseerd– ის საშუალებით tinkercad.com– ის საშუალებით, ვიმსჯელებთ იმაზე, რომ ჩვენ ვგეგმავთ გადავიტანოთ ეს პროტოტიპი, რომელიც დაგეგმილია.

ეს არის 5 ღილაკი, რომლებიც აძლიერებენ ღილაკს და ასევე იყენებენ 5 ღილაკს, რომლითაც შეგიძლიათ დააჭიროთ ღილაკს კომბინაციაში და შეაფასეთ ის, რაც ჩვენ ვსაუბრობთ ჩვენს მიერ შექმნილ აუდიტორულ ეფექტზე. LED– ების განათება შეიძლება შეიცავდეს კონტროლს ყველა იმ შემთხვევაში, თუ ისინი მუშაობენ წარმატებული მუშაობის დროს.

ნაბიჯი 3: კოდის პროტოტიპი

გლობალური ვარიაბელენი

In eerste deel van de code initialiseer je globale variabelen voor de pins van arduino uno waar alle pushbuttons mee verbonden zijn.

// დაარეგისტრირეთ პინი ნომრები მთავარ ღილაკზე (შესვლა) და შემდეგ ღილაკებზე და ზარალზე: const int mainButton = A1; // gitaar snaar const int lightSensor = A0; const int buttonPin1 = 2; // nummer van pushbutton1 const int buttonPin2 = 3; // nummer van pushbutton2const int buttonPin3 = 4; // nummer van pushbutton3const int buttonPin4 = 5; // nummer van pushbutton4const int buttonPin5 = 6; // რიცხვითი van ღილაკი 5

ეს ნიშნავს, რომ მას trae მასივები აანთებს, რაც შეიძლება გამოყენებულ იქნას ღილაკზე და დამატებით.

const int aantalKnoppen = 5; const სიმებიანი namenKnoppen [aantalKnoppen] = {"knop 1", "knop 2", "knop 3", "knop 4", "knop 5"}; const int knopPinnen [aantalKnoppen] = {2, 3, 4, 5, 6};

არ ვიცი, რა არის საჭირო იმისათვის, რომ დადგინდეს LED ლიცენზია.

const int ledPin1 = 13; // LED პინის ნომერი 13

const int ledPin2 = 12; // LED პინის ნომერი 12 const int ledPin3 = 11; // LED პინის ნომერი 11 const int ledPin4 = 10; // LED პინის ნომერი 10 const int ledPin5 = 9; // LED პინის ნომერი 9 const int potPin = A5; // LED pin pin- ის ნომერი A5

De laatste globale variabelen dienen als 'შტატები' voor de სენსორები (ზედიზედ დააჭირეთ ღილაკებს, რომლებიც დაკავშირებულია ნიუ -იორესთან?

// initialiseer buttonStates voor de knoppen (ingedrukt of niet) int mainButtonState = 0; int ღილაკი სახელმწიფო 1 = 0; int ღილაკი სახელმწიფო 2 = 0; int ღილაკი სახელმწიფო 3 = 0; int ღილაკი სახელმწიფო 4 = 0; int ღილაკი სახელმწიფო 5 = 0; int lightSensorState = 0; int potValue = 0; int lightValue = 0;

Აწყობა

უშეცდომოდ შეიქმნა ფუნქციის დაყენება. Deze is van het type void (geeft geen waarde terug) და ინსტრუქციის მიხედვით hierin worden maar 1 keer uitgevoerd.

Bij elke functie არის კომენტარი geschreven wat er concretet gedean wordt. დამატებითი მითითებები იმის შესახებ, თუ რა სპეციფიკური ფუნქცია აქვს კონკრეტულ საქმეს, თქვენ არ მოგეხსენებათ არდუინოს მითითება

void setup () {// მონაცემთა სიჩქარე წამში (baud) voor seriele მონაცემთა გადაცემა Serial.begin (9600); // ledPin variabelen als output pinMode (ledPin1, OUTPUT) ინიციალიზატორი; pinMode (ledPin2, OUTPUT); pinMode (ledPin3, OUTPUT); pinMode (ledPin4, OUTPUT); pinMode (ledPin5, OUTPUT); // ინიციალიზებელი ღილაკებით და შეყვანისთვის: pinMode (mainButton, INPUT); pinMode (buttonPin1, INPUT); pinMode (buttonPin2, INPUT); pinMode (buttonPin3, INPUT); pinMode (buttonPin4, INPUT); pinMode (buttonPin5, INPUT); pinMode (potPin, INPUT); pinMode (lightSensor, INPUT); }

ბათილი ფუნქცია

Na setup () functie volgt de loop () functie, de instructies die hierin staan gaan herhaald uitgevoerd worden.

void loop () {// lees de staat van de pushbuttons uit (ingedrukt of niet) mainButtonState = digitalRead (mainButton); buttonState1 = digitalRead (ღილაკი Pin1); buttonState2 = digitalRead (ღილაკი Pin2); buttonState3 = digitalRead (ღილაკი Pin3); buttonState4 = digitalRead (ღილაკი Pin4); buttonState5 = ციფრული წაკითხვა (buttonPin5);

// ყველა ღილაკს სტატუსი een მასივში

int buttonStates = {buttonState1, buttonState2, buttonState3, buttonState4, buttonState5};

// რაც შეიძლება ნაკლები პოტენციომეტრი და ლიცენზიოსი

potValue = analogRead (potPin); lightValue = analogRead (lightSensor);

// გამოცხადება მასივი mainStates და სტანდარტული სტანდარტების დაცვა 0 in.

int mainStates = {0, 0, 0, 0, 0};

// loop over de array aantalKnoppen

for (int i = 0; i <aantalKnoppen; i ++) {pinMode (knopPinnen , INPUT); // initialiseer alle knopPinnen als input digitalRead (knopPinnen ); // lees de waarde van alle knoppinnen uit // indien de mainswitch (snaar) ingedrukt is, print all knopnamen, alle buttonstates if (mainButtonState == HIGH) {Serial.print (namenKnoppen ); Serial.print (","); Serial.println (buttonStates ); }}

ნაბიჯი 4: პროტოტიპი Uittesten

ნადიტი არის პროტოტიპი gebouwd არის მოდელის მოდელი და კოდი geschreven არის დამუშავების პროცესში, არის მისი პროტოტიპი uit te testen. ვიდეო დე თქვენ შეგიძლიათ გაიგოთ, რა რეაქცია გექნებათ თქვენს მიერ არჩეულ ლიდერობაში და რა არის კომბინაციები მათ მიერ მიღებულ მოღვაწეობაში.

ვიდეოს შესახებ არის ვიდეო, რომლითაც თქვენ შეძლებთ გაეცნოთ თქვენს ხელებს და გაზარდოთ პოტენომეტრი, რომელიც გამოიყენება დამუშავების პროცესში.

ნაბიჯი 5: Behuizing "ontmantelen" En Kijken Welke Componenten Gebruikt Gaan Worden

Als de code correct werkte op het prototype zijn we begonnen met het "ontmantelen" van onze Guitar Hero-gitaar. ჩვენ შევეცადეთ გავარკვიოთ, რომ ჩვენ შევხვდით და შევიკრიბეთ, როგორც ორიგინალური კომპონენტი, რაც შეიძლება მოხდეს, როდესაც ჩვენ ვაგროვებთ ჩვენს კონტროლერს. ჩვენ შეგვიძლია განვსაზღვროთ, რომ ჩვენ ვიყენებთ ღილაკებს საუკეთესო ღილაკებზე (zie volgende stap). ჩვენ გითხრათ, რომ გებრუიქტი ხმამაღლა ვკითხულობთ ჩვენს პროდუქტს და ვნახავთ ღილაკს (იხილეთ ღილაკი, რომლითაც თქვენ გექნებათ კომბინაცია) გვეუბნება ორიგინალ twee ღილაკებს, რომლებიც გამოიყენება Gebruikt (zie vierde foto). De LEDjes zullen verdwijnen (deze waren enkel ter indicatie zodat we zagen dat alle knoppen სწორი მუშაობა.

ნაბიჯი 6: Werking Originele Buttons + Dremelen

ამ ვიდეოში შეგიძლიათ გამოიყენოთ თქვენი ორიგინალური კვანძები, რომლებიც ასევე ცნობილია როგორც შეკელარი, ისე რომ თქვენ გექნებათ შესაძლებლობა, გამოიყენოთ ეს კომბინაცია.

ყველა საჭირო ღილაკს გაეცანით ორიგინალ კვანძში, რომლითაც თქვენ შეძლებთ გაეცნოთ ორიგინალურ ბმულებს და გამოიყენოთ თქვენი ფოტოები.

ნაბიჯი 7: Solderen– ის გადაფრქვევა + ღილაკები Vastlijmen

Omdat we niet meer met een breadboard werken moeten de draden gesoldeerd worden om zo de verschillende componenten met elkaar te verbinden. რა თქმა უნდა, თქვენ შეგიძლიათ დააჭიროთ ღილაკებს, რომლითაც თქვენ შეგიძლიათ გაიგოთ ფოტოების ფოტოები. ეს არის ის, რაც ჩვენ ვიცით, თუ რა არის საჭირო.

ნაბიჯი 8: Plaats Maken De Behuizing

Omdat dit Guitar Hero-model redelijk krap was om mee te werken hebben we extra plaats moeten maken d.m.v. დერმელენი. Zo hebben we uit de achterkant van de gitaar een hele strook verwijderd zodat er meer plaats ontstaat voor de bedrading in gitaar. Omdat er overal in de binnenkant obstakels waren, waaronder veel buisjes om de vijzen in te bevestigen, hebben we die ook verwijderd om optimaal van de gegeven ruimte gebruik te kunnen maken. Op de vierde en vijfde foto is a zien dat we in de achterkant van de gitaar een doorgang hebben gecreëerd voor de draden die naar de buttons de gaan omdat de gitaar anders niet meer te sluiten was. ამ სურათის გაცნობისას თქვენ მოგეცემათ შესაძლებლობა გვესმოდეს რექტრეტიკული სიტყვები და არდუინოს კარი შევაღწიოთ მათ მიერ გაგზავნილ სიტყვებს.

ნაბიჯი 9: Bedrading Aansluiten Op Protobord

Om alle componenten met elkaar te verbinden hebben we gebruik gemaakt van een protobord. ეს არის ის, რაც ითვალისწინებს იმ ფაქტს, რომ მას აქვს შესაძლებლობა შეასრულოს მუშაობა და მიიღოს breadbord, რაც შეიძლება ეფექტური იყოს. We hebben de bedrading aan het bordje gesoldeerd zoals te zien is op de derde foto. Dit bord is het centrale punt van waaruit al onze verbindingen vertrekken en samenkomen (zie foto 2).

ნაბიჯი 10: ვერსია

დამთავრების შეხებით, თქვენ შეგიძლიათ დარწმუნდეთ, რომ ეს არის დამატებითი სტაბილურობა. Op deze foto is te zien hoe we het deel dat we er hebben uitgehaald d.m.v. dremelen achteraan de buttons verstevigen met stukjes karton.

ნაბიჯი 11: Code Voor Het Communiceren Met Reaper

Deze კოდი ოპგელედელდ არის twee delen– ში, მაგრამ eerste deel არის de arduino IDE (ინტერაქტიული განვითარების გარემო) geschreven. Die code wordt geüpload naar arduino zelf en dien om all waarden van de sensors of van midi controller uit te lezen en der te sturen naar processing.

დამუშავება არის tweede gedeelte. Deze code dient om alles wat arduino doorstuurt te ontvangen en door te sturen naar Reaper.

არდუინო

/* ეს კოდი არის ძირითადი ესკიზი დამუშავებასთან სერიალის საშუალებით.

ეს არის გეგმა, რომელშიც შეგიძლიათ განათავსოთ თქვენი საკუთარი კოდი

მითითებულია თქვენივე ღილაკებისთვის, პოტენომეტრებისთვის ან სენსორებისთვის.

მას აქვს ხელის ჩამორთმევა, რათა დავრწმუნდეთ, რომ ჩვენ გვაქვს კონტაქტი

და ფორმატი, რომელშიც ჩვენ ვსაუბრობთ, გადაწყვეტილია

მნიშვნელოვანია გზავნილის ანალოგიურად შექმნა, რათა დამუშავებამ იცოდეს როგორ მოახდინოს მისი დაშლა და სწორი OSC- შეტყობინებების გაგზავნა ჩვენს DAW– ში

დამზადებულია werkcollege AV&IT– ისთვის

ოქტომბერი 2017

*

/ ბოდის მაჩვენებელი

const long baudRate = 115200;

// დრო დაველოდოთ ms– ს გამოკითხვებს შორის ქინძისთავებს

const int loopPauseTime = 200; // მილი წამი

// სერიალზე გაგზავნილი შეტყობინების საწყისი და ბოლო მნიშვნელობები

const String startString = "*", endString = "#";

const char contactCharacter = '|';

// pin id's

// სხვა გლობალური ცვლადები

const int aantalKnoppen = 5; const String namenKnoppen [aantalKnoppen] = {"knop 1", "knop 2", "knop 3", "knop 4", "knop 5"}; const int knopPinnen [aantalKnoppen] = {2, 3, 4, 5, 6}; const int mainButton = A1;

int mainButtonState = 0;

int potValue = 0;

// ანალიზის სენსორები

const int potPin = A5; // pin voor tremolo

// ჩვენ გვჭირდება ეს ფუნქცია დამუშავების ესკიზთან კონტაქტის დასამყარებლად

// შეინახეთ იგი აქ void estabContact () {while (Serial.available () <= 0) {Serial.print (contactCharacter); // გაგზავნეთ სიმბოლო და დაელოდეთ პასუხს … გადადება (loopPauseTime); } Serial.read (); }

void setup () {

// დააყენეთ pinModes ყველა ქინძისთავისთვის (int i = 0; i <aantalKnoppen; i ++) {pinMode (knopPinnen , INPUT); } pinMode (mainButton, INPUT); // კომენტირებისას თუ იყენებთ სენსორებს, რომლებიც მუშაობენ 3V- ზე 5V- ის ნაცვლად // თქვენ მოგიწევთ "ext" პინის მიერთება 3.3V ასევე // analogReference (EXTERNAL);

// სერიული კომუნიკაციის ინიციალიზაცია

Serial.begin (baudRate); ხოლო (! სერიული); // დაელოდეთ ხელის ჩამორთმევას հաստատვაContact (); }

ბათილი მარყუჟი () {

// ნაბიჯი 1: წაკითხვის ღილაკები // გამოკითხეთ ყველა ქინძისთავები და განათავსეთ კითხვა შესაბამის დიაპაზონში int ღილაკი სახელმწიფოები [aantalKnoppen]; /* buttonStates [0] = digitalRead (knopPinnen [0]); buttonStates [1] = digitalRead (knopPinnen [1]); buttonStates [2] = digitalRead (knopPinnen [2]); buttonStates [3] = digitalRead (knopPinnen [3]); buttonStates [4] = digitalRead (knopPinnen [4]); */ mainButtonState = digitalRead (მთავარი ღილაკი); for (int i = 0; i <aantalKnoppen; i ++) {buttonStates = digitalRead (knopPinnen ); } potValue = analogRead (potPin); // მაგალითები: // float v0 = რუკა (bpm, 0, 1023, 60, 250); // თუ გსურთ გამოიყენოთ ნორმალიზებული float (მაგ. მოცულობისთვის) // float v1 = რუკა (analogRead (pin2), fromMin, fromMax, 0, 100) / 100.0;

// ნაბიჯი 2: დაწერე შეტყობინება

Serial.print (startString); // შეტყობინებების თანმიმდევრობის დაწყება (int i = 0; i <aantalKnoppen; i ++) {if (mainButtonState == HIGH) {Serial.print (namenKnoppen ); Serial.print (","); Serial.print (buttonStates ); if (i <aantalKnoppen - 1) {Serial.print (","); }} else {buttonStates = 0; Serial.print (namenKnoppen ); Serial.print (","); Serial.print (buttonStates ); if (i <aantalKnoppen - 1) {Serial.print (","); }}} Serial.print (","); Serial.print ("ტრემოლო"); Serial.print (","); Serial.print (რუკა (potValue, 0, 1023, 0, 100)); // ჩაწერეთ შეტყობინების ბოლო Serial.print (endString);

// დაიცადე ცოტა ხნით..

დაგვიანება (loopPauseTime); }

დამუშავება

პასუხისმგებლობის შეზღუდვის განაცხადი: Niet alle code van de processing sketch staat hier in geschreven, voor de volledige code zie het bestand: ProcessingSoundControl_handout_v6_1.pde in bijlage

De volgende ინსტრუქციები moeten aangepast worden (indien nodig):

// Baudrate moet hetzelfde zijn zoals in arduino ესკიზი

საბოლოო int baudRate = 115200;

// Zoek naar het IP მისამართი reaper (zie ეკრანის სურათები ბიჟლაჟში)

// დამუშავება stuurt naar dit andres en reaper luistert hier naar //

// საბოლოო სიმებიანი დისტანციური IP = "192.168.1.43"; //მაგალითად. "127.0.0.1";

საბოლოო სიმებიანი დისტანციური IP = "10.3.209.60";

// გაითვალისწინეთ sendPort და შეავსეთ ეს Reaper- ში.

// ეს არის პორტი, რომელსაც უგზავნის დამუშავება და უსმენს Reaper.

საბოლოო int listenPort = 12000, sendPort = 12000;

// listenPort აქ არის აქტიურად გამართვის.

// პორტის სახელები აქაც არის გამართული.

// საბოლოო სიმებიანი პორტის სახელი = "/dev/ttyACM0";

საბოლოო სიმებიანი portName = "COM5"; // "/dev/ttyUSB0";

////////////////////// USER PARAMETERS END /////////////////////// ////

იმპორტის დამუშავება. სერიალი.*;

java.util.*;

იმპორტი oscP5.*;

იმპორტი netP5.*;

OscP5 oscP5;

NetAddress myRemoteLocation;

სერიული commsPort; // სერიული პორტი

ლოგიკური შეტყობინება ჩამოვიდა = ყალბი;

სიმებიანი შემომავალი = "", IncomingOSCMessage = "";

საბოლოო char startChar = '*', endChar = '#'; საბოლოო char contactCharacter = '|';

// დავრწმუნდეთ, რომ ჩვენ ვგზავნით მხოლოდ პარამეტრებს (მნიშვნელობებს), რომლებიც იცვლება

// ეს გლობალური ვარიაციები აქ არის ნაჩვენები, მაგრამ არ უნდა იყოს // ინიციალიზებული აქ! HashMap oldParams, newParams, toSendParams;

// ჩვენ უნდა გავყოთ შეტყობინება ყოველ მძიმით

void processIncoming () {String resVec = incoming.split (","); // ჩვენ ვიღებთ სახელის+მნიშვნელობის წყვილებს // ასე რომ, თითოეული სახელისთვის (+2)… სცადეთ {for (int i = 0; i <resVec.length; i+= 2) {float value = Float.parseFloat (resVec [i+ 1]); // ჩადეთ ისინი ახალ Hashtable newParams.put (resVec , მნიშვნელობა); }} // თუ შეცდომა მოხდება, დავიჭიროთ მისი ჩვენება და გასვლა. დაჭერა (გამონაკლისი ex) {println ("გამონაკლისის შეტყობინება:" + ყოფილი); printArray (resVec); გასვლა (); }}

// ჩვენი შეტყობინებების გასაფილტრავად

/ * ჩვენ დარწმუნებული ვართ, რომ არსებობს მხოლოდ OSC- შეტყობინება, როდესაც * შეყვანის შეტყობინება (სერიული) იცვლება * ეს არის: თუ ჩვენ ვტრიალებთ/ვაჭერთ ღილაკს და ის ცვლის მნიშვნელობას. * ასე რომ, ჩვენ გავფილტროთ შემომავალი მნიშვნელობები, რომლებიც რეალურად იცვლება * შენიშვნა: ჩვენ არ ავიცილებთ თავიდან მნიშვნელობების გადახტომას * როგორც მაგ. აქსელერომეტრებიდან ან დისტანციის სენსორებიდან * თქვენ უნდა გაასწოროთ ის Arduino– ში */ void filterParams () {toSendParams = new HashMap (); for (სიმებიანი გასაღები: newParams.keySet ()) {// თუ გასაღები უკვე არის თუ (oldParams.containsKey (გასაღები)) {// გასაღები არის და მნიშვნელობა არ არის იგივე, შემდეგ განაახლეთ თუ (! oldParams.get (გასაღები). ტოლია (newParams.get (გასაღები))) {toSendParams.put (გასაღები, newParams.get (გასაღები)); }} სხვა {// გასაღები არ არის ძველ პარამებში, ასე რომ ჩაწერეთ! toSendParams.put (გასაღები, newParams.get (გასაღები)); } oldParams.put (გასაღები, newParams.get (გასაღები)); }}

void makeOSC () {

for (სიმებიანი გასაღები: toSendParams.keySet ()) {OscMessage myMessage = ახალი OscMessage ("/"+ გასაღები); myMessage.add (toSendParams.get (გასაღები)); / * გაგზავნეთ შეტყობინება */ oscP5.send (myMessage, myRemoteLocation); }}

void translateMessage () {

processIcoming (); filterParams (); makeOSC (); } // როდესაც ჩვენ გვსურს ამობეჭდოთ ფანჯარაში void ShowIncoming () {// შემომავალი შეტყობინების სანახავად, როგორც მითითებულია HashMap ტექსტში ("შემომავალი არდუინოდან", 20, 20); int y = 20; for (სიმებიანი გასაღები: newParams.keySet ()) {y = y+20; ტექსტი (გასაღები, 20, y); ტექსტი (newParams.get (გასაღები), 300, y); }}

void showOsc () {

ტექსტი (IncomingOSCMessage, 300, 200); IncomingOSCMessage = ""; }

void setup () {

ზომა (1000, 800); // სცენის ზომის შევსება (255); ფონი (0); oldParams = ახალი HashMap (); newParams = ახალი HashMap (); // printArray (Serial.list ()); commsPort = ახალი სერიალი (ეს, portName, baudRate);

/ * დაწყება oscP5, მოსმენა შემომავალი შეტყობინებებისათვის */

oscP5 = ახალი OscP5 (ეს, listenPort);

/* myRemoteLocation არის NetAddress. NetAddress იღებს 2 პარამეტრს, * IP მისამართი და პორტის ნომერი.myRemoteLocation გამოიყენება როგორც პარამეტრი * oscP5.send () osc პაკეტების სხვა კომპიუტერზე, მოწყობილობაზე, * პროგრამაზე გაგზავნისას. გამოყენება იხილეთ ქვემოთ. სატესტო მიზნებისთვის მოსასმენი პორტი * და დისტანციური მდებარეობის მისამართის პორტი ერთი და იგივეა, შესაბამისად თქვენ * შეტყობინებებს დააბრუნებთ ამ ესკიზზე. */ myRemoteLocation = ახალი NetAddress (დისტანციური IP, sendPort); }

ბათილად გათამაშება () {

if (messageArrived) {ფონი (0); translateMessage (); ShowIncoming (); messageArrived = ყალბი; } showOsc (); }

void serialEvent (სერიული commsPort) {

// წაიკითხეთ ბაიტი სერიული პორტიდან: char inChar = commsPort.readChar (); გადართვა (inChar) {case contactCharacter: commsPort.write (contactCharacter); // მოითხოვეთ მეტი ბეჭდვა ("იწყება …"); შესვენება; საქმე startChar: შემომავალი = ""; შესვენება; საქმე endChar: messageArrived = true; // println ("დასრულება msg"); შესვენება; ნაგულისხმევი: შემომავალი += inChar; შესვენება; }}

/* შემომავალი osc შეტყობინება გადაეგზავნება oscEvent მეთოდს. */

void oscEvent (OscMessage theOscMessage) {float value = theOscMessage.get (0).floatValue (); // მიიღეთ პირველი osc არგუმენტი

შემომავალი OSCMessage += "\ n" +

String.format ("### მიიღო osc შეტყობინება:" + "addrpattern:" + theOscMessage.addrPattern () + ": %f", მნიშვნელობა); println (შემომავალი OSCMessage); }

ნაბიჯი 12: მაკონტროლებელი Uittesten

Nu alles არის aangesloten, alle code is geschreven en alles is gedubbelcheckt is het eindelijk tijd om om de controller z'n werk te laten doen. დააგემოვნეთ, თუ რა ეფექტი მოაქვს Reaper– ში და გენიალურად გიტარის გმირის MIDI კონტროლერი!