add schematic pdfs and firmware code

Code/devterm_keyboard/README.md

@@ -0,0 +1,13 @@
+Arduino 1.8.13
+
+http://dan.drown.org/stm32duino/package_STM32duino_index.json
+
+STM32F1xx/GD32F1xx boards 
+by stm32duino version 2021.2.22
+
+  GENERIC STM32F103R series
+
+  gd32f1_generic_boot20_pc13.bin
+  generic_boot20_pc13.bin
+  
+  

Code/devterm_keyboard/devterm.h

@@ -0,0 +1,29 @@
+#ifndef DEVTERM_H
+#define DEVTERM_H
+
+
+#include <USBComposite.h>
+
+typedef struct keyboard_state{
+
+  uint8_t layer;
+  uint8_t shift;
+  uint8_t caps_lock;
+  
+}KEYBOARD_STATE;
+
+class DEVTERM {
+  public:
+    HIDKeyboard *Keyboard;
+    HIDMouse *Mouse; 
+    HIDJoystick *Joystick;
+    KEYBOARD_STATE Keyboard_state;
+    USBCompositeSerial *_Serial;
+    //if not to use USBCompositeSerial,then use default Serial
+    //**Serial and USBCompositeSerial can not use together, otherwise the keyboard firmware uploading will be dead**
+    //and you will need to find a way out to flash the stm32duino bootloader once again
+    //USBSerial *_Serial;//_Serial = &Serial;
+};
+
+
+#endif

Code/devterm_keyboard/devterm_keyboard.ino

@@ -0,0 +1,49 @@
+#include "keyboard.h"
+#include "keys.h"
+#include "trackball.h"
+#include "devterm.h"
+
+#include <USBComposite.h>
+
+#define SER_NUM_STR "20210320"
+
+USBHID HID;
+DEVTERM dev_term;
+
+void setup() {
+  USBComposite.setManufacturerString("ClockworkPI");
+  USBComposite.setProductString("DevTerm");
+  USBComposite.setSerialString(SER_NUM_STR);
+  
+  dev_term.Keyboard = new HIDKeyboard(HID);
+  dev_term.Joystick = new HIDJoystick(HID);
+  dev_term.Mouse    = new HIDMouse(HID);
+  
+  dev_term.Keyboard_state.shift = 0;
+  dev_term.Keyboard_state.layer = 0;
+  dev_term.Keyboard_state.caps_lock = 0;
+  
+  dev_term._Serial = new  USBCompositeSerial;
+  
+  HID.begin(*dev_term._Serial,HID_KEYBOARD_MOUSE_JOYSTICK);
+
+  while(!USBComposite);//wait until usb port been plugged in to PC
+  
+
+  keyboard_init(&dev_term);
+  keys_init(&dev_term);
+  trackball_init(&dev_term);
+  
+  dev_term._Serial->println("setup done");
+
+  //delay(3000);
+}
+
+void loop() {
+
+  trackball_task(&dev_term);
+  keys_task(&dev_term); //keys above keyboard
+  keyboard_task(&dev_term);
+  
+
+}

Code/devterm_keyboard/helper.h

@@ -0,0 +1,19 @@
+/*
+ * 
+
+
+
+ */
+#ifndef HELPER_H
+#define HELPER_H
+
+#include <stdint.h>
+#include <stdbool.h>
+#include <string.h>
+
+
+uint8_t read_io(uint8_t io);
+
+
+
+#endif

Code/devterm_keyboard/helper.ino

@@ -0,0 +1,11 @@
+#include "helper.h"
+
+
+uint8_t read_io(uint8_t io) {
+  
+  if(digitalRead(io) == LOW ){
+    return 0;
+  }else {
+    return 1;
+  }
+}

Code/devterm_keyboard/keyboard.h

