Como usar o teclado PS2 para armazenar texto no cartão SD usando Arduino- (Parte 42/49)

As placas do microcontrolador AVR que são fornecidas com todos os circuitos básicos para a operação do microcontrolador que foi atualizado com o arduino carregador de inicialização são chamadas de placas Arduino. O arduino pode se comunicar com outros dispositivos usando E/S digital, porta serial, porta I2C, porta SPI, etc. O IDE do Arduino é tão simples de usar que qualquer pessoa que tenha conhecimento básico de programação C pode começar a usá-lo rapidamente. O projeto em como começar com o arduino explica as etapas necessárias para começar a usar uma placa Arduino.A placa Arduino usada neste projeto é a placa Arduino Pro-Mini e a versão IDE do Arduino é 1.0.3 para Windows. A placa Arduino pro-mini possui dentro dela um microcontrolador ATMEGA328 que possui uma memória EEPROM interna de 1Kb.

A imagem da placa arduino pro-mini e do arduino IDE são mostradas abaixo;

Fig. 2: Placa Arduino Pro-Mini típica

Fig. 3: Janela do software Arduino IDE

Como a placa arduino pro-mini não possui circuito para interface com a porta serial ou porta USB do PC, uma placa conversora USB para TTL externa é necessária para conectá-la ao PC. Este hardware auxilia na programação da placa arduino e também auxilia na comunicação serial com a porta USB do PC.

4: Placa conversora USB para TTL externa para programação Arduino e comunicação serial

Presume-se que o leitor tenha passado pelo projeto como começar com o arduino e experimentei todas as coisas discutidas lá.O cartão de memória usado neste projeto específico é um cartão SD de 2 GB da Transcend, mas o código deve funcionar com cartões SD de todos os fornecedores. O cartão SD opera em lógica de 3,3 V e, portanto, para fazer a interface com um microcontrolador que funciona em lógica de 5 V, deve-se usar um Conversor de Nível Lógico. Como o cartão de memória tem interface usando o barramento SPI, podem ser usados ​​os módulos conversores de nível lógico de quatro canais que estão comumente disponíveis no mercado. A imagem do módulo Logic Level Converter utilizado neste projeto é mostrada na imagem a seguir;

Fig. 5: Circuito do Módulo Conversor de Nível Lógico

O cartão de memória SD e o lado de baixa tensão do Conversor Lógico de Nível devem ser fornecidos com fonte de alimentação de 3,3V e para isso pode-se utilizar qualquer IC regulador de 3,3V. Sugere-se que um LED bicolor seja conectado nas linhas positivas de 3,3 V e MISO e MOSI do cartão SD. A imagem do cartão de memória e os circuitos necessários que foram construídos para este projeto específico são mostrados na imagem a seguir. Na imagem pode-se ver um potenciômetro que na verdade forma o circuito com um regulador variável SMD IC LM117 embaixo dele. Recomenda-se a utilização do LM1117 que é um regulador de 3,3V e que não necessita de outros componentes para ajustar a tensão conforme mostrado no diagrama de circuito deste projeto.

Fig. 6: Interface do cartão de memória SD usando Level Contoller com Arduino

A placa Arduino pro-mini possui pinos digitais marcados como 2, 3, 4 até 13. Entre os pinos digitais quatro pinos, nomeadamente 10, 11, 12 e 13, podem ser configurados como SS, MOSI, MISO e SCK. O MISO do cartão de memória deve ser conectado ao pino número 11, o MOSI deve ser conectado ao pino número 12 e o SCK deve ser conectado ao pino número 13 do Arduino pro-min. O SS do cartão SD deve ser conectado ao pino que está definido como pino SS do Arduino no código escrito. Os projetos anteriores em como fazer a interface de um cartão SD com o Arduino e como usar o cartão SD para armazenar o valor do sensor discute mais sobre os detalhes da interface do cartão SD com o Arduino.

