Subversion Repositories pentevo

Rev

Rev 1024 | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed | ?url?

  1. #include <avr/io.h>
  2. #include <util/delay.h>
  3.  
  4. #include "pins.h"
  5. #include "mytypes.h"
  6.  
  7. #include "rs232.h"
  8. #include "zx.h"
  9. #include "joystick.h"
  10. #include "kbmap.h"
  11.  
  12. //if want Log than comment next string
  13. #undef LOGENABLE
  14.  
  15. #define JOY_PIN_R_M   0b00000001
  16. #define JOY_PIN_L_X   0b00000010
  17. #define JOY_PIN_D_Y   0b00000100
  18. #define JOY_PIN_U_Z   0b00001000
  19. #define JOY_PIN_B_A   0b00010000
  20. #define JOY_PIN_RLDUB 0b00011111
  21. #define JOY_PIN_C_S
  22.  
  23. const UBYTE joymaps[4][12]={
  24. //default                              
  25. //              Right   Left    Down    Up              B               C               A
  26.         {       KEY_P,  KEY_O,  KEY_A,  KEY_Q,  KEY_M,  KEY_SS, KEY_SP,
  27. //              Start   Mode    X               Y               Z
  28.                 KEY_EN, KEY_C,  KEY_N,  KEY_Y,  KEY_Z},
  29. //Kempston
  30. //              Right   Left    Down    Up              B               C               A
  31.         {       0x00,   0x00,   0x00,   0x00,   0x00,   0x00,   0x00,
  32. //              Start   Mode    X               Y               Z
  33.                 0x00,   0x00,   KEY_EN, KEY_SP, KEY_Z},
  34. //Super Mario
  35. //              Right   Left    Down    Up              B               C               A
  36.         {       KEY_8,  KEY_5,  KEY_6,  KEY_7,  KEY_S,  KEY_SS, KEY_A,
  37. //              Start   Mode    X               Y               Z
  38.                 KEY_EN, KEY_SP, KEY_X,  KEY_Y,  KEY_Z},
  39. //Elite
  40. //              Right   Left    Down    Up              B               C               A
  41.         {       KEY_M,  KEY_N,  KEY_X,  KEY_S,  KEY_A,  KEY_SP, KEY_F,
  42. //              Start   Mode    X               Y               Z
  43.                 KEY_D,  KEY_T,  KEY_E,  KEY_J,  KEY_SS}};
  44.  
  45. #define JOY_MAP_DEFAULT (UBYTE *)joymaps[0]
  46. #define JOY_MAP_KEMPST  (UBYTE *)joymaps[1]
  47. #define JOY_MAP_SMB             (UBYTE *)joymaps[2]
  48. #define JOY_MAP_ELITE   (UBYTE *)joymaps[3]
  49. UBYTE * joymap = JOY_MAP_DEFAULT;
  50. #define J_WAIT 10
  51.  
  52. volatile UBYTE gamepad_type = JOY_NEED_DETECT;
  53. volatile UWORD jkey_state = 0x0000;
  54.  
  55. void joystick_init(void){
  56.         UBYTE joy_state;
  57.        
  58.         SEGA_SYNC_UP();
  59.         DDRA  = 0b00000100;
  60.         _delay_us(50000);
  61.         //первый фронт клолка
  62.         _delay_us(J_WAIT);
  63.         //как минимум один из left/right должен быть в 1
  64.         //и как минимум один из up/down должен быть в 1
  65.         joy_state = JOYSTICK_PIN;
  66.         gamepad_type = JOY_SWITCHS;
  67.         if( (joy_state & ( JOY_PIN_L_X|JOY_PIN_R_M ) ) != 0 )
  68.         {
  69.                 if( (joy_state & ( JOY_PIN_D_Y|JOY_PIN_U_Z ) ) != 0 )
  70.                 {
  71.                         gamepad_type = JOY_SEGA_12KEY;
  72.                 }
  73.         }
  74.         if( gamepad_type != JOY_SWITCHS )
  75.         {
  76.                 SEGA_SYNC_DOWN();
  77.                 //первый спад клока
  78.                 _delay_us(J_WAIT);
  79.                 //как минимум один из left/right должен быть в 0
  80.                 //и как минимум один из up/down должен быть в 1
  81.                 gamepad_type = JOY_SWITCHS;
  82.                 joy_state = JOYSTICK_PIN;
  83.                 if( (joy_state & ( JOY_PIN_L_X|JOY_PIN_R_M ) ) != ( JOY_PIN_L_X|JOY_PIN_R_M ) )
  84.                 {
  85.                         if( (joy_state & ( JOY_PIN_D_Y|JOY_PIN_U_Z ) ) != 0 )
  86.                         {
  87.                                 gamepad_type = JOY_SEGA_12KEY;
  88.                         }
  89.                 }
  90.                
  91.                 SEGA_SYNC_UP();
  92.         }
  93.        
  94.         if( gamepad_type != JOY_SWITCHS )
  95.         {
  96.                 // sega-pad есть, определим 8 или 12 кнопок
  97.                 _delay_us(J_WAIT);
  98.                 SEGA_SYNC_DOWN();
  99.                 // второй спад клока
  100.                 _delay_us(J_WAIT);
  101.                 SEGA_SYNC_UP();
  102.                 _delay_us(J_WAIT);
  103.                 SEGA_SYNC_DOWN();
  104.                 // третий спад клока
  105.                 // определим 8 или 12 кнопок у джоя
  106.                 // left/right/up/down должы быть в 0
  107.                 _delay_us(J_WAIT);
  108.                 if( ( JOYSTICK_PIN & ( JOY_PIN_D_Y|JOY_PIN_U_Z|JOY_PIN_L_X|JOY_PIN_R_M ) ) == 0 )
  109.                 {
  110.                         gamepad_type = JOY_SEGA_12KEY;
  111.                 }
  112.                 else
  113.                 {
  114.                         gamepad_type = JOY_SEGA_8KEY;
  115.                 }
  116.                 SEGA_SYNC_UP();
  117.         }
  118.        
  119.         if( gamepad_type & JOY_SEGA_12KEY )
  120.         {// для 12 кнопок закончим цикл клока
  121.                 _delay_us(J_WAIT);
  122.                 SEGA_SYNC_DOWN();
  123.                 _delay_us(J_WAIT);
  124.                 SEGA_SYNC_UP();
  125.         }
  126.        
  127.         if( gamepad_type != JOY_SWITCHS )
  128.         {//запустим прерывание, если есть sega-pad
  129.                 OCR0 = TCNT0 + 255;
  130.                 TCCR0 = 0b00111101;
  131.         }
  132.         else
  133.         {
  134.                 DDRA  = 0b00000000;
  135.         }
  136. }
  137.  
  138.  
  139. void sega_parsing(void){
  140.         static UWORD jkey_state_old = 0x0000;
  141.         static UBYTE kempst_old = 0x00;
  142.         static UBYTE jkey_mode = 0x00;
  143.        
  144.         if( jkey_state_old == jkey_state )
  145.         {//изменений нет, выходим
  146.                 return;
  147.         }
  148.        
  149.         jkey_state_old = jkey_state;
  150.        
  151.         zx_realkbd[5] = 0xff;
  152.         zx_realkbd[6] = 0xff;
  153.         zx_realkbd[7] = 0xff;
  154.         zx_realkbd[8] = 0xff;
  155.         zx_realkbd[9] = 0xff;
  156.        
  157.         if((jkey_state & 0x0e00) == 0x0e00){
  158.                 if(jkey_mode == 0){
  159.                         jkey_mode = 1;
  160.                         joymap = (UBYTE *)joymaps[(jkey_state & 0x0030) >> 4];
  161.                 }
  162.         }else{
  163.                 UBYTE i = 0;
  164.                 jkey_mode = 0;
  165.                 if((joymap == JOY_MAP_SMB) && (jkey_state & 0x000f)) //CAPSSHIFT
  166.                         zx_realkbd[5]&=0xfe;
  167.                 if(joymap == JOY_MAP_KEMPST){                  
  168.                         if (kempst_old ^ (jkey_state & 0x00ff))
  169.                         {
  170.                                 kempst_old = jkey_state & 0x00ff;
  171.                                 zx_spi_send(SPI_KEMPSTON_JOYSTICK, kempst_old, 0x7F);
  172.                         }
  173.                         i = 8;
  174.                         jkey_state >>= 8;
  175.                 }
  176.                 for(; i < 12; i++){
  177.                         if(jkey_state & 0x0001){
  178.                                 zx_realkbd[(joymap[i]>>3)+5] &= ~(0b10000000>>(joymap[i]&0x07));
  179.                         }
  180.                         jkey_state >>= 1;
  181.                 }
  182.         }
  183.        
  184.         // UWORD l = jkey_state;
  185.         // rs232_transmit('\r');
  186.         // for(UBYTE j=0;j<16;j++){
  187.                 // if(l & 0x8000)rs232_transmit('1');
  188.                 // else rs232_transmit('0');
  189.                 // l = l << 1;
  190.         // }
  191. }
  192.  
  193. void joystick_task(void)
  194. {
  195.         static UBYTE joy_state = 0;
  196.        
  197.         if( gamepad_type != JOY_SWITCHS )
  198.         {
  199.                 return;
  200.         }
  201.        
  202.         UBYTE temp = (~JOYSTICK_PIN) & JOYSTICK_MASK;
  203.  
  204.         if ( joy_state ^ temp )
  205.         {
  206.                 //change state of joystick pins
  207.                 joy_state = temp;
  208.  
  209.                 //send to port
  210.                 zx_spi_send(SPI_KEMPSTON_JOYSTICK, joy_state, 0x7F);
  211.  
  212. #ifdef LOGENABLE
  213.         char log_joystick[] = "JS..\r\n";
  214.         log_joystick[2] = ((temp >> 4) <= 9 )?'0'+(temp >> 4):'A'+(temp >> 4)-10;
  215.         log_joystick[3] = ((temp & 0x0F) <= 9 )?'0'+(temp & 0x0F):'A'+(temp & 0x0F)-10;
  216.         to_log(log_joystick);
  217. #endif
  218.         }
  219. }
  220.