Auswertung einer 3x4 Matrix

[Hugo P. (portisch)]

Hallo!

Da ich nicht den originalen Post von Peter Dannegger verunstallten 
wollte hier meine Frage dazu.

Ich habe den Code so umgeändert um ein 3x4 Keypad einzulesen.
Es hat 3 Spalten und 4 Zeilen.
Nun habe ich aber alle Pins auf einen Port gelegt. Kann das so gehen 
oder kommt es da zum Kurzschluss?
Muss man die Richtung des Ports (Output/Input) vorher noch setzen?

/* keyboard Interface:
 * 4 rows x 3 columns: P0.0 - P0.3 * P2
 * support multiple keys pressed simultaniously
 * if more than two keys pressed, then every key need a decoupling diode
 *
 * 0x00         = no key changed
 * 0x01 .. 0x0C = key released
 * 0x81 .. 0x8C = key pressed
 */

/* P0 == PORTD
 * PD0    COL 1
 * PD1    COL 2
 * PD2    COL 3
 
 * P2 == PIND
 * PD3    ROW A 
 * PD4    ROW B
 * PD5    ROW C
 * PD6    ROW D
 */   

//#pragma cd pl(9999)
#include <avr/io.h>

#define idata
#define code

#define P0 PORTD
#define P2 PIND

#define KEY_PRESS_MASK  0x80

#define nop() \
   asm volatile ("nop")

uint8_t n_keys_pressed;        // 0, 1 or 2
static uint8_t idata valid_keys[3];    // last returned values
static uint8_t idata last_keys[3];    // t - 1


void InitKeyboard( void )
{
  uint8_t i;

  for( i = 0; i < 3; ++i ){
    valid_keys[i] = 0xFF;        // low active
    last_keys[i]  = 0xFF;
  }
  n_keys_pressed = 0;
}


uint8_t GetKey( void )    // call with debouncing time (10..200msec)
{
  uint8_t i, j;
  uint8_t mask;
  uint8_t key;
  uint8_t column;
  uint8_t key_nr = 0;
  uint8_t code ROW[] = { ~0x08, ~0x10, ~0x20, ~0x40 };    // low active

  for( i = 0; i < 4;  ++i ){

    P2 |= 0x07;
    P0 &= ROW[i];          // set rows
  
  nop();
  
    column = P2;          // read column

    if( column != valid_keys[i] && key_nr == 0 ){
      for( mask = 1, j = 0; j < 3; mask <<= 1, j++ ){

        key = column & mask;        // check bitwise

        if( key == (last_keys[i] & mask) ){    // debouncing

    if( key != (valid_keys[i] & mask) ){    // key not handled

      valid_keys[i] = valid_keys[i] & ~mask | key;
      key_nr = 3 * i + j + 1;      // 0x01 ... 0x0C

      if( key == 0 ){        // low active
        n_keys_pressed++;
        key_nr |= KEY_PRESS_MASK;      // 0x81 ... 0x8C
      }else{
        n_keys_pressed--;
      }
      break;
    }
        }
      }
    }
    last_keys[i] = column;        // for next debouncing
  }
  return key_nr;
}

Auch wie läuft das Entprellen ab? Muss ich in meiner Hauptschleife 
sozusagen dann vor jedem Aufruf von KetKey ein Delay drinnen haben?