O projeto utiliza o conector PS2 para conectar o teclado à placa Arduino. O conector PS2 possui um pino para Dados e outro pino para Relógio e usando apenas esses dois pinos o teclado se comunica com o dispositivo host. O mouse sempre possui um conector mini-DIN macho de 6 pinos para interface PS2 e o dispositivo host sempre possui o pino fêmea correspondente. As imagens e as pinagens dos conectores macho e fêmea do PS2 são mostradas na imagem a seguir, a única diferença entre os conectores de teclado e mouse do PS2 está na cor.

A imagem do pino masculino do PS2

7: Conector macho mini-DIN de 6 pinos para interface PS2

A imagem do pin feminino do PS2

Fig. 8: Plugue conector fêmea Mini DIN de 6 pinos para interface PS2

A pinagem dos conectores macho e fêmea PS2

Fig. 9: Pinagem dos conectores PS2 macho e fêmea

Quando se trata de conectar o conector fêmea à placa de circuito, deve-se conseguir identificar os pinos na parte inferior do conector PS2 e a imagem a seguir será útil.

Fig. 10: Parte inferior do conector fêmea Mini DIN para interface PS2

O código escrito para este projeto usa o arquivo de biblioteca PS2 personalizado chamado “PS2Keyboard.h” que contém todas as rotinas necessárias para acessar um mouse PS2 e os detalhes de como usar esta biblioteca para fazer interface com um teclado PS2 já foram discutidos em um projeto anterior sobre como fazer a interface do teclado PS2 com o Arduino e como conectar o teclado PS2 com LCD usando Arduino. Existem basicamente três funções que o usuário pode utilizar diretamente em seu código: “keyboard.begin ”, keyboard.available e “mouse.report(data)”.

O Arduino IDE fornece uma biblioteca chamada que possui várias funções para acessar o cartão de memória SD. A biblioteca é capaz de acessar o FAT16 ou Sistema de arquivos FAT32 do cartão SD usando o microcontrolador AVR da placa Arduino para que os arquivos possam ser lidos, modificados ou gravados. As funções usadas neste projeto específico são SD.begin , SD.open , arquivo. print , file.read e file.close da biblioteca e os detalhes sobre eles são explicados em um projeto anterior em como fazer a interface do cartão SD com o Arduino.

À medida que o código é executado, ele primeiro abre um arquivo específico para leitura e exibe todo o seu conteúdo na janela Serial Monitor. Em seguida, fecha o mesmo arquivo e o reabre no modo de gravação. Depois disso, o usuário pode digitar todo o texto no cartão de memória usando o teclado PS2 e será salvo nele. Na próxima vez que o código for executado, ele exibirá os mesmos dados que foram lidos do cartão SD junto com os dados anteriores no mesmo arquivo.

Os dados são exibidos no monitor serial janela com a ajuda das funções Serial.begin ,Serial.print e Serial.println que já foram discutidos em projetos anteriores em como fazer comunicação serial com o Arduino, como enviar e receber dados seriais usando arduino e como fazer depuração serial com o Arduino.

Antes de compilar o código certifique-se de que os arquivos “PS2Keyboard.h” e “PS2Keyboard.cpp” sejam mantidos na mesma pasta onde o arquivo .pde foi salvo. Quando a codificação estiver concluída pode-se verificar e fazer upload do código para a placa Arduino conforme explicado no projeto como começar com o Arduino.

###




/*================================= EG LABS =======================================

The demonstration of simple read write using Keyboard into the SD card

 

 The circuit:

 * SD card attached to SPI bus as follows:

 ** MOSI - pin 11

 ** MISO - pin 12

 ** CLK - pin 13

 ** CS - pin 4

 

 Keyboard:

 DATA PIN TO PIN NUMBER 8

 CLOCK PIN TO PIN NUMBER 3

============================== EG LABS ===================================*/


#include 

#include "PS2Keyboard.h"


#define DATA_PIN 8


PS2Keyboard keyboard;

File myFile;                                                                  // variable required to hold the file descriptor

const int chipSelect = 6;                                                     // the pin number which is needs to be used as a SS pin

char dat;


void setup 

{

   pinMode(9, OUTPUT);     

   Serial.begin(9600);                                                        // initialize the serial port at baud rate 9600

   Serial.print("Initializing SD card...");                                  

   pinMode(10, OUTPUT);                                      // It is a must to set the hardware SS pin as output eventhough it is not using

  

   while(!SD.begin(chipSelect));                                              // initialize the SD card

   Serial.println("card initialized.");                                       

 

   while(!(myFile = SD.open("new.txt")));                                     // open the file for reading

   while (myFile.available )                                                 // read the file till the last byte

     Serial.write(myFile.read );

   myFile.close ;                                                            // close the file


   keyboard.begin(DATA_PIN);                                                   // initialize the PS2 keyboard

   digitalWrite(9, HIGH);  

}


void loop 

{

  if(keyboard.available )

  {

    dat = keyboard.read ;                                                     // read the data from the keyboard

    

    while(!(myFile = SD.open("new.txt", FILE_WRITE)));                         // open a file for writing

    myFile.print(dat);                                                         // write the string into the file

    myFile.close ;       

    

    Serial.write(dat);

  }else;

}

//*************PS2.h**************//



#ifndef PS2Keyboard_h

#define PS2Keyboard_h

#include 

#include 

#include 


/*

 * PS2 keyboard "make" codes to check for certain keys.

 */


// Give these codes that aren't used by anything else

// Making all the control key codes above 0x80 makes it simple to check for

// printable characters at the calling level.

#define PS2_KC_BKSP    0x80

#define PS2_KC_UP      0x81

#define PS2_KC_DOWN    0x82

#define PS2_KC_LEFT    0x83

#define PS2_KC_RIGHT   0x84

#define PS2_KC_PGDN    0x85

#define PS2_KC_PGUP    0x86

#define PS2_KC_END     0x87

#define PS2_KC_HOME    0x88

#define PS2_KC_INS     0x89

#define PS2_KC_DEL     0x8A

#define PS2_KC_ESC     0x8B

#define PS2_KC_CLON    0x8C // caps_lock on

#define PS2_KC_CLOFF   0x8D // caps_lock off

#include "binary.h"

typedef uint8_t boolean;

typedef uint8_t byte;


/*

 * This PIN is hardcoded in the init routine later on. If you change this

 * make sure you change the interrupt initialization as well.

 */

#define PS2_INT_PIN 3


/**

 * Purpose: Provides an easy access to PS2 keyboards

 * Author:  Christian Weichel

 */

class PS2Keyboard {


  private:

    int  m_dataPin;

    byte m_charBuffer;


  public:

  /**

  * This constructor does basically nothing. Please call the begin(int)

  * method before using any other method of this class.

  */

  PS2Keyboard ;


    /**

     * Starts the keyboard "service" by registering the external interrupt.

     * setting the pin modes correctly and driving those needed to high.

     * The propably best place to call this method is in the setup routine.

     */

    void begin(int dataPin);


    /**

     * Returns true if there is a char to be read, false if not.

     */

    bool available ;


    /**

     * Sends a reset command to the keyboard and re-initialises all the control

     * variables within the PS2Keybaord code.

     */

    void reset ;


    /**

     * Returns the char last read from the keyboard. If the user has pressed two

     * keys between calls to this method, only the later one will be availble. Once

     * the char has been read, the buffer will be cleared.

     * If there is no char availble, 0 is returned.

     */

    byte read ;


    /**

     * Returns the status of the  key, the  key, the  key and the

     * caps_lock state. Note that shift and caps_lock are handled within the

     * Ps2Keyboard code (and the return value from read  is already modified), but

     * being able to read them here may be useful.

     * This routine is optional BUT MUST ONLY be read after available  has returned

     * true and BEFORE read  is called to retrieve the character. Reading it after

     * the call to read  will return unpredictable values.

     */

    byte read_extra ;


};


#endif

###




#include 

#include 

#include 

#include "Arduino.h"

#include "PS2Keyboard.h"


#include "binary.h"

typedef uint8_t boolean;

typedef uint8_t byte;


/*

 * I do know this is so uncool, but I just don't see a way arround it

 * REALLY BAD STUFF AHEAD

 *

 * The variables are used for internal status management of the ISR. The're

 * not kept in the object instance because the ISR has to be as fast as anyhow

 * possible. So the overhead of a CPP method call is to be avoided.

 *

 * PLEASE DO NOT REFER TO THESE VARIABLES IN YOUR CODE AS THEY MIGHT VANISH SOME

 * HAPPY DAY.

 */

int  ps2Keyboard_DataPin;

byte ps2Keyboard_CurrentBuffer;

volatile byte ps2Keyboard_CharBuffer;

volatile byte ps2Keyboard_BufferPos;


// variables used to remember information about key presses

volatile bool ps2Keyboard_shift;     // indicates shift key is pressed

volatile bool ps2Keyboard_ctrl;      // indicates the ctrl key is pressed

volatile bool ps2Keyboard_alt;       // indicates the alt key is pressed

volatile bool ps2Keyboard_extend;    // remembers a keyboard extended char received

volatile bool ps2Keyboard_release;   // distinguishes key presses from releases

volatile bool ps2Keyboard_caps_lock; // remembers shift lock has been pressed


// vairables used in sending command bytes to the keyboard, eg caps_lock light

volatile boolean cmd_in_progress;

volatile int     cmd_count;

         byte    cmd_value;

volatile byte    cmd_ack_value;

         byte    cmd_parity;

volatile boolean cmd_ack_byte_ok;


// sending command bytes to the keybaord needs proper parity (otherwise the keyboard

// just asks you to repeat the byte)

byte odd_parity(byte val) {

  int i, count = 1;  // start with 0 for even parity

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

    if (val&1) count++;

    val = val>>1;

  }

  return count & 1; // bottom bit of count is parity bit

}


void kbd_send_command(byte val) {

  // stop interrupt routine from receiving characters so that we can use it

  // to send a byte

  cmd_in_progress = true;

  cmd_count       = 0;


  // set up the byte to shift out and initialise the ack bit

  cmd_value      = val;

  cmd_ack_value  = 1;    // the kbd will clear this bit on receiving the byte

  cmd_parity     = odd_parity(val);


  // set the data pin as an output, ready for driving

  digitalWrite(ps2Keyboard_DataPin, HIGH);

  pinMode(ps2Keyboard_DataPin, OUTPUT);


  // drive clock pin low - this is going to generate the first

  // interrupt of the shifting out process

  pinMode(PS2_INT_PIN, OUTPUT);

  digitalWrite(PS2_INT_PIN, LOW);


  // wait at least one clock cycle (in case the kbd is mid transmission)

  delayMicroseconds(60);


  // set up the 0 start bit

  digitalWrite(ps2Keyboard_DataPin, LOW);

  // let go of clock - the kbd takes over driving the clock from here

  digitalWrite(PS2_INT_PIN, HIGH);

  pinMode(PS2_INT_PIN, INPUT);


  // wait for interrupt routine to shift out byte, parity and receive ack bit

  while (cmd_ack_value!=0) ;


  // switch back to the interrupt routine receiving characters from the kbd

  cmd_in_progress = false;

}


void PS2Keyboard::reset  {

  kbd_send_command(0xFF);   // send the kbd reset code to the kbd: 3 lights

                            // should flash briefly on the kbd


  // reset all the global variables

  ps2Keyboard_CurrentBuffer = 0;

  ps2Keyboard_CharBuffer    = 0;

  ps2Keyboard_BufferPos     = 0;

  ps2Keyboard_shift         = false;

  ps2Keyboard_ctrl          = false;

  ps2Keyboard_alt           = false;

  ps2Keyboard_extend        = false;

  ps2Keyboard_release       = false;

  ps2Keyboard_caps_lock     = false;

  cmd_in_progress           = false;

  cmd_count                 = 0;

  cmd_value                 = 0;

  cmd_ack_value             = 1;

}


// val : bit_2=caps_lock, bit_1=num_lock, bit_0=scroll_lock

void kbd_set_lights(byte val) {

  // When setting the lights with the 0xED command the keyboard responds

  // with an "ack byte", 0xFA. This is NOT the same as the "ack bit" that

  // follows the succesful shifting of each command byte. See this web

  // page for a good description of all this:

  // 

  cmd_ack_byte_ok = false;   // initialise the ack byte flag

  kbd_send_command(0xED);    // send the command byte

  while (!cmd_ack_byte_ok) ; // ack byte from keyboard sets this flag

  kbd_send_command(val);     // now send the data

}


// The ISR for the external interrupt

// This may look like a lot of code for an Interrupt routine, but the switch

// statements are fast and the path through the routine is only ever a few

// simple lines of code.

void ps2interrupt (void) {

  int value = digitalRead(ps2Keyboard_DataPin);


  // This is the code to send a byte to the keyboard. Actually its 12 bits:

  // a start bit, 8 data bits, 1 parity, 1 stop bit, 1 ack bit (from the kbd)

  if (cmd_in_progress) {

    cmd_count++;          // cmd_count keeps track of the shifting

    switch (cmd_count) {

    case 1: // start bit

      digitalWrite(ps2Keyboard_DataPin,LOW);

      break;

    case 2: case 3: case 4: case 5: case 6: case 7: case 8: case 9:

      // data bits to shift

      digitalWrite(ps2Keyboard_DataPin,cmd_value&1);

      cmd_value = cmd_value>>1;

      break;

    case 10:  // parity bit

      digitalWrite(ps2Keyboard_DataPin,cmd_parity);

      break;

    case 11:  // stop bit

      // release the data pin, so stop bit actually relies on pull-up

      // but this ensures the data pin is ready to be driven by the kbd for

      // for the next bit.

      digitalWrite(ps2Keyboard_DataPin, HIGH);

      pinMode(ps2Keyboard_DataPin, INPUT);

      break;

    case 12: // ack bit - driven by the kbd, so we read its value

      cmd_ack_value = digitalRead(ps2Keyboard_DataPin);

      cmd_in_progress = false;  // done shifting out

    }

    return; // don't fall through to the receive section of the ISR

  }


  // receive section of the ISR

  // shift the bits in

  if(ps2Keyboard_BufferPos > 0 && ps2Keyboard_BufferPos < 11) {

    ps2Keyboard_CurrentBuffer  = (value << (ps2Keyboard_BufferPos - 1));

  }

  ps2Keyboard_BufferPos++; // keep track of shift-in position


  if(ps2Keyboard_BufferPos == 11) { // a complete character received

    switch (ps2Keyboard_CurrentBuffer) {

    case 0xF0: { // key release char

      ps2Keyboard_release = true;

      ps2Keyboard_extend = false;

      break;

    }

    case 0xFA: { // command acknowlegde byte

      cmd_ack_byte_ok = true;

      break;

    }

    case 0xE0: { // extended char set

      ps2Keyboard_extend = true;

      break;

    }

    case 0x12:   // left shift

    case 0x59: { // right shift

      ps2Keyboard_shift = ps2Keyboard_release? false : true;

      ps2Keyboard_release = false;

      break;

    }

    case 0x11: { // alt key (right alt is extended 0x11)

      ps2Keyboard_alt = ps2Keyboard_release? false : true;

      ps2Keyboard_release = false;

      break;

    }

    case 0x14: { // ctrl key (right ctrl is extended 0x14)

      ps2Keyboard_ctrl = ps2Keyboard_release? false : true;

      ps2Keyboard_release = false;

      break;

    }

    case 0x58: { // caps lock key

      if (!ps2Keyboard_release) {

ps2Keyboard_caps_lock = ps2Keyboard_caps_lock? false : true;

// allow caps lock code through to enable light on and off

        ps2Keyboard_CharBuffer = ps2Keyboard_CurrentBuffer;

      }

      else {

ps2Keyboard_release = false;

      }

      break;

    }

    default: { // a real key

      if (ps2Keyboard_release) { // although ignore if its just released

        ps2Keyboard_release = false;

      }

      else { // real keys go into CharBuffer

        ps2Keyboard_CharBuffer = ps2Keyboard_CurrentBuffer;

      }

    }

    }

    ps2Keyboard_CurrentBuffer = 0;

    ps2Keyboard_BufferPos = 0;

  }

}


PS2Keyboard::PS2Keyboard  {

  // nothing to do here 

}


void PS2Keyboard::begin(int dataPin) {

  // Prepare the global variables

  ps2Keyboard_DataPin       = dataPin;

  ps2Keyboard_CurrentBuffer = 0;

  ps2Keyboard_CharBuffer    = 0;

  ps2Keyboard_BufferPos     = 0;

  ps2Keyboard_shift         = false;

  ps2Keyboard_ctrl          = false;

  ps2Keyboard_alt           = false;

  ps2Keyboard_extend        = false;

  ps2Keyboard_release       = false;

  ps2Keyboard_caps_lock     = false;

  cmd_in_progress           = false;

  cmd_count                 = 0;

  cmd_value                 = 0;

  cmd_ack_value             = 1;


  // initialize the pins

  pinMode(PS2_INT_PIN, INPUT);

  digitalWrite(PS2_INT_PIN, HIGH);

  pinMode(dataPin, INPUT);

  digitalWrite(dataPin, HIGH);


  attachInterrupt(1, ps2interrupt, FALLING);

#if 0

  // Global Enable INT1 interrupt

  EIMSK  = ( 1 << INT1);

  // Falling edge triggers interrupt

  EICRA  = (0 << ISC10)   (1 << ISC11);

#endif

}


bool PS2Keyboard::available  {

  return ps2Keyboard_CharBuffer != 0;

}


// This routine allows a calling program to see if other other keys are held

// down when a character is received: ie , ,  or 

// Note that this routine must be called after available  has returned true,

// but BEFORE read . The read  routine clears the buffer and allows another

// character to be received so these bits can change anytime after the read .

byte PS2Keyboard::read_extra  {

  return (ps2Keyboard_caps_lock<<3)  

         (ps2Keyboard_shift<<2)  

         (ps2Keyboard_alt<<1)  

          ps2Keyboard_ctrl;

}


byte PS2Keyboard::read  {

  byte result;


  // read the raw data from the keyboard

  result = ps2Keyboard_CharBuffer;


  // Use a switch for the code to character conversion.

  // This is fast and actually only uses 4 bytes per simple line

  switch (result) {

  case 0x1C: result="a"; break;

  case 0x32: result="b"; break;

  case 0x21: result="c"; break;

  case 0x23: result="d"; break;

  case 0x24: result="e"; break;

  case 0x2B: result="f"; break;

  case 0x34: result="g"; break;

  case 0x33: result="h"; break;

  case 0x43: result="i"; break;

  case 0x3B: result="j"; break;

  case 0x42: result="k"; break;

  case 0x4B: result="l"; break;

  case 0x3A: result="m"; break;

  case 0x31: result="n"; break;

  case 0x44: result="o"; break;

  case 0x4D: result="p"; break;

  case 0x15: result="q"; break;

  case 0x2D: result="r"; break;

  case 0x1B: result="s"; break;

  case 0x2C: result="t"; break;

  case 0x3C: result="u"; break;

  case 0x2A: result="v"; break;

  case 0x1D: result="w"; break;

  case 0x22: result="x"; break;

  case 0x35: result="y"; break;

  case 0x1A: result="z"; break;


    // note that caps lock only used on a-z

  case 0x41: result = ps2Keyboard_shift? '<' : ','; break;

  case 0x49: result = ps2Keyboard_shift? '>' : '.'; break;

  case 0x4A: result = ps2Keyboard_shift? '?' : '/'; break;

  case 0x54: result = ps2Keyboard_shift? '{' : '('; break;

  case 0x5B: result = ps2Keyboard_shift? '}' : ')'; break;

  case 0x4E: result = ps2Keyboard_shift? '_' : '-'; break;

  case 0x55: result = ps2Keyboard_shift? '+' : '='; break;

  case 0x29: result=" "; break;


  case 0x45: result = ps2Keyboard_shift? ')' : '0'; break;

  case 0x16: result = ps2Keyboard_shift? '!' : '1'; break;

  case 0x1E: result = ps2Keyboard_shift? '@' : '2'; break;

  case 0x26: result = ps2Keyboard_shift? '£' : '3'; break;

  case 0x25: result = ps2Keyboard_shift? '$' : '4'; break;

  case 0x2E: result = ps2Keyboard_shift? '%' : '5'; break;

  case 0x36: result = ps2Keyboard_shift? '^' : '6'; break;

  case 0x3D: result = ps2Keyboard_shift? '&' : '7'; break;

  case 0x3E: result = ps2Keyboard_shift? '*' : '8'; break;

  case 0x46: result = ps2Keyboard_shift? '(' : '9'; break;


  case 0x0D: result="t"; break;

  case 0x5A: result="n"; break;

  case 0x66: result = PS2_KC_BKSP;  break;

  case 0x69: result = ps2Keyboard_extend? PS2_KC_END   : '1'; break;

  case 0x6B: result = ps2Keyboard_extend? PS2_KC_LEFT  : '4'; break;

  case 0x6C: result = ps2Keyboard_extend? PS2_KC_HOME  : '7'; break;

  case 0x70: result = ps2Keyboard_extend? PS2_KC_INS   : '0'; break;

  case 0x71: result = ps2Keyboard_extend? PS2_KC_DEL   : '.'; break;

  case 0x72: result = ps2Keyboard_extend? PS2_KC_DOWN  : '2'; break;

  case 0x73: result="5"; break;

  case 0x74: result = ps2Keyboard_extend? PS2_KC_RIGHT : '6'; break;

  case 0x75: result = ps2Keyboard_extend? PS2_KC_UP    : '8'; break;

  case 0x76: result = PS2_KC_ESC; break;

  case 0x79: result="+"; break;

  case 0x7A: result = ps2Keyboard_extend? PS2_KC_PGDN  : '3'; break;

  case 0x7B: result="-"; break;

  case 0x7C: result="*"; break;

  case 0x7D: result = ps2Keyboard_extend? PS2_KC_PGUP  : '9'; break;


  case 0x58:

    // setting the keyboard lights is done here. Ideally it would be done

    // in the interrupt routine itself and the key codes associated wth

    // caps lock key presses would never be passed on as characters.

    // However it would make the interrupt routine very messy with lots

    // of extra state associated with the control of a caps_lock

    // key code causing a cmd byte to transmit, causing an ack_byte to

    // be received, then a data byte to transmit. Much easier done here.

    // The downside, however, is that the light going on or off at the

    // right time relies on the calling program to be checking for

    // characters on a regular basis. If the calling program stops

    // polling for characters at any point pressing the caps lock key

    // will not change the state of the caps lock light while polling

    // is not happening.

    result = ps2Keyboard_caps_lock? PS2_KC_CLON : PS2_KC_CLOFF;

    if (ps2Keyboard_caps_lock) kbd_set_lights(4);

    else                       kbd_set_lights(0);

    break;


    // Reset the shift counter for unexpected values, to get back into sink

    // This allows for hot plugging a keyboard in and out

  default:  delay(500); // but wait a bit in case part way through a shift

            ps2Keyboard_BufferPos  = 0;

            ps2Keyboard_shift      = false;

            ps2Keyboard_ctrl       = false;

            ps2Keyboard_alt        = false;

            ps2Keyboard_extend     = false;

            ps2Keyboard_release    = false;

            ps2Keyboard_caps_lock  = false;

  } // end switch(result)


  // shift a-z chars here (less code than in the switch statement)

  if (((result>='a') && (result<='z')) &&

      ((ps2Keyboard_shift && !ps2Keyboard_caps_lock)   

       (!ps2Keyboard_shift && ps2Keyboard_caps_lock))) {

    result = result + ('A'-'a');

  }


  // done with the character

  ps2Keyboard_CharBuffer = 0;


  return(result);

}

###

• Arduino ProMini
• LIDERADO
• Resistor