Since the Nspire is so fast, it is hard to program responsive, but not oversensitive keyboard input. I have a solution to this! (Hopefully you can help improve it too)

From what I've seen in most Ndless programs, the bulk of the main function is in something like this:
while(!isKeyPressed(NSPIRE_KEY_ESC))
{
// Code
}If one just inserts things like if(isKeyPressed(KEY_NSPIRE_ENTER)), a single tap of the enter button may register 10 times, which is really bad if you're trying to type in numbers or words. However, if one does:
// Insert whatever value of x below
sleep(x);
if(isKeyPressed(someKey))
{
}
Then low values of x will result in input registering twice or three times, and high values of x resulting in the Nspire detecting nothing at all. I have tried this many times and couldn't find a "magic value" between the two. My new method uses a counter to see how many iterations it has gone through the while loop since the previous key press, and uses idle() instead of sleep(). A key will only register if it has been at least x iterations. In code:
// I used 5 as the minimum number of iterations here
int numIterations = 5;
while(!isKeyPressed(NSPIRE_KEY_ESC))
{
  // Optional, but saves power
  idle();
  if(isKeyPressed(someKey) && numIterations == 5)
  {
    numIterations = 0;
    // Stuff
  }
  // Prevents numIterations from going above 5
  if (numIterations < 5)
    numIterations++;
}
Does anyone have any other ideas? What do you do in your Ndless programs?

It's actually C

I don't know if there is something for key release, because that would be an event. It's hard to turn an event into a function some program calls. I have browsed the source of many Ndless programs, and all of them seem to be using isKeyPressed().

Yes, key debouncing and anti-repeat can be done by either taking into account the key only after a number of iterations, or just waiting for 100-200ms after each keypress taken into account. The waiting period can be performed by e.g. a CPU busy-wait loop, or by an idle loop until some timer expires / some interrupt fires once or several times.

That is a very good solution, the only problem I see with it is that it holds up the whole program while the key is held down which may not be desirable in some situations.

I really like your solution

That is a very good solution

Thanks 

the only problem I see with it is that it holds up the whole program while the key is held down which may not be desirable in some situations.

I can imagine that this will be problematic in games etc. but for menus or typing text I haven't yet found a better solution. (or none I think better)
For games I think you could do like the following:
(this is just an idea I have right now, never tested it)
int (key_pressed(t_key is_pressed, int* block_value)
{

    if ( *block_value < VALUE_A && isKeyPressed(is_pressed) )
         {
           *block_value += VALUE_B ;
           return 1 ;
         }
   return 0 ;
}

int main()
{

     int block_value = 0 ;
     while( SOMETHING ) //main loop
     {
            if ( key_pressed(KEY_NSPIRE_WHATEVER, &block_value)
            {
                   //do what you want
            }
             //etc.
            if ( block_value > 0 )
                   block_value -= VALUE_C ; //or any other way to reduce "block_value", can probably done in a more controlled fashion like it gets updated when an action finishes or so...
      }
      return 0 ;
}
What do you think of this?

I don't understand your code; specifically, I don't get block_value, VALUE_A, and VALUE_B.

As said it was fast written down... I thought it still comprehensible, seems not to be the case
Ok I explain it in words:

You have a "global"(it is declared in main and passed by pointer) value "block_value" which causes key_presses to be ignored
if its value is to high ( higher than "VALUE_A", who I didn't want to give a specific value, maybe that's where the confusion comes from.)

"block_value" is incremented each time a key is pressed and not ignored. (in fact, with a bit more code you could assign different "increment" values to different keys.)
Now you can decrement ( or increment) "block_value" outside the "key" function, either always in the main loop or if certain other conditions are meet.

Basically this method, or something similar gives you a fine grained control (as may be needed in games where there can be a lot of factors) if a key results in an action or not.


I wonder right now if my english is more understandable...lol.

In case now passed seconds is the single factor, there is a Clock in the nspire.

int key_pressed(t_key is_pressed)
{

if ( isKeyPressed(is_pressed) )
{
unsigned time_start = *(volatile unsigned*)0x90090000 ; //get the time when key is first pressed down
while ( *(volatile unsigned*)0x90090000 < time_start+SECONDS_TO_WAIT && isKeyPressed(is_pressed) )  //compare additionally to the current time
{
//loop to prevent more than one reaction per key-press or per "SECONDS_TO_WAIT" seconds.
}
return 1 ;
}
else
return 0 ;

}
I hope this code is understandable

Ndless's wait_no_key_pressed() and any_key_pressed() may also help you: http://hackspire.unsads.com/wiki/index.php/Libndls#Keyboard
You can have a look at the keypad testing program in arm/tests of Ndless source code.

No, you need to get through your if-list.
Anyway if such a function returned the key code, wouldn't you also need to use all these if? Also several key can be pressed at a time, so this couldn't really be done.