when it doesn't open the game window, the code gets stuck at -> GamestepDisplay("Waiting for Game to start...") I need it to recognize that and return to another function which would be -> inqueue:
loop
{
GamestepDisplay("Waiting for Game to start...")
WinActivate, League of Legends ahk_exe LeagueClientUx.exe
sleep 250
HumanClickL(470, 360) ;click Reconnect button (even if not present)
WinActivate, League of Legends (TM) Client ahk_exe League of Legends.exe
sleep 250
if QueueCheck()=1
{
goto, inqueue
}
if QueueCheck()=2
{
goto, startqueue
}
CoordMode, Mouse, Screen
mousemove, A_ScreenWidth/2, A_ScreenHeight/2
click, Right
CoordMode, Mouse, Relative
PixelSearch, ci, di, 137, 0, 137, 0, 0xceae63, 5, Fast RGB
if ErrorLevel=0
{
WinActivate, League of Legends (TM) Client ahk_exe League of Legends.exe
SleepRandom(150)
goto, ingame
}
if ErrorLevel=1
{
SleepRandom(4000)
}
}
}
Else
{
Loop
{
if QueueCheck()=1
{
goto, inqueue
}
if QueueCheck()=2
{
goto, startqueue
}
}
}
she asks me
I am trying to make an AutoHotKey script that will spam the left mouse button whenever I am holding down on the mouse, but when I release it, it stops spamming left mouse button. I have started, but it isn't working the way I want it to. I am just getting two clicks and then it stops, even when I keep holding down the mouse button. Here is my code:
while (true) {
GetKeyState, OutVar, LButton
while (OutVar = "D") {
Send {lbutton}
GetKeyState, OutVar, LButton
}
}
And this is what I am using to test the mouse clicks.
Using Send to change the state of the button interferes with GetKeyState. You can solve this by using the P mode in GetKeyState, which retrieves the physical (real) state of the key.
#InstallMouseHook
Loop {
BtnIsDown := GetKeyState("LButton", "P")
While (BtnIsDown) {
Send {LButton}
BtnIsDown := GetKeyState("LButton", "P")
}
}
Alternatively, if you don't need to send the button up event, you can just use this:
Loop {
BtnIsDown := GetKeyState("LButton")
While (BtnIsDown) {
Send {LButton Down}
BtnIsDown := GetKeyState("LButton")
}
}
Simply,
Loop {
if GetKeyState("LButton")
Send {LButton Down}
else
Break
}
return
fly := True
Start()
{
Global fly
fly := True
While (fly == True)
{
Send, {Shift down}{W down}
Sleep, 10
}
}
End()
{
Global fly
fly := False
Send, {Shift up}{W up}
}
MButton::
Send, {K}
Start()
+XButton2::
Send, {K}
End()
Return
I don't know why, but everytime i stop the program it prints a double "k" at the final and i have no clue why is this happening, could someone point me where is the error? thank you very much!! ^v^
You're missing Returns to stop code execution.
Every hotkey label is to be ended with a Return so it doesn't bleed through to something unwanted (in your case, to the next hotkey label).
Your auto-execute section is also bleeding through, but in this instance it doesn't matter, since the code-execution encounters just functions before being stopped by a hotkey label.
Also, using SendInput is recommended over just normal Send.
And wrapping K in { } does nothing for you, and it could even result in undesired behavior in special cases (read the documentation for this).
Wrapping a character in { } is only to be done for escaping characters with special meaning in a send command, such as + (shift) or ! (Alt) (also read the documentation for a full explanation on this).
Here's an example of adding those missing Returns to your script:
fly := True
return
Start()
{
Global fly
fly := True
While (fly == True)
{
SendInput, {Shift down}{W down}
Sleep, 10
}
}
End()
{
Global fly
fly := False
SendInput, {Shift up}{W up}
}
MButton::
SendInput, K
Start()
Return
+XButton2::
SendInput, K
End()
Return
When I ran the code for a drivetrain and opened serial monitor it was working, but when I powered on Arduino via dc Jack and ran the code. It was not working, because code is needed to restart after connection. I want to know that how can I solve this problem of PS2 communication and run my drivetrain without restart or starting serial monitor.
Code that I uploaded was given in this instructable
http://www.instructables.com/id/Control-anything-with-ps2-controller-and-Arduino-/
I got my answer by experimenting a lot. First thing is that you have to either restart your arduino or configure your pin after connection of ps2 to arduino. This can be done by 2 ways :
1) Restart arduino after connection by code or
2) configure again after connection
1 option you know well, i am discussing 2nd i.e configure :
as you know that you have already configured pins by function ps2x.config_gamepad();
Now you have to reconfigure it after connection of ps2 to arduino, you can use a function called reconfig_gamepad(); after read_gamepad(); in void loop.
my code for holonomic drive train is below find out comments // there are total four commented lines in code. good luck. Hope this will solve your problem also.
#include <PS2X_lib.h> //for v1.6
int dir1=13;
int dir2=11;
int dir3=9;
int dir4=7;
int pwm1=12;
int pwm2=10;
int pwm3=8;
int pwm4=6;
int value_mapped;
/******************************************************************
* set pins connected to PS2 controller:
* - 1e column: original
* - 2e colmun: Stef?
* replace pin numbers by the ones you use
******************************************************************/
#define PS2_DAT 44 //14
#define PS2_CMD 46 //15
#define PS2_SEL 48 //16
#define PS2_CLK 50 //17
/******************************************************************
* select modes of PS2 controller:
* - pressures = analog reading of push-butttons
* - rumble = motor rumbling
* uncomment 1 of the lines for each mode selection
******************************************************************/
//#define pressures true
#define pressures false
//#define rumble true
#define rumble false
PS2X ps2x; // create PS2 Controller Class
//right now, the library does NOT support hot pluggable controllers, meaning
//you must always either restart your Arduino after you connect the controller,
//or call config_gamepad(pins) again after connecting the controller.
int error = 0;
byte type = 0;
byte vibrate = 0;
void setup(){
Serial.begin(57600);
pinMode(dir1,OUTPUT);
pinMode(dir2,OUTPUT);
pinMode(dir3,OUTPUT);
pinMode(dir4,OUTPUT);
pinMode(pwm1,OUTPUT);
pinMode(pwm2,OUTPUT);
pinMode(pwm3,OUTPUT);
pinMode(pwm4,OUTPUT);
delay(1000); //added delay to give wireless ps2 module some time to startup, before configuring it
//CHANGES for v1.6 HERE!!! **************PAY ATTENTION*************
if_error_is_found: // <!---- changed here --->
//setup pins and settings: GamePad(clock, command, attention, data, Pressures?, Rumble?) check for error
error = ps2x.config_gamepad(PS2_CLK, PS2_CMD, PS2_SEL, PS2_DAT, pressures, rumble);
if(error == 0){
Serial.print("Found Controller, configured successful ");
Serial.print("pressures = ");
if (pressures)
Serial.println("true ");
else
Serial.println("false");
Serial.print("rumble = ");
if (rumble)
Serial.println("true)");
else
Serial.println("false");
Serial.println("Try out all the buttons, X will vibrate the controller, faster as you press harder;");
Serial.println("holding L1 or R1 will print out the analog stick values.");
Serial.println("Note: Go to www.billporter.info for updates and to report bugs.");
}
else if(error == 1)
{
Serial.println("No controller found, check wiring, see readme.txt to enable debug. visit www.billporter.info for troubleshooting tips");
goto if_error_is_found; // <!---- changed here --->
}
else if(error == 2)
Serial.println("Controller found but not accepting commands. see readme.txt to enable debug. Visit www.billporter.info for troubleshooting tips");
else if(error == 3)
Serial.println("Controller refusing to enter Pressures mode, may not support it. ");
// Serial.print(ps2x.Analog(1), HEX);
type = ps2x.readType();
switch(type) {
case 0:
Serial.print("Unknown Controller type found ");
break;
case 1:
Serial.print("DualShock Controller found ");
break;
case 2:
Serial.print("GuitarHero Controller found ");
break;
case 3:
Serial.print("Wireless Sony DualShock Controller found ");
break;
}
}
void loop() {
/* You must Read Gamepad to get new values and set vibration values
ps2x.read_gamepad(small motor on/off, larger motor strenght from 0-255)
if you don't enable the rumble, use ps2x.read_gamepad(); with no values
You should call this at least once a second
*/
if(error == 1) //skip loop if no controller found
return;
if(type == 2){ //Guitar Hero Controller
ps2x.read_gamepad(); //read controller
if(ps2x.ButtonPressed(GREEN_FRET))
Serial.println("Green Fret Pressed");
if(ps2x.ButtonPressed(RED_FRET))
Serial.println("Red Fret Pressed");
if(ps2x.ButtonPressed(YELLOW_FRET))
Serial.println("Yellow Fret Pressed");
if(ps2x.ButtonPressed(BLUE_FRET))
Serial.println("Blue Fret Pressed");
if(ps2x.ButtonPressed(ORANGE_FRET))
Serial.println("Orange Fret Pressed");
if(ps2x.ButtonPressed(STAR_POWER))
Serial.println("Star Power Command");
if(ps2x.Button(UP_STRUM)) //will be TRUE as long as button is pressed
Serial.println("Up Strum");
if(ps2x.Button(DOWN_STRUM))
Serial.println("DOWN Strum");
if(ps2x.Button(PSB_START)) //will be TRUE as long as button is pressed
Serial.println("Start is being held");
if(ps2x.Button(PSB_SELECT))
Serial.println("Select is being held");
if(ps2x.Button(ORANGE_FRET)) { // print stick value IF TRUE
Serial.print("Wammy Bar Position:");
Serial.println(ps2x.Analog(WHAMMY_BAR), DEC);
}
}
else { //DualShock Controller
ps2x.read_gamepad(); //read controller and set large motor to spin at 'vibrate' speed
ps2x.reconfig_gamepad(); // <!---- changed here --->
if(ps2x.Button(PSB_START)) //will be TRUE as long as button is pressed
Serial.println("Start is being held");
if(ps2x.Button(PSB_SELECT))
Serial.println("Select is being held");
if(ps2x.Button(PSB_PAD_UP)) { //will be TRUE as long as button is pressed
Serial.print("Up held this hard: ");
Serial.println(ps2x.Analog(PSAB_PAD_UP), DEC);
}
if(ps2x.Button(PSB_PAD_RIGHT)){
Serial.print("Right held this hard: ");
Serial.println(ps2x.Analog(PSAB_PAD_RIGHT), DEC);
}
if(ps2x.Button(PSB_PAD_LEFT)){
Serial.print("LEFT held this hard: ");
Serial.println(ps2x.Analog(PSAB_PAD_LEFT), DEC);
}
if(ps2x.Button(PSB_PAD_DOWN)){
Serial.print("DOWN held this hard: ");
Serial.println(ps2x.Analog(PSAB_PAD_DOWN), DEC);
}
vibrate = ps2x.Analog(PSAB_CROSS); //this will set the large motor vibrate speed based on how hard you press the blue (X) button
if (ps2x.NewButtonState()) { //will be TRUE if any button changes state (on to off, or off to on)
if(ps2x.Button(PSB_L3))
Serial.println("L3 pressed");
if(ps2x.Button(PSB_R3))
Serial.println("R3 pressed");
if(ps2x.Button(PSB_L2))
Serial.println("L2 pressed");
if(ps2x.Button(PSB_R2))
Serial.println("R2 pressed");
if(ps2x.Button(PSB_TRIANGLE))
Serial.println("Triangle pressed");
}
if(ps2x.ButtonPressed(PSB_CIRCLE)) //will be TRUE if button was JUST pressed
Serial.println("Circle just pressed");
if(ps2x.NewButtonState(PSB_CROSS)) //will be TRUE if button was JUST pressed OR released
Serial.println("X just changed");
if(ps2x.ButtonReleased(PSB_SQUARE)) //will be TRUE if button was JUST released
Serial.println("Square just released");
// if(ps2x.Button(PSB_L1) || ps2x.Button(PSB_R1)) { //print stick values if either is TRUE
Serial.println("Stick Values:");
Serial.print(ps2x.Analog(PSS_LY), DEC); //Left stick, Y axis. Other options: LX, RY, RX
//Forward Direction And BAckward Diretion
if(ps2x.Button(PSB_R1)){
if(ps2x.Analog(PSS_RY)>=0)
{
//Forward Direction
if(ps2x.Analog(PSS_RY)<127)
{
Serial.println("All MOtor Running Forward");
digitalWrite(dir1,LOW);
digitalWrite(dir2,HIGH);
digitalWrite(dir3,HIGH);
digitalWrite(dir4,LOW);
value_mapped=map(ps2x.Analog(PSS_RY),127,0,0,80);
analogWrite(pwm1,value_mapped);
analogWrite(pwm2,value_mapped);
analogWrite(pwm3,value_mapped);
analogWrite(pwm4,value_mapped);
}
//BAckward Direction
if(ps2x.Analog(PSS_RY)>=127)
{
Serial.println("All MOtor Running Backward");
digitalWrite(dir1,HIGH);
digitalWrite(dir2,LOW);
digitalWrite(dir3,LOW);
digitalWrite(dir4,HIGH);
value_mapped=map(ps2x.Analog(PSS_RY),127,255,0,80);
analogWrite(pwm1,value_mapped);
analogWrite(pwm2,value_mapped);
analogWrite(pwm3,value_mapped);
analogWrite(pwm4,value_mapped);
}
}
// LEft OR Right Direction
if(ps2x.Analog(PSS_RX)>=0)
{
//Left diretion
if(ps2x.Analog(PSS_RX)<128)
{
Serial.println("All MOtor Running Left");
digitalWrite(dir1,HIGH);
digitalWrite(dir2,HIGH);
digitalWrite(dir3,LOW);
digitalWrite(dir4,LOW);
value_mapped=map(ps2x.Analog(PSS_RX),128,0,0,80);
analogWrite(pwm1,value_mapped);
analogWrite(pwm2,value_mapped);
analogWrite(pwm3,value_mapped);
analogWrite(pwm4,value_mapped);
}
//Right Direction
if(ps2x.Analog(PSS_RX)>128)
{
Serial.println("All MOtor Running Right");
digitalWrite(dir1,LOW);
digitalWrite(dir2,LOW);
digitalWrite(dir3,HIGH);
digitalWrite(dir4,HIGH);
value_mapped=map(ps2x.Analog(PSS_RX),128,255,0,80);
analogWrite(pwm1,value_mapped);
analogWrite(pwm2,value_mapped);
analogWrite(pwm3,value_mapped);
analogWrite(pwm4,value_mapped);
}
}
//All MOtors Clock
if( (ps2x.Analog(PSS_LX)<128) )
{
Serial.println("CLOCKWISE RUNNING ALL MOTORS");
digitalWrite(dir1,LOW);
digitalWrite(dir2,LOW);
digitalWrite(dir3,LOW);
digitalWrite(dir4,LOW);
value_mapped=map(ps2x.Analog(PSS_LX),128,0,0,80);
analogWrite(pwm1,value_mapped);
analogWrite(pwm2,value_mapped);
analogWrite(pwm3,value_mapped);
analogWrite(pwm4,value_mapped);
}
//All MOtors Anti-CLockwise
if(ps2x.Analog(PSS_LX)>128)
{
Serial.println("CLOCKWISE RUNNING ALL MOTORS");
digitalWrite(dir1,HIGH);
digitalWrite(dir2,HIGH);
digitalWrite(dir3,HIGH);
digitalWrite(dir4,HIGH);
value_mapped=map(ps2x.Analog(PSS_LX),128,255,0,80);
analogWrite(pwm1,value_mapped);
analogWrite(pwm2,value_mapped);
analogWrite(pwm3,value_mapped);
analogWrite(pwm4,value_mapped);
}
}
if(ps2x.Button(PSB_L1)){
if((ps2x.Analog(PSS_LX)>=120) && (ps2x.Analog(PSS_LX)<=128)){
analogWrite(pwm1,0);
analogWrite(pwm3,0);
}
//dIAGONAL L
if(ps2x.Analog(PSS_LX)<120)
{
Serial.println("CLOCKWISE RUNNING ALL MOTORS");
digitalWrite(dir1,LOW);
digitalWrite(dir3,HIGH);
value_mapped=map(ps2x.Analog(PSS_LX),128,0,0,80);
analogWrite(pwm1,value_mapped);
analogWrite(pwm3,value_mapped);
}
//dIAGONAL R
if(ps2x.Analog(PSS_LX)>=128)
{
Serial.println("CLOCKWISE RUNNING ALL MOTORS");
digitalWrite(dir2,HIGH);
digitalWrite(dir4,LOW);
value_mapped=map(ps2x.Analog(PSS_LX),128,255,0,80);
analogWrite(pwm2,value_mapped);
analogWrite(pwm4,value_mapped);
}
}
Serial.print(",");
Serial.print(ps2x.Analog(PSS_LX), DEC);
Serial.print(",");
Serial.print(ps2x.Analog(PSS_RY), DEC);
Serial.print(",");
Serial.println(ps2x.Analog(PSS_RX), DEC);
// }
}
delay(50);
}
Here's how I did it.....
void setup()
{
Serial.begin(9600);
// retry logic to avoid a reset after power up
do
{
delay(1000);
error = ps2x.config_gamepad(13, 11, 10, 12, true, true);
if (error == 1)
Serial.println("No controller found, retry in a sec");
} while (error == 1);
if (error == 0)
{
Serial.println("Found Controller, configured successful");
Serial.println("Try out all the buttons, X will vibrate the controller, faster as you press harder;");
Serial.println("holding L1 or R1 will print out the analog stick values.");
Serial.println("Go to www.billporter.info for updates and to report bugs.");
}
else if (error == 2)
Serial.println("Controller found but not accepting commands. see readme.txt to enable debug. Visit www.billporter.info for troubleshooting tips");
else if (error == 3)
Serial.println("Controller refusing to enter Pressures mode, may not support it. ");
type = ps2x.readType();
switch (type)
{
case 0:
Serial.println("Unknown Controller type");
Here's my problem.
I wrote a little Volume Control Script to control my volume like windows do with it's Microsoft Keyboard's shortcut.
I have 3 functions. Two to controls volumes and the other one to control the Hold state of the key to continue rise or down my volume
Here's the code.
;//**************************************************
;// Volume Mouse Control
;//**************************************************
VolumeUp(p_numberToDecrease, p_holdToDecrease = true)
{
Send {Volume_Up %p_numberToDecrease%}
if(p_holdtoDecrease)
{
VolumeHoldTreatment("Up")
}
}
VolumeDown(p_numberToDecrease, p_holdToDecrease = true)
{
Send {Volume_Down %p_numberToDecrease%}
if(p_holdtoDecrease)
{
VolumeHoldTreatment("Down")
}
}
VolumeHoldTreatment(p_treatment)
{
Count := 0
Sleep 300
While GetKeyState(A_ThisHotkey,"P")
{
++Count
if(p_treatment == "Up")
{
Send {Volume_Up %Count%}
}
else
{
Send {Volume_Down %Count%}
}
Sleep 25
}
}
When I call the methods in the shortcuts like this ↓, they work correctly.
I can rise up and down my volume.
If I hold the key more then 300ms, the volume will continue rising/downing.
XButton1:: VolumeDown(1)
XButton2:: VolumeUp(1)
But When I add my mute shortcut ↓
XButton1 & XButton2:: Send {Volume_Mute}
XButton2 & XButton1:: Send {Volume_Mute}
The hold behavior don't act normaly. I need to press my Button1/2 two times to call the hold behavior. Why ?
Thanks for your help
The combinations
XButton1 & XButton2:: Send {Volume_Mute}
XButton2 & XButton1:: Send {Volume_Mute}
make XButton1 and XButton2 prefix keys. Prefix keys have a slightly different behaviour. They only fire upon release, which can't be avoided: For example, if you press XButton1, it is possible that you will press XButton2, causing the combination to be triggered. Only if you haven't pressed any additional button, XButton1:: will be triggered, and that on the other hand can't be determined before it was released.
To your VolumeHoldTreatment() function: In this case, a loop with GetKeyState() isn't necessary. A normal key will continue firing anyway when you hold it down. That's why some people are able to produce the word LOL with way too many O letters, with only three keystrokes.
Disregarding the mute function, something like this would do exactly the same:
XButton1::Send, {Volume_Down}
XButton2::Send, {Volume_Up}
Avoiding the use of a combination like XButton1 & XButton2 and therewith preventing the occurrence of prefix keys will save you a lot of trouble and can e.g. be accomplished like this:
XButton1::
if( GetKeyState("XButton2") ) {
Send, {Volume_Mute}
} else {
Send, {Volume_Down}
}
return
XButton2::
if( GetKeyState("XButton1") ) {
Send, {Volume_Mute}
} else {
Send, {Volume_Up}
}
return
This will work almost flawlessly: If you hold just one button, it will be triggered again and again, continuously sending Volume_Up or Volume_Down. As soon as you press both keys, two things will happen:
The key you pressed first will stop firing
The other key will send the {Volume_Mute}
Unfortunately, this comes with two downsides when muting: a) There will always be at least one Volume_Up or Volume_Down (even more when you take a really long time pressing the second button) sent before the {Volume_Mute} is sent. b) If you hold both keys for a long time, {Volume_Mute} will be sent over and over again; but this at least won't change the outcome.
Update:
The XButtons indeed show a strange behaviour, namely they don't keep firing when they are held down. Check out this code:
XButton1::
if( GetKeyState("XButton2", "P") ) {
SetTimer, FireVolumeUp, Off
Send, {Volume_Mute}
} else {
SetTimer, FireVolumeDown, 100
}
return
XButton1 Up::
SetTimer, FireVolumeDown, Off
return
XButton2::
if( GetKeyState("XButton1", "P") ) {
SetTimer, FireVolumeDown, Off
Send, {Volume_Mute}
} else {
SetTimer, FireVolumeUp, 100
}
return
XButton2 Up::
SetTimer, FireVolumeUp, Off
return
FireVolumeUp:
Send, {Volume_Up}
return
FireVolumeDown:
Send, {Volume_Down}
return
This has become more similar to your code, but it uses timers instead of loops, making the script able to execute other code in between timer runs. Also, I'm using XButtonN Up:: hotkeys, leading to more precision in terms of detecting the key release. The rest should be pretty self-explanatory. If you don't want the timers to wait 100 ms before their first run, add a GoSub, FireVolume... before each SetTimer.