Simulate Keyboard Input

[Mahmod Ohner]

Iwas wondering how can I simulate a key depression in C++. Such as having code that when I run the program it presses the letter "W" key. I don't want to be displaying it in a console window I just want it to display the "W" key every time I click on a text field. Thanks!

Maybe you would be interested in the SCAN codes as well, not just in ASCII. SCAN codes can even tell (and simulate) when the key is downpressed, but also when that key is actually released. SCAN codes are usually followed as well by the ASCII codes in the "input buffer".Here, about the "input buffer" (which is actually a FIFO list in RAM):How to clear input buffer in C?

EDIT: the machine to receive the input should not require any specific software installed or network access. I need to use a physical USB cable and the destination machine should react as if a physical keyboard is present on that USB port.

You could use a Raspberry Pi Zero in USB gadget mode. In this mode, the Raspberry Pi can behave as many standard USB devices (keyboard, mouse, mass storage, etc.) and you will then be able to e.g. "inject" keystrokes from a program running on the Pi (and you can then control this program remotely as you see fit).

The Raspberry Pi Zero is not the only device allowing this; but it's cheap, it's easy to get one, and there are many documentations out there explaining how to do this, so it's (IMHO) a pretty good starting point for a project like this!

The host computer sends commands to the Teensy through the UART bridge. The Teensy pretends it is a keyboard and presses virtual buttons on the other PC. Etherkey is the software that runs on the Teensy and forwards keys from the host computer to the virtual keyboard.

The USB end of the device appears as a HID keyboard to the host, and I can connect to the serial end from another computer and send it characters which will then be 'typed'. There are some special patterns to allow modifier keys. If the sending computer doesn't have a real serial port, a common USB-Serial adapter can be used with this as well, though that makes it harder to tell which end is pretending to be the keyboard.

You can use usbip to make USB devices (including a keyboard) on a host computer available as USB devices on a client computer over the network. As it's a USB device, it will be indistinguishable from any USB device attached locally.

The control program can be written in any language with that supports the manner of output that will control the "key" matrix inputs of the keyboard controller, and the usb end plug, plugs into the target computer as a usb keyboard as desired.

