public void Unpack(byte[] buf)
{
sync0 = buf[0];
sync1 = buf[1];
version = buf[2];
count = buf[3];
int dataIdx = 0;
for (int i = CHANNEL_OFFSET; i < CHANNEL_OFFSET + (CHANNEL_COUNT * 2); i += 2)
{
byte upper = buf[i];
byte lower = buf[i + 1];
UInt16 val = (UInt16)(upper << 8);
val += lower;
channels[dataIdx++] = val;
}
switches = buf[16];
timeStamp = DateTime.Now.Ticks;
if (buf.Length == PACKET_SIZE_W_HINT)
{
muscleStateHint = (MuscleState)buf[17];
}
}
private void CheckPulseStatus()
{
// relaxed muscle after pulsating
if ((state != MuscleState.RELAXED) && GetIntensity() < active)
{
ExecuteActions(relaxedActions);
state = MuscleState.RELAXED;
}
// hasnt relaxed muscle
if (state == MuscleState.PULSED)
{
state = MuscleState.HELD;
}
// pulsed muscle after being relaxed
if (state == MuscleState.RELAXED && GetIntensity() > resting && cooldown <= 0)
{
ExecuteActions(singlePulseActions);
state = MuscleState.PULSED;
cooldown = cooldownFrames;
}
if (state == MuscleState.HELD)
{
ExecuteActions(continuousPulseActions);
}
}
private void Predict()
{
TrainingValue tmp = new TrainingValue();
tmp.Features = new double[FEATURE_COUNT];
FillTrainingValue(ref tmp, fftResults);
int result = trainer.Predict(tmp);
predictedMuscleState = (MuscleState)result;
}
public void Update()
{
EMGPacket packet;
MuscleState hintedMuscleState = MuscleState.NONE;
while (reader.TryDequeue(out packet))
{
hintedMuscleState = packet.muscleStateHint;
packet.muscleStateHint = currentMuscleState;
rawReadings.Add(packet);
}
if (hintedMuscleState != MuscleState.NONE)
{
// If packages are being read from file, a MuscleState hint will be stored in them
// Take the current muscle state from packets instead of being specified by the player
currentMuscleState = hintedMuscleState;
}
if (rawReadings.Count >= FFT_SAMPLE_SIZE)
{
Idle();
switch (mode)
{
case Mode.TRAINING:
Train();
break;
case Mode.PREDICTING:
Predict();
break;
case Mode.WRITING:
Write();
break;
default:
break;
}
processorCallbacks.ForEach(callback => callback());
rawReadings.Clear();
readings.Clear();
}
if (mode != Mode.WRITING)
{
/* Discard packets received during processing */
reader.ClearQueue();
}
}
private void WeaponTick(MuscleState state)
{
if (state == MuscleState.RELAXED)
{
currentWeapon.MuscleRelaxedTick();
}
else if (state == MuscleState.TENSE)
{
currentWeapon.MuscleTenseTick();
}
}
internal static List <TrainingValue> GetTrainingValues(List <EMGPacket> packets, bool enableSkip)
{
List <TrainingValue> values = new List <TrainingValue>(EMGProcessor.FFT_SAMPLE_SIZE);
int skipsRemaining = 0;
for (int i = 0; i < packets.Count / EMGProcessor.FFT_SAMPLE_SIZE; i++)
{
if (enableSkip && skipsRemaining > 0)
{
skipsRemaining--;
continue;
}
Complex[] data = new Complex[EMGProcessor.FFT_SAMPLE_SIZE];
int start = i * EMGProcessor.FFT_SAMPLE_SIZE;
int end = start + EMGProcessor.FFT_SAMPLE_SIZE;
MuscleState startMuscleState = packets[start].muscleStateHint;
for (int j = start; j < end; j++)
{
EMGPacket packet = packets[j];
if (packet.muscleStateHint != startMuscleState)
{
skipsRemaining += EMGProcessor.SKIPS_AFTER_TRANSITION;
break;
}
data[j - start] = new Complex(EMGProcessor.ValueFromPacket(packet), 0);
}
if (enableSkip && skipsRemaining > 0)
{
continue;
}
FourierTransform.FFT(data, FourierTransform.Direction.Forward);
List <Complex> fftResults = new List <Complex>(data);
TrainingValue trainingValue = new TrainingValue((int)packets[start].muscleStateHint, EMGProcessor.FEATURE_COUNT);
EMGProcessor.FillTrainingValue(ref trainingValue, fftResults);
values.Add(trainingValue);
}
return(values);
}
public void ChangeMode(Mode newMode)
{
if (mode == Mode.TRAINING)
{
EndTraining();
}
else if (mode == Mode.PREDICTING)
{
predictedMuscleState = MuscleState.NONE;
trainer = new Trainer(FEATURE_COUNT, ClassifierType.DecisionTree);
}
else if (mode == Mode.WRITING)
{
outFileStream = null;
}
mode = newMode;
}
