Universal Mouse and Keyboard Console on The fly New Version
5 posts
• Page 1 of 1
Universal Mouse and Keyboard Console on The fly New Version
New Version Deadzone Shape Circle
You can Use Gtuner Or if you have the Bluetooh Modul Gtuner Air to Interactive Configuration Adjustmant Deadzone
----------------------------------------------------------------------------------------------------------------------------------------------
Titan Two Settings
Set on Titan 2 800 Dpi
Set on Titan 2 Input Poling Rate 1000Hz
Set on Titan 2 Output Poling 250Hu
Mouse 500 Hz Dpi 3200 Dpi
----------------------------------------------------------------------------------------------------------------------------------------------
Keyboard Controls
WASD Left Stick
Q L1/LB/L
E R1/RB/R
R Square/X/Y
F R3/RS/SR
C Circle/B/A
G Triangle/Y/X
Tap Touch Click/View /Minus/Select/Back
For Ps4 and Ps5 Hold Tap move mouse for Touch mimic
Left Shift L3/LS/SR
Spacebar Cross/A/B
ESC Options/Menu/Plus/Start
Left Alt PS/Xbox/Home/Guide
1 DPad Up
2 DPad Right
3 DPad Down
4 DPad Left
Up Arrow DPad Up
Right Arrow DPad Right
Down Arrow DPad Down
Left Arrow DPad Left
6 Share/Capture
T Push To Talk
Mouse
Left Button R2/RT /ZR
Right Button L2/LT/ZL
Button 4 Circle/B/A
Button5 Triangle/Y/X
Wheal Middel Button R3/RS/SR
Whael Up DPad Left
Wheal Donw DPad Right
---------------------------------------------------------------------------------------------------------------------------------------------------------
Old Version
Hello this Script is a Universal Mouse and Keyboard Console Special thanks to mss1988 i he made the Interactive Configuration and Calibraton for Gyro Script
https://www.consoletuner.com/forum/viewtopic.php?f=23&t=18364
I mode he Script for mouse and Keyboard an Input Translater is no more needed
This Script add
Deadzone Adjustmant include Diagonal Deadzone
Sensetivity Adjustmant and Sensitivity Multipliers
Deadzone In and out Adjustmant
I made one Script with Curvs and one Normal and ad Ratio XY And DD Factor
How to Use
You can Use Gtuner Or if you have the Bluetooh Modul Gtuner Air to Interactive Configuration Adjustmant
I testet with this Settings
Set on Titan 2 1600 Dpi
Set on Titan 2 Input and Output Poling Rate 250Hz
Mouse 250 Hz Dpi 1600
Keyboard on Port B Mouse on Usb Prog you need an OtG Usb Micro
Or you use it over Gtuner Capture Mode
Controls
Sensetivity Goes form 0 to 6 You can this Value form 1 to 7
Press F1 to Sensetivity Up Press
Press F2 to Sensetivity Down
Press F4 to Mouse Calibration
its good if your mouse is Jitter or Shaky if Sensetivity ia to high
If you have on ADS Press Keyboard M and then F4
Please dont Touch the mouse if you are Calibration mode Titan Two Changing the Light is is done goes back to Blue Light
Keyboard Controls
WASD Left Stick
Q L1/LB/L
E R1/RB/R
R Square/X/Y
F R3/RS/SR
C Circle/B/A
G Triangle/Y/X
Tap Touch Click/View /Minus/Select/Back
For Ps4 and Ps5 Hold Tap move mouse for Touch mimic
Left Shift L3/LS/SR
Spacebar Cross/A/B
ESC Options/Menu/Plus/Start
Left Alt PS/Xbox/Home/Guide
1 DPad Up
2 DPad Right
3 DPad Down
4 DPad Left
Up Arrow DPad Up
Right Arrow DPad Right
Down Arrow DPad Down
Left Arrow DPad Left
6 Share/Capture
Mouse
Left Button R2/RT /ZR
Right Button L2/LT/ZL
Button 4 Circle/B/A
Button5 Triangle/Y/X
Wheal Middel Button R3/RS/SR
Whael Up DPad Left
Wheal Donw DPad Right
Downloade
You can Use Gtuner Or if you have the Bluetooh Modul Gtuner Air to Interactive Configuration Adjustmant Deadzone
----------------------------------------------------------------------------------------------------------------------------------------------
Titan Two Settings
Set on Titan 2 800 Dpi
Set on Titan 2 Input Poling Rate 1000Hz
Set on Titan 2 Output Poling 250Hu
Mouse 500 Hz Dpi 3200 Dpi
----------------------------------------------------------------------------------------------------------------------------------------------
Keyboard Controls
WASD Left Stick
Q L1/LB/L
E R1/RB/R
R Square/X/Y
F R3/RS/SR
C Circle/B/A
G Triangle/Y/X
Tap Touch Click/View /Minus/Select/Back
For Ps4 and Ps5 Hold Tap move mouse for Touch mimic
Left Shift L3/LS/SR
Spacebar Cross/A/B
ESC Options/Menu/Plus/Start
Left Alt PS/Xbox/Home/Guide
1 DPad Up
2 DPad Right
3 DPad Down
4 DPad Left
Up Arrow DPad Up
Right Arrow DPad Right
Down Arrow DPad Down
Left Arrow DPad Left
6 Share/Capture
T Push To Talk
Mouse
Left Button R2/RT /ZR
Right Button L2/LT/ZL
Button 4 Circle/B/A
Button5 Triangle/Y/X
Wheal Middel Button R3/RS/SR
Whael Up DPad Left
Wheal Donw DPad Right
---------------------------------------------------------------------------------------------------------------------------------------------------------
Old Version
Hello this Script is a Universal Mouse and Keyboard Console Special thanks to mss1988 i he made the Interactive Configuration and Calibraton for Gyro Script
https://www.consoletuner.com/forum/viewtopic.php?f=23&t=18364
I mode he Script for mouse and Keyboard an Input Translater is no more needed
This Script add
Deadzone Adjustmant include Diagonal Deadzone
Sensetivity Adjustmant and Sensitivity Multipliers
Deadzone In and out Adjustmant
I made one Script with Curvs and one Normal and ad Ratio XY And DD Factor
How to Use
You can Use Gtuner Or if you have the Bluetooh Modul Gtuner Air to Interactive Configuration Adjustmant
I testet with this Settings
Set on Titan 2 1600 Dpi
Set on Titan 2 Input and Output Poling Rate 250Hz
Mouse 250 Hz Dpi 1600
Keyboard on Port B Mouse on Usb Prog you need an OtG Usb Micro
Or you use it over Gtuner Capture Mode
Controls
Sensetivity Goes form 0 to 6 You can this Value form 1 to 7
Press F1 to Sensetivity Up Press
Press F2 to Sensetivity Down
Press F4 to Mouse Calibration
its good if your mouse is Jitter or Shaky if Sensetivity ia to high
If you have on ADS Press Keyboard M and then F4
Please dont Touch the mouse if you are Calibration mode Titan Two Changing the Light is is done goes back to Blue Light
Keyboard Controls
WASD Left Stick
Q L1/LB/L
E R1/RB/R
R Square/X/Y
F R3/RS/SR
C Circle/B/A
G Triangle/Y/X
Tap Touch Click/View /Minus/Select/Back
For Ps4 and Ps5 Hold Tap move mouse for Touch mimic
Left Shift L3/LS/SR
Spacebar Cross/A/B
ESC Options/Menu/Plus/Start
Left Alt PS/Xbox/Home/Guide
1 DPad Up
2 DPad Right
3 DPad Down
4 DPad Left
Up Arrow DPad Up
Right Arrow DPad Right
Down Arrow DPad Down
Left Arrow DPad Left
6 Share/Capture
Mouse
Left Button R2/RT /ZR
Right Button L2/LT/ZL
Button 4 Circle/B/A
Button5 Triangle/Y/X
Wheal Middel Button R3/RS/SR
Whael Up DPad Left
Wheal Donw DPad Right
Downloade
Last edited by teddy18 on Fri Nov 05, 2021 8:05 pm, edited 4 times in total.
-
teddy18 - Lieutenant
- Posts: 346
- Joined: Sun Jul 19, 2015 4:18 pm
Re: Universal Mouse and Keboard Console on The fly
Script
Universal Mouse and Keyboard Console 1.4
Universal Mouse and Keboard Console with Curve Ver 1.5
Universal Mouse and Keyboard Console 1.4
- Code: Select all
#pragma METAINFO("Universal Mouse and Keboard Console", 1, 4, "mss1988 & teddy18")
#include <switch.gph>
/*
<cfgdesc>
[Gyro Aiming Activation]
byteoffset = 0
bitsize = 8
control = checkbox
default = 0
item = On L1/LB
[Gyro Aiming Activation2]
group = true
groupcol = true
byteoffset = 1
bitsize = 8
control = checkbox
default = 0
item = On L2/LT
[Gyro Aiming Activation3]
group = true
groupcol = true
byteoffset = 2
bitsize = 8
control = checkbox
default = 0
item = On R1/RB
[Gyro Aiming Activation4]
group = true
groupcol = true
byteoffset = 3
bitsize = 8
control = checkbox
default = 0
item = On R2/RT
[Gyro Aiming Activation5]
group = true
groupcol = true
byteoffset = 4
bitsize = 8
control = checkbox
default = 1
item = Always On
[Sensitivity]
group = false
shortdesc = Base sensitivity X
byteoffset = 5
bitsize = 32
control = spinboxf
default = 100
minimum = 10
maximum = 20000
step = 1
decimals = 2
[SensitivityY]
group = true
groupcol = true
shortdesc = Base sensitivity Y
byteoffset = 9
bitsize = 32
control = spinboxf
default = 160
minimum = 10
maximum = 20000
step = 1
decimals = 2
[Sensitivity Multipliers]
group = false
groupcol = false
shortdesc = Active Sensitivity Multiplier:
byteoffset = 13
bitsize = 8
control = slider
default = 3
minimum = 1
maximum = 7
step = 1
[Sensitivity Multipliers1]
group = true
groupcol = false
shortdesc = Sensitivity Multiplier 1:
byteoffset = 14
bitsize = 32
control = spinboxf
default = 50
minimum = 10
maximum = 1000
step = 1
decimals = 2
[Sensitivity Multipliers2]
group = true
groupcol = false
shortdesc = Sensitivity Multiplier 2:
byteoffset = 18
bitsize = 32
control = spinboxf
default = 75
minimum = 10
maximum = 1000
step = 1
decimals = 2
[Sensitivity Multipliers3]
group = true
groupcol = false
shortdesc = Sensitivity Multiplier 3:
byteoffset = 22
bitsize = 32
control = spinboxf
default = 100
minimum = 10
maximum = 1000
step = 1
decimals = 2
[Sensitivity Multipliers4]
group = true
groupcol = false
shortdesc = Sensitivity Multiplier 4:
byteoffset = 26
bitsize = 32
control = spinboxf
default = 125
minimum = 10
maximum = 1000
step = 1
decimals = 2
[Sensitivity Multipliers5]
group = true
groupcol = false
shortdesc = Sensitivity Multiplier 5:
byteoffset = 30
bitsize = 32
control = spinboxf
default = 150
minimum = 10
maximum = 1000
step = 1
decimals = 2
[Sensitivity Multipliers6]
group = true
groupcol = false
shortdesc = Sensitivity Multiplier 6:
byteoffset = 34
bitsize = 32
control = spinboxf
default = 175
minimum = 10
maximum = 1000
step = 1
decimals = 2
[Sensitivity Multipliers7]
group = true
groupcol = false
shortdesc = Sensitivity Multiplier 7:
byteoffset = 38
bitsize = 32
control = spinboxf
default = 200
minimum = 10
maximum = 1000
step = 1
decimals = 2
[Deadzones]
group = false
shortdesc = Ignore Gyro if Right Stick X is greater than:
byteoffset = 42
bitsize = 32
control = spinboxf
default = 200
minimum = 0
maximum = 1000
step = 1
decimals = 1
[DeadzonesY]
group = true
groupcol = false
shortdesc = Ignore Gyro if Right Stick Y is greater than:
byteoffset = 46
bitsize = 32
control = spinboxf
default = 200
minimum = 0
maximum = 1000
step = 1
decimals = 1
[DeadzonesD]
group = true
groupcol = false
shortdesc = Right Stick Diagonal Deadzone:
byteoffset = 50
bitsize = 32
control = spinboxf
default = 38
minimum = 0
maximum = 200
step = 1
decimals = 2
[DeadzonesO]
group = true
groupcol = false
shortdesc = Right Stick Outer Deadzone:
byteoffset = 54
bitsize = 32
control = spinboxf
default = 9200
minimum = 0
maximum = 10000
step = 1
decimals = 2
[DeadzonesI]
group = true
groupcol = false
shortdesc = Right Stick Inner Deadzone:
byteoffset = 58
bitsize = 32
control = spinboxf
default = 013
minimum = 0
maximum = 10000
step = 1
decimals = 2
[Calibration]
group = false
groupcol = false
shortdesc = Delay (ms):
byteoffset = 62
bitsize = 32
control = slider
default = 3000
minimum = 500
maximum = 10000
step = 500
[CalibrationS]
group = true
groupcol = false
shortdesc = Samples:
byteoffset = 66
bitsize = 32
control = slider
default = 300
minimum = 100
maximum = 10000
step = 100
</cfgdesc>
*/
//Constants
#define PAD_OTHER 0
#define PAD_PS4 1
#define PAD_SWITCH 2
uint8 PAD_IDS[5] = { 6, 5, 4, 2, 1 };
uint8 PAD_IDS_LENGHT = 5;
//Persistent memory addereses
#define ADDR_ACTIVATE_L1 0
#define ADDR_ACTIVATE_L2 1
#define ADDR_ACTIVATE_R1 2
#define ADDR_ACTIVATE_R2 3
#define ADDR_ACTIVATE_ALWAYS_ON 4
#define ADDR_BASE_SENSITIVITY_X 5
#define ADDR_BASE_SENSITIVITY_Y 9
#define ADDR_SENSITIVITY_MULTIPLIER_INDEX 13
#define ADDR_SENSITIVITY_MULTIPLIER_0 14
#define ADDR_SENSITIVITY_MULTIPLIER_1 18
#define ADDR_SENSITIVITY_MULTIPLIER_2 22
#define ADDR_SENSITIVITY_MULTIPLIER_3 26
#define ADDR_SENSITIVITY_MULTIPLIER_4 30
#define ADDR_SENSITIVITY_MULTIPLIER_5 34
#define ADDR_SENSITIVITY_MULTIPLIER_6 38
#define ADDR_DEADZONE_X 42
#define ADDR_DEADZONE_Y 46
#define ADDR_DEADZONE_D 50
#define ADDR_OUTER_DEADZONE 54
#define ADDR_INNER_DEADZONE 58
#define ADDR_CALIBRATION_DELAY 62
#define ADDR_CALIBRATION_SAMPLES 66
#define ADDR_CALIB_PS4_X 92
#define ADDR_CALIB_PS4_Y 96
#define ADDR_CALIB_PS4_Z 100
#define ADDR_CALIB_SWITCH_X 104
#define ADDR_CALIB_SWITCH_Y 108
#define ADDR_CALIB_SWITCH_Z 116
#define ADDR_CALIB_OTHER_X 116
#define ADDR_CALIB_OTHER_Y 120
#define ADDR_CALIB_OTHER_Z 124
#define LED_DELAY 2000
//Variables
fix32 mCalibOffsetX = 0.0;
fix32 mCalibOffsetY = 0.0;
fix32 mCalibOffsetZ = 0.0;
bool mIsActivatedCalibrating = FALSE;
bool mIsActivatedIncreaseSensitivity = FALSE;
bool mIsActivatedDecreaseSensitivity = FALSE;
bool mIsActivatedLeds = FALSE;
fix32 mBaseSensitivityX = 1.0;
fix32 mBaseSensitivityY = 1.6;
uint8 mSensitivityMultiplierIndex = 2;
fix32 mSensitivityMultipliersArray[7] = { 0.5, 0.75, 1.0, 1.25, 1.5, 1.75, 2.0 };
uint32 mCalibrationDelay = 3000;
uint32 mCalibrationSamples = 300;
uint32 mCalibrationCycleIndex = 0;
fix32 mDeadzoneX = 20.0; // Deadzone GYRO_1_YZ Input
fix32 mDeadzoneY = 20.0; // Deadzone GYRO_1_YX Input
fix32 mDeadzoneD = 0.38; // Deadzone Diagonal input
fix32 mOuterDeadzone = 92.00;
fix32 mInnerDeadzone = 0.13;
bool mIsActivateL1 = FALSE;
bool mIsActivateL2 = TRUE;
bool mIsActivateR1 = FALSE;
bool mIsActivateR2 = TRUE;
bool mIsAlwaysOn = FALSE;
bool mIsMotionAimingOn = TRUE;
uint32 mTimeCounter = 0;
bool mIsActivatedDebugging = FALSE;
init
{
pmem_load();
printf("Values loaded:");
pmem_read(ADDR_ACTIVATE_L1, &mIsActivateL1);
printf("Activate L1: %d", mIsActivateL1);
pmem_read(ADDR_ACTIVATE_L2, &mIsActivateL2);
printf("Activate L2: %d", mIsActivateL2);
pmem_read(ADDR_ACTIVATE_R1, &mIsActivateR1);
printf("Activate R1: %d", mIsActivateR1);
pmem_read(ADDR_ACTIVATE_R2, &mIsActivateR2);
printf("Activate R2: %d", mIsActivateR2);
pmem_read(ADDR_ACTIVATE_ALWAYS_ON, &mIsAlwaysOn);
printf("Activate AlwaysOn: %d", mIsAlwaysOn);
pmem_read(ADDR_BASE_SENSITIVITY_X, &mBaseSensitivityX);
printf("Base sensitivity X: %f", mBaseSensitivityX);
pmem_read(ADDR_BASE_SENSITIVITY_Y, &mBaseSensitivityY);
printf("Base sensitivity Y: %f", mBaseSensitivityY);
pmem_read(ADDR_SENSITIVITY_MULTIPLIER_INDEX, &mSensitivityMultiplierIndex);
mSensitivityMultiplierIndex--;
printf("Sensitivity multiplier index: %d", mSensitivityMultiplierIndex);
pmem_read(ADDR_SENSITIVITY_MULTIPLIER_0, &mSensitivityMultipliersArray[0]);
printf("Sensitivity multiplier [0]: %f", mSensitivityMultipliersArray[0]);
pmem_read(ADDR_SENSITIVITY_MULTIPLIER_1, &mSensitivityMultipliersArray[1]);
printf("Sensitivity multiplier [1]: %f", mSensitivityMultipliersArray[1]);
pmem_read(ADDR_SENSITIVITY_MULTIPLIER_2, &mSensitivityMultipliersArray[2]);
printf("Sensitivity multiplier [2]: %f", mSensitivityMultipliersArray[2]);
pmem_read(ADDR_SENSITIVITY_MULTIPLIER_3, &mSensitivityMultipliersArray[3]);
printf("Sensitivity multiplier [3]: %f", mSensitivityMultipliersArray[3]);
pmem_read(ADDR_SENSITIVITY_MULTIPLIER_4, &mSensitivityMultipliersArray[4]);
printf("Sensitivity multiplier [4]: %f", mSensitivityMultipliersArray[4]);
pmem_read(ADDR_SENSITIVITY_MULTIPLIER_5, &mSensitivityMultipliersArray[5]);
printf("Sensitivity multiplier [5]: %f", mSensitivityMultipliersArray[5]);
pmem_read(ADDR_SENSITIVITY_MULTIPLIER_6, &mSensitivityMultipliersArray[6]);
printf("Sensitivity multiplier [6]: %f", mSensitivityMultipliersArray[6]);
pmem_read(ADDR_DEADZONE_X, &mDeadzoneX);
printf("Deadzone X: %f", mDeadzoneX);
pmem_read(ADDR_DEADZONE_Y, &mDeadzoneY);
printf("Deadzone Y: %f", mDeadzoneY);
pmem_read(ADDR_DEADZONE_D, &mDeadzoneD);
printf("Deadzone D: %f", mDeadzoneD);
pmem_read(ADDR_OUTER_DEADZONE, &mOuterDeadzone);
printf("Outer Deadzone: %f", mOuterDeadzone);
pmem_read(ADDR_INNER_DEADZONE, &mInnerDeadzone);
printf("Inner Deadzone: %f", mInnerDeadzone);
pmem_read(ADDR_CALIBRATION_DELAY, &mCalibrationDelay);
printf("Calibration Delay: %d", mCalibrationDelay);
pmem_read(ADDR_CALIBRATION_SAMPLES, &mCalibrationSamples);
printf("Calibration Samples: %d", mCalibrationSamples);
FetchCalibration();
// Load Keyboard maping to Console
const uint8 kmap[] = { 0xE2, 0x00, 0x2B, 0x01, 0x29, 0x02, 0x08, 0x03, 0x09, 0x05, 0x14, 0x06, 0x10, 0x07, 0xE1, 0x08, 0x52, 0x09, 0x51, 0x0A, 0x50, 0x0B, 0x4F, 0x0C, 0x1E, 0x09, 0x20, 0x0A, 0x21, 0x0B, 0x1F, 0x0C, 0x0A, 0x0D, 0x06, 0x0E, 0x2C, 0x0F, 0x15, 0x10, 0x23, 0x11, 0x04, 0x97, 0x07, 0x17, 0x1A, 0x98, 0x16, 0x18, 0x3A, 0x26, 0x3B, 0x27, 0x3C, 0x28, 0x3D, 0x29 };
keymapping(kmap);
// Load MOUSE maping to Console
const uint8 mmap[] = { 0x00, 0x1D, 0x01, 0x1E, 0x06, 0x05, 0x08, 0x0D, 0x02, 0x0B, 0x03, 0x0C, 0x07, 0x0E, 0x04, 0x04, 0x05, 0x07 };
mousemapping(mmap);
// Load Controller maping to Console Block
const uint8 cmap[] = { 0x17, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A };
remapper(cmap);
}
main
{
ResetLeds();
ActivateIncreaseSensitivity(event_release(PADDLE_1) );
IncreaseSensitivity();
ActivateDecreaseSensitivity(event_release(PADDLE_2) );
DecreaseSensitivity();
ActivateCalibration(get_val(PADDLE_4)> 0.0 );
Calibrate();
Debug();
ToggleAlwaysOn(get_val(PADDLE_3) > 0.0 && get_prev(BUTTON_13) == 0.0 && get_actual(BUTTON_13) > 0.0);
ToggleMotionAiming(get_val(PADDLE_3) > 0.0 && get_prev(BUTTON_12) == 0.0 && get_actual(BUTTON_12) > 0.0);
MotionAiming(mIsMotionAimingOn && !mIsActivatedCalibrating && !mIsActivatedDebugging &&
(abs(get_val(STICK_1_X)) <= mDeadzoneX && (abs(get_val(STICK_1_Y)) <= mDeadzoneY)) &&
(mIsAlwaysOn ||
(mIsActivateL1 && (get_val(BUTTON_7) > 98.0)) ||
(mIsActivateL2 && (get_val(BUTTON_8) > 98.0)) ||
(mIsActivateR1 && (get_val(BUTTON_4) > 98.0)) ||
(mIsActivateR2 && (get_val(BUTTON_5) > 98.0))));
AddInnerDeadzone();
AddOuterDeadzone();
MimicTouch(get_val(BUTTON_2) > 90.0 && GetPadType() != PAD_PS4);
}
void ResetLeds()
{
if(mIsActivatedLeds)
{
if(mTimeCounter > LED_DELAY)
{
led_reset();
mTimeCounter = 0;
}
else
{
mTimeCounter += elapsed_time();
}
}
}
void ActivateIncreaseSensitivity(bool aIsActivated)
{
if(aIsActivated)
{
if(mSensitivityMultiplierIndex < 6) //increase sensivity multiplier
mIsActivatedIncreaseSensitivity = TRUE;
else
{
SetLeds(7);
mIsActivatedLeds = TRUE;
}
}
}
void IncreaseSensitivity()
{
if(mIsActivatedIncreaseSensitivity)
{
mSensitivityMultiplierIndex = mSensitivityMultiplierIndex + 1;
SetLeds(mSensitivityMultiplierIndex+1);
SaveSensitivityIndex();
mIsActivatedIncreaseSensitivity = FALSE;
mIsActivatedLeds = TRUE;
}
}
void ActivateDecreaseSensitivity(bool aIsActivated)
{
if(aIsActivated)
{
if(mSensitivityMultiplierIndex > 0) //decrease sensivity multiplier
mIsActivatedDecreaseSensitivity = TRUE;
else
{
SetLeds(0);
mIsActivatedLeds = TRUE;
}
}
}
void DecreaseSensitivity()
{
if(mIsActivatedDecreaseSensitivity)
{
mSensitivityMultiplierIndex = mSensitivityMultiplierIndex - 1;
SetLeds(mSensitivityMultiplierIndex+1);
SaveSensitivityIndex();
mIsActivatedDecreaseSensitivity = FALSE;
mIsActivatedLeds = TRUE;
}
}
void ActivateCalibration(bool aIsActivated)
{
if(aIsActivated && !mIsActivatedCalibrating)
{
mCalibOffsetX = 0.0;
mCalibOffsetY = 0.0;
mCalibOffsetZ = 0.0;
mCalibrationCycleIndex = 0;
mTimeCounter = 0;
SetLeds(6);
printf("Calibration started. Delay: %d, Samples: %d", mCalibrationDelay, mCalibrationSamples);
mIsActivatedCalibrating = TRUE;
}
}
void Calibrate()
{
if(mIsActivatedCalibrating)
{
mTimeCounter += elapsed_time();
if(mTimeCounter > mCalibrationDelay)
{
SetLeds(15);
if(mCalibrationCycleIndex < mCalibrationSamples)
{
mCalibrationCycleIndex += 1;
mCalibOffsetX += get_actual(ACCEL_1_X);
mCalibOffsetZ += get_actual(ACCEL_1_Y);
}
else
{
mCalibOffsetX /= (fix32)mCalibrationSamples;
mCalibOffsetY /= (fix32)mCalibrationSamples;
mCalibOffsetZ /= (fix32)mCalibrationSamples;
StoreCalibration();
mTimeCounter = 0;
led_reset();
mIsActivatedCalibrating = FALSE;
}
}
}
}
void FetchCalibration()
{
uint8 padType = GetPadType();
pmem_load();
switch(padType)
{
case PAD_OTHER:
pmem_read(ADDR_CALIB_OTHER_X, &mCalibOffsetX);
pmem_read(ADDR_CALIB_OTHER_Y, &mCalibOffsetY);
pmem_read(ADDR_CALIB_OTHER_Z, &mCalibOffsetZ);
printf("Other gamepad calibration. X: %f, Y: %f, Z: %f", mCalibOffsetX, mCalibOffsetY, mCalibOffsetZ);
break;
case PAD_PS4:
pmem_read(ADDR_CALIB_PS4_X, &mCalibOffsetX);
pmem_read(ADDR_CALIB_PS4_Y, &mCalibOffsetY);
pmem_read(ADDR_CALIB_PS4_Z, &mCalibOffsetZ);
printf("DualShock 4 calibration. X: %f, Y: %f, Z: %f", mCalibOffsetX, mCalibOffsetY, mCalibOffsetZ);
break;
case PAD_SWITCH:
pmem_read(ADDR_CALIB_SWITCH_X, &mCalibOffsetX);
pmem_read(ADDR_CALIB_SWITCH_Y, &mCalibOffsetY);
pmem_read(ADDR_CALIB_SWITCH_Z, &mCalibOffsetZ);
printf("Pro Controller calibration. X: %f, Y: %f, Z: %f", mCalibOffsetX, mCalibOffsetY, mCalibOffsetZ);
break;
}
}
void StoreCalibration()
{
uint8 padType = GetPadType();
printf("Pad type set: %d", padType);
switch(padType)
{
case PAD_OTHER:
pmem_write(ADDR_CALIB_OTHER_X, mCalibOffsetX);
pmem_write(ADDR_CALIB_OTHER_Y, mCalibOffsetY);
pmem_write(ADDR_CALIB_OTHER_Z, mCalibOffsetZ);
printf("Stored other gamepad calibration. X: %f, Y: %f, Z: %f", mCalibOffsetX, mCalibOffsetY, mCalibOffsetZ);
break;
case PAD_PS4:
pmem_write(ADDR_CALIB_PS4_X, mCalibOffsetX);
pmem_write(ADDR_CALIB_PS4_Y, mCalibOffsetY);
pmem_write(ADDR_CALIB_PS4_Z, mCalibOffsetZ);
printf("Stored DualShock 4 calibration. X: %f, Y: %f, Z: %f", mCalibOffsetX, mCalibOffsetY, mCalibOffsetZ);
break;
case PAD_SWITCH:
pmem_write(ADDR_CALIB_SWITCH_X, mCalibOffsetX);
pmem_write(ADDR_CALIB_SWITCH_Y, mCalibOffsetY);
pmem_write(ADDR_CALIB_SWITCH_Z, mCalibOffsetZ);
printf("Stored Pro Controller calibration. X: %f, Y: %f, Z: %f", mCalibOffsetX, mCalibOffsetY, mCalibOffsetZ);
break;
}
pmem_save();
}
uint8 GetPadType()
{
uint8 status, protocol, device, i = 0;
while(i < PAD_IDS_LENGHT)
{
status = port_status(PAD_IDS[i], &protocol, &device);
if(status)
{
if(protocol == PROTOCOL_PS4)
return PAD_PS4;
else if(protocol == PROTOCOL_SWITCH)
return PAD_SWITCH;
else
return PAD_OTHER;
}
i++;
}
return(-1);
}
void Debug()
{
if(mIsActivatedCalibrating || !mIsActivatedDebugging)
return;
set_val(GYRO_1_X, (get_val(GYRO_1_X) - mCalibOffsetX) * 1000.0);
set_val(GYRO_1_Y, (get_val(GYRO_1_Y) - mCalibOffsetY) * 1000.0);
set_val(GYRO_1_Z, (get_val(GYRO_1_Z) - mCalibOffsetZ) * 1000.0);
}
void ToggleAlwaysOn(bool aIsActivated)
{
if(aIsActivated)
{
mIsAlwaysOn = !mIsAlwaysOn;
pmem_write(ADDR_ACTIVATE_ALWAYS_ON, mIsAlwaysOn);
pmem_save();
}
}
void ToggleMotionAiming(bool aIsActivated)
{
if(aIsActivated)
{
mIsMotionAimingOn = !mIsMotionAimingOn;
}
}
void MotionAiming(bool aIsActivated)
{
if(aIsActivated)
{
static fix32 accelX, accelY;
static fix32 stickX, stickY;
if(accelX != get_actual(ACCEL_1_X) || accelY != get_actual(ACCEL_1_Y))
{
accelX = get_actual(ACCEL_1_X);
accelY = get_actual(ACCEL_1_Y);
stickX = (accelX - mCalibOffsetZ) * mBaseSensitivityX * mSensitivityMultipliersArray[mSensitivityMultiplierIndex];
stickY = (accelY - mCalibOffsetX) * mBaseSensitivityY * mSensitivityMultipliersArray[mSensitivityMultiplierIndex];
fix32 signalX = (stickX < 0.0) ? (stickX = inv(stickX), -1.0) : (stickX > 0.0) ? 1.0 : 0.0;
fix32 signalY = (stickY < 0.0) ? (stickY = inv(stickY), -1.0) : (stickY > 0.0) ? 1.0 : 0.0;
fix32 angle = atan2(stickY, stickX);
stickX = clamp(((mDeadzoneX * pow(cos(angle), mDeadzoneD)) + stickX) * signalX, -100.0, 100.0);
stickY = clamp(((mDeadzoneY * pow(sin(angle), mDeadzoneD)) + stickY) * signalY, -100.0, 100.0);
}
set_val(STICK_1_X, stickX);
set_val(STICK_1_Y, stickY);
return;
}
}
void AddInnerDeadzone()
{
if(abs(get_val(STICK_1_Y)) > 5.00 && abs(get_val(STICK_1_Y)) < mInnerDeadzone)
set_val(STICK_1_Y, 0.0);
if(abs(get_val(STICK_1_X)) > 5.00 && abs(get_val(STICK_1_X)) < mInnerDeadzone)
set_val(STICK_1_X, 0.0);
}
void AddOuterDeadzone()
{
if(get_val(STICK_1_Y) <= mOuterDeadzone * -1.00)
set_val(STICK_1_Y, -100);
if(get_val(STICK_1_Y) >= mOuterDeadzone)
set_val(STICK_1_Y, 100);
if(get_val(STICK_1_X) <= mOuterDeadzone * -1.00)
set_val(STICK_1_X, -100);
if(get_val(STICK_1_X) >= mOuterDeadzone)
set_val(STICK_1_X, 100);
}
void SaveSensitivityIndex()
{
printf("Sensitivity Index: %d, Sensitivity Multiplier: %f", mSensitivityMultiplierIndex, mSensitivityMultipliersArray[mSensitivityMultiplierIndex]);
pmem_write(ADDR_SENSITIVITY_MULTIPLIER_INDEX, mSensitivityMultiplierIndex);
pmem_save();
}
void SetLeds(uint8 aLeds)
{
if(aLeds == 1)
aLeds = 0;
fix32 bits[4];
bits[0] = (aLeds & (1 << 0)) == 0 ? 0.0 : 100.0;
bits[1] = (aLeds & (1 << 1)) == 0 ? 0.0 : 100.0;
bits[2] = (aLeds & (1 << 2)) == 0 ? 0.0 : 100.0;
bits[4] = (aLeds & (1 << 3)) == 0 ? 0.0 : 100.0;
led_set(LED_1, bits[0], 800);
led_set(LED_2, bits[1], 800);
led_set(LED_3, bits[2], 800);
led_set(LED_4, bits[3], 800);
}
void MimicTouch(bool aIsActivated)
{
if(aIsActivated)
{
set_val(BUTTON_19, 100.0);
set_val(POINT_1_X, get_actual(ACCEL_1_X));
set_val(POINT_1_Y, get_actual(ACCEL_1_Y));
set_val(STICK_1_X, 0.0);
set_val(STICK_1_Y, 0.0);
}
}
Universal Mouse and Keboard Console with Curve Ver 1.5
- Code: Select all
GIVMXYF:FF010001000000000000000100000306090C0F1215181B1E2124272A2D303336393C
- Code: Select all
#pragma METAINFO("Universal Mouse and Keboard Console with Curve", 1, 5, "mss1988 & teddy18")
#include <switch.gph>
/*
<cfgdesc>
[Gyro Aiming Activation]
byteoffset = 0
bitsize = 8
control = checkbox
default = 0
item = On L1/LB
[Gyro Aiming Activation2]
group = true
groupcol = true
byteoffset = 1
bitsize = 8
control = checkbox
default = 0
item = On L2/LT
[Gyro Aiming Activation3]
group = true
groupcol = true
byteoffset = 2
bitsize = 8
control = checkbox
default = 0
item = On R1/RB
[Gyro Aiming Activation4]
group = true
groupcol = true
byteoffset = 3
bitsize = 8
control = checkbox
default = 0
item = On R2/RT
[Gyro Aiming Activation5]
group = true
groupcol = true
byteoffset = 4
bitsize = 8
control = checkbox
default = 1
item = Always On
[Sensitivity]
group = false
shortdesc = Base sensitivity X
byteoffset = 5
bitsize = 32
control = spinboxf
default = 100
minimum = 10
maximum = 20000
step = 1
decimals = 2
[SensitivityY]
group = true
groupcol = true
shortdesc = Base sensitivity Y
byteoffset = 9
bitsize = 32
control = spinboxf
default = 160
minimum = 10
maximum = 20000
step = 1
decimals = 2
[Sensitivity Multipliers]
group = false
groupcol = false
shortdesc = Active Sensitivity Multiplier:
byteoffset = 13
bitsize = 8
control = slider
default = 3
minimum = 1
maximum = 7
step = 1
[Sensitivity Multipliers1]
group = true
groupcol = false
shortdesc = Sensitivity Multiplier 1:
byteoffset = 14
bitsize = 32
control = spinboxf
default = 50
minimum = 10
maximum = 1000
step = 1
decimals = 2
[Sensitivity Multipliers2]
group = true
groupcol = false
shortdesc = Sensitivity Multiplier 2:
byteoffset = 18
bitsize = 32
control = spinboxf
default = 75
minimum = 10
maximum = 1000
step = 1
decimals = 2
[Sensitivity Multipliers3]
group = true
groupcol = false
shortdesc = Sensitivity Multiplier 3:
byteoffset = 22
bitsize = 32
control = spinboxf
default = 100
minimum = 10
maximum = 1000
step = 1
decimals = 2
[Sensitivity Multipliers4]
group = true
groupcol = false
shortdesc = Sensitivity Multiplier 4:
byteoffset = 26
bitsize = 32
control = spinboxf
default = 125
minimum = 10
maximum = 1000
step = 1
decimals = 2
[Sensitivity Multipliers5]
group = true
groupcol = false
shortdesc = Sensitivity Multiplier 5:
byteoffset = 30
bitsize = 32
control = spinboxf
default = 150
minimum = 10
maximum = 1000
step = 1
decimals = 2
[Sensitivity Multipliers6]
group = true
groupcol = false
shortdesc = Sensitivity Multiplier 6:
byteoffset = 34
bitsize = 32
control = spinboxf
default = 175
minimum = 10
maximum = 1000
step = 1
decimals = 2
[Sensitivity Multipliers7]
group = true
groupcol = false
shortdesc = Sensitivity Multiplier 7:
byteoffset = 38
bitsize = 32
control = spinboxf
default = 200
minimum = 10
maximum = 1000
step = 1
decimals = 2
[Deadzones]
group = false
shortdesc = Ignore Gyro if Right Stick X is greater than:
byteoffset = 42
bitsize = 32
control = spinboxf
default = 200
minimum = 0
maximum = 1000
step = 1
decimals = 1
[DeadzonesY]
group = true
groupcol = false
shortdesc = Ignore Gyro if Right Stick Y is greater than:
byteoffset = 46
bitsize = 32
control = spinboxf
default = 200
minimum = 0
maximum = 1000
step = 1
decimals = 1
[DeadzonesD]
group = true
groupcol = false
shortdesc = Right Stick Diagonal Deadzone:
byteoffset = 50
bitsize = 32
control = spinboxf
default = 38
minimum = 0
maximum = 200
step = 1
decimals = 2
[DeadzonesO]
group = true
groupcol = false
shortdesc = Right Stick Outer Deadzone:
byteoffset = 54
bitsize = 32
control = spinboxf
default = 9200
minimum = 0
maximum = 10000
step = 1
decimals = 2
[DeadzonesI]
group = true
groupcol = false
shortdesc = Right Stick Inner Deadzone:
byteoffset = 58
bitsize = 32
control = spinboxf
default = 013
minimum = 0
maximum = 10000
step = 1
decimals = 2
[Calibration]
group = false
groupcol = false
shortdesc = Delay (ms):
byteoffset = 62
bitsize = 32
control = slider
default = 3000
minimum = 500
maximum = 10000
step = 500
[CalibrationS]
group = true
groupcol = false
shortdesc = Samples:
byteoffset = 66
bitsize = 32
control = slider
default = 300
minimum = 100
maximum = 10000
step = 100
</cfgdesc>
*/
//Constants
#define PAD_OTHER 0
#define PAD_PS4 1
#define PAD_SWITCH 2
uint8 PAD_IDS[5] = { 6, 5, 4, 2, 1 };
uint8 PAD_IDS_LENGHT = 5;
//Persistent memory addereses
#define ADDR_ACTIVATE_L1 0
#define ADDR_ACTIVATE_L2 1
#define ADDR_ACTIVATE_R1 2
#define ADDR_ACTIVATE_R2 3
#define ADDR_ACTIVATE_ALWAYS_ON 4
#define ADDR_BASE_SENSITIVITY_X 5
#define ADDR_BASE_SENSITIVITY_Y 9
#define ADDR_SENSITIVITY_MULTIPLIER_INDEX 13
#define ADDR_SENSITIVITY_MULTIPLIER_0 14
#define ADDR_SENSITIVITY_MULTIPLIER_1 18
#define ADDR_SENSITIVITY_MULTIPLIER_2 22
#define ADDR_SENSITIVITY_MULTIPLIER_3 26
#define ADDR_SENSITIVITY_MULTIPLIER_4 30
#define ADDR_SENSITIVITY_MULTIPLIER_5 34
#define ADDR_SENSITIVITY_MULTIPLIER_6 38
#define ADDR_DEADZONE_X 42
#define ADDR_DEADZONE_Y 46
#define ADDR_DEADZONE_D 50
#define ADDR_OUTER_DEADZONE 54
#define ADDR_INNER_DEADZONE 58
#define ADDR_CALIBRATION_DELAY 62
#define ADDR_CALIBRATION_SAMPLES 66
#define ADDR_CALIB_PS4_X 92
#define ADDR_CALIB_PS4_Y 96
#define ADDR_CALIB_PS4_Z 100
#define ADDR_CALIB_SWITCH_X 104
#define ADDR_CALIB_SWITCH_Y 108
#define ADDR_CALIB_SWITCH_Z 116
#define ADDR_CALIB_OTHER_X 116
#define ADDR_CALIB_OTHER_Y 120
#define ADDR_CALIB_OTHER_Z 124
#define LED_DELAY 2000
//Variables
fix32 mCalibOffsetX = 0.0;
fix32 mCalibOffsetY = 0.0;
fix32 mCalibOffsetZ = 0.0;
bool mIsActivatedCalibrating = FALSE;
bool mIsActivatedIncreaseSensitivity = FALSE;
bool mIsActivatedDecreaseSensitivity = FALSE;
bool mIsActivatedLeds = FALSE;
fix32 mBaseSensitivityX = 1.0;
fix32 mBaseSensitivityY = 1.6;
uint8 mSensitivityMultiplierIndex = 2;
fix32 mSensitivityMultipliersArray[7] = { 0.5, 0.75, 1.0, 1.25, 1.5, 1.75, 2.0 };
uint32 mCalibrationDelay = 3000;
uint32 mCalibrationSamples = 300;
uint32 mCalibrationCycleIndex = 0;
fix32 mDeadzoneX = 20.0; // Deadzone GYRO_1_YZ Input
fix32 mDeadzoneY = 20.0; // Deadzone GYRO_1_YX Input
fix32 mDeadzoneD = 0.38; // Deadzone Diagonal input
fix32 mOuterDeadzone = 92.00;
fix32 mInnerDeadzone = 0.13;
bool mIsActivateL1 = FALSE;
bool mIsActivateL2 = TRUE;
bool mIsActivateR1 = FALSE;
bool mIsActivateR2 = TRUE;
bool mIsAlwaysOn = FALSE;
bool mIsMotionAimingOn = TRUE;
uint32 mTimeCounter = 0;
bool mIsActivatedDebugging = FALSE;
init
{
pmem_load();
printf("Values loaded:");
pmem_read(ADDR_ACTIVATE_L1, &mIsActivateL1);
printf("Activate L1: %d", mIsActivateL1);
pmem_read(ADDR_ACTIVATE_L2, &mIsActivateL2);
printf("Activate L2: %d", mIsActivateL2);
pmem_read(ADDR_ACTIVATE_R1, &mIsActivateR1);
printf("Activate R1: %d", mIsActivateR1);
pmem_read(ADDR_ACTIVATE_R2, &mIsActivateR2);
printf("Activate R2: %d", mIsActivateR2);
pmem_read(ADDR_ACTIVATE_ALWAYS_ON, &mIsAlwaysOn);
printf("Activate AlwaysOn: %d", mIsAlwaysOn);
pmem_read(ADDR_BASE_SENSITIVITY_X, &mBaseSensitivityX);
printf("Base sensitivity X: %f", mBaseSensitivityX);
pmem_read(ADDR_BASE_SENSITIVITY_Y, &mBaseSensitivityY);
printf("Base sensitivity Y: %f", mBaseSensitivityY);
pmem_read(ADDR_SENSITIVITY_MULTIPLIER_INDEX, &mSensitivityMultiplierIndex);
mSensitivityMultiplierIndex--;
printf("Sensitivity multiplier index: %d", mSensitivityMultiplierIndex);
pmem_read(ADDR_SENSITIVITY_MULTIPLIER_0, &mSensitivityMultipliersArray[0]);
printf("Sensitivity multiplier [0]: %f", mSensitivityMultipliersArray[0]);
pmem_read(ADDR_SENSITIVITY_MULTIPLIER_1, &mSensitivityMultipliersArray[1]);
printf("Sensitivity multiplier [1]: %f", mSensitivityMultipliersArray[1]);
pmem_read(ADDR_SENSITIVITY_MULTIPLIER_2, &mSensitivityMultipliersArray[2]);
printf("Sensitivity multiplier [2]: %f", mSensitivityMultipliersArray[2]);
pmem_read(ADDR_SENSITIVITY_MULTIPLIER_3, &mSensitivityMultipliersArray[3]);
printf("Sensitivity multiplier [3]: %f", mSensitivityMultipliersArray[3]);
pmem_read(ADDR_SENSITIVITY_MULTIPLIER_4, &mSensitivityMultipliersArray[4]);
printf("Sensitivity multiplier [4]: %f", mSensitivityMultipliersArray[4]);
pmem_read(ADDR_SENSITIVITY_MULTIPLIER_5, &mSensitivityMultipliersArray[5]);
printf("Sensitivity multiplier [5]: %f", mSensitivityMultipliersArray[5]);
pmem_read(ADDR_SENSITIVITY_MULTIPLIER_6, &mSensitivityMultipliersArray[6]);
printf("Sensitivity multiplier [6]: %f", mSensitivityMultipliersArray[6]);
pmem_read(ADDR_DEADZONE_X, &mDeadzoneX);
printf("Deadzone X: %f", mDeadzoneX);
pmem_read(ADDR_DEADZONE_Y, &mDeadzoneY);
printf("Deadzone Y: %f", mDeadzoneY);
pmem_read(ADDR_DEADZONE_D, &mDeadzoneD);
printf("Deadzone D: %f", mDeadzoneD);
pmem_read(ADDR_OUTER_DEADZONE, &mOuterDeadzone);
printf("Outer Deadzone: %f", mOuterDeadzone);
pmem_read(ADDR_INNER_DEADZONE, &mInnerDeadzone);
printf("Inner Deadzone: %f", mInnerDeadzone);
pmem_read(ADDR_CALIBRATION_DELAY, &mCalibrationDelay);
printf("Calibration Delay: %d", mCalibrationDelay);
pmem_read(ADDR_CALIBRATION_SAMPLES, &mCalibrationSamples);
printf("Calibration Samples: %d", mCalibrationSamples);
FetchCalibration();
// Load Keyboard maping to Console
const uint8 kmap[] = { 0xE2, 0x00, 0x2B, 0x01, 0x29, 0x02, 0x08, 0x03, 0x09, 0x05, 0x14, 0x06, 0x10, 0x07, 0xE1, 0x08, 0x52, 0x09, 0x51, 0x0A, 0x50, 0x0B, 0x4F, 0x0C, 0x1E, 0x09, 0x20, 0x0A, 0x21, 0x0B, 0x1F, 0x0C, 0x0A, 0x0D, 0x06, 0x0E, 0x2C, 0x0F, 0x15, 0x10, 0x23, 0x11, 0x04, 0x97, 0x07, 0x17, 0x1A, 0x98, 0x16, 0x18, 0x3A, 0x26, 0x3B, 0x27, 0x3C, 0x28, 0x3D, 0x29 };
keymapping(kmap);
// Load MOUSE maping to Console
const uint8 mmap[] = { 0x00, 0x1D, 0x01, 0x1E, 0x06, 0x05, 0x08, 0x0D, 0x02, 0x0B, 0x03, 0x0C, 0x07, 0x0E, 0x04, 0x04, 0x05, 0x07 };
mousemapping(mmap);
// Load Controller maping to Console Block
const uint8 cmap[] = { 0x17, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A };
remapper(cmap);
}
main
{
ResetLeds();
ActivateIncreaseSensitivity(event_release(PADDLE_1) );
IncreaseSensitivity();
ActivateDecreaseSensitivity(event_release(PADDLE_2) );
DecreaseSensitivity();
ActivateCalibration(get_val(PADDLE_4)> 0.0 );
Calibrate();
Debug();
ToggleAlwaysOn(get_val(PADDLE_3) > 0.0 && get_prev(BUTTON_13) == 0.0 && get_actual(BUTTON_13) > 0.0);
ToggleMotionAiming(get_val(PADDLE_3) > 0.0 && get_prev(BUTTON_12) == 0.0 && get_actual(BUTTON_12) > 0.0);
MotionAiming(mIsMotionAimingOn && !mIsActivatedCalibrating && !mIsActivatedDebugging &&
(abs(get_val(STICK_1_X)) <= mDeadzoneX && (abs(get_val(STICK_1_Y)) <= mDeadzoneY)) &&
(mIsAlwaysOn ||
(mIsActivateL1 && (get_val(BUTTON_7) > 98.0)) ||
(mIsActivateL2 && (get_val(BUTTON_8) > 98.0)) ||
(mIsActivateR1 && (get_val(BUTTON_4) > 98.0)) ||
(mIsActivateR2 && (get_val(BUTTON_5) > 98.0))));
AddInnerDeadzone();
AddOuterDeadzone();
MimicTouch(get_val(BUTTON_2) > 90.0 && GetPadType() != PAD_PS4);
set_val(ACCEL_1_X, stick_response(ACCEL_1_X));
set_val(ACCEL_1_Y, stick_response(ACCEL_1_Y));
}
void ResetLeds()
{
if(mIsActivatedLeds)
{
if(mTimeCounter > LED_DELAY)
{
led_reset();
mTimeCounter = 0;
}
else
{
mTimeCounter += elapsed_time();
}
}
}
void ActivateIncreaseSensitivity(bool aIsActivated)
{
if(aIsActivated)
{
if(mSensitivityMultiplierIndex < 6) //increase sensivity multiplier
mIsActivatedIncreaseSensitivity = TRUE;
else
{
SetLeds(7);
mIsActivatedLeds = TRUE;
}
}
}
void IncreaseSensitivity()
{
if(mIsActivatedIncreaseSensitivity)
{
mSensitivityMultiplierIndex = mSensitivityMultiplierIndex + 1;
SetLeds(mSensitivityMultiplierIndex+1);
SaveSensitivityIndex();
mIsActivatedIncreaseSensitivity = FALSE;
mIsActivatedLeds = TRUE;
}
}
void ActivateDecreaseSensitivity(bool aIsActivated)
{
if(aIsActivated)
{
if(mSensitivityMultiplierIndex > 0) //decrease sensivity multiplier
mIsActivatedDecreaseSensitivity = TRUE;
else
{
SetLeds(0);
mIsActivatedLeds = TRUE;
}
}
}
void DecreaseSensitivity()
{
if(mIsActivatedDecreaseSensitivity)
{
mSensitivityMultiplierIndex = mSensitivityMultiplierIndex - 1;
SetLeds(mSensitivityMultiplierIndex+1);
SaveSensitivityIndex();
mIsActivatedDecreaseSensitivity = FALSE;
mIsActivatedLeds = TRUE;
}
}
void ActivateCalibration(bool aIsActivated)
{
if(aIsActivated && !mIsActivatedCalibrating)
{
mCalibOffsetX = 0.0;
mCalibOffsetY = 0.0;
mCalibOffsetZ = 0.0;
mCalibrationCycleIndex = 0;
mTimeCounter = 0;
SetLeds(6);
printf("Calibration started. Delay: %d, Samples: %d", mCalibrationDelay, mCalibrationSamples);
mIsActivatedCalibrating = TRUE;
}
}
void Calibrate()
{
if(mIsActivatedCalibrating)
{
mTimeCounter += elapsed_time();
if(mTimeCounter > mCalibrationDelay)
{
SetLeds(15);
if(mCalibrationCycleIndex < mCalibrationSamples)
{
mCalibrationCycleIndex += 1;
mCalibOffsetX += get_actual(ACCEL_1_X);
mCalibOffsetZ += get_actual(ACCEL_1_Y);
}
else
{
mCalibOffsetX /= (fix32)mCalibrationSamples;
mCalibOffsetY /= (fix32)mCalibrationSamples;
mCalibOffsetZ /= (fix32)mCalibrationSamples;
StoreCalibration();
mTimeCounter = 0;
led_reset();
mIsActivatedCalibrating = FALSE;
}
}
}
}
void FetchCalibration()
{
uint8 padType = GetPadType();
pmem_load();
switch(padType)
{
case PAD_OTHER:
pmem_read(ADDR_CALIB_OTHER_X, &mCalibOffsetX);
pmem_read(ADDR_CALIB_OTHER_Y, &mCalibOffsetY);
pmem_read(ADDR_CALIB_OTHER_Z, &mCalibOffsetZ);
printf("Other gamepad calibration. X: %f, Y: %f, Z: %f", mCalibOffsetX, mCalibOffsetY, mCalibOffsetZ);
break;
case PAD_PS4:
pmem_read(ADDR_CALIB_PS4_X, &mCalibOffsetX);
pmem_read(ADDR_CALIB_PS4_Y, &mCalibOffsetY);
pmem_read(ADDR_CALIB_PS4_Z, &mCalibOffsetZ);
printf("DualShock 4 calibration. X: %f, Y: %f, Z: %f", mCalibOffsetX, mCalibOffsetY, mCalibOffsetZ);
break;
case PAD_SWITCH:
pmem_read(ADDR_CALIB_SWITCH_X, &mCalibOffsetX);
pmem_read(ADDR_CALIB_SWITCH_Y, &mCalibOffsetY);
pmem_read(ADDR_CALIB_SWITCH_Z, &mCalibOffsetZ);
printf("Pro Controller calibration. X: %f, Y: %f, Z: %f", mCalibOffsetX, mCalibOffsetY, mCalibOffsetZ);
break;
}
}
void StoreCalibration()
{
uint8 padType = GetPadType();
printf("Pad type set: %d", padType);
switch(padType)
{
case PAD_OTHER:
pmem_write(ADDR_CALIB_OTHER_X, mCalibOffsetX);
pmem_write(ADDR_CALIB_OTHER_Y, mCalibOffsetY);
pmem_write(ADDR_CALIB_OTHER_Z, mCalibOffsetZ);
printf("Stored other gamepad calibration. X: %f, Y: %f, Z: %f", mCalibOffsetX, mCalibOffsetY, mCalibOffsetZ);
break;
case PAD_PS4:
pmem_write(ADDR_CALIB_PS4_X, mCalibOffsetX);
pmem_write(ADDR_CALIB_PS4_Y, mCalibOffsetY);
pmem_write(ADDR_CALIB_PS4_Z, mCalibOffsetZ);
printf("Stored DualShock 4 calibration. X: %f, Y: %f, Z: %f", mCalibOffsetX, mCalibOffsetY, mCalibOffsetZ);
break;
case PAD_SWITCH:
pmem_write(ADDR_CALIB_SWITCH_X, mCalibOffsetX);
pmem_write(ADDR_CALIB_SWITCH_Y, mCalibOffsetY);
pmem_write(ADDR_CALIB_SWITCH_Z, mCalibOffsetZ);
printf("Stored Pro Controller calibration. X: %f, Y: %f, Z: %f", mCalibOffsetX, mCalibOffsetY, mCalibOffsetZ);
break;
}
pmem_save();
}
uint8 GetPadType()
{
uint8 status, protocol, device, i = 0;
while(i < PAD_IDS_LENGHT)
{
status = port_status(PAD_IDS[i], &protocol, &device);
if(status)
{
if(protocol == PROTOCOL_PS4)
return PAD_PS4;
else if(protocol == PROTOCOL_SWITCH)
return PAD_SWITCH;
else
return PAD_OTHER;
}
i++;
}
return(-1);
}
void Debug()
{
if(mIsActivatedCalibrating || !mIsActivatedDebugging)
return;
set_val(GYRO_1_X, (get_val(GYRO_1_X) - mCalibOffsetX) * 1000.0);
set_val(GYRO_1_Y, (get_val(GYRO_1_Y) - mCalibOffsetY) * 1000.0);
set_val(GYRO_1_Z, (get_val(GYRO_1_Z) - mCalibOffsetZ) * 1000.0);
}
void ToggleAlwaysOn(bool aIsActivated)
{
if(aIsActivated)
{
mIsAlwaysOn = !mIsAlwaysOn;
pmem_write(ADDR_ACTIVATE_ALWAYS_ON, mIsAlwaysOn);
pmem_save();
}
}
void ToggleMotionAiming(bool aIsActivated)
{
if(aIsActivated)
{
mIsMotionAimingOn = !mIsMotionAimingOn;
}
}
void MotionAiming(bool aIsActivated)
{
if(aIsActivated)
{
static fix32 accelX, accelY;
static fix32 stickX, stickY;
if(accelX != get_actual(ACCEL_1_X) || accelY != get_actual(ACCEL_1_Y))
{
accelX = get_actual(ACCEL_1_X);
accelY = get_actual(ACCEL_1_Y);
stickX = (accelX - mCalibOffsetZ) * mBaseSensitivityX * mSensitivityMultipliersArray[mSensitivityMultiplierIndex];
stickY = (accelY - mCalibOffsetX) * mBaseSensitivityY * mSensitivityMultipliersArray[mSensitivityMultiplierIndex];
fix32 signalX = (stickX < 0.0) ? (stickX = inv(stickX), -1.0) : (stickX > 0.0) ? 1.0 : 0.0;
fix32 signalY = (stickY < 0.0) ? (stickY = inv(stickY), -1.0) : (stickY > 0.0) ? 1.0 : 0.0;
fix32 angle = atan2(stickY, stickX);
stickX = clamp(((mDeadzoneX * pow(cos(angle), mDeadzoneD)) + stickX) * signalX, -100.0, 100.0);
stickY = clamp(((mDeadzoneY * pow(sin(angle), mDeadzoneD)) + stickY) * signalY, -100.0, 100.0);
}
set_val(STICK_1_X, stickX);
set_val(STICK_1_Y, stickY);
return;
}
}
void AddInnerDeadzone()
{
if(abs(get_val(STICK_1_Y)) > 5.00 && abs(get_val(STICK_1_Y)) < mInnerDeadzone)
set_val(STICK_1_Y, 0.0);
if(abs(get_val(STICK_1_X)) > 5.00 && abs(get_val(STICK_1_X)) < mInnerDeadzone)
set_val(STICK_1_X, 0.0);
}
void AddOuterDeadzone()
{
if(get_val(STICK_1_Y) <= mOuterDeadzone * -1.00)
set_val(STICK_1_Y, -100);
if(get_val(STICK_1_Y) >= mOuterDeadzone)
set_val(STICK_1_Y, 100);
if(get_val(STICK_1_X) <= mOuterDeadzone * -1.00)
set_val(STICK_1_X, -100);
if(get_val(STICK_1_X) >= mOuterDeadzone)
set_val(STICK_1_X, 100);
}
void SaveSensitivityIndex()
{
printf("Sensitivity Index: %d, Sensitivity Multiplier: %f", mSensitivityMultiplierIndex, mSensitivityMultipliersArray[mSensitivityMultiplierIndex]);
pmem_write(ADDR_SENSITIVITY_MULTIPLIER_INDEX, mSensitivityMultiplierIndex);
pmem_save();
}
void SetLeds(uint8 aLeds)
{
if(aLeds == 1)
aLeds = 0;
fix32 bits[4];
bits[0] = (aLeds & (1 << 0)) == 0 ? 0.0 : 100.0;
bits[1] = (aLeds & (1 << 1)) == 0 ? 0.0 : 100.0;
bits[2] = (aLeds & (1 << 2)) == 0 ? 0.0 : 100.0;
bits[4] = (aLeds & (1 << 3)) == 0 ? 0.0 : 100.0;
led_set(LED_1, bits[0], 800);
led_set(LED_2, bits[1], 800);
led_set(LED_3, bits[2], 800);
led_set(LED_4, bits[3], 800);
}
void MimicTouch(bool aIsActivated)
{
if(aIsActivated)
{
set_val(BUTTON_19, 100.0);
set_val(POINT_1_X, get_actual(ACCEL_1_X));
set_val(POINT_1_Y, get_actual(ACCEL_1_Y));
set_val(STICK_1_X, 0.0);
set_val(STICK_1_Y, 0.0);
}
}
fix32 stick_response(uint8 idx) {
const uint8 mxyc[] = { 0xFF, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x03, 0x06, 0x09, 0x0C, 0x0F, 0x12, 0x15, 0x18, 0x1B, 0x1E, 0x21, 0x24, 0x27, 0x2A, 0x2D, 0x30, 0x33, 0x36, 0x39, 0x3C };
fix32 value = get_actual(idx);
fix32 signal = (value >= 0.0 ? 1.0 : -1.0);
value = abs(value);
return(value * signal);
}
-
teddy18 - Lieutenant
- Posts: 346
- Joined: Sun Jul 19, 2015 4:18 pm
Re: Universal Mouse and Keboard Console on The fly
Script
Universal Mouse and Keboard Console with Curve Ver 1.6 Ratio 1.00 DD Factor 0.14
Universal Mouse and Keboard Console with Curve Ver 1.7 Ratio 1.00 DD Factor 0.20
Universal Mouse and Keboard Console with Curve Ver 1.6 Ratio 1.00 DD Factor 0.14
- Code: Select all
GIVMXYF:FF010001000023000000000100000306090C0F1215181B1E2124272A2D303336393C
- Code: Select all
#pragma METAINFO("Universal Mouse and Keboard Console with Curve", 1, 6, "mss1988 & teddy18")
#include <switch.gph>
/*
<cfgdesc>
[Gyro Aiming Activation]
byteoffset = 0
bitsize = 8
control = checkbox
default = 0
item = On L1/LB
[Gyro Aiming Activation2]
group = true
groupcol = true
byteoffset = 1
bitsize = 8
control = checkbox
default = 0
item = On L2/LT
[Gyro Aiming Activation3]
group = true
groupcol = true
byteoffset = 2
bitsize = 8
control = checkbox
default = 0
item = On R1/RB
[Gyro Aiming Activation4]
group = true
groupcol = true
byteoffset = 3
bitsize = 8
control = checkbox
default = 0
item = On R2/RT
[Gyro Aiming Activation5]
group = true
groupcol = true
byteoffset = 4
bitsize = 8
control = checkbox
default = 1
item = Always On
[Sensitivity]
group = false
shortdesc = Base sensitivity X
byteoffset = 5
bitsize = 32
control = spinboxf
default = 100
minimum = 10
maximum = 20000
step = 1
decimals = 2
[SensitivityY]
group = true
groupcol = true
shortdesc = Base sensitivity Y
byteoffset = 9
bitsize = 32
control = spinboxf
default = 160
minimum = 10
maximum = 20000
step = 1
decimals = 2
[Sensitivity Multipliers]
group = false
groupcol = false
shortdesc = Active Sensitivity Multiplier:
byteoffset = 13
bitsize = 8
control = slider
default = 3
minimum = 1
maximum = 7
step = 1
[Sensitivity Multipliers1]
group = true
groupcol = false
shortdesc = Sensitivity Multiplier 1:
byteoffset = 14
bitsize = 32
control = spinboxf
default = 50
minimum = 10
maximum = 1000
step = 1
decimals = 2
[Sensitivity Multipliers2]
group = true
groupcol = false
shortdesc = Sensitivity Multiplier 2:
byteoffset = 18
bitsize = 32
control = spinboxf
default = 75
minimum = 10
maximum = 1000
step = 1
decimals = 2
[Sensitivity Multipliers3]
group = true
groupcol = false
shortdesc = Sensitivity Multiplier 3:
byteoffset = 22
bitsize = 32
control = spinboxf
default = 100
minimum = 10
maximum = 1000
step = 1
decimals = 2
[Sensitivity Multipliers4]
group = true
groupcol = false
shortdesc = Sensitivity Multiplier 4:
byteoffset = 26
bitsize = 32
control = spinboxf
default = 125
minimum = 10
maximum = 1000
step = 1
decimals = 2
[Sensitivity Multipliers5]
group = true
groupcol = false
shortdesc = Sensitivity Multiplier 5:
byteoffset = 30
bitsize = 32
control = spinboxf
default = 150
minimum = 10
maximum = 1000
step = 1
decimals = 2
[Sensitivity Multipliers6]
group = true
groupcol = false
shortdesc = Sensitivity Multiplier 6:
byteoffset = 34
bitsize = 32
control = spinboxf
default = 175
minimum = 10
maximum = 1000
step = 1
decimals = 2
[Sensitivity Multipliers7]
group = true
groupcol = false
shortdesc = Sensitivity Multiplier 7:
byteoffset = 38
bitsize = 32
control = spinboxf
default = 200
minimum = 10
maximum = 1000
step = 1
decimals = 2
[Deadzones]
group = false
shortdesc = Ignore Gyro if Right Stick X is greater than:
byteoffset = 42
bitsize = 32
control = spinboxf
default = 200
minimum = 0
maximum = 1000
step = 1
decimals = 1
[DeadzonesY]
group = true
groupcol = false
shortdesc = Ignore Gyro if Right Stick Y is greater than:
byteoffset = 46
bitsize = 32
control = spinboxf
default = 200
minimum = 0
maximum = 1000
step = 1
decimals = 1
[DeadzonesD]
group = true
groupcol = false
shortdesc = Right Stick Diagonal Deadzone:
byteoffset = 50
bitsize = 32
control = spinboxf
default = 38
minimum = 0
maximum = 200
step = 1
decimals = 2
[DeadzonesO]
group = true
groupcol = false
shortdesc = Right Stick Outer Deadzone:
byteoffset = 54
bitsize = 32
control = spinboxf
default = 9200
minimum = 0
maximum = 10000
step = 1
decimals = 2
[DeadzonesI]
group = true
groupcol = false
shortdesc = Right Stick Inner Deadzone:
byteoffset = 58
bitsize = 32
control = spinboxf
default = 013
minimum = 0
maximum = 10000
step = 1
decimals = 2
[Calibration]
group = false
groupcol = false
shortdesc = Delay (ms):
byteoffset = 62
bitsize = 32
control = slider
default = 3000
minimum = 500
maximum = 10000
step = 500
[CalibrationS]
group = true
groupcol = false
shortdesc = Samples:
byteoffset = 66
bitsize = 32
control = slider
default = 300
minimum = 100
maximum = 10000
step = 100
</cfgdesc>
*/
//Constants
#define PAD_OTHER 0
#define PAD_PS4 1
#define PAD_SWITCH 2
uint8 PAD_IDS[5] = { 6, 5, 4, 2, 1 };
uint8 PAD_IDS_LENGHT = 5;
//Persistent memory addereses
#define ADDR_ACTIVATE_L1 0
#define ADDR_ACTIVATE_L2 1
#define ADDR_ACTIVATE_R1 2
#define ADDR_ACTIVATE_R2 3
#define ADDR_ACTIVATE_ALWAYS_ON 4
#define ADDR_BASE_SENSITIVITY_X 5
#define ADDR_BASE_SENSITIVITY_Y 9
#define ADDR_SENSITIVITY_MULTIPLIER_INDEX 13
#define ADDR_SENSITIVITY_MULTIPLIER_0 14
#define ADDR_SENSITIVITY_MULTIPLIER_1 18
#define ADDR_SENSITIVITY_MULTIPLIER_2 22
#define ADDR_SENSITIVITY_MULTIPLIER_3 26
#define ADDR_SENSITIVITY_MULTIPLIER_4 30
#define ADDR_SENSITIVITY_MULTIPLIER_5 34
#define ADDR_SENSITIVITY_MULTIPLIER_6 38
#define ADDR_DEADZONE_X 42
#define ADDR_DEADZONE_Y 46
#define ADDR_DEADZONE_D 50
#define ADDR_OUTER_DEADZONE 54
#define ADDR_INNER_DEADZONE 58
#define ADDR_CALIBRATION_DELAY 62
#define ADDR_CALIBRATION_SAMPLES 66
#define ADDR_CALIB_PS4_X 92
#define ADDR_CALIB_PS4_Y 96
#define ADDR_CALIB_PS4_Z 100
#define ADDR_CALIB_SWITCH_X 104
#define ADDR_CALIB_SWITCH_Y 108
#define ADDR_CALIB_SWITCH_Z 116
#define ADDR_CALIB_OTHER_X 116
#define ADDR_CALIB_OTHER_Y 120
#define ADDR_CALIB_OTHER_Z 124
#define LED_DELAY 2000
//Variables
fix32 mCalibOffsetX = 0.0;
fix32 mCalibOffsetY = 0.0;
fix32 mCalibOffsetZ = 0.0;
bool mIsActivatedCalibrating = FALSE;
bool mIsActivatedIncreaseSensitivity = FALSE;
bool mIsActivatedDecreaseSensitivity = FALSE;
bool mIsActivatedLeds = FALSE;
fix32 mBaseSensitivityX = 1.0;
fix32 mBaseSensitivityY = 1.6;
uint8 mSensitivityMultiplierIndex = 2;
fix32 mSensitivityMultipliersArray[7] = { 0.5, 0.75, 1.0, 1.25, 1.5, 1.75, 2.0 };
uint32 mCalibrationDelay = 3000;
uint32 mCalibrationSamples = 300;
uint32 mCalibrationCycleIndex = 0;
fix32 mDeadzoneX = 20.0; // Deadzone GYRO_1_YZ Input
fix32 mDeadzoneY = 20.0; // Deadzone GYRO_1_YX Input
fix32 mDeadzoneD = 0.38; // Deadzone Diagonal input
fix32 mOuterDeadzone = 92.00;
fix32 mInnerDeadzone = 0.13;
bool mIsActivateL1 = FALSE;
bool mIsActivateL2 = TRUE;
bool mIsActivateR1 = FALSE;
bool mIsActivateR2 = TRUE;
bool mIsAlwaysOn = FALSE;
bool mIsMotionAimingOn = TRUE;
uint32 mTimeCounter = 0;
bool mIsActivatedDebugging = FALSE;
init
{
pmem_load();
printf("Values loaded:");
pmem_read(ADDR_ACTIVATE_L1, &mIsActivateL1);
printf("Activate L1: %d", mIsActivateL1);
pmem_read(ADDR_ACTIVATE_L2, &mIsActivateL2);
printf("Activate L2: %d", mIsActivateL2);
pmem_read(ADDR_ACTIVATE_R1, &mIsActivateR1);
printf("Activate R1: %d", mIsActivateR1);
pmem_read(ADDR_ACTIVATE_R2, &mIsActivateR2);
printf("Activate R2: %d", mIsActivateR2);
pmem_read(ADDR_ACTIVATE_ALWAYS_ON, &mIsAlwaysOn);
printf("Activate AlwaysOn: %d", mIsAlwaysOn);
pmem_read(ADDR_BASE_SENSITIVITY_X, &mBaseSensitivityX);
printf("Base sensitivity X: %f", mBaseSensitivityX);
pmem_read(ADDR_BASE_SENSITIVITY_Y, &mBaseSensitivityY);
printf("Base sensitivity Y: %f", mBaseSensitivityY);
pmem_read(ADDR_SENSITIVITY_MULTIPLIER_INDEX, &mSensitivityMultiplierIndex);
mSensitivityMultiplierIndex--;
printf("Sensitivity multiplier index: %d", mSensitivityMultiplierIndex);
pmem_read(ADDR_SENSITIVITY_MULTIPLIER_0, &mSensitivityMultipliersArray[0]);
printf("Sensitivity multiplier [0]: %f", mSensitivityMultipliersArray[0]);
pmem_read(ADDR_SENSITIVITY_MULTIPLIER_1, &mSensitivityMultipliersArray[1]);
printf("Sensitivity multiplier [1]: %f", mSensitivityMultipliersArray[1]);
pmem_read(ADDR_SENSITIVITY_MULTIPLIER_2, &mSensitivityMultipliersArray[2]);
printf("Sensitivity multiplier [2]: %f", mSensitivityMultipliersArray[2]);
pmem_read(ADDR_SENSITIVITY_MULTIPLIER_3, &mSensitivityMultipliersArray[3]);
printf("Sensitivity multiplier [3]: %f", mSensitivityMultipliersArray[3]);
pmem_read(ADDR_SENSITIVITY_MULTIPLIER_4, &mSensitivityMultipliersArray[4]);
printf("Sensitivity multiplier [4]: %f", mSensitivityMultipliersArray[4]);
pmem_read(ADDR_SENSITIVITY_MULTIPLIER_5, &mSensitivityMultipliersArray[5]);
printf("Sensitivity multiplier [5]: %f", mSensitivityMultipliersArray[5]);
pmem_read(ADDR_SENSITIVITY_MULTIPLIER_6, &mSensitivityMultipliersArray[6]);
printf("Sensitivity multiplier [6]: %f", mSensitivityMultipliersArray[6]);
pmem_read(ADDR_DEADZONE_X, &mDeadzoneX);
printf("Deadzone X: %f", mDeadzoneX);
pmem_read(ADDR_DEADZONE_Y, &mDeadzoneY);
printf("Deadzone Y: %f", mDeadzoneY);
pmem_read(ADDR_DEADZONE_D, &mDeadzoneD);
printf("Deadzone D: %f", mDeadzoneD);
pmem_read(ADDR_OUTER_DEADZONE, &mOuterDeadzone);
printf("Outer Deadzone: %f", mOuterDeadzone);
pmem_read(ADDR_INNER_DEADZONE, &mInnerDeadzone);
printf("Inner Deadzone: %f", mInnerDeadzone);
pmem_read(ADDR_CALIBRATION_DELAY, &mCalibrationDelay);
printf("Calibration Delay: %d", mCalibrationDelay);
pmem_read(ADDR_CALIBRATION_SAMPLES, &mCalibrationSamples);
printf("Calibration Samples: %d", mCalibrationSamples);
FetchCalibration();
// Load Keyboard maping to Console
const uint8 kmap[] = { 0xE2, 0x00, 0x2B, 0x01, 0x29, 0x02, 0x08, 0x03, 0x09, 0x05, 0x14, 0x06, 0x10, 0x07, 0xE1, 0x08, 0x52, 0x09, 0x51, 0x0A, 0x50, 0x0B, 0x4F, 0x0C, 0x1E, 0x09, 0x20, 0x0A, 0x21, 0x0B, 0x1F, 0x0C, 0x0A, 0x0D, 0x06, 0x0E, 0x2C, 0x0F, 0x15, 0x10, 0x23, 0x11, 0x04, 0x97, 0x07, 0x17, 0x1A, 0x98, 0x16, 0x18, 0x3A, 0x26, 0x3B, 0x27, 0x3C, 0x28, 0x3D, 0x29 };
keymapping(kmap);
// Load MOUSE maping to Console
const uint8 mmap[] = { 0x00, 0x1D, 0x01, 0x1E, 0x06, 0x05, 0x08, 0x0D, 0x02, 0x0B, 0x03, 0x0C, 0x07, 0x0E, 0x04, 0x04, 0x05, 0x07 };
mousemapping(mmap);
// Load Controller maping to Console Block
const uint8 cmap[] = { 0x17, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A };
remapper(cmap);
}
main
{
ResetLeds();
ActivateIncreaseSensitivity(event_release(PADDLE_1) );
IncreaseSensitivity();
ActivateDecreaseSensitivity(event_release(PADDLE_2) );
DecreaseSensitivity();
ActivateCalibration(get_val(PADDLE_4)> 0.0 );
Calibrate();
Debug();
ToggleAlwaysOn(get_val(PADDLE_3) > 0.0 && get_prev(BUTTON_13) == 0.0 && get_actual(BUTTON_13) > 0.0);
ToggleMotionAiming(get_val(PADDLE_3) > 0.0 && get_prev(BUTTON_12) == 0.0 && get_actual(BUTTON_12) > 0.0);
MotionAiming(mIsMotionAimingOn && !mIsActivatedCalibrating && !mIsActivatedDebugging &&
(abs(get_val(STICK_1_X)) <= mDeadzoneX && (abs(get_val(STICK_1_Y)) <= mDeadzoneY)) &&
(mIsAlwaysOn ||
(mIsActivateL1 && (get_val(BUTTON_7) > 98.0)) ||
(mIsActivateL2 && (get_val(BUTTON_8) > 98.0)) ||
(mIsActivateR1 && (get_val(BUTTON_4) > 98.0)) ||
(mIsActivateR2 && (get_val(BUTTON_5) > 98.0))));
AddInnerDeadzone();
AddOuterDeadzone();
MimicTouch(get_val(BUTTON_2) > 90.0 && GetPadType() != PAD_PS4);
set_val(ACCEL_1_X, stick_response(ACCEL_1_X));
set_val(ACCEL_1_Y, stick_response(ACCEL_1_Y));
}
void ResetLeds()
{
if(mIsActivatedLeds)
{
if(mTimeCounter > LED_DELAY)
{
led_reset();
mTimeCounter = 0;
}
else
{
mTimeCounter += elapsed_time();
}
}
}
void ActivateIncreaseSensitivity(bool aIsActivated)
{
if(aIsActivated)
{
if(mSensitivityMultiplierIndex < 6) //increase sensivity multiplier
mIsActivatedIncreaseSensitivity = TRUE;
else
{
SetLeds(7);
mIsActivatedLeds = TRUE;
}
}
}
void IncreaseSensitivity()
{
if(mIsActivatedIncreaseSensitivity)
{
mSensitivityMultiplierIndex = mSensitivityMultiplierIndex + 1;
SetLeds(mSensitivityMultiplierIndex+1);
SaveSensitivityIndex();
mIsActivatedIncreaseSensitivity = FALSE;
mIsActivatedLeds = TRUE;
}
}
void ActivateDecreaseSensitivity(bool aIsActivated)
{
if(aIsActivated)
{
if(mSensitivityMultiplierIndex > 0) //decrease sensivity multiplier
mIsActivatedDecreaseSensitivity = TRUE;
else
{
SetLeds(0);
mIsActivatedLeds = TRUE;
}
}
}
void DecreaseSensitivity()
{
if(mIsActivatedDecreaseSensitivity)
{
mSensitivityMultiplierIndex = mSensitivityMultiplierIndex - 1;
SetLeds(mSensitivityMultiplierIndex+1);
SaveSensitivityIndex();
mIsActivatedDecreaseSensitivity = FALSE;
mIsActivatedLeds = TRUE;
}
}
void ActivateCalibration(bool aIsActivated)
{
if(aIsActivated && !mIsActivatedCalibrating)
{
mCalibOffsetX = 0.0;
mCalibOffsetY = 0.0;
mCalibOffsetZ = 0.0;
mCalibrationCycleIndex = 0;
mTimeCounter = 0;
SetLeds(6);
printf("Calibration started. Delay: %d, Samples: %d", mCalibrationDelay, mCalibrationSamples);
mIsActivatedCalibrating = TRUE;
}
}
void Calibrate()
{
if(mIsActivatedCalibrating)
{
mTimeCounter += elapsed_time();
if(mTimeCounter > mCalibrationDelay)
{
SetLeds(15);
if(mCalibrationCycleIndex < mCalibrationSamples)
{
mCalibrationCycleIndex += 1;
mCalibOffsetX += get_actual(ACCEL_1_X);
mCalibOffsetZ += get_actual(ACCEL_1_Y);
}
else
{
mCalibOffsetX /= (fix32)mCalibrationSamples;
mCalibOffsetY /= (fix32)mCalibrationSamples;
mCalibOffsetZ /= (fix32)mCalibrationSamples;
StoreCalibration();
mTimeCounter = 0;
led_reset();
mIsActivatedCalibrating = FALSE;
}
}
}
}
void FetchCalibration()
{
uint8 padType = GetPadType();
pmem_load();
switch(padType)
{
case PAD_OTHER:
pmem_read(ADDR_CALIB_OTHER_X, &mCalibOffsetX);
pmem_read(ADDR_CALIB_OTHER_Y, &mCalibOffsetY);
pmem_read(ADDR_CALIB_OTHER_Z, &mCalibOffsetZ);
printf("Other gamepad calibration. X: %f, Y: %f, Z: %f", mCalibOffsetX, mCalibOffsetY, mCalibOffsetZ);
break;
case PAD_PS4:
pmem_read(ADDR_CALIB_PS4_X, &mCalibOffsetX);
pmem_read(ADDR_CALIB_PS4_Y, &mCalibOffsetY);
pmem_read(ADDR_CALIB_PS4_Z, &mCalibOffsetZ);
printf("DualShock 4 calibration. X: %f, Y: %f, Z: %f", mCalibOffsetX, mCalibOffsetY, mCalibOffsetZ);
break;
case PAD_SWITCH:
pmem_read(ADDR_CALIB_SWITCH_X, &mCalibOffsetX);
pmem_read(ADDR_CALIB_SWITCH_Y, &mCalibOffsetY);
pmem_read(ADDR_CALIB_SWITCH_Z, &mCalibOffsetZ);
printf("Pro Controller calibration. X: %f, Y: %f, Z: %f", mCalibOffsetX, mCalibOffsetY, mCalibOffsetZ);
break;
}
}
void StoreCalibration()
{
uint8 padType = GetPadType();
printf("Pad type set: %d", padType);
switch(padType)
{
case PAD_OTHER:
pmem_write(ADDR_CALIB_OTHER_X, mCalibOffsetX);
pmem_write(ADDR_CALIB_OTHER_Y, mCalibOffsetY);
pmem_write(ADDR_CALIB_OTHER_Z, mCalibOffsetZ);
printf("Stored other gamepad calibration. X: %f, Y: %f, Z: %f", mCalibOffsetX, mCalibOffsetY, mCalibOffsetZ);
break;
case PAD_PS4:
pmem_write(ADDR_CALIB_PS4_X, mCalibOffsetX);
pmem_write(ADDR_CALIB_PS4_Y, mCalibOffsetY);
pmem_write(ADDR_CALIB_PS4_Z, mCalibOffsetZ);
printf("Stored DualShock 4 calibration. X: %f, Y: %f, Z: %f", mCalibOffsetX, mCalibOffsetY, mCalibOffsetZ);
break;
case PAD_SWITCH:
pmem_write(ADDR_CALIB_SWITCH_X, mCalibOffsetX);
pmem_write(ADDR_CALIB_SWITCH_Y, mCalibOffsetY);
pmem_write(ADDR_CALIB_SWITCH_Z, mCalibOffsetZ);
printf("Stored Pro Controller calibration. X: %f, Y: %f, Z: %f", mCalibOffsetX, mCalibOffsetY, mCalibOffsetZ);
break;
}
pmem_save();
}
uint8 GetPadType()
{
uint8 status, protocol, device, i = 0;
while(i < PAD_IDS_LENGHT)
{
status = port_status(PAD_IDS[i], &protocol, &device);
if(status)
{
if(protocol == PROTOCOL_PS4)
return PAD_PS4;
else if(protocol == PROTOCOL_SWITCH)
return PAD_SWITCH;
else
return PAD_OTHER;
}
i++;
}
return(-1);
}
void Debug()
{
if(mIsActivatedCalibrating || !mIsActivatedDebugging)
return;
set_val(GYRO_1_X, (get_val(GYRO_1_X) - mCalibOffsetX) * 1000.0);
set_val(GYRO_1_Y, (get_val(GYRO_1_Y) - mCalibOffsetY) * 1000.0);
set_val(GYRO_1_Z, (get_val(GYRO_1_Z) - mCalibOffsetZ) * 1000.0);
}
void ToggleAlwaysOn(bool aIsActivated)
{
if(aIsActivated)
{
mIsAlwaysOn = !mIsAlwaysOn;
pmem_write(ADDR_ACTIVATE_ALWAYS_ON, mIsAlwaysOn);
pmem_save();
}
}
void ToggleMotionAiming(bool aIsActivated)
{
if(aIsActivated)
{
mIsMotionAimingOn = !mIsMotionAimingOn;
}
}
void MotionAiming(bool aIsActivated)
{
if(aIsActivated)
{
static fix32 accelX, accelY;
static fix32 stickX, stickY;
if(accelX != get_actual(ACCEL_1_X) || accelY != get_actual(ACCEL_1_Y))
{
accelX = get_actual(ACCEL_1_X);
accelY = get_actual(ACCEL_1_Y);
stickX = (accelX - mCalibOffsetZ) * mBaseSensitivityX * mSensitivityMultipliersArray[mSensitivityMultiplierIndex];
stickY = (accelY - mCalibOffsetX) * mBaseSensitivityY * mSensitivityMultipliersArray[mSensitivityMultiplierIndex];
fix32 signalX = (stickX < 0.0) ? (stickX = inv(stickX), -1.0) : (stickX > 0.0) ? 1.0 : 0.0;
fix32 signalY = (stickY < 0.0) ? (stickY = inv(stickY), -1.0) : (stickY > 0.0) ? 1.0 : 0.0;
fix32 angle = atan2(stickY, stickX);
stickX = clamp(((mDeadzoneX * pow(cos(angle), mDeadzoneD)) + stickX) * signalX, -100.0, 100.0);
stickY = clamp(((mDeadzoneY * pow(sin(angle), mDeadzoneD)) + stickY) * signalY, -100.0, 100.0);
}
set_val(STICK_1_X, stickX);
set_val(STICK_1_Y, stickY);
return;
}
}
void AddInnerDeadzone()
{
if(abs(get_val(STICK_1_Y)) > 5.00 && abs(get_val(STICK_1_Y)) < mInnerDeadzone)
set_val(STICK_1_Y, 0.0);
if(abs(get_val(STICK_1_X)) > 5.00 && abs(get_val(STICK_1_X)) < mInnerDeadzone)
set_val(STICK_1_X, 0.0);
}
void AddOuterDeadzone()
{
if(get_val(STICK_1_Y) <= mOuterDeadzone * -1.00)
set_val(STICK_1_Y, -100);
if(get_val(STICK_1_Y) >= mOuterDeadzone)
set_val(STICK_1_Y, 100);
if(get_val(STICK_1_X) <= mOuterDeadzone * -1.00)
set_val(STICK_1_X, -100);
if(get_val(STICK_1_X) >= mOuterDeadzone)
set_val(STICK_1_X, 100);
}
void SaveSensitivityIndex()
{
printf("Sensitivity Index: %d, Sensitivity Multiplier: %f", mSensitivityMultiplierIndex, mSensitivityMultipliersArray[mSensitivityMultiplierIndex]);
pmem_write(ADDR_SENSITIVITY_MULTIPLIER_INDEX, mSensitivityMultiplierIndex);
pmem_save();
}
void SetLeds(uint8 aLeds)
{
if(aLeds == 1)
aLeds = 0;
fix32 bits[4];
bits[0] = (aLeds & (1 << 0)) == 0 ? 0.0 : 100.0;
bits[1] = (aLeds & (1 << 1)) == 0 ? 0.0 : 100.0;
bits[2] = (aLeds & (1 << 2)) == 0 ? 0.0 : 100.0;
bits[4] = (aLeds & (1 << 3)) == 0 ? 0.0 : 100.0;
led_set(LED_1, bits[0], 800);
led_set(LED_2, bits[1], 800);
led_set(LED_3, bits[2], 800);
led_set(LED_4, bits[3], 800);
}
void MimicTouch(bool aIsActivated)
{
if(aIsActivated)
{
set_val(BUTTON_19, 100.0);
set_val(POINT_1_X, get_actual(ACCEL_1_X));
set_val(POINT_1_Y, get_actual(ACCEL_1_Y));
set_val(STICK_1_X, 0.0);
set_val(STICK_1_Y, 0.0);
}
}
fix32 stick_response(uint8 idx) {
const uint8 mxyc[] = { 0xFF, 0x01, 0x00, 0x01, 0x00, 0x00, 0x23, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x03, 0x06, 0x09, 0x0C, 0x0F, 0x12, 0x15, 0x18, 0x1B, 0x1E, 0x21, 0x24, 0x27, 0x2A, 0x2D, 0x30, 0x33, 0x36, 0x39, 0x3C };
fix32 value = get_actual(idx);
fix32 signal = (value >= 0.0 ? 1.0 : -1.0);
value = abs(value);
return(value * signal);
}
Universal Mouse and Keboard Console with Curve Ver 1.7 Ratio 1.00 DD Factor 0.20
- Code: Select all
GIVMXYF:FF010001000033000000000100000306090C0F1215181B1E2124272A2D303336393
- Code: Select all
#pragma METAINFO("Universal Mouse and Keboard Console with Curve", 1, 7, "mss1988 & teddy18")
#include <switch.gph>
/*
<cfgdesc>
[Gyro Aiming Activation]
byteoffset = 0
bitsize = 8
control = checkbox
default = 0
item = On L1/LB
[Gyro Aiming Activation2]
group = true
groupcol = true
byteoffset = 1
bitsize = 8
control = checkbox
default = 0
item = On L2/LT
[Gyro Aiming Activation3]
group = true
groupcol = true
byteoffset = 2
bitsize = 8
control = checkbox
default = 0
item = On R1/RB
[Gyro Aiming Activation4]
group = true
groupcol = true
byteoffset = 3
bitsize = 8
control = checkbox
default = 0
item = On R2/RT
[Gyro Aiming Activation5]
group = true
groupcol = true
byteoffset = 4
bitsize = 8
control = checkbox
default = 1
item = Always On
[Sensitivity]
group = false
shortdesc = Base sensitivity X
byteoffset = 5
bitsize = 32
control = spinboxf
default = 100
minimum = 10
maximum = 20000
step = 1
decimals = 2
[SensitivityY]
group = true
groupcol = true
shortdesc = Base sensitivity Y
byteoffset = 9
bitsize = 32
control = spinboxf
default = 160
minimum = 10
maximum = 20000
step = 1
decimals = 2
[Sensitivity Multipliers]
group = false
groupcol = false
shortdesc = Active Sensitivity Multiplier:
byteoffset = 13
bitsize = 8
control = slider
default = 3
minimum = 1
maximum = 7
step = 1
[Sensitivity Multipliers1]
group = true
groupcol = false
shortdesc = Sensitivity Multiplier 1:
byteoffset = 14
bitsize = 32
control = spinboxf
default = 50
minimum = 10
maximum = 1000
step = 1
decimals = 2
[Sensitivity Multipliers2]
group = true
groupcol = false
shortdesc = Sensitivity Multiplier 2:
byteoffset = 18
bitsize = 32
control = spinboxf
default = 75
minimum = 10
maximum = 1000
step = 1
decimals = 2
[Sensitivity Multipliers3]
group = true
groupcol = false
shortdesc = Sensitivity Multiplier 3:
byteoffset = 22
bitsize = 32
control = spinboxf
default = 100
minimum = 10
maximum = 1000
step = 1
decimals = 2
[Sensitivity Multipliers4]
group = true
groupcol = false
shortdesc = Sensitivity Multiplier 4:
byteoffset = 26
bitsize = 32
control = spinboxf
default = 125
minimum = 10
maximum = 1000
step = 1
decimals = 2
[Sensitivity Multipliers5]
group = true
groupcol = false
shortdesc = Sensitivity Multiplier 5:
byteoffset = 30
bitsize = 32
control = spinboxf
default = 150
minimum = 10
maximum = 1000
step = 1
decimals = 2
[Sensitivity Multipliers6]
group = true
groupcol = false
shortdesc = Sensitivity Multiplier 6:
byteoffset = 34
bitsize = 32
control = spinboxf
default = 175
minimum = 10
maximum = 1000
step = 1
decimals = 2
[Sensitivity Multipliers7]
group = true
groupcol = false
shortdesc = Sensitivity Multiplier 7:
byteoffset = 38
bitsize = 32
control = spinboxf
default = 200
minimum = 10
maximum = 1000
step = 1
decimals = 2
[Deadzones]
group = false
shortdesc = Ignore Gyro if Right Stick X is greater than:
byteoffset = 42
bitsize = 32
control = spinboxf
default = 200
minimum = 0
maximum = 1000
step = 1
decimals = 1
[DeadzonesY]
group = true
groupcol = false
shortdesc = Ignore Gyro if Right Stick Y is greater than:
byteoffset = 46
bitsize = 32
control = spinboxf
default = 200
minimum = 0
maximum = 1000
step = 1
decimals = 1
[DeadzonesD]
group = true
groupcol = false
shortdesc = Right Stick Diagonal Deadzone:
byteoffset = 50
bitsize = 32
control = spinboxf
default = 38
minimum = 0
maximum = 200
step = 1
decimals = 2
[DeadzonesO]
group = true
groupcol = false
shortdesc = Right Stick Outer Deadzone:
byteoffset = 54
bitsize = 32
control = spinboxf
default = 9200
minimum = 0
maximum = 10000
step = 1
decimals = 2
[DeadzonesI]
group = true
groupcol = false
shortdesc = Right Stick Inner Deadzone:
byteoffset = 58
bitsize = 32
control = spinboxf
default = 013
minimum = 0
maximum = 10000
step = 1
decimals = 2
[Calibration]
group = false
groupcol = false
shortdesc = Delay (ms):
byteoffset = 62
bitsize = 32
control = slider
default = 3000
minimum = 500
maximum = 10000
step = 500
[CalibrationS]
group = true
groupcol = false
shortdesc = Samples:
byteoffset = 66
bitsize = 32
control = slider
default = 300
minimum = 100
maximum = 10000
step = 100
</cfgdesc>
*/
//Constants
#define PAD_OTHER 0
#define PAD_PS4 1
#define PAD_SWITCH 2
uint8 PAD_IDS[5] = { 6, 5, 4, 2, 1 };
uint8 PAD_IDS_LENGHT = 5;
//Persistent memory addereses
#define ADDR_ACTIVATE_L1 0
#define ADDR_ACTIVATE_L2 1
#define ADDR_ACTIVATE_R1 2
#define ADDR_ACTIVATE_R2 3
#define ADDR_ACTIVATE_ALWAYS_ON 4
#define ADDR_BASE_SENSITIVITY_X 5
#define ADDR_BASE_SENSITIVITY_Y 9
#define ADDR_SENSITIVITY_MULTIPLIER_INDEX 13
#define ADDR_SENSITIVITY_MULTIPLIER_0 14
#define ADDR_SENSITIVITY_MULTIPLIER_1 18
#define ADDR_SENSITIVITY_MULTIPLIER_2 22
#define ADDR_SENSITIVITY_MULTIPLIER_3 26
#define ADDR_SENSITIVITY_MULTIPLIER_4 30
#define ADDR_SENSITIVITY_MULTIPLIER_5 34
#define ADDR_SENSITIVITY_MULTIPLIER_6 38
#define ADDR_DEADZONE_X 42
#define ADDR_DEADZONE_Y 46
#define ADDR_DEADZONE_D 50
#define ADDR_OUTER_DEADZONE 54
#define ADDR_INNER_DEADZONE 58
#define ADDR_CALIBRATION_DELAY 62
#define ADDR_CALIBRATION_SAMPLES 66
#define ADDR_CALIB_PS4_X 92
#define ADDR_CALIB_PS4_Y 96
#define ADDR_CALIB_PS4_Z 100
#define ADDR_CALIB_SWITCH_X 104
#define ADDR_CALIB_SWITCH_Y 108
#define ADDR_CALIB_SWITCH_Z 116
#define ADDR_CALIB_OTHER_X 116
#define ADDR_CALIB_OTHER_Y 120
#define ADDR_CALIB_OTHER_Z 124
#define LED_DELAY 2000
//Variables
fix32 mCalibOffsetX = 0.0;
fix32 mCalibOffsetY = 0.0;
fix32 mCalibOffsetZ = 0.0;
bool mIsActivatedCalibrating = FALSE;
bool mIsActivatedIncreaseSensitivity = FALSE;
bool mIsActivatedDecreaseSensitivity = FALSE;
bool mIsActivatedLeds = FALSE;
fix32 mBaseSensitivityX = 1.0;
fix32 mBaseSensitivityY = 1.6;
uint8 mSensitivityMultiplierIndex = 2;
fix32 mSensitivityMultipliersArray[7] = { 0.5, 0.75, 1.0, 1.25, 1.5, 1.75, 2.0 };
uint32 mCalibrationDelay = 3000;
uint32 mCalibrationSamples = 300;
uint32 mCalibrationCycleIndex = 0;
fix32 mDeadzoneX = 20.0; // Deadzone GYRO_1_YZ Input
fix32 mDeadzoneY = 20.0; // Deadzone GYRO_1_YX Input
fix32 mDeadzoneD = 0.38; // Deadzone Diagonal input
fix32 mOuterDeadzone = 92.00;
fix32 mInnerDeadzone = 0.13;
bool mIsActivateL1 = FALSE;
bool mIsActivateL2 = TRUE;
bool mIsActivateR1 = FALSE;
bool mIsActivateR2 = TRUE;
bool mIsAlwaysOn = FALSE;
bool mIsMotionAimingOn = TRUE;
uint32 mTimeCounter = 0;
bool mIsActivatedDebugging = FALSE;
init
{
pmem_load();
printf("Values loaded:");
pmem_read(ADDR_ACTIVATE_L1, &mIsActivateL1);
printf("Activate L1: %d", mIsActivateL1);
pmem_read(ADDR_ACTIVATE_L2, &mIsActivateL2);
printf("Activate L2: %d", mIsActivateL2);
pmem_read(ADDR_ACTIVATE_R1, &mIsActivateR1);
printf("Activate R1: %d", mIsActivateR1);
pmem_read(ADDR_ACTIVATE_R2, &mIsActivateR2);
printf("Activate R2: %d", mIsActivateR2);
pmem_read(ADDR_ACTIVATE_ALWAYS_ON, &mIsAlwaysOn);
printf("Activate AlwaysOn: %d", mIsAlwaysOn);
pmem_read(ADDR_BASE_SENSITIVITY_X, &mBaseSensitivityX);
printf("Base sensitivity X: %f", mBaseSensitivityX);
pmem_read(ADDR_BASE_SENSITIVITY_Y, &mBaseSensitivityY);
printf("Base sensitivity Y: %f", mBaseSensitivityY);
pmem_read(ADDR_SENSITIVITY_MULTIPLIER_INDEX, &mSensitivityMultiplierIndex);
mSensitivityMultiplierIndex--;
printf("Sensitivity multiplier index: %d", mSensitivityMultiplierIndex);
pmem_read(ADDR_SENSITIVITY_MULTIPLIER_0, &mSensitivityMultipliersArray[0]);
printf("Sensitivity multiplier [0]: %f", mSensitivityMultipliersArray[0]);
pmem_read(ADDR_SENSITIVITY_MULTIPLIER_1, &mSensitivityMultipliersArray[1]);
printf("Sensitivity multiplier [1]: %f", mSensitivityMultipliersArray[1]);
pmem_read(ADDR_SENSITIVITY_MULTIPLIER_2, &mSensitivityMultipliersArray[2]);
printf("Sensitivity multiplier [2]: %f", mSensitivityMultipliersArray[2]);
pmem_read(ADDR_SENSITIVITY_MULTIPLIER_3, &mSensitivityMultipliersArray[3]);
printf("Sensitivity multiplier [3]: %f", mSensitivityMultipliersArray[3]);
pmem_read(ADDR_SENSITIVITY_MULTIPLIER_4, &mSensitivityMultipliersArray[4]);
printf("Sensitivity multiplier [4]: %f", mSensitivityMultipliersArray[4]);
pmem_read(ADDR_SENSITIVITY_MULTIPLIER_5, &mSensitivityMultipliersArray[5]);
printf("Sensitivity multiplier [5]: %f", mSensitivityMultipliersArray[5]);
pmem_read(ADDR_SENSITIVITY_MULTIPLIER_6, &mSensitivityMultipliersArray[6]);
printf("Sensitivity multiplier [6]: %f", mSensitivityMultipliersArray[6]);
pmem_read(ADDR_DEADZONE_X, &mDeadzoneX);
printf("Deadzone X: %f", mDeadzoneX);
pmem_read(ADDR_DEADZONE_Y, &mDeadzoneY);
printf("Deadzone Y: %f", mDeadzoneY);
pmem_read(ADDR_DEADZONE_D, &mDeadzoneD);
printf("Deadzone D: %f", mDeadzoneD);
pmem_read(ADDR_OUTER_DEADZONE, &mOuterDeadzone);
printf("Outer Deadzone: %f", mOuterDeadzone);
pmem_read(ADDR_INNER_DEADZONE, &mInnerDeadzone);
printf("Inner Deadzone: %f", mInnerDeadzone);
pmem_read(ADDR_CALIBRATION_DELAY, &mCalibrationDelay);
printf("Calibration Delay: %d", mCalibrationDelay);
pmem_read(ADDR_CALIBRATION_SAMPLES, &mCalibrationSamples);
printf("Calibration Samples: %d", mCalibrationSamples);
FetchCalibration();
// Load Keyboard maping to Console
const uint8 kmap[] = { 0xE2, 0x00, 0x2B, 0x01, 0x29, 0x02, 0x08, 0x03, 0x09, 0x05, 0x14, 0x06, 0x10, 0x07, 0xE1, 0x08, 0x52, 0x09, 0x51, 0x0A, 0x50, 0x0B, 0x4F, 0x0C, 0x1E, 0x09, 0x20, 0x0A, 0x21, 0x0B, 0x1F, 0x0C, 0x0A, 0x0D, 0x06, 0x0E, 0x2C, 0x0F, 0x15, 0x10, 0x23, 0x11, 0x04, 0x97, 0x07, 0x17, 0x1A, 0x98, 0x16, 0x18, 0x3A, 0x26, 0x3B, 0x27, 0x3C, 0x28, 0x3D, 0x29 };
keymapping(kmap);
// Load MOUSE maping to Console
const uint8 mmap[] = { 0x00, 0x1D, 0x01, 0x1E, 0x06, 0x05, 0x08, 0x0D, 0x02, 0x0B, 0x03, 0x0C, 0x07, 0x0E, 0x04, 0x04, 0x05, 0x07 };
mousemapping(mmap);
// Load Controller maping to Console Block
const uint8 cmap[] = { 0x17, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A };
remapper(cmap);
}
main
{
ResetLeds();
ActivateIncreaseSensitivity(event_release(PADDLE_1) );
IncreaseSensitivity();
ActivateDecreaseSensitivity(event_release(PADDLE_2) );
DecreaseSensitivity();
ActivateCalibration(get_val(PADDLE_4)> 0.0 );
Calibrate();
Debug();
ToggleAlwaysOn(get_val(PADDLE_3) > 0.0 && get_prev(BUTTON_13) == 0.0 && get_actual(BUTTON_13) > 0.0);
ToggleMotionAiming(get_val(PADDLE_3) > 0.0 && get_prev(BUTTON_12) == 0.0 && get_actual(BUTTON_12) > 0.0);
MotionAiming(mIsMotionAimingOn && !mIsActivatedCalibrating && !mIsActivatedDebugging &&
(abs(get_val(STICK_1_X)) <= mDeadzoneX && (abs(get_val(STICK_1_Y)) <= mDeadzoneY)) &&
(mIsAlwaysOn ||
(mIsActivateL1 && (get_val(BUTTON_7) > 98.0)) ||
(mIsActivateL2 && (get_val(BUTTON_8) > 98.0)) ||
(mIsActivateR1 && (get_val(BUTTON_4) > 98.0)) ||
(mIsActivateR2 && (get_val(BUTTON_5) > 98.0))));
AddInnerDeadzone();
AddOuterDeadzone();
MimicTouch(get_val(BUTTON_2) > 90.0 && GetPadType() != PAD_PS4);
set_val(ACCEL_1_X, stick_response(ACCEL_1_X));
set_val(ACCEL_1_Y, stick_response(ACCEL_1_Y));
}
void ResetLeds()
{
if(mIsActivatedLeds)
{
if(mTimeCounter > LED_DELAY)
{
led_reset();
mTimeCounter = 0;
}
else
{
mTimeCounter += elapsed_time();
}
}
}
void ActivateIncreaseSensitivity(bool aIsActivated)
{
if(aIsActivated)
{
if(mSensitivityMultiplierIndex < 6) //increase sensivity multiplier
mIsActivatedIncreaseSensitivity = TRUE;
else
{
SetLeds(7);
mIsActivatedLeds = TRUE;
}
}
}
void IncreaseSensitivity()
{
if(mIsActivatedIncreaseSensitivity)
{
mSensitivityMultiplierIndex = mSensitivityMultiplierIndex + 1;
SetLeds(mSensitivityMultiplierIndex+1);
SaveSensitivityIndex();
mIsActivatedIncreaseSensitivity = FALSE;
mIsActivatedLeds = TRUE;
}
}
void ActivateDecreaseSensitivity(bool aIsActivated)
{
if(aIsActivated)
{
if(mSensitivityMultiplierIndex > 0) //decrease sensivity multiplier
mIsActivatedDecreaseSensitivity = TRUE;
else
{
SetLeds(0);
mIsActivatedLeds = TRUE;
}
}
}
void DecreaseSensitivity()
{
if(mIsActivatedDecreaseSensitivity)
{
mSensitivityMultiplierIndex = mSensitivityMultiplierIndex - 1;
SetLeds(mSensitivityMultiplierIndex+1);
SaveSensitivityIndex();
mIsActivatedDecreaseSensitivity = FALSE;
mIsActivatedLeds = TRUE;
}
}
void ActivateCalibration(bool aIsActivated)
{
if(aIsActivated && !mIsActivatedCalibrating)
{
mCalibOffsetX = 0.0;
mCalibOffsetY = 0.0;
mCalibOffsetZ = 0.0;
mCalibrationCycleIndex = 0;
mTimeCounter = 0;
SetLeds(6);
printf("Calibration started. Delay: %d, Samples: %d", mCalibrationDelay, mCalibrationSamples);
mIsActivatedCalibrating = TRUE;
}
}
void Calibrate()
{
if(mIsActivatedCalibrating)
{
mTimeCounter += elapsed_time();
if(mTimeCounter > mCalibrationDelay)
{
SetLeds(15);
if(mCalibrationCycleIndex < mCalibrationSamples)
{
mCalibrationCycleIndex += 1;
mCalibOffsetX += get_actual(ACCEL_1_X);
mCalibOffsetZ += get_actual(ACCEL_1_Y);
}
else
{
mCalibOffsetX /= (fix32)mCalibrationSamples;
mCalibOffsetY /= (fix32)mCalibrationSamples;
mCalibOffsetZ /= (fix32)mCalibrationSamples;
StoreCalibration();
mTimeCounter = 0;
led_reset();
mIsActivatedCalibrating = FALSE;
}
}
}
}
void FetchCalibration()
{
uint8 padType = GetPadType();
pmem_load();
switch(padType)
{
case PAD_OTHER:
pmem_read(ADDR_CALIB_OTHER_X, &mCalibOffsetX);
pmem_read(ADDR_CALIB_OTHER_Y, &mCalibOffsetY);
pmem_read(ADDR_CALIB_OTHER_Z, &mCalibOffsetZ);
printf("Other gamepad calibration. X: %f, Y: %f, Z: %f", mCalibOffsetX, mCalibOffsetY, mCalibOffsetZ);
break;
case PAD_PS4:
pmem_read(ADDR_CALIB_PS4_X, &mCalibOffsetX);
pmem_read(ADDR_CALIB_PS4_Y, &mCalibOffsetY);
pmem_read(ADDR_CALIB_PS4_Z, &mCalibOffsetZ);
printf("DualShock 4 calibration. X: %f, Y: %f, Z: %f", mCalibOffsetX, mCalibOffsetY, mCalibOffsetZ);
break;
case PAD_SWITCH:
pmem_read(ADDR_CALIB_SWITCH_X, &mCalibOffsetX);
pmem_read(ADDR_CALIB_SWITCH_Y, &mCalibOffsetY);
pmem_read(ADDR_CALIB_SWITCH_Z, &mCalibOffsetZ);
printf("Pro Controller calibration. X: %f, Y: %f, Z: %f", mCalibOffsetX, mCalibOffsetY, mCalibOffsetZ);
break;
}
}
void StoreCalibration()
{
uint8 padType = GetPadType();
printf("Pad type set: %d", padType);
switch(padType)
{
case PAD_OTHER:
pmem_write(ADDR_CALIB_OTHER_X, mCalibOffsetX);
pmem_write(ADDR_CALIB_OTHER_Y, mCalibOffsetY);
pmem_write(ADDR_CALIB_OTHER_Z, mCalibOffsetZ);
printf("Stored other gamepad calibration. X: %f, Y: %f, Z: %f", mCalibOffsetX, mCalibOffsetY, mCalibOffsetZ);
break;
case PAD_PS4:
pmem_write(ADDR_CALIB_PS4_X, mCalibOffsetX);
pmem_write(ADDR_CALIB_PS4_Y, mCalibOffsetY);
pmem_write(ADDR_CALIB_PS4_Z, mCalibOffsetZ);
printf("Stored DualShock 4 calibration. X: %f, Y: %f, Z: %f", mCalibOffsetX, mCalibOffsetY, mCalibOffsetZ);
break;
case PAD_SWITCH:
pmem_write(ADDR_CALIB_SWITCH_X, mCalibOffsetX);
pmem_write(ADDR_CALIB_SWITCH_Y, mCalibOffsetY);
pmem_write(ADDR_CALIB_SWITCH_Z, mCalibOffsetZ);
printf("Stored Pro Controller calibration. X: %f, Y: %f, Z: %f", mCalibOffsetX, mCalibOffsetY, mCalibOffsetZ);
break;
}
pmem_save();
}
uint8 GetPadType()
{
uint8 status, protocol, device, i = 0;
while(i < PAD_IDS_LENGHT)
{
status = port_status(PAD_IDS[i], &protocol, &device);
if(status)
{
if(protocol == PROTOCOL_PS4)
return PAD_PS4;
else if(protocol == PROTOCOL_SWITCH)
return PAD_SWITCH;
else
return PAD_OTHER;
}
i++;
}
return(-1);
}
void Debug()
{
if(mIsActivatedCalibrating || !mIsActivatedDebugging)
return;
set_val(GYRO_1_X, (get_val(GYRO_1_X) - mCalibOffsetX) * 1000.0);
set_val(GYRO_1_Y, (get_val(GYRO_1_Y) - mCalibOffsetY) * 1000.0);
set_val(GYRO_1_Z, (get_val(GYRO_1_Z) - mCalibOffsetZ) * 1000.0);
}
void ToggleAlwaysOn(bool aIsActivated)
{
if(aIsActivated)
{
mIsAlwaysOn = !mIsAlwaysOn;
pmem_write(ADDR_ACTIVATE_ALWAYS_ON, mIsAlwaysOn);
pmem_save();
}
}
void ToggleMotionAiming(bool aIsActivated)
{
if(aIsActivated)
{
mIsMotionAimingOn = !mIsMotionAimingOn;
}
}
void MotionAiming(bool aIsActivated)
{
if(aIsActivated)
{
static fix32 accelX, accelY;
static fix32 stickX, stickY;
if(accelX != get_actual(ACCEL_1_X) || accelY != get_actual(ACCEL_1_Y))
{
accelX = get_actual(ACCEL_1_X);
accelY = get_actual(ACCEL_1_Y);
stickX = (accelX - mCalibOffsetZ) * mBaseSensitivityX * mSensitivityMultipliersArray[mSensitivityMultiplierIndex];
stickY = (accelY - mCalibOffsetX) * mBaseSensitivityY * mSensitivityMultipliersArray[mSensitivityMultiplierIndex];
fix32 signalX = (stickX < 0.0) ? (stickX = inv(stickX), -1.0) : (stickX > 0.0) ? 1.0 : 0.0;
fix32 signalY = (stickY < 0.0) ? (stickY = inv(stickY), -1.0) : (stickY > 0.0) ? 1.0 : 0.0;
fix32 angle = atan2(stickY, stickX);
stickX = clamp(((mDeadzoneX * pow(cos(angle), mDeadzoneD)) + stickX) * signalX, -100.0, 100.0);
stickY = clamp(((mDeadzoneY * pow(sin(angle), mDeadzoneD)) + stickY) * signalY, -100.0, 100.0);
}
set_val(STICK_1_X, stickX);
set_val(STICK_1_Y, stickY);
return;
}
}
void AddInnerDeadzone()
{
if(abs(get_val(STICK_1_Y)) > 5.00 && abs(get_val(STICK_1_Y)) < mInnerDeadzone)
set_val(STICK_1_Y, 0.0);
if(abs(get_val(STICK_1_X)) > 5.00 && abs(get_val(STICK_1_X)) < mInnerDeadzone)
set_val(STICK_1_X, 0.0);
}
void AddOuterDeadzone()
{
if(get_val(STICK_1_Y) <= mOuterDeadzone * -1.00)
set_val(STICK_1_Y, -100);
if(get_val(STICK_1_Y) >= mOuterDeadzone)
set_val(STICK_1_Y, 100);
if(get_val(STICK_1_X) <= mOuterDeadzone * -1.00)
set_val(STICK_1_X, -100);
if(get_val(STICK_1_X) >= mOuterDeadzone)
set_val(STICK_1_X, 100);
}
void SaveSensitivityIndex()
{
printf("Sensitivity Index: %d, Sensitivity Multiplier: %f", mSensitivityMultiplierIndex, mSensitivityMultipliersArray[mSensitivityMultiplierIndex]);
pmem_write(ADDR_SENSITIVITY_MULTIPLIER_INDEX, mSensitivityMultiplierIndex);
pmem_save();
}
void SetLeds(uint8 aLeds)
{
if(aLeds == 1)
aLeds = 0;
fix32 bits[4];
bits[0] = (aLeds & (1 << 0)) == 0 ? 0.0 : 100.0;
bits[1] = (aLeds & (1 << 1)) == 0 ? 0.0 : 100.0;
bits[2] = (aLeds & (1 << 2)) == 0 ? 0.0 : 100.0;
bits[4] = (aLeds & (1 << 3)) == 0 ? 0.0 : 100.0;
led_set(LED_1, bits[0], 800);
led_set(LED_2, bits[1], 800);
led_set(LED_3, bits[2], 800);
led_set(LED_4, bits[3], 800);
}
void MimicTouch(bool aIsActivated)
{
if(aIsActivated)
{
set_val(BUTTON_19, 100.0);
set_val(POINT_1_X, get_actual(ACCEL_1_X));
set_val(POINT_1_Y, get_actual(ACCEL_1_Y));
set_val(STICK_1_X, 0.0);
set_val(STICK_1_Y, 0.0);
}
}
fix32 stick_response(uint8 idx) {
const uint8 mxyc[] = { 0xFF, 0x01, 0x00, 0x01, 0x00, 0x00, 0x33, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x03, 0x06, 0x09, 0x0C, 0x0F, 0x12, 0x15, 0x18, 0x1B, 0x1E, 0x21, 0x24, 0x27, 0x2A, 0x2D, 0x30, 0x33, 0x36, 0x39, 0x3C };
fix32 value = get_actual(idx);
fix32 signal = (value >= 0.0 ? 1.0 : -1.0);
value = abs(value);
return(value * signal);
}
-
teddy18 - Lieutenant
- Posts: 346
- Joined: Sun Jul 19, 2015 4:18 pm
Re: Universal Mouse and Keboard Console on The fly
Script
Universal Mouse and Keboard Console with Curve Ver 1.8 Ratio 1.83 DD Factor 0.20
Universal Mouse and Keboard Console with Curve Ver 1.9 Ratio 1.83 DD Factor 0.14
Universal Mouse and Keboard Console with Curve Ver 1.8 Ratio 1.83 DD Factor 0.20
- Code: Select all
GIVMXYF:FF010001D40033000000000100000306090C0F1215181B1E2124272A2D303336393C
- Code: Select all
#pragma METAINFO("Universal Mouse and Keboard Console with Curve", 1, 8, "mss1988 & teddy18")
#include <switch.gph>
/*
<cfgdesc>
[Gyro Aiming Activation]
byteoffset = 0
bitsize = 8
control = checkbox
default = 0
item = On L1/LB
[Gyro Aiming Activation2]
group = true
groupcol = true
byteoffset = 1
bitsize = 8
control = checkbox
default = 0
item = On L2/LT
[Gyro Aiming Activation3]
group = true
groupcol = true
byteoffset = 2
bitsize = 8
control = checkbox
default = 0
item = On R1/RB
[Gyro Aiming Activation4]
group = true
groupcol = true
byteoffset = 3
bitsize = 8
control = checkbox
default = 0
item = On R2/RT
[Gyro Aiming Activation5]
group = true
groupcol = true
byteoffset = 4
bitsize = 8
control = checkbox
default = 1
item = Always On
[Sensitivity]
group = false
shortdesc = Base sensitivity X
byteoffset = 5
bitsize = 32
control = spinboxf
default = 100
minimum = 10
maximum = 20000
step = 1
decimals = 2
[SensitivityY]
group = true
groupcol = true
shortdesc = Base sensitivity Y
byteoffset = 9
bitsize = 32
control = spinboxf
default = 160
minimum = 10
maximum = 20000
step = 1
decimals = 2
[Sensitivity Multipliers]
group = false
groupcol = false
shortdesc = Active Sensitivity Multiplier:
byteoffset = 13
bitsize = 8
control = slider
default = 3
minimum = 1
maximum = 7
step = 1
[Sensitivity Multipliers1]
group = true
groupcol = false
shortdesc = Sensitivity Multiplier 1:
byteoffset = 14
bitsize = 32
control = spinboxf
default = 50
minimum = 10
maximum = 1000
step = 1
decimals = 2
[Sensitivity Multipliers2]
group = true
groupcol = false
shortdesc = Sensitivity Multiplier 2:
byteoffset = 18
bitsize = 32
control = spinboxf
default = 75
minimum = 10
maximum = 1000
step = 1
decimals = 2
[Sensitivity Multipliers3]
group = true
groupcol = false
shortdesc = Sensitivity Multiplier 3:
byteoffset = 22
bitsize = 32
control = spinboxf
default = 100
minimum = 10
maximum = 1000
step = 1
decimals = 2
[Sensitivity Multipliers4]
group = true
groupcol = false
shortdesc = Sensitivity Multiplier 4:
byteoffset = 26
bitsize = 32
control = spinboxf
default = 125
minimum = 10
maximum = 1000
step = 1
decimals = 2
[Sensitivity Multipliers5]
group = true
groupcol = false
shortdesc = Sensitivity Multiplier 5:
byteoffset = 30
bitsize = 32
control = spinboxf
default = 150
minimum = 10
maximum = 1000
step = 1
decimals = 2
[Sensitivity Multipliers6]
group = true
groupcol = false
shortdesc = Sensitivity Multiplier 6:
byteoffset = 34
bitsize = 32
control = spinboxf
default = 175
minimum = 10
maximum = 1000
step = 1
decimals = 2
[Sensitivity Multipliers7]
group = true
groupcol = false
shortdesc = Sensitivity Multiplier 7:
byteoffset = 38
bitsize = 32
control = spinboxf
default = 200
minimum = 10
maximum = 1000
step = 1
decimals = 2
[Deadzones]
group = false
shortdesc = Ignore Gyro if Right Stick X is greater than:
byteoffset = 42
bitsize = 32
control = spinboxf
default = 200
minimum = 0
maximum = 1000
step = 1
decimals = 1
[DeadzonesY]
group = true
groupcol = false
shortdesc = Ignore Gyro if Right Stick Y is greater than:
byteoffset = 46
bitsize = 32
control = spinboxf
default = 200
minimum = 0
maximum = 1000
step = 1
decimals = 1
[DeadzonesD]
group = true
groupcol = false
shortdesc = Right Stick Diagonal Deadzone:
byteoffset = 50
bitsize = 32
control = spinboxf
default = 38
minimum = 0
maximum = 200
step = 1
decimals = 2
[DeadzonesO]
group = true
groupcol = false
shortdesc = Right Stick Outer Deadzone:
byteoffset = 54
bitsize = 32
control = spinboxf
default = 9200
minimum = 0
maximum = 10000
step = 1
decimals = 2
[DeadzonesI]
group = true
groupcol = false
shortdesc = Right Stick Inner Deadzone:
byteoffset = 58
bitsize = 32
control = spinboxf
default = 013
minimum = 0
maximum = 10000
step = 1
decimals = 2
[Calibration]
group = false
groupcol = false
shortdesc = Delay (ms):
byteoffset = 62
bitsize = 32
control = slider
default = 3000
minimum = 500
maximum = 10000
step = 500
[CalibrationS]
group = true
groupcol = false
shortdesc = Samples:
byteoffset = 66
bitsize = 32
control = slider
default = 300
minimum = 100
maximum = 10000
step = 100
</cfgdesc>
*/
//Constants
#define PAD_OTHER 0
#define PAD_PS4 1
#define PAD_SWITCH 2
uint8 PAD_IDS[5] = { 6, 5, 4, 2, 1 };
uint8 PAD_IDS_LENGHT = 5;
//Persistent memory addereses
#define ADDR_ACTIVATE_L1 0
#define ADDR_ACTIVATE_L2 1
#define ADDR_ACTIVATE_R1 2
#define ADDR_ACTIVATE_R2 3
#define ADDR_ACTIVATE_ALWAYS_ON 4
#define ADDR_BASE_SENSITIVITY_X 5
#define ADDR_BASE_SENSITIVITY_Y 9
#define ADDR_SENSITIVITY_MULTIPLIER_INDEX 13
#define ADDR_SENSITIVITY_MULTIPLIER_0 14
#define ADDR_SENSITIVITY_MULTIPLIER_1 18
#define ADDR_SENSITIVITY_MULTIPLIER_2 22
#define ADDR_SENSITIVITY_MULTIPLIER_3 26
#define ADDR_SENSITIVITY_MULTIPLIER_4 30
#define ADDR_SENSITIVITY_MULTIPLIER_5 34
#define ADDR_SENSITIVITY_MULTIPLIER_6 38
#define ADDR_DEADZONE_X 42
#define ADDR_DEADZONE_Y 46
#define ADDR_DEADZONE_D 50
#define ADDR_OUTER_DEADZONE 54
#define ADDR_INNER_DEADZONE 58
#define ADDR_CALIBRATION_DELAY 62
#define ADDR_CALIBRATION_SAMPLES 66
#define ADDR_CALIB_PS4_X 92
#define ADDR_CALIB_PS4_Y 96
#define ADDR_CALIB_PS4_Z 100
#define ADDR_CALIB_SWITCH_X 104
#define ADDR_CALIB_SWITCH_Y 108
#define ADDR_CALIB_SWITCH_Z 116
#define ADDR_CALIB_OTHER_X 116
#define ADDR_CALIB_OTHER_Y 120
#define ADDR_CALIB_OTHER_Z 124
#define LED_DELAY 2000
//Variables
fix32 mCalibOffsetX = 0.0;
fix32 mCalibOffsetY = 0.0;
fix32 mCalibOffsetZ = 0.0;
bool mIsActivatedCalibrating = FALSE;
bool mIsActivatedIncreaseSensitivity = FALSE;
bool mIsActivatedDecreaseSensitivity = FALSE;
bool mIsActivatedLeds = FALSE;
fix32 mBaseSensitivityX = 1.0;
fix32 mBaseSensitivityY = 1.6;
uint8 mSensitivityMultiplierIndex = 2;
fix32 mSensitivityMultipliersArray[7] = { 0.5, 0.75, 1.0, 1.25, 1.5, 1.75, 2.0 };
uint32 mCalibrationDelay = 3000;
uint32 mCalibrationSamples = 300;
uint32 mCalibrationCycleIndex = 0;
fix32 mDeadzoneX = 20.0; // Deadzone GYRO_1_YZ Input
fix32 mDeadzoneY = 20.0; // Deadzone GYRO_1_YX Input
fix32 mDeadzoneD = 0.38; // Deadzone Diagonal input
fix32 mOuterDeadzone = 92.00;
fix32 mInnerDeadzone = 0.13;
bool mIsActivateL1 = FALSE;
bool mIsActivateL2 = TRUE;
bool mIsActivateR1 = FALSE;
bool mIsActivateR2 = TRUE;
bool mIsAlwaysOn = FALSE;
bool mIsMotionAimingOn = TRUE;
uint32 mTimeCounter = 0;
bool mIsActivatedDebugging = FALSE;
init
{
pmem_load();
printf("Values loaded:");
pmem_read(ADDR_ACTIVATE_L1, &mIsActivateL1);
printf("Activate L1: %d", mIsActivateL1);
pmem_read(ADDR_ACTIVATE_L2, &mIsActivateL2);
printf("Activate L2: %d", mIsActivateL2);
pmem_read(ADDR_ACTIVATE_R1, &mIsActivateR1);
printf("Activate R1: %d", mIsActivateR1);
pmem_read(ADDR_ACTIVATE_R2, &mIsActivateR2);
printf("Activate R2: %d", mIsActivateR2);
pmem_read(ADDR_ACTIVATE_ALWAYS_ON, &mIsAlwaysOn);
printf("Activate AlwaysOn: %d", mIsAlwaysOn);
pmem_read(ADDR_BASE_SENSITIVITY_X, &mBaseSensitivityX);
printf("Base sensitivity X: %f", mBaseSensitivityX);
pmem_read(ADDR_BASE_SENSITIVITY_Y, &mBaseSensitivityY);
printf("Base sensitivity Y: %f", mBaseSensitivityY);
pmem_read(ADDR_SENSITIVITY_MULTIPLIER_INDEX, &mSensitivityMultiplierIndex);
mSensitivityMultiplierIndex--;
printf("Sensitivity multiplier index: %d", mSensitivityMultiplierIndex);
pmem_read(ADDR_SENSITIVITY_MULTIPLIER_0, &mSensitivityMultipliersArray[0]);
printf("Sensitivity multiplier [0]: %f", mSensitivityMultipliersArray[0]);
pmem_read(ADDR_SENSITIVITY_MULTIPLIER_1, &mSensitivityMultipliersArray[1]);
printf("Sensitivity multiplier [1]: %f", mSensitivityMultipliersArray[1]);
pmem_read(ADDR_SENSITIVITY_MULTIPLIER_2, &mSensitivityMultipliersArray[2]);
printf("Sensitivity multiplier [2]: %f", mSensitivityMultipliersArray[2]);
pmem_read(ADDR_SENSITIVITY_MULTIPLIER_3, &mSensitivityMultipliersArray[3]);
printf("Sensitivity multiplier [3]: %f", mSensitivityMultipliersArray[3]);
pmem_read(ADDR_SENSITIVITY_MULTIPLIER_4, &mSensitivityMultipliersArray[4]);
printf("Sensitivity multiplier [4]: %f", mSensitivityMultipliersArray[4]);
pmem_read(ADDR_SENSITIVITY_MULTIPLIER_5, &mSensitivityMultipliersArray[5]);
printf("Sensitivity multiplier [5]: %f", mSensitivityMultipliersArray[5]);
pmem_read(ADDR_SENSITIVITY_MULTIPLIER_6, &mSensitivityMultipliersArray[6]);
printf("Sensitivity multiplier [6]: %f", mSensitivityMultipliersArray[6]);
pmem_read(ADDR_DEADZONE_X, &mDeadzoneX);
printf("Deadzone X: %f", mDeadzoneX);
pmem_read(ADDR_DEADZONE_Y, &mDeadzoneY);
printf("Deadzone Y: %f", mDeadzoneY);
pmem_read(ADDR_DEADZONE_D, &mDeadzoneD);
printf("Deadzone D: %f", mDeadzoneD);
pmem_read(ADDR_OUTER_DEADZONE, &mOuterDeadzone);
printf("Outer Deadzone: %f", mOuterDeadzone);
pmem_read(ADDR_INNER_DEADZONE, &mInnerDeadzone);
printf("Inner Deadzone: %f", mInnerDeadzone);
pmem_read(ADDR_CALIBRATION_DELAY, &mCalibrationDelay);
printf("Calibration Delay: %d", mCalibrationDelay);
pmem_read(ADDR_CALIBRATION_SAMPLES, &mCalibrationSamples);
printf("Calibration Samples: %d", mCalibrationSamples);
FetchCalibration();
// Load Keyboard maping to Console
const uint8 kmap[] = { 0xE2, 0x00, 0x2B, 0x01, 0x29, 0x02, 0x08, 0x03, 0x09, 0x05, 0x14, 0x06, 0x10, 0x07, 0xE1, 0x08, 0x52, 0x09, 0x51, 0x0A, 0x50, 0x0B, 0x4F, 0x0C, 0x1E, 0x09, 0x20, 0x0A, 0x21, 0x0B, 0x1F, 0x0C, 0x0A, 0x0D, 0x06, 0x0E, 0x2C, 0x0F, 0x15, 0x10, 0x23, 0x11, 0x04, 0x97, 0x07, 0x17, 0x1A, 0x98, 0x16, 0x18, 0x3A, 0x26, 0x3B, 0x27, 0x3C, 0x28, 0x3D, 0x29 };
keymapping(kmap);
// Load MOUSE maping to Console
const uint8 mmap[] = { 0x00, 0x1D, 0x01, 0x1E, 0x06, 0x05, 0x08, 0x0D, 0x02, 0x0B, 0x03, 0x0C, 0x07, 0x0E, 0x04, 0x04, 0x05, 0x07 };
mousemapping(mmap);
// Load Controller maping to Console Block
const uint8 cmap[] = { 0x17, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A };
remapper(cmap);
}
main
{
ResetLeds();
ActivateIncreaseSensitivity(event_release(PADDLE_1) );
IncreaseSensitivity();
ActivateDecreaseSensitivity(event_release(PADDLE_2) );
DecreaseSensitivity();
ActivateCalibration(get_val(PADDLE_4)> 0.0 );
Calibrate();
Debug();
ToggleAlwaysOn(get_val(PADDLE_3) > 0.0 && get_prev(BUTTON_13) == 0.0 && get_actual(BUTTON_13) > 0.0);
ToggleMotionAiming(get_val(PADDLE_3) > 0.0 && get_prev(BUTTON_12) == 0.0 && get_actual(BUTTON_12) > 0.0);
MotionAiming(mIsMotionAimingOn && !mIsActivatedCalibrating && !mIsActivatedDebugging &&
(abs(get_val(STICK_1_X)) <= mDeadzoneX && (abs(get_val(STICK_1_Y)) <= mDeadzoneY)) &&
(mIsAlwaysOn ||
(mIsActivateL1 && (get_val(BUTTON_7) > 98.0)) ||
(mIsActivateL2 && (get_val(BUTTON_8) > 98.0)) ||
(mIsActivateR1 && (get_val(BUTTON_4) > 98.0)) ||
(mIsActivateR2 && (get_val(BUTTON_5) > 98.0))));
AddInnerDeadzone();
AddOuterDeadzone();
MimicTouch(get_val(BUTTON_2) > 90.0 && GetPadType() != PAD_PS4);
set_val(ACCEL_1_X, stick_response(ACCEL_1_X));
set_val(ACCEL_1_Y, stick_response(ACCEL_1_Y));
}
void ResetLeds()
{
if(mIsActivatedLeds)
{
if(mTimeCounter > LED_DELAY)
{
led_reset();
mTimeCounter = 0;
}
else
{
mTimeCounter += elapsed_time();
}
}
}
void ActivateIncreaseSensitivity(bool aIsActivated)
{
if(aIsActivated)
{
if(mSensitivityMultiplierIndex < 6) //increase sensivity multiplier
mIsActivatedIncreaseSensitivity = TRUE;
else
{
SetLeds(7);
mIsActivatedLeds = TRUE;
}
}
}
void IncreaseSensitivity()
{
if(mIsActivatedIncreaseSensitivity)
{
mSensitivityMultiplierIndex = mSensitivityMultiplierIndex + 1;
SetLeds(mSensitivityMultiplierIndex+1);
SaveSensitivityIndex();
mIsActivatedIncreaseSensitivity = FALSE;
mIsActivatedLeds = TRUE;
}
}
void ActivateDecreaseSensitivity(bool aIsActivated)
{
if(aIsActivated)
{
if(mSensitivityMultiplierIndex > 0) //decrease sensivity multiplier
mIsActivatedDecreaseSensitivity = TRUE;
else
{
SetLeds(0);
mIsActivatedLeds = TRUE;
}
}
}
void DecreaseSensitivity()
{
if(mIsActivatedDecreaseSensitivity)
{
mSensitivityMultiplierIndex = mSensitivityMultiplierIndex - 1;
SetLeds(mSensitivityMultiplierIndex+1);
SaveSensitivityIndex();
mIsActivatedDecreaseSensitivity = FALSE;
mIsActivatedLeds = TRUE;
}
}
void ActivateCalibration(bool aIsActivated)
{
if(aIsActivated && !mIsActivatedCalibrating)
{
mCalibOffsetX = 0.0;
mCalibOffsetY = 0.0;
mCalibOffsetZ = 0.0;
mCalibrationCycleIndex = 0;
mTimeCounter = 0;
SetLeds(6);
printf("Calibration started. Delay: %d, Samples: %d", mCalibrationDelay, mCalibrationSamples);
mIsActivatedCalibrating = TRUE;
}
}
void Calibrate()
{
if(mIsActivatedCalibrating)
{
mTimeCounter += elapsed_time();
if(mTimeCounter > mCalibrationDelay)
{
SetLeds(15);
if(mCalibrationCycleIndex < mCalibrationSamples)
{
mCalibrationCycleIndex += 1;
mCalibOffsetX += get_actual(ACCEL_1_X);
mCalibOffsetZ += get_actual(ACCEL_1_Y);
}
else
{
mCalibOffsetX /= (fix32)mCalibrationSamples;
mCalibOffsetY /= (fix32)mCalibrationSamples;
mCalibOffsetZ /= (fix32)mCalibrationSamples;
StoreCalibration();
mTimeCounter = 0;
led_reset();
mIsActivatedCalibrating = FALSE;
}
}
}
}
void FetchCalibration()
{
uint8 padType = GetPadType();
pmem_load();
switch(padType)
{
case PAD_OTHER:
pmem_read(ADDR_CALIB_OTHER_X, &mCalibOffsetX);
pmem_read(ADDR_CALIB_OTHER_Y, &mCalibOffsetY);
pmem_read(ADDR_CALIB_OTHER_Z, &mCalibOffsetZ);
printf("Other gamepad calibration. X: %f, Y: %f, Z: %f", mCalibOffsetX, mCalibOffsetY, mCalibOffsetZ);
break;
case PAD_PS4:
pmem_read(ADDR_CALIB_PS4_X, &mCalibOffsetX);
pmem_read(ADDR_CALIB_PS4_Y, &mCalibOffsetY);
pmem_read(ADDR_CALIB_PS4_Z, &mCalibOffsetZ);
printf("DualShock 4 calibration. X: %f, Y: %f, Z: %f", mCalibOffsetX, mCalibOffsetY, mCalibOffsetZ);
break;
case PAD_SWITCH:
pmem_read(ADDR_CALIB_SWITCH_X, &mCalibOffsetX);
pmem_read(ADDR_CALIB_SWITCH_Y, &mCalibOffsetY);
pmem_read(ADDR_CALIB_SWITCH_Z, &mCalibOffsetZ);
printf("Pro Controller calibration. X: %f, Y: %f, Z: %f", mCalibOffsetX, mCalibOffsetY, mCalibOffsetZ);
break;
}
}
void StoreCalibration()
{
uint8 padType = GetPadType();
printf("Pad type set: %d", padType);
switch(padType)
{
case PAD_OTHER:
pmem_write(ADDR_CALIB_OTHER_X, mCalibOffsetX);
pmem_write(ADDR_CALIB_OTHER_Y, mCalibOffsetY);
pmem_write(ADDR_CALIB_OTHER_Z, mCalibOffsetZ);
printf("Stored other gamepad calibration. X: %f, Y: %f, Z: %f", mCalibOffsetX, mCalibOffsetY, mCalibOffsetZ);
break;
case PAD_PS4:
pmem_write(ADDR_CALIB_PS4_X, mCalibOffsetX);
pmem_write(ADDR_CALIB_PS4_Y, mCalibOffsetY);
pmem_write(ADDR_CALIB_PS4_Z, mCalibOffsetZ);
printf("Stored DualShock 4 calibration. X: %f, Y: %f, Z: %f", mCalibOffsetX, mCalibOffsetY, mCalibOffsetZ);
break;
case PAD_SWITCH:
pmem_write(ADDR_CALIB_SWITCH_X, mCalibOffsetX);
pmem_write(ADDR_CALIB_SWITCH_Y, mCalibOffsetY);
pmem_write(ADDR_CALIB_SWITCH_Z, mCalibOffsetZ);
printf("Stored Pro Controller calibration. X: %f, Y: %f, Z: %f", mCalibOffsetX, mCalibOffsetY, mCalibOffsetZ);
break;
}
pmem_save();
}
uint8 GetPadType()
{
uint8 status, protocol, device, i = 0;
while(i < PAD_IDS_LENGHT)
{
status = port_status(PAD_IDS[i], &protocol, &device);
if(status)
{
if(protocol == PROTOCOL_PS4)
return PAD_PS4;
else if(protocol == PROTOCOL_SWITCH)
return PAD_SWITCH;
else
return PAD_OTHER;
}
i++;
}
return(-1);
}
void Debug()
{
if(mIsActivatedCalibrating || !mIsActivatedDebugging)
return;
set_val(GYRO_1_X, (get_val(GYRO_1_X) - mCalibOffsetX) * 1000.0);
set_val(GYRO_1_Y, (get_val(GYRO_1_Y) - mCalibOffsetY) * 1000.0);
set_val(GYRO_1_Z, (get_val(GYRO_1_Z) - mCalibOffsetZ) * 1000.0);
}
void ToggleAlwaysOn(bool aIsActivated)
{
if(aIsActivated)
{
mIsAlwaysOn = !mIsAlwaysOn;
pmem_write(ADDR_ACTIVATE_ALWAYS_ON, mIsAlwaysOn);
pmem_save();
}
}
void ToggleMotionAiming(bool aIsActivated)
{
if(aIsActivated)
{
mIsMotionAimingOn = !mIsMotionAimingOn;
}
}
void MotionAiming(bool aIsActivated)
{
if(aIsActivated)
{
static fix32 accelX, accelY;
static fix32 stickX, stickY;
if(accelX != get_actual(ACCEL_1_X) || accelY != get_actual(ACCEL_1_Y))
{
accelX = get_actual(ACCEL_1_X);
accelY = get_actual(ACCEL_1_Y);
stickX = (accelX - mCalibOffsetZ) * mBaseSensitivityX * mSensitivityMultipliersArray[mSensitivityMultiplierIndex];
stickY = (accelY - mCalibOffsetX) * mBaseSensitivityY * mSensitivityMultipliersArray[mSensitivityMultiplierIndex];
fix32 signalX = (stickX < 0.0) ? (stickX = inv(stickX), -1.0) : (stickX > 0.0) ? 1.0 : 0.0;
fix32 signalY = (stickY < 0.0) ? (stickY = inv(stickY), -1.0) : (stickY > 0.0) ? 1.0 : 0.0;
fix32 angle = atan2(stickY, stickX);
stickX = clamp(((mDeadzoneX * pow(cos(angle), mDeadzoneD)) + stickX) * signalX, -100.0, 100.0);
stickY = clamp(((mDeadzoneY * pow(sin(angle), mDeadzoneD)) + stickY) * signalY, -100.0, 100.0);
}
set_val(STICK_1_X, stickX);
set_val(STICK_1_Y, stickY);
return;
}
}
void AddInnerDeadzone()
{
if(abs(get_val(STICK_1_Y)) > 5.00 && abs(get_val(STICK_1_Y)) < mInnerDeadzone)
set_val(STICK_1_Y, 0.0);
if(abs(get_val(STICK_1_X)) > 5.00 && abs(get_val(STICK_1_X)) < mInnerDeadzone)
set_val(STICK_1_X, 0.0);
}
void AddOuterDeadzone()
{
if(get_val(STICK_1_Y) <= mOuterDeadzone * -1.00)
set_val(STICK_1_Y, -100);
if(get_val(STICK_1_Y) >= mOuterDeadzone)
set_val(STICK_1_Y, 100);
if(get_val(STICK_1_X) <= mOuterDeadzone * -1.00)
set_val(STICK_1_X, -100);
if(get_val(STICK_1_X) >= mOuterDeadzone)
set_val(STICK_1_X, 100);
}
void SaveSensitivityIndex()
{
printf("Sensitivity Index: %d, Sensitivity Multiplier: %f", mSensitivityMultiplierIndex, mSensitivityMultipliersArray[mSensitivityMultiplierIndex]);
pmem_write(ADDR_SENSITIVITY_MULTIPLIER_INDEX, mSensitivityMultiplierIndex);
pmem_save();
}
void SetLeds(uint8 aLeds)
{
if(aLeds == 1)
aLeds = 0;
fix32 bits[4];
bits[0] = (aLeds & (1 << 0)) == 0 ? 0.0 : 100.0;
bits[1] = (aLeds & (1 << 1)) == 0 ? 0.0 : 100.0;
bits[2] = (aLeds & (1 << 2)) == 0 ? 0.0 : 100.0;
bits[4] = (aLeds & (1 << 3)) == 0 ? 0.0 : 100.0;
led_set(LED_1, bits[0], 800);
led_set(LED_2, bits[1], 800);
led_set(LED_3, bits[2], 800);
led_set(LED_4, bits[3], 800);
}
void MimicTouch(bool aIsActivated)
{
if(aIsActivated)
{
set_val(BUTTON_19, 100.0);
set_val(POINT_1_X, get_actual(ACCEL_1_X));
set_val(POINT_1_Y, get_actual(ACCEL_1_Y));
set_val(STICK_1_X, 0.0);
set_val(STICK_1_Y, 0.0);
}
}
fix32 stick_response(uint8 idx) {
const uint8 mxyc[] = { 0xFF, 0x01, 0x00, 0x01, 0xD4, 0x00, 0x33, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x03, 0x06, 0x09, 0x0C, 0x0F, 0x12, 0x15, 0x18, 0x1B, 0x1E, 0x21, 0x24, 0x27, 0x2A, 0x2D, 0x30, 0x33, 0x36, 0x39, 0x3C };
fix32 value = get_actual(idx);
fix32 signal = (value >= 0.0 ? 1.0 : -1.0);
value = abs(value);
return(value * signal);
}
Universal Mouse and Keboard Console with Curve Ver 1.9 Ratio 1.83 DD Factor 0.14
- Code: Select all
GIVMXYF:FF010001D40023000000000100000306090C0F1215181B1E2124272A2D303336393C
- Code: Select all
#pragma METAINFO("Universal Mouse and Keboard Console with Curve", 1, 9, "mss1988 & teddy18")
#include <switch.gph>
/*
<cfgdesc>
[Gyro Aiming Activation]
byteoffset = 0
bitsize = 8
control = checkbox
default = 0
item = On L1/LB
[Gyro Aiming Activation2]
group = true
groupcol = true
byteoffset = 1
bitsize = 8
control = checkbox
default = 0
item = On L2/LT
[Gyro Aiming Activation3]
group = true
groupcol = true
byteoffset = 2
bitsize = 8
control = checkbox
default = 0
item = On R1/RB
[Gyro Aiming Activation4]
group = true
groupcol = true
byteoffset = 3
bitsize = 8
control = checkbox
default = 0
item = On R2/RT
[Gyro Aiming Activation5]
group = true
groupcol = true
byteoffset = 4
bitsize = 8
control = checkbox
default = 1
item = Always On
[Sensitivity]
group = false
shortdesc = Base sensitivity X
byteoffset = 5
bitsize = 32
control = spinboxf
default = 100
minimum = 10
maximum = 20000
step = 1
decimals = 2
[SensitivityY]
group = true
groupcol = true
shortdesc = Base sensitivity Y
byteoffset = 9
bitsize = 32
control = spinboxf
default = 160
minimum = 10
maximum = 20000
step = 1
decimals = 2
[Sensitivity Multipliers]
group = false
groupcol = false
shortdesc = Active Sensitivity Multiplier:
byteoffset = 13
bitsize = 8
control = slider
default = 3
minimum = 1
maximum = 7
step = 1
[Sensitivity Multipliers1]
group = true
groupcol = false
shortdesc = Sensitivity Multiplier 1:
byteoffset = 14
bitsize = 32
control = spinboxf
default = 50
minimum = 10
maximum = 1000
step = 1
decimals = 2
[Sensitivity Multipliers2]
group = true
groupcol = false
shortdesc = Sensitivity Multiplier 2:
byteoffset = 18
bitsize = 32
control = spinboxf
default = 75
minimum = 10
maximum = 1000
step = 1
decimals = 2
[Sensitivity Multipliers3]
group = true
groupcol = false
shortdesc = Sensitivity Multiplier 3:
byteoffset = 22
bitsize = 32
control = spinboxf
default = 100
minimum = 10
maximum = 1000
step = 1
decimals = 2
[Sensitivity Multipliers4]
group = true
groupcol = false
shortdesc = Sensitivity Multiplier 4:
byteoffset = 26
bitsize = 32
control = spinboxf
default = 125
minimum = 10
maximum = 1000
step = 1
decimals = 2
[Sensitivity Multipliers5]
group = true
groupcol = false
shortdesc = Sensitivity Multiplier 5:
byteoffset = 30
bitsize = 32
control = spinboxf
default = 150
minimum = 10
maximum = 1000
step = 1
decimals = 2
[Sensitivity Multipliers6]
group = true
groupcol = false
shortdesc = Sensitivity Multiplier 6:
byteoffset = 34
bitsize = 32
control = spinboxf
default = 175
minimum = 10
maximum = 1000
step = 1
decimals = 2
[Sensitivity Multipliers7]
group = true
groupcol = false
shortdesc = Sensitivity Multiplier 7:
byteoffset = 38
bitsize = 32
control = spinboxf
default = 200
minimum = 10
maximum = 1000
step = 1
decimals = 2
[Deadzones]
group = false
shortdesc = Ignore Gyro if Right Stick X is greater than:
byteoffset = 42
bitsize = 32
control = spinboxf
default = 200
minimum = 0
maximum = 1000
step = 1
decimals = 1
[DeadzonesY]
group = true
groupcol = false
shortdesc = Ignore Gyro if Right Stick Y is greater than:
byteoffset = 46
bitsize = 32
control = spinboxf
default = 200
minimum = 0
maximum = 1000
step = 1
decimals = 1
[DeadzonesD]
group = true
groupcol = false
shortdesc = Right Stick Diagonal Deadzone:
byteoffset = 50
bitsize = 32
control = spinboxf
default = 38
minimum = 0
maximum = 200
step = 1
decimals = 2
[DeadzonesO]
group = true
groupcol = false
shortdesc = Right Stick Outer Deadzone:
byteoffset = 54
bitsize = 32
control = spinboxf
default = 9200
minimum = 0
maximum = 10000
step = 1
decimals = 2
[DeadzonesI]
group = true
groupcol = false
shortdesc = Right Stick Inner Deadzone:
byteoffset = 58
bitsize = 32
control = spinboxf
default = 013
minimum = 0
maximum = 10000
step = 1
decimals = 2
[Calibration]
group = false
groupcol = false
shortdesc = Delay (ms):
byteoffset = 62
bitsize = 32
control = slider
default = 3000
minimum = 500
maximum = 10000
step = 500
[CalibrationS]
group = true
groupcol = false
shortdesc = Samples:
byteoffset = 66
bitsize = 32
control = slider
default = 300
minimum = 100
maximum = 10000
step = 100
</cfgdesc>
*/
//Constants
#define PAD_OTHER 0
#define PAD_PS4 1
#define PAD_SWITCH 2
uint8 PAD_IDS[5] = { 6, 5, 4, 2, 1 };
uint8 PAD_IDS_LENGHT = 5;
//Persistent memory addereses
#define ADDR_ACTIVATE_L1 0
#define ADDR_ACTIVATE_L2 1
#define ADDR_ACTIVATE_R1 2
#define ADDR_ACTIVATE_R2 3
#define ADDR_ACTIVATE_ALWAYS_ON 4
#define ADDR_BASE_SENSITIVITY_X 5
#define ADDR_BASE_SENSITIVITY_Y 9
#define ADDR_SENSITIVITY_MULTIPLIER_INDEX 13
#define ADDR_SENSITIVITY_MULTIPLIER_0 14
#define ADDR_SENSITIVITY_MULTIPLIER_1 18
#define ADDR_SENSITIVITY_MULTIPLIER_2 22
#define ADDR_SENSITIVITY_MULTIPLIER_3 26
#define ADDR_SENSITIVITY_MULTIPLIER_4 30
#define ADDR_SENSITIVITY_MULTIPLIER_5 34
#define ADDR_SENSITIVITY_MULTIPLIER_6 38
#define ADDR_DEADZONE_X 42
#define ADDR_DEADZONE_Y 46
#define ADDR_DEADZONE_D 50
#define ADDR_OUTER_DEADZONE 54
#define ADDR_INNER_DEADZONE 58
#define ADDR_CALIBRATION_DELAY 62
#define ADDR_CALIBRATION_SAMPLES 66
#define ADDR_CALIB_PS4_X 92
#define ADDR_CALIB_PS4_Y 96
#define ADDR_CALIB_PS4_Z 100
#define ADDR_CALIB_SWITCH_X 104
#define ADDR_CALIB_SWITCH_Y 108
#define ADDR_CALIB_SWITCH_Z 116
#define ADDR_CALIB_OTHER_X 116
#define ADDR_CALIB_OTHER_Y 120
#define ADDR_CALIB_OTHER_Z 124
#define LED_DELAY 2000
//Variables
fix32 mCalibOffsetX = 0.0;
fix32 mCalibOffsetY = 0.0;
fix32 mCalibOffsetZ = 0.0;
bool mIsActivatedCalibrating = FALSE;
bool mIsActivatedIncreaseSensitivity = FALSE;
bool mIsActivatedDecreaseSensitivity = FALSE;
bool mIsActivatedLeds = FALSE;
fix32 mBaseSensitivityX = 1.0;
fix32 mBaseSensitivityY = 1.6;
uint8 mSensitivityMultiplierIndex = 2;
fix32 mSensitivityMultipliersArray[7] = { 0.5, 0.75, 1.0, 1.25, 1.5, 1.75, 2.0 };
uint32 mCalibrationDelay = 3000;
uint32 mCalibrationSamples = 300;
uint32 mCalibrationCycleIndex = 0;
fix32 mDeadzoneX = 20.0; // Deadzone GYRO_1_YZ Input
fix32 mDeadzoneY = 20.0; // Deadzone GYRO_1_YX Input
fix32 mDeadzoneD = 0.38; // Deadzone Diagonal input
fix32 mOuterDeadzone = 92.00;
fix32 mInnerDeadzone = 0.13;
bool mIsActivateL1 = FALSE;
bool mIsActivateL2 = TRUE;
bool mIsActivateR1 = FALSE;
bool mIsActivateR2 = TRUE;
bool mIsAlwaysOn = FALSE;
bool mIsMotionAimingOn = TRUE;
uint32 mTimeCounter = 0;
bool mIsActivatedDebugging = FALSE;
init
{
pmem_load();
printf("Values loaded:");
pmem_read(ADDR_ACTIVATE_L1, &mIsActivateL1);
printf("Activate L1: %d", mIsActivateL1);
pmem_read(ADDR_ACTIVATE_L2, &mIsActivateL2);
printf("Activate L2: %d", mIsActivateL2);
pmem_read(ADDR_ACTIVATE_R1, &mIsActivateR1);
printf("Activate R1: %d", mIsActivateR1);
pmem_read(ADDR_ACTIVATE_R2, &mIsActivateR2);
printf("Activate R2: %d", mIsActivateR2);
pmem_read(ADDR_ACTIVATE_ALWAYS_ON, &mIsAlwaysOn);
printf("Activate AlwaysOn: %d", mIsAlwaysOn);
pmem_read(ADDR_BASE_SENSITIVITY_X, &mBaseSensitivityX);
printf("Base sensitivity X: %f", mBaseSensitivityX);
pmem_read(ADDR_BASE_SENSITIVITY_Y, &mBaseSensitivityY);
printf("Base sensitivity Y: %f", mBaseSensitivityY);
pmem_read(ADDR_SENSITIVITY_MULTIPLIER_INDEX, &mSensitivityMultiplierIndex);
mSensitivityMultiplierIndex--;
printf("Sensitivity multiplier index: %d", mSensitivityMultiplierIndex);
pmem_read(ADDR_SENSITIVITY_MULTIPLIER_0, &mSensitivityMultipliersArray[0]);
printf("Sensitivity multiplier [0]: %f", mSensitivityMultipliersArray[0]);
pmem_read(ADDR_SENSITIVITY_MULTIPLIER_1, &mSensitivityMultipliersArray[1]);
printf("Sensitivity multiplier [1]: %f", mSensitivityMultipliersArray[1]);
pmem_read(ADDR_SENSITIVITY_MULTIPLIER_2, &mSensitivityMultipliersArray[2]);
printf("Sensitivity multiplier [2]: %f", mSensitivityMultipliersArray[2]);
pmem_read(ADDR_SENSITIVITY_MULTIPLIER_3, &mSensitivityMultipliersArray[3]);
printf("Sensitivity multiplier [3]: %f", mSensitivityMultipliersArray[3]);
pmem_read(ADDR_SENSITIVITY_MULTIPLIER_4, &mSensitivityMultipliersArray[4]);
printf("Sensitivity multiplier [4]: %f", mSensitivityMultipliersArray[4]);
pmem_read(ADDR_SENSITIVITY_MULTIPLIER_5, &mSensitivityMultipliersArray[5]);
printf("Sensitivity multiplier [5]: %f", mSensitivityMultipliersArray[5]);
pmem_read(ADDR_SENSITIVITY_MULTIPLIER_6, &mSensitivityMultipliersArray[6]);
printf("Sensitivity multiplier [6]: %f", mSensitivityMultipliersArray[6]);
pmem_read(ADDR_DEADZONE_X, &mDeadzoneX);
printf("Deadzone X: %f", mDeadzoneX);
pmem_read(ADDR_DEADZONE_Y, &mDeadzoneY);
printf("Deadzone Y: %f", mDeadzoneY);
pmem_read(ADDR_DEADZONE_D, &mDeadzoneD);
printf("Deadzone D: %f", mDeadzoneD);
pmem_read(ADDR_OUTER_DEADZONE, &mOuterDeadzone);
printf("Outer Deadzone: %f", mOuterDeadzone);
pmem_read(ADDR_INNER_DEADZONE, &mInnerDeadzone);
printf("Inner Deadzone: %f", mInnerDeadzone);
pmem_read(ADDR_CALIBRATION_DELAY, &mCalibrationDelay);
printf("Calibration Delay: %d", mCalibrationDelay);
pmem_read(ADDR_CALIBRATION_SAMPLES, &mCalibrationSamples);
printf("Calibration Samples: %d", mCalibrationSamples);
FetchCalibration();
// Load Keyboard maping to Console
const uint8 kmap[] = { 0xE2, 0x00, 0x2B, 0x01, 0x29, 0x02, 0x08, 0x03, 0x09, 0x05, 0x14, 0x06, 0x10, 0x07, 0xE1, 0x08, 0x52, 0x09, 0x51, 0x0A, 0x50, 0x0B, 0x4F, 0x0C, 0x1E, 0x09, 0x20, 0x0A, 0x21, 0x0B, 0x1F, 0x0C, 0x0A, 0x0D, 0x06, 0x0E, 0x2C, 0x0F, 0x15, 0x10, 0x23, 0x11, 0x04, 0x97, 0x07, 0x17, 0x1A, 0x98, 0x16, 0x18, 0x3A, 0x26, 0x3B, 0x27, 0x3C, 0x28, 0x3D, 0x29 };
keymapping(kmap);
// Load MOUSE maping to Console
const uint8 mmap[] = { 0x00, 0x1D, 0x01, 0x1E, 0x06, 0x05, 0x08, 0x0D, 0x02, 0x0B, 0x03, 0x0C, 0x07, 0x0E, 0x04, 0x04, 0x05, 0x07 };
mousemapping(mmap);
// Load Controller maping to Console Block
const uint8 cmap[] = { 0x17, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A, 0x2A };
remapper(cmap);
}
main
{
ResetLeds();
ActivateIncreaseSensitivity(event_release(PADDLE_1) );
IncreaseSensitivity();
ActivateDecreaseSensitivity(event_release(PADDLE_2) );
DecreaseSensitivity();
ActivateCalibration(get_val(PADDLE_4)> 0.0 );
Calibrate();
Debug();
ToggleAlwaysOn(get_val(PADDLE_3) > 0.0 && get_prev(BUTTON_13) == 0.0 && get_actual(BUTTON_13) > 0.0);
ToggleMotionAiming(get_val(PADDLE_3) > 0.0 && get_prev(BUTTON_12) == 0.0 && get_actual(BUTTON_12) > 0.0);
MotionAiming(mIsMotionAimingOn && !mIsActivatedCalibrating && !mIsActivatedDebugging &&
(abs(get_val(STICK_1_X)) <= mDeadzoneX && (abs(get_val(STICK_1_Y)) <= mDeadzoneY)) &&
(mIsAlwaysOn ||
(mIsActivateL1 && (get_val(BUTTON_7) > 98.0)) ||
(mIsActivateL2 && (get_val(BUTTON_8) > 98.0)) ||
(mIsActivateR1 && (get_val(BUTTON_4) > 98.0)) ||
(mIsActivateR2 && (get_val(BUTTON_5) > 98.0))));
AddInnerDeadzone();
AddOuterDeadzone();
MimicTouch(get_val(BUTTON_2) > 90.0 && GetPadType() != PAD_PS4);
set_val(ACCEL_1_X, stick_response(ACCEL_1_X));
set_val(ACCEL_1_Y, stick_response(ACCEL_1_Y));
}
void ResetLeds()
{
if(mIsActivatedLeds)
{
if(mTimeCounter > LED_DELAY)
{
led_reset();
mTimeCounter = 0;
}
else
{
mTimeCounter += elapsed_time();
}
}
}
void ActivateIncreaseSensitivity(bool aIsActivated)
{
if(aIsActivated)
{
if(mSensitivityMultiplierIndex < 6) //increase sensivity multiplier
mIsActivatedIncreaseSensitivity = TRUE;
else
{
SetLeds(7);
mIsActivatedLeds = TRUE;
}
}
}
void IncreaseSensitivity()
{
if(mIsActivatedIncreaseSensitivity)
{
mSensitivityMultiplierIndex = mSensitivityMultiplierIndex + 1;
SetLeds(mSensitivityMultiplierIndex+1);
SaveSensitivityIndex();
mIsActivatedIncreaseSensitivity = FALSE;
mIsActivatedLeds = TRUE;
}
}
void ActivateDecreaseSensitivity(bool aIsActivated)
{
if(aIsActivated)
{
if(mSensitivityMultiplierIndex > 0) //decrease sensivity multiplier
mIsActivatedDecreaseSensitivity = TRUE;
else
{
SetLeds(0);
mIsActivatedLeds = TRUE;
}
}
}
void DecreaseSensitivity()
{
if(mIsActivatedDecreaseSensitivity)
{
mSensitivityMultiplierIndex = mSensitivityMultiplierIndex - 1;
SetLeds(mSensitivityMultiplierIndex+1);
SaveSensitivityIndex();
mIsActivatedDecreaseSensitivity = FALSE;
mIsActivatedLeds = TRUE;
}
}
void ActivateCalibration(bool aIsActivated)
{
if(aIsActivated && !mIsActivatedCalibrating)
{
mCalibOffsetX = 0.0;
mCalibOffsetY = 0.0;
mCalibOffsetZ = 0.0;
mCalibrationCycleIndex = 0;
mTimeCounter = 0;
SetLeds(6);
printf("Calibration started. Delay: %d, Samples: %d", mCalibrationDelay, mCalibrationSamples);
mIsActivatedCalibrating = TRUE;
}
}
void Calibrate()
{
if(mIsActivatedCalibrating)
{
mTimeCounter += elapsed_time();
if(mTimeCounter > mCalibrationDelay)
{
SetLeds(15);
if(mCalibrationCycleIndex < mCalibrationSamples)
{
mCalibrationCycleIndex += 1;
mCalibOffsetX += get_actual(ACCEL_1_X);
mCalibOffsetZ += get_actual(ACCEL_1_Y);
}
else
{
mCalibOffsetX /= (fix32)mCalibrationSamples;
mCalibOffsetY /= (fix32)mCalibrationSamples;
mCalibOffsetZ /= (fix32)mCalibrationSamples;
StoreCalibration();
mTimeCounter = 0;
led_reset();
mIsActivatedCalibrating = FALSE;
}
}
}
}
void FetchCalibration()
{
uint8 padType = GetPadType();
pmem_load();
switch(padType)
{
case PAD_OTHER:
pmem_read(ADDR_CALIB_OTHER_X, &mCalibOffsetX);
pmem_read(ADDR_CALIB_OTHER_Y, &mCalibOffsetY);
pmem_read(ADDR_CALIB_OTHER_Z, &mCalibOffsetZ);
printf("Other gamepad calibration. X: %f, Y: %f, Z: %f", mCalibOffsetX, mCalibOffsetY, mCalibOffsetZ);
break;
case PAD_PS4:
pmem_read(ADDR_CALIB_PS4_X, &mCalibOffsetX);
pmem_read(ADDR_CALIB_PS4_Y, &mCalibOffsetY);
pmem_read(ADDR_CALIB_PS4_Z, &mCalibOffsetZ);
printf("DualShock 4 calibration. X: %f, Y: %f, Z: %f", mCalibOffsetX, mCalibOffsetY, mCalibOffsetZ);
break;
case PAD_SWITCH:
pmem_read(ADDR_CALIB_SWITCH_X, &mCalibOffsetX);
pmem_read(ADDR_CALIB_SWITCH_Y, &mCalibOffsetY);
pmem_read(ADDR_CALIB_SWITCH_Z, &mCalibOffsetZ);
printf("Pro Controller calibration. X: %f, Y: %f, Z: %f", mCalibOffsetX, mCalibOffsetY, mCalibOffsetZ);
break;
}
}
void StoreCalibration()
{
uint8 padType = GetPadType();
printf("Pad type set: %d", padType);
switch(padType)
{
case PAD_OTHER:
pmem_write(ADDR_CALIB_OTHER_X, mCalibOffsetX);
pmem_write(ADDR_CALIB_OTHER_Y, mCalibOffsetY);
pmem_write(ADDR_CALIB_OTHER_Z, mCalibOffsetZ);
printf("Stored other gamepad calibration. X: %f, Y: %f, Z: %f", mCalibOffsetX, mCalibOffsetY, mCalibOffsetZ);
break;
case PAD_PS4:
pmem_write(ADDR_CALIB_PS4_X, mCalibOffsetX);
pmem_write(ADDR_CALIB_PS4_Y, mCalibOffsetY);
pmem_write(ADDR_CALIB_PS4_Z, mCalibOffsetZ);
printf("Stored DualShock 4 calibration. X: %f, Y: %f, Z: %f", mCalibOffsetX, mCalibOffsetY, mCalibOffsetZ);
break;
case PAD_SWITCH:
pmem_write(ADDR_CALIB_SWITCH_X, mCalibOffsetX);
pmem_write(ADDR_CALIB_SWITCH_Y, mCalibOffsetY);
pmem_write(ADDR_CALIB_SWITCH_Z, mCalibOffsetZ);
printf("Stored Pro Controller calibration. X: %f, Y: %f, Z: %f", mCalibOffsetX, mCalibOffsetY, mCalibOffsetZ);
break;
}
pmem_save();
}
uint8 GetPadType()
{
uint8 status, protocol, device, i = 0;
while(i < PAD_IDS_LENGHT)
{
status = port_status(PAD_IDS[i], &protocol, &device);
if(status)
{
if(protocol == PROTOCOL_PS4)
return PAD_PS4;
else if(protocol == PROTOCOL_SWITCH)
return PAD_SWITCH;
else
return PAD_OTHER;
}
i++;
}
return(-1);
}
void Debug()
{
if(mIsActivatedCalibrating || !mIsActivatedDebugging)
return;
set_val(GYRO_1_X, (get_val(GYRO_1_X) - mCalibOffsetX) * 1000.0);
set_val(GYRO_1_Y, (get_val(GYRO_1_Y) - mCalibOffsetY) * 1000.0);
set_val(GYRO_1_Z, (get_val(GYRO_1_Z) - mCalibOffsetZ) * 1000.0);
}
void ToggleAlwaysOn(bool aIsActivated)
{
if(aIsActivated)
{
mIsAlwaysOn = !mIsAlwaysOn;
pmem_write(ADDR_ACTIVATE_ALWAYS_ON, mIsAlwaysOn);
pmem_save();
}
}
void ToggleMotionAiming(bool aIsActivated)
{
if(aIsActivated)
{
mIsMotionAimingOn = !mIsMotionAimingOn;
}
}
void MotionAiming(bool aIsActivated)
{
if(aIsActivated)
{
static fix32 accelX, accelY;
static fix32 stickX, stickY;
if(accelX != get_actual(ACCEL_1_X) || accelY != get_actual(ACCEL_1_Y))
{
accelX = get_actual(ACCEL_1_X);
accelY = get_actual(ACCEL_1_Y);
stickX = (accelX - mCalibOffsetZ) * mBaseSensitivityX * mSensitivityMultipliersArray[mSensitivityMultiplierIndex];
stickY = (accelY - mCalibOffsetX) * mBaseSensitivityY * mSensitivityMultipliersArray[mSensitivityMultiplierIndex];
fix32 signalX = (stickX < 0.0) ? (stickX = inv(stickX), -1.0) : (stickX > 0.0) ? 1.0 : 0.0;
fix32 signalY = (stickY < 0.0) ? (stickY = inv(stickY), -1.0) : (stickY > 0.0) ? 1.0 : 0.0;
fix32 angle = atan2(stickY, stickX);
stickX = clamp(((mDeadzoneX * pow(cos(angle), mDeadzoneD)) + stickX) * signalX, -100.0, 100.0);
stickY = clamp(((mDeadzoneY * pow(sin(angle), mDeadzoneD)) + stickY) * signalY, -100.0, 100.0);
}
set_val(STICK_1_X, stickX);
set_val(STICK_1_Y, stickY);
return;
}
}
void AddInnerDeadzone()
{
if(abs(get_val(STICK_1_Y)) > 5.00 && abs(get_val(STICK_1_Y)) < mInnerDeadzone)
set_val(STICK_1_Y, 0.0);
if(abs(get_val(STICK_1_X)) > 5.00 && abs(get_val(STICK_1_X)) < mInnerDeadzone)
set_val(STICK_1_X, 0.0);
}
void AddOuterDeadzone()
{
if(get_val(STICK_1_Y) <= mOuterDeadzone * -1.00)
set_val(STICK_1_Y, -100);
if(get_val(STICK_1_Y) >= mOuterDeadzone)
set_val(STICK_1_Y, 100);
if(get_val(STICK_1_X) <= mOuterDeadzone * -1.00)
set_val(STICK_1_X, -100);
if(get_val(STICK_1_X) >= mOuterDeadzone)
set_val(STICK_1_X, 100);
}
void SaveSensitivityIndex()
{
printf("Sensitivity Index: %d, Sensitivity Multiplier: %f", mSensitivityMultiplierIndex, mSensitivityMultipliersArray[mSensitivityMultiplierIndex]);
pmem_write(ADDR_SENSITIVITY_MULTIPLIER_INDEX, mSensitivityMultiplierIndex);
pmem_save();
}
void SetLeds(uint8 aLeds)
{
if(aLeds == 1)
aLeds = 0;
fix32 bits[4];
bits[0] = (aLeds & (1 << 0)) == 0 ? 0.0 : 100.0;
bits[1] = (aLeds & (1 << 1)) == 0 ? 0.0 : 100.0;
bits[2] = (aLeds & (1 << 2)) == 0 ? 0.0 : 100.0;
bits[4] = (aLeds & (1 << 3)) == 0 ? 0.0 : 100.0;
led_set(LED_1, bits[0], 800);
led_set(LED_2, bits[1], 800);
led_set(LED_3, bits[2], 800);
led_set(LED_4, bits[3], 800);
}
void MimicTouch(bool aIsActivated)
{
if(aIsActivated)
{
set_val(BUTTON_19, 100.0);
set_val(POINT_1_X, get_actual(ACCEL_1_X));
set_val(POINT_1_Y, get_actual(ACCEL_1_Y));
set_val(STICK_1_X, 0.0);
set_val(STICK_1_Y, 0.0);
}
}
fix32 stick_response(uint8 idx) {
const uint8 mxyc[] = { 0xFF, 0x01, 0x00, 0x01, 0xD4, 0x00, 0x23, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x03, 0x06, 0x09, 0x0C, 0x0F, 0x12, 0x15, 0x18, 0x1B, 0x1E, 0x21, 0x24, 0x27, 0x2A, 0x2D, 0x30, 0x33, 0x36, 0x39, 0x3C };
fix32 value = get_actual(idx);
fix32 signal = (value >= 0.0 ? 1.0 : -1.0);
value = abs(value);
return(value * signal);
}
-
teddy18 - Lieutenant
- Posts: 346
- Joined: Sun Jul 19, 2015 4:18 pm
Re: Universal Mouse and Keyboard Console on The fly New Vers
New Version Deadzone Shape Circle
You can Use Gtuner Or if you have the Bluetooh Modul Gtuner Air to Interactive Configuration Adjustmant Deadzone
Titan Two Settings
Set on Titan 2 800 Dpi
Set on Titan 2 Input Poling Rate 1000Hz
Set on Titan 2 Output Poling 250Hu
Mouse 500 Hz Dpi 3200 Dpi
Keyboard Controls
WASD Left Stick
Q L1/LB/L
E R1/RB/R
R Square/X/Y
F R3/RS/SR
C Circle/B/A
G Triangle/Y/X
Tap Touch Click/View /Minus/Select/Back
For Ps4 and Ps5 Hold Tap move mouse for Touch mimic
Left Shift L3/LS/SR
Spacebar Cross/A/B
ESC Options/Menu/Plus/Start
Left Alt PS/Xbox/Home/Guide
1 DPad Up
2 DPad Right
3 DPad Down
4 DPad Left
Up Arrow DPad Up
Right Arrow DPad Right
Down Arrow DPad Down
Left Arrow DPad Left
6 Share/Capture
T Push To Talk
Mouse
Left Button R2/RT /ZR
Right Button L2/LT/ZL
Button 4 Circle/B/A
Button5 Triangle/Y/X
Wheal Middel Button R3/RS/SR
Whael Up DPad Left
Wheal Donw DPad Right
[list=] [/list]
You can Use Gtuner Or if you have the Bluetooh Modul Gtuner Air to Interactive Configuration Adjustmant Deadzone
Titan Two Settings
Set on Titan 2 800 Dpi
Set on Titan 2 Input Poling Rate 1000Hz
Set on Titan 2 Output Poling 250Hu
Mouse 500 Hz Dpi 3200 Dpi
Keyboard Controls
WASD Left Stick
Q L1/LB/L
E R1/RB/R
R Square/X/Y
F R3/RS/SR
C Circle/B/A
G Triangle/Y/X
Tap Touch Click/View /Minus/Select/Back
For Ps4 and Ps5 Hold Tap move mouse for Touch mimic
Left Shift L3/LS/SR
Spacebar Cross/A/B
ESC Options/Menu/Plus/Start
Left Alt PS/Xbox/Home/Guide
1 DPad Up
2 DPad Right
3 DPad Down
4 DPad Left
Up Arrow DPad Up
Right Arrow DPad Right
Down Arrow DPad Down
Left Arrow DPad Left
6 Share/Capture
T Push To Talk
Mouse
Left Button R2/RT /ZR
Right Button L2/LT/ZL
Button 4 Circle/B/A
Button5 Triangle/Y/X
Wheal Middel Button R3/RS/SR
Whael Up DPad Left
Wheal Donw DPad Right
- Code: Select all
#pragma METAINFO("Mouse Keyboard Script Dz Shape Circle ", 1, 0, "teddy18")
#import "example-file.git"
#include "DZ.gph"
#define PAD_OTHER 0
#define PAD_PS4 1
#define PAD_PS5 2
uint8 PAD_IDS[5] = { 6, 5, 4, 2, 1 };
uint8 PAD_IDS_LENGHT = 5;
init {
remapper(example_file_cmap);
keymapping(example_file_kmap);
mousemapping(example_file_mmap);
mxyconverter(example_file_mxyc);
push_to_talk(FALSE);
}
main {
MimicTouch(get_val(BUTTON_2) > 90.0 && GetPadType() != PAD_PS4);
MimicTouch(get_val(BUTTON_2) > 90.0 && GetPadType() != PAD_PS5);
if(event_active(PADDLE_1)) {push_to_talk(TRUE);} else if(event_release(PADDLE_1)) {push_to_talk(FALSE);}
}
uint8 GetPadType()
{
uint8 status, protocol, device, i = 0;
while(i < PAD_IDS_LENGHT)
{
status = port_status(PAD_IDS[i], &protocol, &device);
if(status)
{
if(protocol == PROTOCOL_PS4)
return PAD_PS4;
else if(protocol == PROTOCOL_PS5)
return PAD_PS5;
}
i++;
}
return(-1);
}
void MimicTouch(bool aIsActivated)
{
if(aIsActivated)
{
set_val(BUTTON_19, 100.0);
set_val(POINT_1_X, get_actual(STICK_1_X));
set_val(POINT_1_Y, get_actual(STICK_1_Y));
set_val(STICK_1_X, 0.0);
set_val(STICK_1_Y, 0.0);
}
}
- Code: Select all
#ifndef DZ
#define DZ
#define init init
#define main main
/*
<cfgdesc>
[CircularDeadzoneHip]
group = false
shortdesc = Change Value of the game's circular deadzone:
byteoffset = 42
bitsize = 32
control = spinboxf
default = 0
minimum = 000
maximum = 080
step = 1
decimals = 2
[CircularDeadzoneEllipseYScaleHip]
group = false
shortdesc = Only Change Vaulu if you have after Changing CircularDeadzone problem ellipical will control width and this the height:
byteoffset = 46
bitsize = 32
control = spinboxf
default = 0
minimum = 000
maximum = 100
step = 1
decimals = 2
[SquareDeadzoneHip]
group = false
shortdesc = Change Value of the game's square/axial deadzone:
byteoffset = 50
bitsize = 32
control = spinboxf
default = 0
minimum = 000
maximum = 080
step = 1
decimals = 2
[RectangleYScaleHip]
group = false
shortdesc = Only Change Vaulu if you have after Changing SquareDeadzone problem rectangular will control width and this the height:
byteoffset = 54
bitsize = 32
control = spinboxf
default = 0
minimum = 000
maximum = 100
step = 1
decimals = 2
[degreeHip]
group = false
shortdesc = Cancel the game's linear curve to make movment Faster
byteoffset = 58
bitsize = 32
control = spinboxf
default = 100
minimum = 100
maximum = 200
step = 1
decimals = 2
[axialRestrictHip]
group = false
shortdesc = Restrict diagonal movement based on distance from the axis:
byteoffset = 62
bitsize = 32
control = spinboxf
default = 0
minimum = 000
maximum = 100
step = 1
decimals = 2
[angularRestrictHip]
group = false
shortdesc = Restrict diagonal movement based on distance from the axis:
byteoffset = 66
bitsize = 32
control = spinboxf
default = 0
minimum = 000
maximum = 090
step = 1
decimals = 2
[angularAntiHip]
group = false
shortdesc = Use to counter reticted diagonal movement around the axes based on angle:
byteoffset = 70
bitsize = 32
control = spinboxf
default = 0
minimum = 000
maximum = 090
step = 1
decimals = 2
[diagonalScaleMinHip]
group = false
shortdesc = scaling the diagonal values Mostly useful for games that don't normalize input/require reach the corners:
byteoffset = 74
bitsize = 32
control = spinboxf
default = 100
minimum = 100
maximum = 200
step = 1
decimals = 2
[diagonalScaleMaxHip]
group = false
shortdesc = scaling the diagonal values Mostly useful for games that don't normalize input/require reach the corners:
byteoffset = 78
bitsize = 32
control = spinboxf
default = 100
minimum = 100
maximum = 200
step = 1
decimals = 2
[CircularDeadzoneAds]
group = false
shortdesc = Change Value of the game's circular deadzone:
byteoffset = 82
bitsize = 32
control = spinboxf
default = 0
minimum = 000
maximum = 080
step = 1
decimals = 2
[CircularDeadzoneEllipseYScaleAds]
group = false
shortdesc = Only Change Vaulu if you have after Changing CircularDeadzone problem ellipical will control width and this the height:
byteoffset = 86
bitsize = 32
control = spinboxf
default = 0
minimum = 000
maximum = 100
step = 1
decimals = 2
[SquareDeadzoneAds]
group = false
shortdesc = Change Value of the game's square/axial deadzone:
byteoffset = 90
bitsize = 32
control = spinboxf
default = 0
minimum = 000
maximum = 080
step = 1
decimals = 2
[RectangleYScaleAds]
group = false
shortdesc = Only Change Vaulu if you have after Changing SquareDeadzone problem rectangular will control width and this the height:
byteoffset = 94
bitsize = 32
control = spinboxf
default = 0
minimum = 000
maximum = 100
step = 1
decimals = 2
[degreeAds]
group = false
shortdesc = Cancel the game's linear curve to make movment Faster
byteoffset = 98
bitsize = 32
control = spinboxf
default = 100
minimum = 100
maximum = 200
step = 1
decimals = 2
[axialRestrictAds]
group = false
shortdesc = Restrict diagonal movement based on distance from the axis:
byteoffset = 102
bitsize = 32
control = spinboxf
default = 0
minimum = 000
maximum = 100
step = 1
decimals = 2
[angularRestrictAds]
group = false
shortdesc = Restrict diagonal movement based on distance from the axis:
byteoffset = 106
bitsize = 32
control = spinboxf
default = 0
minimum = 000
maximum = 090
step = 1
decimals = 2
[angularAntiAds]
group = false
shortdesc = Use to counter reticted diagonal movement around the axes based on angle:
byteoffset = 110
bitsize = 32
control = spinboxf
default = 0
minimum = 000
maximum = 090
step = 1
decimals = 2
[diagonalScaleMinAds]
group = false
shortdesc = scaling the diagonal values Mostly useful for games that don't normalize input/require reach the corners:
byteoffset = 114
bitsize = 32
control = spinboxf
default = 100
minimum = 100
maximum = 200
step = 1
decimals = 2
[diagonalScaleMaxAds]
group = false
shortdesc = scaling the diagonal values Mostly useful for games that don't normalize input/require reach the corners:
byteoffset = 118
bitsize = 32
control = spinboxf
default = 100
minimum = 100
maximum = 200
step = 1
decimals = 2
</cfgdesc>
*/
//CHANGE BELOW VALUES
#define CircularDeadzoneHip 42
#define CircularDeadzoneEllipseYScaleHip 46
#define SquareDeadzoneHip 50
#define RectangleYScaleHip 54
#define degreeHip 58
#define axialRestrictHip 62
#define angularRestrictHip 66
#define angularAntiHip 70
#define diagonalScaleMinHip 74
#define diagonalScaleMaxHip 78
#define CircularDeadzoneAds 82
#define CircularDeadzoneEllipseYScaleAds 86
#define SquareDeadzoneAds 90
#define RectangleYScaleAds 94
#define degreeAds 98
#define axialRestrictAds 102
#define angularRestrictAds 106
#define angularAntiAds 110
#define diagonalScaleMinAds 114
#define diagonalScaleMaxAds 118
//RIGHT STICK SETTINGS
fix32 deadzone = 0.00; //Enter value of desired circular deadzone.
fix32 antiCircularDeadzone = 0.00; //Enter value of the game's circular deadzone. Common sizes are 0.2 to 0.25.
fix32 antiEllipseYScale = 0.00; //Only change if deadzone is ellipical. When changed, antiCircleDeadzone will control width and this the height.
fix32 antiSquareDeadzone = 0.00; //Enter value of the game's square/axial deadzone. Common sizes are 0.2 to 0.25.
fix32 antiRectangleYScale = 0.00; //Only change if deadzone is rectangular. When changed, antiSquareDeadzone will control the width and this the height.
fix32 outerDeadzoneIn = 1.04; //Only useful if user's stick is unable to reach certain magnitudes. 1.00 is ideal normnally.
fix32 outerDeadzoneOut = 1.00; //Enter value of the maximum range you want to limit stick output. Do not use values over 1.
fix32 degree = 1.00; //Enter value of the game's curve to cancel it into a linear curve. Larger values result in faster starting movement.
fix32 axialRestrict = 0.00; //Restrict diagonal movement based on distance from the axis.
fix32 angularRestrict = 0.00; //Restrict diagonal movement around axis based on angle.
fix32 angularAnti = 0.00; //Use to counter reticted diagonal movement around the axes based on angle.
fix32 diagonalScaleMin = 1.00; ///Use to warp lower magnitude diagonal values.
fix32 diagonalScaleMax = 1.00; //Use to warp higher magnitude diagonal values.
bool uncapValues = FALSE; //Choose if to uncap values beyond the outerDeadzone.
int8 useAlternate = 50; //Choose to use alternate settings when a button is held down.
int8 useAlternate2 = 50; //Please use values of ~42-60 to ignore buttons, or replace value of the button you'd
//like to use to switch to the alternate values below. The button values can be
//found in the leftmost column from Help > GPC Input Reference or by pressing F1.
//RIGHT STICK ALTERNATE SETTINGS
fix32 deadzoneA = 0.00;
fix32 antiCircularDeadzoneA = 0.00;
fix32 antiEllipseYScaleA = 0.00;
fix32 antiSquareDeadzoneA = 0.00;
fix32 antiRectangleYScaleA = 0.00;
fix32 outerDeadzoneInA = 1.04;
fix32 outerDeadzoneOutA = 1.00;
fix32 degreeA = 1.00;
fix32 axialRestrictA = 0.00;
fix32 angularRestrictA = 0.00;
fix32 angularAntiA = 0.00;
fix32 diagonalScaleMinA = 1.00;
fix32 diagonalScaleMaxA = 1.00;
bool uncapValuesA = FALSE;
//RIGHT STICK ALTERNATE 2 SETTINGS
fix32 deadzoneA2 = 0.00;
fix32 antiCircularDeadzoneA2 = 0.00;
fix32 antiEllipseYScaleA2 = 0.00;
fix32 antiSquareDeadzoneA2 = 0.00;
fix32 antiRectangleYScaleA2 = 0.00;
fix32 outerDeadzoneInA2 = 1.00;
fix32 outerDeadzoneOutA2 = 1.00;
fix32 degreeA2 = 1.00;
fix32 axialRestrictA2 = 0.00;
fix32 angularRestrictA2 = 0.00;
fix32 angularAntiA2 = 0.00;
fix32 diagonalScaleMinA2 = 1.00;
fix32 diagonalScaleMaxA2 = 1.00;
bool uncapValuesA2 = FALSE;
fix32 stickRX, stickRY;
init
{
pmem_load();
printf("Values loaded:");
pmem_read(CircularDeadzoneHip, &antiCircularDeadzone);
printf("CircularDeadzoneHip: %f", antiCircularDeadzone);
pmem_read(CircularDeadzoneEllipseYScaleHip, &antiEllipseYScale);
printf("CircularDeadzoneEllipseYScaleHip: %f", antiEllipseYScale);
pmem_read(SquareDeadzoneHip, &antiSquareDeadzone);
printf("SquareDeadzoneHip: %f", antiSquareDeadzone);
pmem_read(RectangleYScaleHip, &antiRectangleYScale);
printf("RectangleYScaleHip: %f", antiRectangleYScale);
pmem_read(degreeHip, °ree);
printf("degreeHip: %f", degree);
pmem_read(axialRestrictHip, &axialRestrict);
printf("axialRestrictHip: %f", axialRestrict);
pmem_read(angularRestrictHip, &angularRestrict);
printf("angularRestrictHip: %f", angularRestrict);
pmem_read(angularAntiHip, &angularAnti);
printf("angularAntiHip: %f", angularAnti);
pmem_read(diagonalScaleMinHip, &diagonalScaleMin);
printf("diagonalScaleMinHip: %f", diagonalScaleMin);
pmem_read(diagonalScaleMaxHip, &diagonalScaleMax);
printf("diagonalScaleMaxHip: %f", diagonalScaleMax);
pmem_read(CircularDeadzoneAds, &antiCircularDeadzoneA);
printf("CircularDeadzoneAds: %f", antiCircularDeadzoneA);
pmem_read(CircularDeadzoneEllipseYScaleAds, &antiEllipseYScaleA);
printf("CircularDeadzoneEllipseYScaleAds: %f", antiEllipseYScaleA);
pmem_read(SquareDeadzoneAds, &antiSquareDeadzoneA);
printf("SquareDeadzoneAds: %f", antiSquareDeadzoneA);
pmem_read(RectangleYScaleAds, &antiRectangleYScaleA);
printf("RectangleYScaleAds: %f", antiRectangleYScaleA);
pmem_read(degreeAds, °reeA);
printf("degreeAds: %f", degreeA);
pmem_read(angularRestrictAds, &angularRestrictA);
printf("angularRestrictAds: %f", angularRestrictA);
pmem_read(angularAntiAds, &angularAntiA);
printf("angularAntiAds: %f", angularAntiA);
pmem_read(diagonalScaleMinAds, &diagonalScaleMinA);
printf("diagonalScaleMinAds: %f", diagonalScaleMinA);
pmem_read(diagonalScaleMaxAds, &diagonalScaleMaxA);
printf("diagonalScaleMaxAds: %f", diagonalScaleMaxA);
}
main {
//Apply right stick settings
static fix32 prevRX, prevRY; //Magic CPU reduction variables by ME.
fix32 currRX = get_val(STICK_1_X);
fix32 currRY = get_val(STICK_1_Y);
if(prevRX != currRX || prevRY != currRY){
if(get_val(BUTTON_8) > 0.00){
applyStick(deadzoneA, antiCircularDeadzoneA, antiEllipseYScaleA, antiSquareDeadzoneA, antiRectangleYScaleA, outerDeadzoneInA, outerDeadzoneOutA, degreeA, axialRestrictA, angularRestrictA, angularAntiA, diagonalScaleMinA, diagonalScaleMaxA, uncapValuesA, 1);
}
else if(get_val(useAlternate2) > 0.00){
applyStick(deadzoneA2, antiCircularDeadzoneA2, antiEllipseYScaleA2, antiSquareDeadzoneA2, antiRectangleYScaleA2, outerDeadzoneInA2, outerDeadzoneOutA2, degreeA2, axialRestrictA2, angularRestrictA2, angularAntiA2, diagonalScaleMinA2, diagonalScaleMaxA2, uncapValuesA2, 1);
}
else{
applyStick(deadzone, antiCircularDeadzone, antiEllipseYScale, antiSquareDeadzone, antiRectangleYScale, outerDeadzoneIn, outerDeadzoneOut, degree, axialRestrict, angularRestrict, angularAnti, diagonalScaleMin, diagonalScaleMax, uncapValues, 1);
}
prevRX = currRX;
prevRY = currRY;
}
set_val(STICK_1_X, stickRX);
set_val(STICK_1_Y, stickRY);
}
void applyStick(fix32 dead, fix32 antiCDead, fix32 antiEScale, fix32 antiSDead, fix32 antiRScale, fix32 outerDeadIn, fix32 outerDeadOut, fix32 deg, fix32 axisRestrict, fix32 angleRestrict, fix32 angular, fix32 dScaleMin, fix32 dScaleMax, bool uncap, int8 stick){
fix32 x;
fix32 y;
if(stick == 1){
x = get_val(STICK_1_X)/100.0;
y = get_val(STICK_1_Y)/100.0;
}
fix32 rAngle = rad2deg(abs(atan(y/x)));
if(abs(x) < 0.0001){rAngle = 90.0;}
//Setting up axial angle deadzone values
fix32 axialX, axialY;
if(abs(x) <= axisRestrict && rAngle > 45.0){axialX = 0.0;}
else{ axialX = (abs(x) - axisRestrict)/(1.0 - axisRestrict); }
if(abs(y) <= axisRestrict && rAngle <= 45.0){axialY = 0.0;}
else{ axialY = (abs(y) - axisRestrict)/(1.0 - axisRestrict); }
fix32 inputMagnitude = sqrt(x*x + y*y);
fix32 outputMagnitude;
fix32 angle = rad2deg(abs(atan(axialY/axialX)));
if(abs(axialX) < 0.0001){angle = 90.0;} //avoids angle change with Atan by avoiding dividing by 0
//Checks if rectangular deadone is used.
if(antiRScale == 0.00){ antiRScale = antiSDead; }
//Ellipse warping
if(antiEScale > 0.00 && antiCDead > 0.00){
antiEScale = antiEScale/antiCDead;
fix32 ellipseAngle = atan((1.0/antiEScale)*tan(deg2rad(rAngle))); //Find scaled ellipse angle
if(ellipseAngle < 0.0){ellipseAngle = 1.570796;} //Capping range to avoid negative rollover
fix32 ellipseX = cos(ellipseAngle); //use cos to find horizontal alligned value
fix32 ellipseY = sqrt( sq(antiEScale)*(1.0 - sq(ellipseX)) ); //use ellipse to find vertical value
antiCDead = antiCDead*sqrt( sq(ellipseX) + sq(ellipseY)); //Find magnitude to scale antiCircleDeadzone
}
//Resizes circular antideadzone to output expected value(counters shrinkage when scaling for the square antideadzone below).
antiCDead = antiCDead/( (antiCDead*(1.0 - antiSDead/outerDeadOut) )/( antiCDead*(1.0 - antiSDead) ) );
//Angular Restriction
if(abs(x) > axisRestrict && abs(y) > axisRestrict){
if((angle > 0.0) && (angle < angleRestrict/2.0)){angle = 0.00;}
if(angle > 90.0 - angleRestrict/2.0 && angle < 90.0){angle = 90.0;}
if((angle > angleRestrict/2.0) && (angle < (90.0 - angleRestrict/2.0))){
angle = ((angle - angleRestrict/2.0)*(90.0))/((90.0 - angleRestrict/2.0) - angleRestrict/2.0);
}
}
fix32 refAngle = angle;
if(refAngle < 0.001){refAngle = 0.0;}
//Diagonal ScalePrep
fix32 diagonal = angle;
if(diagonal > 45.0){
diagonal = (((diagonal - 45.0)*(-45.0))/(45.0)) + 45.0;
}
//Angular Restriction Countering
if(angle < 90.0 && angle > 0.0){
angle = ((angle - 0.0)*((90.0 - (angular/2.0)) - (angular/2.0)))/(90.0) + (angular/2.0);
}
//Flipping angles back to correct quadrant
if(axialX < 0.0 && axialY > 0.0){angle = -angle;}
if(axialX > 0.0 && axialY < 0.0){angle = angle - 180.0;}
if(axialX < 0.0 && axialY < 0.0){angle = angle + 180.0;}
//~~~~~~~~~~Deadzone wrap~~~~~~~~~~~~~~~~~~//
if(inputMagnitude > dead){
outputMagnitude = (inputMagnitude - dead)/(outerDeadIn - dead);
//Circular antideadzone scaling
outputMagnitude = ((pow(outputMagnitude, (1.0/deg))*(outerDeadOut - antiCDead) + antiCDead));
//Capping max range
if(outputMagnitude > outerDeadOut && !uncap){
outputMagnitude = outerDeadOut;
}
//Diagonal Scale
fix32 dScale = (((outputMagnitude - antiCDead)*(dScaleMax - dScaleMin))/(outerDeadOut - antiCDead)) + dScaleMin;
fix32 cScale = (((diagonal - 0.0)*(1.0/sqrt(2.0)))/(45.0)); //Both these lines scale the intensity of the warping
cScale = 1.0 - sqrt(1.0 - cScale*cScale); //based on a circular curve to the perfect diagonal
dScale = (((cScale - 0.0)*(dScale - 1.0))/(.29289)) + 1.0;
outputMagnitude = outputMagnitude*dScale;
//Scaling values for square antideadzone
fix32 newX = cos(deg2rad(angle))*outputMagnitude;
fix32 newY = sin(deg2rad(angle))*outputMagnitude;
//Magic angle wobble fix by user ME.
if (angle > 45.0 && angle < 225.0) {
newX = inv(sin(deg2rad(angle - 90.0)))*outputMagnitude;
newY = inv(cos(deg2rad(angle - 270.0)))*outputMagnitude;
}
//Square antideadzone scaling
fix32 outputX = abs(newX)*(1.0 - antiSDead/outerDeadOut) + antiSDead;
if(x < 0.0){outputX = outputX*(-1.0);}
if(refAngle == 90.0){outputX = 0.0;}
fix32 outputY = abs(newY)*(1.0 - antiRScale/outerDeadOut) + antiRScale;
if(y < -0.0){outputY = outputY*(-1.0);}
if(refAngle == 0.0){outputY = 0.0;}
//Output
if(stick == 1){
stickRX = clamp(outputX*100.0, -outerDeadOut*100.0, outerDeadOut*100.0);
stickRY = clamp(outputY*100.0, -outerDeadOut*100.0, outerDeadOut*100.0);
}
}
else{
if(stick == 1){
stickRX = 0.0;
stickRY = 0.0;
}
else{
}
}
}
#endif
Input TranslaterCircle Deadzone
[list=] [/list]
-
teddy18 - Lieutenant
- Posts: 346
- Joined: Sun Jul 19, 2015 4:18 pm
5 posts
• Page 1 of 1
Return to User's Script Documentation
Who is online
Users browsing this forum: No registered users and 63 guests