If using a Linux based OS, Python is likely your language of choice. If using a Windows based OS, .Net is likely your language of choice (specific flavor C#, VB is up to you). It's likely even Node.js or PHP could be used if you can control GPIO or Parallel port pins.

I'm facing the same situation (specific scenario: I need to unlock my workstation remotely from the PRE-OS BitLocker screen). I've ordered the following HW, so I'm posting this to share my research, but not my experiences

Windows Forms provides the System.Windows.Forms.SendKeys class for sending keystrokes to the active application. There are two methods to send keystrokes to an application: SendKeys.Send and SendKeys.SendWait. The difference between the two methods is that SendWait blocks the current thread when the keystroke is sent, waiting for a response, while Send doesn't. For more information about SendWait, see To send a keystroke to a different application.

Behind the scenes, SendKeys uses an older Windows implementation for sending input, which may fail on modern Windows where it's expected that the application isn't running with administrative rights. If the older implementation fails, the code automatically tries the newer Windows implementation for sending input. Additionally, when the SendKeys class uses the new implementation, the SendWait method no longer blocks the current thread when sending keystrokes to another application.

If your application relies on consistent behavior regardless of the operating system, you can force the SendKeys class to use the new implementation by adding the following application setting to your app.config file.

The following code example uses Send to simulate pressing the ALT and DOWN keys together. These keystrokes cause the ComboBox control to display its dropdown. This example assumes a Form with a Button and ComboBox.

The SendKeys.Send and SendKeys.SendWait methods send keystrokes to the active application, which is usually the application you're sending keystrokes from. To send keystrokes to another application, you first need to activate it. Because there's no managed method to activate another application, you must use native Windows methods to focus the other application. The following code example uses platform invoke to call the FindWindow and SetForegroundWindow methods to activate the Calculator application window, and then calls Send to issue a series of calculations to the Calculator application.

The following code example uses Send to simulate pressing keys into the Windows 10 Calculator application. It first searches for an application window with title of Calculator and then activates it. Once activated, the keystrokes are sent to calculate 10 plus 10.

The easiest way to simulate keyboard events is to call a method on the object that raises the event. Most events have a corresponding method that invokes them, named in the pattern of On followed by EventName, such as OnKeyPress. This option is only possible within custom controls or forms, because these methods are protected and can't be accessed from outside the context of the control or form.

As herewasplato has stated I haven't seen anything to simulate the keyboard/mouse click outside of the API. Undoubtedly it would be extremely useful particularly for those creating bots in games if such functionality existed since many games prevent any input except actual keyboard/mouse clicks. hmmmm

there is one company i know of, which have a physical interface, plugs directly into the ps/2 socket, and comes with software to "sTimulate" the way the keys are sent, that is the only real way ive seen of sending "real" keys directly to the pc.

If you know how a keyboard works its quite simple, each button press is a certain electric charge, each key is a different amount of charge, when a key is pressed, its charge is converted into scancode, there is no other way to really send scancodes without simulation, because a keyboard doesnt work that way, its the windows api which read the scancodes that have already been "understood" by the Bios and ps/2.

EDIT: of course what you could do, if you have an old keyboard, is take the buttons off, take the rubber bits away and expose the keyboard metal bits. Then if your any good with creating hardware, make a box that will sending a certain voltage thru copper wire, and a set interval (or have a switch to change the interval) and attach them directly to the keyboard itself, that really is the only way to send REAL keys without directly accessing the ps/2

Control a mouse, create a virtual keyboard and monitor keyboard input with this handy Python module.

One of the earliest Tuesday Tooling posts was a keyboard simulator but this post covers a much better implementation, that does not require root access!

Pynput is a module which can control a keyboard and mouse, or it can monitor those devices and act accordingly.

With Pynput we can have Python simulate a keypress, move the mouse to a specific point on the screen and monitor the inputs.

Hey can I make a keylogger with this?

Yes you could, but don't. Using this project to monitor a co-worker, friend or anyone else is immoral and wrong! Don't be silly, and use this tool for useful and good projects.

We import the pynput module, specific the Key and Controller classes which are used to access the keyboard. We then create an object keyboard which creates a connection from our code to the virtual keyboard. To type a sentence or paragraph we use keyboard.type().

This code will type Hello World into any open text editor. I added a pause of five second to give me chance to open the text editor window.

To press a specific key, in this case to type

I store the letters inside a list and then use a for loop to iterate over each letter, typing each letter into the open editor. Note how there is a press and release function which emulates a quick tap of the key or if used with a sleep() between them it can emulate a long press.

To use special keys such as Enter, ESC, Shift etc we need to pass the name of the key but with the Key prefix to say that we are using the keyboard. In this case I press Enter (Key.enter)at the end of each line to create a new line.

If you ever need to control the mouse using code then this is the module for you. In this example I use the randint function from random to generate random number between 0 and 1920 and 0 and 1080, using these ranges I can position the mouse at any point on my 1080p laptop screen. The random numbers generated move the mouse in a crazy pattern.

I was thinking something like On "left mouse clicked": Do action But you can substitute left mouse for right and vice versa. Or allowing a sprite to look at and turn towards the mouse, allowing the player to aim something like a gun or projectile launcher.

Well I tried coding this up but quickly hit a wall . I wanted the external script to reach into the simulator iframe and grab the game screen element. The idea was to add event listeners to get mouse events happening within it. But the iframe loads from a different domain, so the browser blocks me from accessing its content. It makes sense; that would be cross-site scripting.

I would love to see this functionality on the official live MakeCode Arcade simulator, to make text input etc. easier and more accessible! Also for text-based games and other use cases than just games, when in the browser on a reglar computer or pad/screen keyboard.

3a8082e126