Skip to content
Snippets Groups Projects
Commit 79aa34f7 authored by Lennard Karger's avatar Lennard Karger
Browse files

Merge branch 'main' into 'Developement_Karger'

Update Dev

See merge request !8
parents 9fb308a6 a1f859a8
Branches
No related tags found
1 merge request!8Update Dev
//-----------------------------------------------------------------------------
// Thema: Social Manufacturing Network / Development Environment
// Datei: MeasMuse.cpp
// Editor: Robert Patzke
// URI/URL: www.mfp-portal.de
// Datum: 14. November 2022
//-----------------------------------------------------------------------------
// Lizenz: CC-BY-SA (siehe Wikipedia: Creative Commons)
//
#include "MeasMuse.h"
// ----------------------------------------------------------------------------
// Konstruktoren und Initialisierungen
// ----------------------------------------------------------------------------
//
MeasMuse::MeasMuse()
{
}
// ----------------------------------------------------------------------------
// Hilfsfunktionen
// ----------------------------------------------------------------------------
//
void MeasMuse::Posture2Midi::setKoeffRoll(MeasMap map)
{
switch(map)
{
case BiLinear:
koeffRoll = (midiArea[aimRoll].high - midiArea[aimRoll].low)
/ (borderHighRoll - borderLowRoll);
midiArea[aimRoll].offset = midiArea[aimRoll].low - (byte) koeffRoll * borderLowRoll;
break;
default:
break;
}
}
void MeasMuse::Posture2Midi::setKoeffPitch(MeasMap map)
{
switch(map)
{
case BiLinear:
koeffPitch = (midiArea[aimPitch].high - midiArea[aimPitch].low)
/ (borderHighPitch - borderLowPitch);
midiArea[aimPitch].offset = midiArea[aimPitch].low - (byte) koeffPitch * borderLowPitch;
break;
default:
break;
}
}
void MeasMuse::Posture2Midi::setKoeffYaw(MeasMap map)
{
switch(map)
{
case BiLinear:
koeffYaw = (midiArea[aimYaw].high - midiArea[aimYaw].low)
/ (borderHighYaw - borderLowYaw);
midiArea[aimYaw].offset = midiArea[aimYaw].low - (byte) koeffYaw * borderLowYaw;
break;
default:
break;
}
}
int MeasMuse::Posture2Midi::getResultRoll(MidiResultPtr refResult, float measValue)
{
float inVal = measValue + offsetRoll;
#ifdef MeasMuseDebug
debInValRoll = inVal;
#endif
if(inVal < borderLowRoll) return(-1);
if(inVal > borderHighRoll) return(1);
byte value = midiArea[aimRoll].offset + (byte) (koeffRoll * inVal);
if(refResult->value != value)
{
refResult->value = value;
refResult->newVal = true;
}
refResult->type = aimRoll;
#ifdef MeasMuseDebug
debResVal = value;
#endif
return(0);
}
int MeasMuse::Posture2Midi::getResultPitch(MidiResultPtr refResult, float measValue)
{
float inVal = measValue + offsetPitch;
if(inVal < borderLowPitch) return(-1);
if(inVal > borderHighPitch) return(1);
byte value = midiArea[aimPitch].offset + (byte) (koeffPitch * inVal);
if(refResult->value != value)
{
refResult->value = value;
refResult->newVal = true;
}
refResult->type = aimPitch;
return(0);
}
int MeasMuse::Posture2Midi::getResultYaw(MidiResultPtr refResult, float measValue)
{
float inVal = measValue + offsetYaw;
if(inVal < borderLowYaw) return(-1);
if(inVal > borderHighYaw) return(1);
byte value = midiArea[aimYaw].offset + (byte) (koeffYaw * inVal);
if(refResult->value != value)
{
refResult->value = value;
refResult->newVal = true;
}
refResult->type = aimYaw;
return(0);
}
// ----------------------------------------------------------------------------
// Konfiguration
// ----------------------------------------------------------------------------
//
void MeasMuse::setRollArea(int channel, float offset, float min, float max)
{
config[channel].offsetRoll = offset;
config[channel].borderLowRoll = min;
config[channel].borderHighRoll = max;
}
void MeasMuse::setPitchArea(int channel, float offset, float min, float max)
{
config[channel].offsetPitch = offset;
config[channel].borderLowPitch = min;
config[channel].borderHighPitch = max;
}
void MeasMuse::setYawArea(int channel, float offset, float min, float max)
{
config[channel].offsetYaw = offset;
config[channel].borderLowYaw = min;
config[channel].borderHighYaw = max;
}
void MeasMuse::setAims(int channel, Meas2Midi aimRoll, Meas2Midi aimPitch, Meas2Midi aimYaw)
{
config[channel].aimRoll = aimRoll;
config[channel].aimPitch = aimPitch;
config[channel].aimYaw = aimYaw;
}
void MeasMuse::setMidiArea(int channel, Meas2Midi midi, byte low, byte high)
{
config[channel].midiArea[midi].low = low;
config[channel].midiArea[midi].high = high;
}
void MeasMuse::setMapping(int channel, MeasMap mapRoll, MeasMap mapPitch, MeasMap mapYaw)
{
config[channel].setKoeffRoll(mapRoll);
config[channel].setKoeffPitch(mapPitch);
config[channel].setKoeffYaw(mapYaw);
}
// ----------------------------------------------------------------------------
// Anwenderfunktionen
// ----------------------------------------------------------------------------
//
int MeasMuse::resultRoll(int channel, MidiResultPtr refResult, float measValue)
{
return(config[channel].getResultRoll(refResult, measValue));
}
int MeasMuse::resultPitch(int channel, MidiResultPtr refResult, float measValue)
{
return(config[channel].getResultPitch(refResult, measValue));
}
int MeasMuse::resultYaw(int channel, MidiResultPtr refResult, float measValue)
{
return(config[channel].getResultYaw(refResult, measValue));
}
//-----------------------------------------------------------------------------
// Thema: Social Manufacturing Network / Development Environment
// Datei: MeasMuse.h
// Editor: Robert Patzke
// URI/URL: www.mfp-portal.de
// Datum: 14. November 2022
//-----------------------------------------------------------------------------
// Lizenz: CC-BY-SA (siehe Wikipedia: Creative Commons)
//
#ifndef _MeasMuse_h
#define _MeasMuse_h
//-----------------------------------------------------------------------------
#include "arduinoDefs.h"
//#define MeasMuseDebug
#define NrOfChannelsMM 16
// ----------------------------------------------------------------------------
// Datentypen
// ----------------------------------------------------------------------------
//
typedef struct _Value2Midi
{
short borderLowAz;
short borderHighAz;
short borderLowAy;
short borderHighAy;
short borderLowAx;
short borderHighAx;
byte lowNote;
byte highNote;
} Value2Midi, *Value2MidiPtr;
enum Meas2Midi
{
Nothing, // keine Zielzuweisung
NoteType, // Zuweisung Notentyp (Länge)
NoteVal, // Zuweisung Notenwert (Höhe)
NoteVel, // Zuweisung Anschagstärke
NrM2M // Anzahl für Array
};
enum MeasMap
{
OneToOne, // Direkte Wertübertragung
BiLinear, // Linear auf Linear
NrMM
};
typedef struct _MidiResult
{
Meas2Midi type;
byte value;
bool newVal;
} MidiResult, *MidiResultPtr;
typedef struct _MidiArea
{
byte low;
byte high;
byte offset;
} MidiArea, *MidiAreaPtr;
// ---------------------------------------------------------------------------
// class MeasMuse
// ---------------------------------------------------------------------------
// Abbildung von Messwerten auf musikalische und andere künstlerische
// Umgebung inklusive der Konfiguration
class MeasMuse
{
// -------------------------------------------------------------------------
// class Posture2Midi, eingebettet
// -------------------------------------------------------------------------
// Details der Konfiguration für einen Kanal
//
public:
class Posture2Midi
{
public:
// Konfigurationsdaten
// -----------------------------------------------------------------------
float offsetRoll;
float borderLowRoll;
float borderHighRoll;
float koeffRoll;
float offsetPitch;
float borderLowPitch;
float borderHighPitch;
float koeffPitch;
float offsetYaw;
float borderLowYaw;
float borderHighYaw;
float koeffYaw;
Meas2Midi aimRoll;
Meas2Midi aimPitch;
Meas2Midi aimYaw;
byte signAreaValue[4];
byte signAreaCtrl[4];
MidiArea midiArea[NrM2M];
// Hilfsfunktionen
// -----------------------------------------------------------------------
//
public:
void setKoeffRoll(MeasMap map);
void setKoeffPitch(MeasMap map);
void setKoeffYaw(MeasMap map);
int getResultRoll(MidiResultPtr refResult, float measValue);
int getResultPitch(MidiResultPtr refResult, float measValue);
int getResultYaw(MidiResultPtr refResult, float measValue);
#ifdef MeasMuseDebug
// Debugging
// -----------------------------------------------------------------------
//
float debInValRoll;
byte debResVal;
#endif
};
public:
// -------------------------------------------------------------------------
// globale klassenspezifische Datentypen
// -------------------------------------------------------------------------
//
private:
// -------------------------------------------------------------------------
// lokale Datentypen
// -------------------------------------------------------------------------
//
// -------------------------------------------------------------------------
// Hilfsfunktionen
// -------------------------------------------------------------------------
//
private:
#ifdef MeasMuseDebug
public:
#endif
// -------------------------------------------------------------------------
// lokale Variablen
// -------------------------------------------------------------------------
//
Posture2Midi config[NrOfChannelsMM]; // Konfiguration der Abbildung
public:
// -------------------------------------------------------------------------
// Konstruktoren und Initialisierungen
// -------------------------------------------------------------------------
//
MeasMuse();
// -------------------------------------------------------------------------
// Konfiguration
// -------------------------------------------------------------------------
//
void setRollArea(int channel, float offset, float min, float max);
void setPitchArea(int channel, float offset, float min, float max);
void setYawArea(int channel, float offset, float min, float max);
void setAims(int channel, Meas2Midi aimRoll, Meas2Midi aimPitch, Meas2Midi aimYaw);
void setMidiArea(int channel, Meas2Midi midi, byte low, byte high);
void setMapping(int channel, MeasMap mapRoll, MeasMap mapPitch, MeasMap mapYaw);
// -------------------------------------------------------------------------
// Anwenderfunktionen
// -------------------------------------------------------------------------
//
int resultRoll(int channel, MidiResultPtr refResult, float measValue);
int resultPitch(int channel, MidiResultPtr refResult, float measValue);
int resultYaw(int channel, MidiResultPtr refResult, float measValue);
};
//-----------------------------------------------------------------------------
#endif // _MeasMuse_h
...@@ -33,64 +33,12 @@ ...@@ -33,64 +33,12 @@
#include "StateMachine.h" #include "StateMachine.h"
#include "nRF52840Radio.h" #include "nRF52840Radio.h"
#include "MidiNotes.h" #include "MidiNotes.h"
#include "MeasMuse.h"
#include "BlePoll.h" #include "BlePoll.h"
#include "ComRingBuf.h" #include "ComRingBuf.h"
#include "nRF52840Ser.h" #include "nRF52840Ser.h"
#include "Monitor.h" #include "Monitor.h"
// ----------------------------------------------------------------------------
// Datentypen
// ----------------------------------------------------------------------------
//
typedef struct _Value2Midi
{
short borderLowAz;
short borderHighAz;
short borderLowAy;
short borderHighAy;
short borderLowAx;
short borderHighAx;
byte lowNote;
byte highNote;
} Value2Midi, *Value2MidiPtr;
enum Meas2Midi
{
NoteType,
NoteVal,
NoteVel
};
typedef struct _MidiBorders
{
byte low;
byte high;
} MidiBorders, *MiniBordersPtr;
typedef struct _Posture2Midi
{
float offsetRoll;
float borderLowRoll;
float borderHighRoll;
float koeffRoll;
float offsetPitch;
float borderLowPitch;
float borderHighPitch;
float koeffPitch;
float offsetYaw;
float borderLowYaw;
float borderHighYaw;
float koeffYaw;
Meas2Midi aimRoll;
Meas2Midi aimPitch;
Meas2Midi aimYaw;
byte signAreaValue[4];
byte signAreaCtrl[4];
MidiBorders midiBords[3];
} Posture2Midi, *Posture2MidiPtr;
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// Vorwärtsreferenzen // Vorwärtsreferenzen
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
...@@ -106,8 +54,7 @@ void apTestController(); ...@@ -106,8 +54,7 @@ void apTestController();
void setParM1(); void setParM1();
void setParM2(); void setParM2();
void setParP1(); void setParP1(int chn);
void setParP2();
#ifdef DebugTerminal #ifdef DebugTerminal
......
...@@ -61,10 +61,12 @@ BlePoll blePoll((IntrfRadio *) &bleCom, micros); ...@@ -61,10 +61,12 @@ BlePoll blePoll((IntrfRadio *) &bleCom, micros);
// festgelegt werden. // festgelegt werden.
Value2Midi val2midArr[NrOfSlavesToPoll + 1]; Value2Midi val2midArr[NrOfSlavesToPoll + 1];
Posture2Midi post2midArr[NrOfSlavesToPoll + 1];
// Jeder Slave bekommt spezifische Value->Midi-Parameter. // Jeder Slave bekommt spezifische Value->Midi-Parameter.
// Index 0 steht für eventuelle Parameter des Masters // Index 0 steht für eventuelle Parameter des Masters
MeasMuse muse;
// Ab atSOAAP2 werden die Konfigurationen in einer eigenen Klasse verwaltet
SerParams ttyParams; SerParams ttyParams;
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
nRF52840Ser tty; nRF52840Ser tty;
...@@ -132,6 +134,16 @@ char *infoThis = ...@@ -132,6 +134,16 @@ char *infoThis =
"c5 Meldung an Slave senden\r\n" "c5 Meldung an Slave senden\r\n"
}; };
// Startmeldung (Version und drehender Strich)
//
char *StartMsg =
{
"%@BleMidiMaster, Version 20221117 "
};
char runView[4] = {'|','/','-','\\'};
int runViewIdx = 0;
Monitor mon(modeEcho | modeNl,0,&lc); Monitor mon(modeEcho | modeNl,0,&lc);
// Eine statische Instanz (mit Konstruktordaten) der Klasse Monitor // Eine statische Instanz (mit Konstruktordaten) der Klasse Monitor
...@@ -160,7 +172,8 @@ void setup() ...@@ -160,7 +172,8 @@ void setup()
bleCom.begin(); // Initialisierung der Datenübertragung bleCom.begin(); // Initialisierung der Datenübertragung
//bleCom.setPower(0x08); // Maximale Sendeleistung bei nRF52840 //bleCom.setPower(0x08); // Maximale Sendeleistung bei nRF52840
// TEST // TEST
bleCom.setPower(0x0FC); // Reduzierte Sendeleistung beim Schreibtisch-Test //bleCom.setPower(0x0FC); // Reduzierte Sendeleistung beim Schreibtisch-Test
bleCom.setPower(0x000); // Standard-Sendeleistung BLE
//appType = BlePoll::atDevSOAAP; //appType = BlePoll::atDevSOAAP;
appType = BlePoll::atSOAAP2; appType = BlePoll::atSOAAP2;
...@@ -219,12 +232,12 @@ void setup() ...@@ -219,12 +232,12 @@ void setup()
// für die Übergabe zu sendender Zeichen // für die Übergabe zu sendender Zeichen
setParM1(); setParM1();
setParP1(); setParP1(1);
midi1.begin(120, nd32, MidiCycle, (IntrfBuf *) &crb); midi1.begin(120, nd32, MidiCycle, (IntrfBuf *) &crb);
midi1.setChannel(1); midi1.setChannel(1);
setParM2(); setParM2();
setParP2(); setParP1(2);
midi2.begin(120, nd32, MidiCycle, (IntrfBuf *) &crb); midi2.begin(120, nd32, MidiCycle, (IntrfBuf *) &crb);
midi2.setChannel(2); midi2.setChannel(2);
//midi2.stop(); //midi2.stop();
...@@ -266,13 +279,18 @@ void loop() ...@@ -266,13 +279,18 @@ void loop()
} }
#ifdef DebugTerminal #ifdef DebugTerminal
// Jede Sekunde erfolgt die Ausgabe einer Versionsmeldung // Jede halbe Sekunde erfolgt die Ausgabe einer Versionsmeldung
// das kann über c0 am Terminal abgeschaltet werden // das kann über c0 am Terminal abgeschaltet werden
// //
if(lc.timerMilli(lcTimer3, 1000, 0)) if(lc.timerMilli(lcTimer3, 500, 0))
{ {
if(!mon.cFlag[0]) if(!mon.cFlag[0])
mon.printcr((char *)"%@TestBleMidiMaster, Version 20221018"); {
mon.print(StartMsg);
mon.cprintcr(runView[runViewIdx]);
runViewIdx++;
if(runViewIdx > 3) runViewIdx = 0;
}
} }
// Die Zeichen %@ am Anfang steuern die Ausgabe bei AndroidMonTerm in ein // Die Zeichen %@ am Anfang steuern die Ausgabe bei AndroidMonTerm in ein
// Textfeld (Label) statt auf das Terminal-Display // Textfeld (Label) statt auf das Terminal-Display
...@@ -289,6 +307,46 @@ void loop() ...@@ -289,6 +307,46 @@ void loop()
lc.end(); // Muss vor dem Ende von LOOP aufgerufen werden lc.end(); // Muss vor dem Ende von LOOP aufgerufen werden
} }
// ----------------------------------------------------------------------------
// Daten auf Midi-Noten abbilden
//
void setParM1()
{
val2midArr[1].borderLowAz = 100;
val2midArr[1].borderHighAz = 8000;
val2midArr[1].borderLowAy = 100;
val2midArr[1].borderHighAy = 8300;
val2midArr[1].borderLowAx = 100;
val2midArr[1].borderHighAx = 4000;
val2midArr[1].lowNote = 23;
val2midArr[1].highNote = 96;
}
void setParM2()
{
val2midArr[2].borderLowAz = 100;
val2midArr[2].borderHighAz = 8000;
val2midArr[2].borderLowAy = 100;
val2midArr[2].borderHighAy = 8300;
val2midArr[2].borderLowAx = 100;
val2midArr[2].borderHighAx = 4000;
val2midArr[2].lowNote = 23;
val2midArr[2].highNote = 96;
}
void setParP1(int chn)
{
muse.setRollArea(chn, 90, 45, 170);
muse.setPitchArea(chn, 90, 45, 170);
muse.setAims(chn, NoteType, NoteVal, Nothing);
muse.setMidiArea(chn, NoteVal, 23, 96);
muse.setMidiArea(chn, NoteType, 2, 12);
muse.setMapping(chn, BiLinear, BiLinear, BiLinear);
}
// **************************************************************************** // ****************************************************************************
// Z u s t a n d s m a s c h i n e S O A A P - A n w e n d u n g (ap) // Z u s t a n d s m a s c h i n e S O A A P - A n w e n d u n g (ap)
// **************************************************************************** // ****************************************************************************
...@@ -352,14 +410,15 @@ void apWaitDE() ...@@ -352,14 +410,15 @@ void apWaitDE()
dword apWaitMeasCnt; dword apWaitMeasCnt;
void apWaitMeas() void apWaitMeas()
{ {
int snr;
apWaitMeasCnt++; apWaitMeasCnt++;
// Ermitteln, ob einer der Slaves einen Messwert hat // Ermitteln, ob einer der Slaves einen Messwert hat
// //
for(curListIdx = 0; curListIdx < apNrOfSlaves; curListIdx++) for(curListIdx = 0; curListIdx < apNrOfSlaves; curListIdx++)
{ {
slNr = apSlaveList[curListIdx]; snr = apSlaveList[curListIdx];
if(blePoll.measAvail(slNr)) break; if(blePoll.measAvail(snr)) break;
} }
if(curListIdx == apNrOfSlaves) return; if(curListIdx == apNrOfSlaves) return;
// Wenn kein Slave neue Messwerte hat, // Wenn kein Slave neue Messwerte hat,
...@@ -402,7 +461,7 @@ void apProcMeas() ...@@ -402,7 +461,7 @@ void apProcMeas()
// Daten überprüfen (auswerten) // Daten überprüfen (auswerten)
// //
short accXold, accYold, accZold; short accXold, accYold, accZold;
float rollOld, pitchOld, yawOld; float rollMeasValue, pitchMeasValue, yawMeasValue;
dword apCheckValuesCnt; dword apCheckValuesCnt;
void apCheckValues() void apCheckValues()
{ {
...@@ -420,9 +479,9 @@ void apCheckValues() ...@@ -420,9 +479,9 @@ void apCheckValues()
break; break;
case BlePoll::atSOAAP2: case BlePoll::atSOAAP2:
rollOld = * (float *) &apMeasByteArray[0]; rollMeasValue = * (float *) &apMeasByteArray[0];
pitchOld = * (float *) &apMeasByteArray[4]; pitchMeasValue = * (float *) &apMeasByteArray[4];
yawOld = * (float *) &apMeasByteArray[8]; yawMeasValue = * (float *) &apMeasByteArray[8];
break; break;
} }
...@@ -430,106 +489,11 @@ void apCheckValues() ...@@ -430,106 +489,11 @@ void apCheckValues()
ap.enter(apCalcResult); ap.enter(apCalcResult);
} }
// ----------------------------------------------------------------------------
// Daten auf Midi-Noten abbilden
//
//short borderLowAz = 100;
//short borderHighAz = 8000;
//short borderLowAy = 100;
//short borderHighAy = 8300;
//short borderLowAx = 100;
//short borderHighAx = 4000;
//byte lowNote = 23;
//byte highNote = 72;
//byte highNote = 96;
void setParM1()
{
val2midArr[1].borderLowAz = 100;
val2midArr[1].borderHighAz = 8000;
val2midArr[1].borderLowAy = 100;
val2midArr[1].borderHighAy = 8300;
val2midArr[1].borderLowAx = 100;
val2midArr[1].borderHighAx = 4000;
val2midArr[1].lowNote = 23;
val2midArr[1].highNote = 96;
}
void setParM2()
{
val2midArr[2].borderLowAz = 100;
val2midArr[2].borderHighAz = 8000;
val2midArr[2].borderLowAy = 100;
val2midArr[2].borderHighAy = 8300;
val2midArr[2].borderLowAx = 100;
val2midArr[2].borderHighAx = 4000;
val2midArr[2].lowNote = 23;
val2midArr[2].highNote = 96;
}
void setParP1()
{
Posture2MidiPtr pmp = &post2midArr[1];
pmp->offsetRoll = 90;
pmp->borderLowRoll = 45;
pmp->borderHighRoll = 170;
pmp->aimRoll = NoteType;
pmp->offsetPitch = 90;
pmp->borderLowPitch = 45;
pmp->borderHighPitch = 170;
pmp->aimPitch = NoteVal;
pmp->midiBords[NoteVal].low = 23;
pmp->midiBords[NoteVal].high = 96;
pmp->midiBords[NoteType].low = 2;
pmp->midiBords[NoteType].high = 12;
pmp->koeffRoll =
(pmp->midiBords[pmp->aimRoll].high - pmp->midiBords[pmp->aimRoll].low) /
(pmp->borderHighRoll - pmp->borderLowRoll);
pmp->koeffPitch =
(pmp->midiBords[pmp->aimPitch].high - pmp->midiBords[pmp->aimPitch].low) /
(pmp->borderHighPitch - pmp->borderLowPitch);
}
void setParP2()
{
Posture2MidiPtr pmp = &post2midArr[2];
pmp->offsetRoll = 90;
pmp->borderLowRoll = 45;
pmp->borderHighRoll = 170;
pmp->aimRoll = NoteType;
pmp->offsetPitch = 90;
pmp->borderLowPitch = 45;
pmp->borderHighPitch = 170;
pmp->aimPitch = NoteVal;
pmp->midiBords[NoteVal].low = 23;
pmp->midiBords[NoteVal].high = 96;
pmp->midiBords[NoteType].low = 2;
pmp->midiBords[NoteType].high = 12;
pmp->koeffRoll =
(pmp->midiBords[pmp->aimRoll].high - pmp->midiBords[pmp->aimRoll].low) /
(pmp->borderHighRoll - pmp->borderLowRoll);
pmp->koeffPitch =
(pmp->midiBords[pmp->aimPitch].high - pmp->midiBords[pmp->aimPitch].low) /
(pmp->borderHighPitch - pmp->borderLowPitch);
}
byte resultAz; byte resultAz;
byte resultAy; byte resultAy;
byte resultAx; byte resultAx;
byte resultNote[3]; MidiResult midiResult[3];
dword apCalcResultCnt; dword apCalcResultCnt;
void apCalcResult() void apCalcResult()
...@@ -538,6 +502,7 @@ void apCalcResult() ...@@ -538,6 +502,7 @@ void apCalcResult()
int result; int result;
float rollVal, pitchVal, yawVal; float rollVal, pitchVal, yawVal;
Meas2Midi meas2midi; Meas2Midi meas2midi;
bool newResult;
apCalcResultCnt++; apCalcResultCnt++;
...@@ -568,44 +533,61 @@ void apCalcResult() ...@@ -568,44 +533,61 @@ void apCalcResult()
break; break;
case BlePoll::atSOAAP2: case BlePoll::atSOAAP2:
rollVal = rollOld + post2midArr[slNr].offsetRoll; // Rollwinkel in positiven Bereich verschieben result = muse.resultRoll(slNr, &midiResult[0], rollMeasValue);
if(rollVal < post2midArr[slNr].borderLowRoll) if(result < 0)
{ {
rollVal = post2midArr[slNr].borderLowRoll; // Inhalt ggf. auf Minimalwert begrenzen // Bereich verlassen (links)
ap.enter(apWaitMeas);
return;
} }
else if(rollVal > post2midArr[slNr].borderHighRoll) else if(result > 0)
{ {
rollVal = post2midArr[slNr].borderHighRoll; // Inhalt ggf. auf Maximalwert begrenzen // Bereich verlassen (rechts)
ap.enter(apWaitMeas);
return;
} }
meas2midi = post2midArr[slNr].aimRoll;
resultNote[meas2midi] =
post2midArr[slNr].midiBords[meas2midi].low +
(byte) ((rollVal - post2midArr[slNr].borderLowRoll) * post2midArr[slNr].koeffRoll);
pitchVal = pitchOld + post2midArr[slNr].offsetPitch; // Pitchwinkel in positiven Bereich verschieben result = muse.resultPitch(slNr, &midiResult[1], pitchMeasValue);
if(pitchVal < post2midArr[slNr].borderLowPitch) if(result < 0)
{ {
pitchVal = post2midArr[slNr].borderLowPitch; // Inhalt ggf. auf Minimalwert begrenzen // Bereich verlassen (links)
ap.enter(apWaitMeas);
return;
} }
else if(pitchVal > post2midArr[slNr].borderHighPitch) else if(result > 0)
{ {
pitchVal = post2midArr[slNr].borderHighPitch; // Inhalt ggf. auf Maximalwert begrenzen // Bereich verlassen (rechts)
ap.enter(apWaitMeas);
return;
} }
meas2midi = post2midArr[slNr].aimPitch;
resultNote[meas2midi] =
post2midArr[slNr].midiBords[meas2midi].low + midiResult[2].type = NoteVel;
(byte) ((pitchVal - post2midArr[slNr].borderLowPitch) * post2midArr[slNr].koeffPitch); midiResult[2].value = 100;
resultNote[NoteVel] = 100;
break; break;
} }
newResult = false;
for(int i = 0; i < 3; i++)
{
if(midiResult[i].newVal)
{
midiResult[i].newVal = false;
newResult = true;
}
}
if(newResult)
ap.enter(apSetResult); ap.enter(apSetResult);
else
ap.enter(apWaitMeas);
} }
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// Bedienen des Midi-Controller // Bedienen des Midi-Controller
// //
dword apSetResultCnt; dword apSetResultCnt;
byte noteTypeIn, noteValIn, noteVelIn;
void apSetResult() void apSetResult()
{ {
apSetResultCnt++; apSetResultCnt++;
...@@ -620,22 +602,21 @@ void apSetResult() ...@@ -620,22 +602,21 @@ void apSetResult()
break; break;
case BlePoll::atSOAAP2: case BlePoll::atSOAAP2:
for(int i = 0; i < 3; i++)
{
if(midiResult[i].type == NoteType)
noteTypeIn = midiResult[i].value;
else if(midiResult[i].type == NoteVal)
noteValIn = midiResult[i].value;
else if(midiResult[i].type == NoteVel)
noteVelIn = midiResult[i].value;
}
if(slNr == 1) if(slNr == 1)
midi1.setChordNote midi1.setChordNote(lastNoteIdxM1,(MidiNotes::NoteTypeIdx) noteTypeIn, noteValIn, noteVelIn);
(
lastNoteIdxM1,
(MidiNotes::NoteTypeIdx) resultNote[NoteType],
resultNote[NoteVal],
resultNote[NoteVel]
);
else if(slNr == 2) else if(slNr == 2)
midi2.setChordNote midi2.setChordNote(lastNoteIdxM1,(MidiNotes::NoteTypeIdx) noteTypeIn, noteValIn, noteVelIn);
(
lastNoteIdxM1,
(MidiNotes::NoteTypeIdx) resultNote[NoteType],
resultNote[NoteVal],
resultNote[NoteVel]
);
break; break;
} }
...@@ -749,7 +730,7 @@ void smCtrlPolling() ...@@ -749,7 +730,7 @@ void smCtrlPolling()
short tmpShort; short tmpShort;
int i; int i;
PlpMeas6Ptr resPtr; PlPduMeasPtr resPtr;
if(sm.firstEnter()) if(sm.firstEnter())
{ {
...@@ -870,20 +851,15 @@ void smCtrlPolling() ...@@ -870,20 +851,15 @@ void smCtrlPolling()
} }
mon.print(tmpDw); mon.cprint(' '); mon.print(tmpDw); mon.cprint(' ');
resPtr = (PlpMeas6Ptr) &slPtr->result; resPtr = (PlPduMeasPtr) &slPtr->result;
mon.print(slPtr->cntLostPdu); mon.cprint('|'); mon.print(slPtr->cntLostPdu); mon.cprint('|');
mon.print(slPtr->cntErrCrc); mon.cprint('|'); mon.print(slPtr->cntErrCrc); mon.cprint('|');
//mon.print(slPtr->result.measCnt); mon.cprint('|'); //mon.print(slPtr->result.measCnt); mon.cprint('|');
mon.print(resPtr->measCnt); mon.cprint('|'); mon.print(resPtr->measCnt); mon.cprint('|');
mon.print(slPtr->cntLostMeas); mon.cprint(' '); mon.print(slPtr->cntLostMeas); mon.cprint(' ');
mon.print(resPtr->plData,12,'.');
for(i = 0; i < 6; i++)
{
//tmpShort = (short) slPtr->result.meas[i];
tmpShort = (short) resPtr->meas[i];
mon.prints(tmpShort); mon.cprint(' ');
}
mon.print((char *) " Poll["); mon.print((char *) " Poll[");
mon.print(slPtr->pIdx); mon.print(slPtr->pIdx);
mon.print((char *) "] "); mon.print((char *) "] ");
...@@ -892,8 +868,6 @@ void smCtrlPolling() ...@@ -892,8 +868,6 @@ void smCtrlPolling()
sm.resetEnter(); sm.resetEnter();
} }
else else
{ {
if(mon.lastKeyIn == ' ') if(mon.lastKeyIn == ' ')
...@@ -1009,12 +983,18 @@ void smReadPollValues() ...@@ -1009,12 +983,18 @@ void smReadPollValues()
char *caHelp = char *caHelp =
{ {
"c Zyklen der Zustandsmaschine\r\n" "c Zyklen der Zustandsmaschine\r\n"
"m Ausgabe Midiwerte\r\n" #ifdef MeasMuseDebug
"d Debug MeasMuse\r\n"
#endif
"m Anzeige Midiwerte\r\n"
"v Anzeige Messwerte\r\n"
"Leerzeichen für Abbruch\r\n" "Leerzeichen für Abbruch\r\n"
}; };
void smCheckApp() void smCheckApp()
{ {
char conv[32];
if(sm.firstEnter()) if(sm.firstEnter())
{ {
mon.print((char *) "Check App "); mon.print((char *) "Check App ");
...@@ -1041,13 +1021,42 @@ void smCheckApp() ...@@ -1041,13 +1021,42 @@ void smCheckApp()
mon.println(apSetResultCnt); mon.println(apSetResultCnt);
sm.resetEnter(); sm.resetEnter();
} }
#ifdef MeasMuseDebug
else if(mon.lastKeyIn == 'D' || mon.lastKeyIn == 'd')
{
mon.cprintln('d');
mon.print(slNr);
sprintf(conv," inVal=%f",muse.config[slNr].debInValRoll);
mon.print(conv);
sprintf(conv," LowRoll=%f",muse.config[slNr].borderLowRoll);
mon.print(conv);
sprintf(conv," HighRoll=%f",muse.config[slNr].borderHighRoll);
mon.print(conv);
sprintf(conv," koeff=%f ",muse.config[slNr].koeffRoll);
mon.print(conv);
mon.println(muse.config[slNr].debResVal);
sm.resetEnter();
}
#endif
else if(mon.lastKeyIn == 'M' || mon.lastKeyIn == 'm') else if(mon.lastKeyIn == 'M' || mon.lastKeyIn == 'm')
{ {
mon.cprintln('m'); mon.cprintln('m');
mon.print(slNr); mon.cprint(' '); mon.print(slNr); mon.cprint(' ');
mon.print(resultNote[NoteType]); mon.cprint(' '); mon.print(noteTypeIn); mon.cprint(' ');
mon.print(resultNote[NoteVal]); mon.cprint(' '); mon.print(noteValIn); mon.cprint(' ');
mon.println(resultNote[NoteVel]); mon.println(noteVelIn);
sm.resetEnter();
}
else if(mon.lastKeyIn == 'V' || mon.lastKeyIn == 'v')
{
mon.cprintln('v');
mon.print(slNr); mon.cprint(' ');
sprintf(conv,"r=%f",rollMeasValue);
mon.print(conv); mon.cprint(' ');
sprintf(conv," p=%f",pitchMeasValue);
mon.print(conv); mon.cprint(' ');
sprintf(conv," y=%f",yawMeasValue);
mon.println(conv);
sm.resetEnter(); sm.resetEnter();
} }
......
0% Loading or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment