What are the ascii values of up down left right?

Question

What are the ASCII values of the arrow keys? (up/down/left/right)

Answer 1

In short:

left arrow: 37
up arrow: 38
right arrow: 39
down arrow: 40

Answer 2

There is no real ascii codes for these keys as such, you will need to check out the scan codes for these keys, known as Make and Break key codes as per helppc's information. The reason the codes sounds 'ascii' is because the key codes are handled by the old BIOS interrupt 0x16 and keyboard interrupt 0x9.

                 Normal Mode            Num lock on
                 Make    Break        Make          Break
Down arrow       E0 50   E0 D0     E0 2A E0 50   E0 D0 E0 AA
Left arrow       E0 4B   E0 CB     E0 2A E0 4B   E0 CB E0 AA
Right arrow      E0 4D   E0 CD     E0 2A E0 4D   E0 CD E0 AA
Up arrow         E0 48   E0 C8     E0 2A E0 48   E0 C8 E0 AA

Hence by looking at the codes following E0 for the Make key code, such as 0x50, 0x4B, 0x4D, 0x48 respectively, that is where the confusion arise from looking at key-codes and treating them as 'ascii'... the answer is don't as the platform varies, the OS varies, under Windows it would have virtual key code corresponding to those keys, not necessarily the same as the BIOS codes, VK_UP, VK_DOWN, VK_LEFT, VK_RIGHT.. this will be found in your C++'s header file windows.h, as I recall in the SDK's include folder.

Do not rely on the key-codes to have the same 'identical ascii' codes shown here as the Operating system will reprogram the entire BIOS code in whatever the OS sees fit, naturally that would be expected because since the BIOS code is 16bit, and the OS (nowadays are 32bit protected mode), of course those codes from the BIOS will no longer be valid.

Hence the original keyboard interrupt 0x9 and BIOS interrupt 0x16 would be wiped from the memory after the BIOS loads it and when the protected mode OS starts loading, it would overwrite that area of memory and replace it with their own 32 bit protected mode handlers to deal with those keyboard scan codes.

Here is a code sample from the old days of DOS programming, using Borland C v3:

#include <bios.h>
int getKey(void){
    int key, lo, hi;
    key = bioskey(0);
    lo = key & 0x00FF;
    hi = (key & 0xFF00) >> 8;
    return (lo == 0) ? hi + 256 : lo;
}

This routine actually, returned the codes for up, down is 328 and 336 respectively, (I do not have the code for left and right actually, this is in my old cook book!) The actual scancode is found in the lo variable. Keys other than the A-Z,0-9, had a scan code of 0 via the bioskey routine.... the reason 256 is added, because variable lo has code of 0 and the hi variable would have the scan code and adds 256 on to it in order not to confuse with the 'ascii' codes...

Answer 3

Really the answer to this question depends on what operating system and programming language you are using. There is no "ASCII code" per se. The operating system detects you hit an arrow key and triggers an event that programs can capture. For example, on modern Windows machines, you would get a WM_KEYUP or WM_KEYDOWN event. It passes a 16-bit value usually to determine which key was pushed.

Answer 4

The ascii values of the:

1. Up key - 224 72

2. Down key - 224 80

3. Left key - 224 75

4. Right key - 224 77

Each of these has two integer values for ascii value, because they are special keys, as opposed to the code for $, which is simply 36. These 2 byte special keys usually have the first digit as either 224, or 0. this can be found with the F# in windows, or the delete key.

EDIT : This may actually be unicode looking back, but they do work.

Answer 5

If you're programming in OpenGL, use GLUT. The following page should help: http://www.lighthouse3d.com/opengl/glut/index.php?5

GLUT_KEY_LEFT   Left function key
GLUT_KEY_RIGHT  Right function key
GLUT_KEY_UP     Up function key
GLUT_KEY_DOWN   Down function key

void processSpecialKeys(int key, int x, int y) {

    switch(key) {
        case GLUT_KEY_F1 : 
                red = 1.0; 
                green = 0.0; 
                blue = 0.0; break;
        case GLUT_KEY_F2 : 
                red = 0.0; 
                green = 1.0; 
                blue = 0.0; break;
        case GLUT_KEY_F3 : 
                red = 0.0; 
                green = 0.0; 
                blue = 1.0; break;
    }
}

Answer 6

You can check it by compiling,and running this small C++ program.

#include <iostream>
#include <conio.h>
#include <cstdlib>

int show;
int main()
{    
while(true)
    {
    int show = getch();
    std::cout << show;
    }
getch(); // Just to keep the console open after program execution  
}

Answer 7

You can utilize the special function for activating the navigation for your programming purpose. Below is the sample code for it.

void Specialkey(int key, int x, int y)
{
    switch(key)
    {
    case GLUT_KEY_UP: 
        /*Do whatever you want*/        
        break;  
    case GLUT_KEY_DOWN: 
        /*Do whatever you want*/
        break;
    case GLUT_KEY_LEFT:
        /*Do whatever you want*/
        break;
    case GLUT_KEY_RIGHT:
        /*Do whatever you want*/
        break;
    }

    glutPostRedisplay();
}

Add this to your main function

glutSpecialFunc(Specialkey);

Hope this will to solve the problem!

Answer 8

If you're working with terminals, as I was when I found this in a search, then you'll find that the arrow keys send the corresponding cursor movement escape sequences. So in this context, UP = ^[[A DOWN = ^[[B RIGHT = ^[[C LEFT = ^[[D with ^[ being the symbol meaning escape, but you'll use the ASCII value for escape which is 27, as well as for the bracket and letter. In my case, using a serial connection to communicate these directions, for Up arrow, I sent the byte sequence 27,91,65 for ^[, [, A

Answer 9

The Ascii codes for arrow characters are the following: ↑ 24 ↓ 25 → 26 ← 27

Answer 10

I got stuck with this question and was not able to find a good solution, so decided to have some tinkering with the Mingw compiler I have. I used C++ and getch() function in <conio.h> header file and pressed the arrow keys to find what value was assigned to these keys. As it turns out, they are assigned values as 22472, 22477, 22480, 22475 for up, right, down and left keys respectively. But wait, it does not work as you would expect. You have to ditch the 224 part and write only the last two digits for the software to recognize the correct key; and as you guessed, 72, 77, 80 and 75 are all preoccupied by other characters, but this works for me and I hope it works for you as well. If you want to run the C++ code for yourself and find out the values for yourself, run this code and press enter to get out of the loop:

#include<iostream>
#include<conio.h>
using namespace std;
int main()
{
    int x;
    while(1){
        x=(int)getch();
        if(x==13){
            break;
        }
        else
            cout<<endl<<endl<<x;
    }
    return getch();
}

Answer 11

If you Come for JavaScript Purpose to get to Know which Key is Pressed.

Then there is a method of AddEventListener of JavaScript name keydown.

which give us that key which is pressed but there are certain method that you can perform on that pressed key that you get by keydown or onkeydown quite same both of them.

The Methods of pressed Key are :-

.code :- This Return a String About Which key is Pressed Like ArrowUp, ArrowDown, KeyW, Keyr and Like that .keyCode :- This Method is Depereciated but still you can use it. This return an integer like for small a ---> 65 , Capital A :- 65 mainly ASCII code means case Insensitive ArrowLeft :- 37, ArrowUp :- 38, ArrowRight :- 39 and ArrowDown :- 40

<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <meta http-equiv="X-UA-Compatible" content="IE=edge" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
  </head>
  <body>
    <h1 id="show">Press Any Button</h1>

  // JavaScript Code Starting From here See Magic By Pressing Any Buttton
  <script>
    document.addEventListener('keydown', (key)=> {
         let keycode = key.keyCode;
         document.getElementById('show').innerText = keycode;

    /*
    let keyString = key.code;
    switch(keyString){
        case "ArrowLeft":
            console.log("Left Key is Pressed");
            break;
        case "ArrowUp":
            console.log("Up Key is Pressed");
            break;
        case "ArrowRight":
            console.log("Right Key is Pressed");
            break;
        case "ArrowDown":
            console.log("Down Key is Pressed");
            break;
        default:
            console.log("Any Other Key is Pressed");
            break;
    }
    */
});
</script>

</body>
</html>

Answer 12

Can't address every operating system/situation, but for AppleScript on a Mac, it is as follows:

LEFT: 28

RIGHT: 29

UP: 30

DOWN: 31

    tell application "System Events" to keystroke (ASCII character 31) --down arrow

Answer 13

Gaa! Go to asciitable.com. The arrow keys are the control equivalent of the HJKL keys. I.e., in vi create a big block of text. Note you can move around in that text using the HJKL keys. The arrow keys are going to be ^H, ^J, ^K, ^L.

At asciitable.com find, "K" in the third column. Now, look at the same row in the first column to find the matching control-code ("VT" in this case).

Answer 14

this is what i get:

Left - 19 Up - 5 Right - 4 Down - 24

Works in Visual Fox Pro