@@ -0,0 +1,52 @@
+#ifndef KEYBOARD_H
+#define KEYBOARD_H
+
+/*
+ * clockworkpi devterm keyboard test2 
+ * able to correct scan the 8x8 keypads re-action
+ */
+
+#include "devterm.h"
+
+#include "keys_io_map.h"
+
+#include <stdint.h>
+#include <stdbool.h>
+#include <string.h>
+
+#define MATRIX_ROWS 8
+#define MATRIX_COLS 8
+
+#ifndef DEBOUNCE
+#   define DEBOUNCE 5
+#endif
+
+void init_rows();
+void init_cols();
+uint8_t read_io(uint8_t io);
+
+void matrix_init();
+uint8_t matrix_scan(void);
+
+bool matrix_is_on(uint8_t row, uint8_t col);
+uint8_t matrix_get_row(uint8_t row) ;
+
+
+//void matrix_print(void);
+
+
+
+void keyboard_task(DEVTERM*);
+void keyboard_init(DEVTERM*);
+
+
+#define KEY_PRESSED 1
+#define KEY_RELEASED 0
+
+#define KEY_PRNT_SCRN 0xCE //Print screen
+#define KEY_PAUSE  0xd0
+
+#define KEY_VOLUME_UP 0x108
+#define KEY_VOLUME_DOWN 0x109
+
+#endif

Code/devterm_keyboard/keyboard.ino

@@ -0,0 +1,188 @@
+#include "keyboard.h"
+#include "helper.h"
+
+
+static bool debouncing = false;
+static uint16_t debouncing_time = 0;
+
+uint8_t matrix_rows[ MATRIX_ROWS ]= {ROW1,ROW2,ROW3,ROW4,ROW5,ROW6,ROW7,ROW8};
+uint8_t matrix_cols[ MATRIX_COLS ] = {COL1,COL2,COL3,COL4,COL5,COL6,COL7,COL8};
+
+/* matrix state(1:on, 0:off) */
+static uint8_t matrix[MATRIX_ROWS];
+static uint8_t matrix_debouncing[MATRIX_COLS];
+static uint8_t matrix_prev[MATRIX_ROWS];
+
+static int8_t jack_idx=-1;
+static uint16_t jack_time = 0;
+
+
+
+void init_rows(){
+  int i;
+  for(i=0;i<8;i++) {
+    pinMode(matrix_rows[i],OUTPUT);
+    digitalWrite(matrix_rows[i],LOW);
+    
+    pinMode(matrix_rows[i],INPUT_PULLDOWN);  
+  }
+}
+
+void init_cols() {
+
+    int i;
+    for(i=0;i<8;i++){
+      pinMode(matrix_cols[i],OUTPUT);
+      digitalWrite(matrix_cols[i],LOW);
+    }
+}
+
+
+
+void matrix_init() {
+  init_cols();
+  init_rows();
+  
+  for (uint8_t i=0; i < MATRIX_ROWS; i++) {
+    matrix[i] = 0;
+    matrix_debouncing[i] = 0;
+    matrix_prev[i] = 0;
+  }
+
+  delay(500);
+}
+
+uint8_t matrix_scan(void) {
+
+  uint8_t data;
+  for(int col = 0; col < MATRIX_COLS;col++){
+    data = 0;
+    digitalWrite(matrix_cols[col],HIGH);
+  
+
+    delayMicroseconds(20);
+
+    data =(
+          ( read_io(matrix_rows[0]) << 0 )  |
+          ( read_io(matrix_rows[1]) << 1 )  |
+          ( read_io(matrix_rows[2]) << 2 )  |
+          ( read_io(matrix_rows[3]) << 3 )  |
+          ( read_io(matrix_rows[4]) << 4 )  |
+          ( read_io(matrix_rows[5]) << 5 )  | 
+          ( read_io(matrix_rows[6]) << 6 )  |
+          ( read_io(matrix_rows[7]) << 7 )  
+    );
+
+    digitalWrite(matrix_cols[col],LOW);
+    if (matrix_debouncing[col] != data) {
+      matrix_debouncing[col] = data;
+      debouncing = true;
+      debouncing_time = millis();
+    }
+  }
+
+  if (debouncing == true  &&  ( (millis() - debouncing_time) > DEBOUNCE )) {
+    for (int row = 0; row < MATRIX_ROWS; row++) {
+      matrix[row] = 0;
+      for (int col = 0; col < MATRIX_COLS; col++) {
+        matrix[row] |= ((matrix_debouncing[col] & (1 << row) ? 1 : 0) << col);
+        
+      }
+     }
+     debouncing = false;
+  }
+  
+  return 1;
+}
+
+
+bool matrix_is_on(uint8_t row, uint8_t col) {
+    return (matrix[row] & (1<<col));
+}
+
+
+
+uint8_t matrix_get_row(uint8_t row) {
+    return matrix[row];
+}
+
+
+void matrix_press(DEVTERM*dv,uint8_t row,uint8_t col) {
+  char buff[128];
+
+  if(matrix_is_on(row,col) == true ){
+    sprintf(buff,"%d %d M%d pressed\n",row,col,(row+1)*10+col+1);
+    dv->_Serial->print(buff);
+    keyboard_action(dv,row,col,KEY_PRESSED);
+  }
+  
+}
+
+void matrix_release(DEVTERM*dv,uint8_t row,uint8_t col) {
+  char buff[128];
+
+  
+  if(matrix_is_on(row,col) == false ){
+    sprintf(buff,"%d %d M%d released\n",row,col,(row+1)*10+col+1);
+    dv->_Serial->print(buff);
+    keyboard_action(dv,row,col,KEY_RELEASED);
+        
+  }
+  
+}
+
+void keyboard_task(DEVTERM*dv)
+{
+
+  uint8_t matrix_row = 0;
+  uint8_t matrix_change = 0;
+
+  matrix_scan();
+  for (uint8_t r = 0; r < MATRIX_ROWS; r++) {
+    matrix_row = matrix_get_row(r);
+    
+      uint8_t col_mask =1;
+      for(uint8_t c=0;c < MATRIX_COLS;c++,col_mask <<=1){
+ 
+        if( ( (matrix_prev[r] & col_mask) == 0) && ( (matrix_row & col_mask) > 0) ) {
+          matrix_press(dv,r,c);
+        }
+        
+        if( ( (matrix_prev[r] & col_mask) > 0) && ( (matrix_row & col_mask) == 0)  ) {
+
+          matrix_release(dv,r,c);
+        }
+        
+        if( ( (matrix_prev[r] & col_mask) > 0) && ( (matrix_row & col_mask) > 0)  ) {//same key
+
+          
+          if( jack_idx == -1){
+            jack_idx = r*MATRIX_ROWS+c;
+          }else{
+            
+            if(jack_idx != r*MATRIX_ROWS+c) {
+              jack_time = 0;
+              jack_idx = r*MATRIX_ROWS+c;
+            }else{              
+              jack_time +=1;
+              if( jack_time % (DEBOUNCE*20) == 0){
+                if(jack_idx > 1){//skip select,start button 
+                  matrix_press(dv,r,c);
+                }
+              } 
+            }
+          }
+        }
+      }
+      
+      matrix_prev[r] = matrix_row;
+    }
+  
+  
+}
+
+
+void keyboard_init(DEVTERM*){
+  matrix_init();
+ 
+}

Code/devterm_keyboard/keymaps.ino

@@ -0,0 +1,288 @@
+#include "devterm.h"
+#include "keyboard.h"
+#include "keys.h"
+
+#define EMP 0XFFFF
+
+/*
+B1 joystick up
+B2 joystick down
+B3 joystick left
+B4 joystick right
+
+B5 joystick A
+B6 joystick B
+B7 joystick X
+B8 joystick Y
+
+B9 left shift
+B10 Fn
+B11 left Ctrl
+B12 Cmd
+B13 left Alt
+B14 mouse left
+B15 mouse mid
+B16 mouse right
+*/
+#define _PRINT_KEY KEY_PRNT_SCRN
+#define _PAUSE_KEY KEY_PAUSE
+#define _VOLUME_M KEY_VOLUME_DOWN
+#define _VOLUME_P KEY_VOLUME_UP
+#define _LEFT_SHIFT_KEY KEY_LEFT_SHIFT 
+#define _LEFT_CTRL_KEY  KEY_LEFT_CTRL
+#define _CMD_KEY        KEY_RIGHT_GUI 
+#define _LEFT_ALT       KEY_LEFT_ALT 
+
+enum SKEYS {
+  _SELECT_KEY =0xe8,  //Joystick.button(n)
+  _START_KEY,          //Joystick.button(n)
+  _JOYSTICK_UP, //B1 //Joystick.Y()
+  _JOYSTICK_DOWN,    //Joystick.Y()
+  _JOYSTICK_LEFT,    //Joystick.X()
+  _JOYSTICK_RIGHT,   //Joystick.X()  
+  _JOYSTICK_A,       //Joystick.button(1)
+  _JOYSTICK_B,       //Joystick.button(2)
+  _JOYSTICK_X,       //Joystick.button(3)
+  _JOYSTICK_Y,       //Joystick.button(4)
+  _FN_KEY,
+  _MOUSE_LEFT,    // Mouse.press(1)
+  _MOUSE_MID,     // Mouse.press(2)
+  _MOUSE_RIGHT,   // Mouse.press(3)
+  
+
+};
+
+#define DEF_LAYER   0x00
+#define SHI_LAYER   0x01
+#define CAPS_LAYER  0x02
+#define FN_LAYER    0x03
+
+/*
+ * keyboard_maps
+ * M11 - M18
+ * M21 - M28
+ * M31 - M38
+ * M41 - M48
+ * M51 - M58
+ * M61 - M68
+ * M71 - M78
+ * M81 - M88
+ */
+const uint16_t keyboard_maps[][MATRIX_ROWS][MATRIX_COLS] = {
+  
+  [DEF_LAYER] = { _SELECT_KEY,_START_KEY,_VOLUME_M,'`','[',']','-','=', \
+    '1','2','3','4','5','6','7','8',\  
+    '9','0',KEY_ESC,KEY_TAB,KEY_UP_ARROW,KEY_DOWN_ARROW,KEY_LEFT_ARROW,KEY_RIGHT_ARROW, \
+    'q','w','e','r','t','y','u','i', \ 
+    'o','p','a','s','d','f','g','h',\  
+    'j','k','l','z','x','c','v','b', \
+    'n','m',',','.','/','\\',';','\'', \
+    KEY_BACKSPACE,KEY_RETURN,KEY_RIGHT_ALT,KEY_RIGHT_CTRL,KEY_RIGHT_SHIFT,' ',EMP,EMP},
+ 
+   [SHI_LAYER] = {_SELECT_KEY,_START_KEY,_VOLUME_P,'~','{','}','_','+', \ 
+    '!','@','#','$','%','^','&','*',\  
+    '(',')',KEY_ESC,KEY_TAB,KEY_PAGE_UP,KEY_PAGE_DOWN,KEY_HOME,KEY_END, \ 
+    'Q','W','E','R','T','Y','U','I', \ 
+    'O','P','A','S','D','F','G','H',\  
+    'J','K','L','Z','X','C','V','B', \ 
+    'N','M','<','>','?','|',':','"', \ 
+    KEY_BACKSPACE,KEY_RETURN,KEY_RIGHT_ALT,KEY_RIGHT_CTRL,KEY_RIGHT_SHIFT,' ',EMP,EMP},
+  
+  [CAPS_LAYER] = { _SELECT_KEY,_START_KEY,_VOLUME_M,'`','[',']','-','=', \ 
+    '1','2','3','4','5','6','7','8',\  
+    '9','0',KEY_ESC,KEY_TAB,KEY_UP_ARROW,KEY_DOWN_ARROW,KEY_LEFT_ARROW,KEY_RIGHT_ARROW, \ 
+    'Q','W','E','R','T','Y','U','I', \ 
+    'O','P','A','S','D','F','G','H',\  
+    'J','K','L','Z','X','C','V','B', \ 
+    'N','M',',','.','/','\\',';','\'', \ 
+    KEY_BACKSPACE,KEY_RETURN,KEY_RIGHT_ALT,KEY_RIGHT_CTRL,KEY_RIGHT_SHIFT,' ',EMP,EMP},
+
+  [FN_LAYER] = { _PRINT_KEY,_PAUSE_KEY,_VOLUME_M,'`','[',']',KEY_F11,KEY_F12, \ 
+    KEY_F1,KEY_F2,KEY_F3,KEY_F4,KEY_F5,KEY_F6,KEY_F7,KEY_F8,\  
+    KEY_F9,KEY_F10,KEY_ESC,KEY_CAPS_LOCK,KEY_UP_ARROW,KEY_DOWN_ARROW,KEY_LEFT_ARROW,KEY_RIGHT_ARROW, \ 
+    'q','w','e','r','t','y','u',KEY_INSERT, \ 
+    'o','p','a','s','d','f','g','h',\  
+    'j','k','l','z','x','c','v','b', \ 
+    'n','m',',','.','/','\\',';','\'', \ 
+    KEY_DELETE,KEY_RETURN,KEY_RIGHT_ALT,KEY_RIGHT_CTRL,KEY_RIGHT_SHIFT,' ',EMP,EMP}
+    
+  
+  
+};
+
+const uint16_t keys_maps[KEYS_NUM] = {_JOYSTICK_UP,_JOYSTICK_DOWN, _JOYSTICK_LEFT, \
+                                      _JOYSTICK_RIGHT,_JOYSTICK_A,_JOYSTICK_B, \
+                                      _JOYSTICK_X,_JOYSTICK_Y,_LEFT_SHIFT_KEY,_FN_KEY,\
+                                      _LEFT_CTRL_KEY,_CMD_KEY , _LEFT_ALT,     \
+                                      _MOUSE_LEFT,_MOUSE_MID,_MOUSE_RIGHT};
+
+
+void keyboard_action(DEVTERM*dv,uint8_t row,uint8_t col,uint8_t mode) {
+
+  uint16_t k;
+  
+  k = keyboard_maps[dv->Keyboard_state.layer][row][col];
+
+  if(k == EMP){
+    return;
+  }
+
+  switch(k) {
+    case _LEFT_SHIFT_KEY:
+    case  KEY_RIGHT_SHIFT:
+    if(mode == KEY_PRESSED) {
+      dv->_Serial->println("into shift layer");
+      dv->Keyboard_state.layer = SHI_LAYER;
+      dv->Keyboard->press(k);
+    }else if(mode == KEY_RELEASED) {
+      dv->_Serial->println("leave shift layer");
+      dv->Keyboard_state.layer = DEF_LAYER;
+      dv->Keyboard->release(k);
+    }
+    break;
+
+    case  KEY_CAPS_LOCK:
+    if(mode == KEY_PRESSED) {
+      dv->Keyboard_state.layer = CAPS_LAYER;
+      dv->Keyboard->press(k);
+      
+    }else if(mode == KEY_RELEASED) {
+      dv->Keyboard->release(k);
+      if(dv->Keyboard_state.caps_lock == 0) {
+        dv->Keyboard_state.caps_lock = 1;
+      }else{
+        dv->Keyboard_state.caps_lock = 0;
+        dv->Keyboard_state.layer = DEF_LAYER;
+      }
+    }
+    
+    break;   
+    case _SELECT_KEY:
+      dv->Joystick->button(9,mode);
+    break;
+    case _START_KEY:
+      dv->Joystick->button(10,mode);
+    break;
+    
+    
+    default:
+      if(mode == KEY_PRESSED) {
+        dv->Keyboard->press(k);
+      }else if(mode == KEY_RELEASED) {
+        dv->Keyboard->release(k);
+      }
+    break;
+  }
+
+  
+}
+
+
+void keypad_action(DEVTERM*dv,uint8_t col,uint8_t mode) {
+
+  uint16_t k;
+  
+  k = keys_maps[col];
+
+  if(k == EMP){
+    return;
+  }
+
+  switch(k) {
+    case _LEFT_SHIFT_KEY:
+    case KEY_RIGHT_SHIFT:
+      if(mode == KEY_PRESSED) {
+        dv->Keyboard_state.layer = SHI_LAYER;
+        dv->Keyboard->press(k);
+      }else if(mode == KEY_RELEASED) {
+        dv->Keyboard_state.layer = DEF_LAYER;
+        dv->Keyboard->release(k);
+      }
+    break;    
+    case  _FN_KEY:
+      if(mode == KEY_PRESSED){
+        dv->Keyboard_state.layer = FN_LAYER;
+      }else if(mode == KEY_RELEASED ) {
+        dv->Keyboard_state.layer = DEF_LAYER;
+      }
+    break;
+    
+    case _JOYSTICK_UP:
+      if(mode == KEY_RELEASED){
+        dv->Joystick->Y(511);
+      }else {
+        dv->Joystick->Y(0);
+      }
+    break;
+    case _JOYSTICK_DOWN:
+      if(mode == KEY_RELEASED){
+        dv->Joystick->Y(511);
+      }else {
+        dv->Joystick->Y(1023);
+      }
+    break;
+    case _JOYSTICK_LEFT:
+      if(mode == KEY_RELEASED){
+        dv->Joystick->X(0);
+      }else {
+        dv->Joystick->X(511);
+      }
+    break;
+    case _JOYSTICK_RIGHT:
+      if(mode == KEY_RELEASED){
+        dv->Joystick->X(511);
+      }else {
+        dv->Joystick->X(1023);
+      }
+    break;
+    case _JOYSTICK_A:
+      dv->Joystick->button(2,mode);
+    break;
+    case _JOYSTICK_B:
+      dv->Joystick->button(3,mode);
+    break;
+    case _JOYSTICK_X:
+      dv->Joystick->button(1,mode);
+    break;
+    case _JOYSTICK_Y:
+      dv->Joystick->button(4,mode);
+    break;
+    case _MOUSE_LEFT:
+      if(mode == KEY_PRESSED){
+        dv->Mouse->press(1);
+      }else if(mode == KEY_RELEASED){
+        dv->Mouse->release(1);
+      }
+    break;
+    case _MOUSE_MID:
+      if(mode == KEY_PRESSED){
+        dv->Mouse->press(2);
+      }else if(mode == KEY_RELEASED){
+        dv->Mouse->release(2);
+      }
+    break;
+
+    case _MOUSE_RIGHT:
+      if(mode == KEY_PRESSED){
+        dv->Mouse->press(3);
+      }else if(mode == KEY_RELEASED){
+        dv->Mouse->release(3);
+      }
+    break;
+    
+    //_LEFT_CTRL_KEY,_CMD_KEY , _LEFT_ALT    
+    case _LEFT_CTRL_KEY:
+    case _CMD_KEY:
+    case _LEFT_ALT:
+      if(mode == KEY_PRESSED){
+        dv->Keyboard->press(k);
+      }else {
+        dv->Keyboard->release(k);
+      }
+    break;
+    
+    default:break;
+    
+  }
+  
+}

Code/devterm_keyboard/keys.h

@@ -0,0 +1,27 @@
+#ifndef KEYS_H
+#define KEYS_H
+/*
+ * keys include the joystick and mouse left/mid/right keys
+ */
+
+#include "devterm.h"
+#include "keys_io_map.h"
+
+#include <stdint.h>
+#include <stdbool.h>
+#include <string.h>
+
+
+#ifndef KEY_DEBOUNCE
+#   define KEY_DEBOUNCE 5
+#endif
+
+#define KEYS_NUM 16
+
+
+void keys_task(DEVTERM*);
+void keys_init(DEVTERM*);
+
+
+
+#endif

Code/devterm_keyboard/keys.ino

@@ -0,0 +1,115 @@
+#include "keys.h"
+
+static bool key_debouncing = false;
+static uint16_t key_debouncing_time = 0;
+
+uint8_t keys_io[ KEYS_NUM ]= {KEY1,KEY2,KEY3,KEY4,KEY5,KEY6,KEY7,KEY8,KEY9,KEY10,KEY11,KEY12,KEY13,KEY14,KEY15,KEY16};
+
+/* keys state(1:on, 0:off) */
+static uint16_t keys;
+static uint16_t keys_debouncing;
+static uint16_t keys_prev;
+
+
+static int8_t keys_jack_idx=-1;
+static uint16_t keys_jack_time = 0;
+
+void init_keys(){
+  int i;
+  for(i=0;i<KEYS_NUM;i++) {
+    pinMode( keys_io[i],INPUT_PULLUP);  
+  }
+}
+
+uint8_t scan_keys(){
+  uint16_t data;
+  uint8_t s;
+  
+  data = 0;
+  delayMicroseconds(20);
+  for(int i = 0;i < KEYS_NUM;i++) {
+    
+    s = digitalRead(keys_io[i]); //HIGH =0,LOW = 1
+    if( s == LOW ){
+      data |= 1 << i;
+    }else {
+      data |= 0 << i;
+    }
+  }
+  
+  if ( keys_debouncing != data ) {
+      keys_debouncing = data;
+      key_debouncing = true;
+      key_debouncing_time = millis();
+  }
+
+   if (key_debouncing == true  &&  ( (millis() - key_debouncing_time) > KEY_DEBOUNCE )) {
+    keys = keys_debouncing;
+    debouncing = false;
+  }
+
+  return 1;
+}
+
+
+void print_keys(DEVTERM*dv) {
+  char buff[128];
+
+  for (int i = 0; i < KEYS_NUM; i++) {
+    if( keys & (1<< i) ){
+      sprintf(buff,"B%d pressed\n",i+1);
+      dv->_Serial->print(buff);
+    }
+  }
+  
+  
+}
+
+void keys_task(DEVTERM*dv){
+
+  uint16_t _change = 0;
+
+  scan_keys();
+
+  uint16_t _mask =1;
+  for(uint8_t c=0;c < KEYS_NUM;c++,_mask <<=1){
+
+    if( (keys_prev & _mask) == 0 && (keys & _mask) > 0){
+      keypad_action(dv,c,KEY_PRESSED);
+    }
+    if( (keys_prev & _mask) > 0 && (keys & _mask) == 0){
+      keypad_action(dv,c,KEY_RELEASED);
+    }
+    
+    if( (keys_prev & _mask) > 0 && (keys & _mask) > 0) { ////same key
+
+      if( c >= 0 && c < 4) {// only allow B1-B4 
+        if( keys_jack_idx == -1){
+          keys_jack_idx = c;
+        }else{
+          if(keys_jack_idx != c) {
+            keys_jack_time = 0;
+            keys_jack_idx = c;
+          }else{              
+            keys_jack_time +=1;
+            if( keys_jack_time % (KEY_DEBOUNCE*20) == 0){
+              keypad_action(dv,c,KEY_PRESSED);
+            } 
+          }
+        }
+      }
+    }
+  }
+
+  keys_prev = keys;
+ 
+}
+
+void keys_init(DEVTERM*dv){
+
+  init_keys();
+  //center the position
+  dv->Joystick->X(511);
+  dv->Joystick->Y(511);
+  
+}

Code/devterm_keyboard/keys_io_map.h

@@ -0,0 +1,49 @@
+#ifndef KEYS_IO_MAP_H
+#define KEYS_IO_MAP_H
+
+#define ROW1 PA0
+#define ROW2 PA1
+#define ROW3 PA2
+#define ROW4 PA3
+#define ROW5 PA4
+#define ROW6 PA5
+#define ROW7 PA6
+#define ROW8 PA7
+
+#define COL1 PC0
+#define COL2 PC1
+#define COL3 PC2
+#define COL4 PC3
+#define COL5 PC4
+#define COL6 PC5
+#define COL7 PC6
+#define COL8 PC7
+
+#define KEY1 PB0 //
+#define KEY2 PB1
+#define KEY3 PB2
+#define KEY4 PB3
+#define KEY5 PB4
+#define KEY6 PB5
+#define KEY7 PB6
+#define KEY8 PB7
+#define KEY9 PB8
+#define KEY10 PB9
+#define KEY11 PB10
+#define KEY12 PB11
+#define KEY13 PB12
+#define KEY14 PB13
+#define KEY15 PB14
+#define KEY16 PB15 //
+
+//ball
+#define HO1 PC8
+#define HO2 PC9
+#define HO3 PC10
+#define HO4 PC11
+#define KEY0 PC12
+
+
+
+
+#endif

Code/devterm_keyboard/trackball.h

@@ -0,0 +1,67 @@
+#ifndef TRACKBALL_H
+#define TRACKBALL_H
+
+#include "devterm.h"
+
+#include "keys_io_map.h"
+
+#define BOUNCE_INTERVAL       30
+#define BASE_MOVE_PIXELS      5
+#define EXPONENTIAL_BOUND     15
+#define EXPONENTIAL_BASE      1.2
+
+#define BTN_PIN               KEY0
+#define RIGHT_PIN             HO3
+#define LEFT_PIN              HO1
+#define DOWN_PIN              HO4
+#define UP_PIN                HO2
+
+
+
+class Direction {
+  public:
+    Direction(int pin1, int pin2) {
+      this->pins[0] = pin1;
+      this->pins[1] = pin2;
+      pinMode(this->pins[0], INPUT);
+      pinMode(this->pins[1], INPUT);
+    };
+    
+    int read_action() {
+      for(int i = 0; i < 2; ++i) {
+        this->current_actions[i] = digitalRead(this->pins[i]);
+        this->current_action_times[i] = millis();
+        if(this->current_actions[i] != this->last_actions[i]) {
+          this->last_actions[i] = this->current_actions[i];
+          exponential = (EXPONENTIAL_BOUND - (this->current_action_times[i] - this->last_action_times[i]));
+          exponential = (exponential > 0) ? exponential : 1;
+          move_multiply = EXPONENTIAL_BASE;
+          for(int i = 0; i < exponential; ++i) {
+            move_multiply *= EXPONENTIAL_BASE;
+          }
+          this->last_action_times[i] = this->current_action_times[i];
+          if(i == 0) {
+            return (-1) * BASE_MOVE_PIXELS * move_multiply;
+          } else {
+            return BASE_MOVE_PIXELS * move_multiply;
+          }
+        }
+      }
+      return 0;
+    };
+    
+  private:
+    int           pins[2];
+    int           current_actions[2];
+    int           last_actions[2];
+    int           exponential;
+    double        move_multiply;
+    unsigned long current_action_times[2];
+    unsigned long last_action_times[2];
+};
+
+void trackball_init(DEVTERM*);
+void trackball_task(DEVTERM*);
+
+
+#endif

Code/devterm_keyboard/trackball.ino

@@ -0,0 +1,53 @@
+/*
+ * clockworkpi devterm trackball 
+ */
+#include "keys_io_map.h"
+
+#include <stdint.h>
+#include <stdbool.h>
+#include <string.h>
+
+#include <USBComposite.h>
+
+#include "trackball.h"
+
+
+int btn_state;
+int btn_read_state;
+unsigned long btn_current_action_time;
+unsigned long btn_last_action_time;
+
+// mouse move
+int x_move, y_move;
+Direction x_direction(LEFT_PIN, RIGHT_PIN);
+Direction y_direction(UP_PIN, DOWN_PIN);
+
+void trackball_task(DEVTERM*dv) {
+  btn_read_state = digitalRead(BTN_PIN);
+  
+  if(btn_read_state != btn_state) {
+    btn_current_action_time = millis();
+    if(btn_current_action_time - btn_last_action_time > BOUNCE_INTERVAL) {
+      btn_state = btn_read_state;
+      btn_last_action_time = btn_current_action_time;
+      
+      if(btn_state == HIGH) {
+        dv->Mouse->release();
+      } else {
+        dv->Mouse->press();
+      }
+    }
+  }
+
+  x_move = x_direction.read_action();
+  y_move = y_direction.read_action();
+  if(x_move != 0 || y_move != 0) {
+    dv->Mouse->move(x_move, y_move, 0);
+  }
+  
+}
+
+
+void trackball_init(DEVTERM*){
+  pinMode(BTN_PIN,INPUT);
+}