Subversion Repositories pentevo

Rev

Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed | ?url?

  1. /* 4                              5678901234567
  2.   ┌─────────────────────────────────────────────┐
  3.   │Detecting mouse...                           │03
  4.   │FF FA AA 00                                  │
  5.   │Customization...                             │
  6.   │F3 FA C8 FA F3 FA 64 FA F3 FA 50 FA          │
  7.   │F2 FA 03                                     │
  8.   │E8 FA 02 FA E6 FA F3 FA 64 FA F4 FA          │
  9.   │Let's go!                                    │
  10.   │08 00 00 00                    ┌───────────┐ │10
  11.   │                               │███        │ │11
  12.   │                               │█L█  M   R │ │12
  13.   │                               │███        │ │13
  14.   │                               │           │ │14
  15.   │                               │ Wheel = 1 │ │15
  16.   │                               │           │ │16
  17.   │                               │ X  =  123 │ │17
  18.   │                               │ Y  =   58 │ │18
  19.   │                               └───────────┘ │
  20.   └─────────────────────────────────────────────┘
  21.    4                              5678901234567  */
  22. //-----------------------------------------------------------------------------
  23.  
  24. #include "_global.h"
  25. #include "_screen.h"
  26. #include "_t_ps2m.h"
  27. #include "_ps2k.h"
  28. #include "_uart.h"
  29. #include <avr/interrupt.h>
  30. #include <util/delay_basic.h>
  31.  
  32. //-----------------------------------------------------------------------------
  33.  
  34. volatile u8 ps2m_bit_count, ps2m_data, ps2m_raw_ready, ps2m_raw_code;
  35. volatile u8 ps2m_flags;
  36. u8 tpsm_id;
  37.  
  38. //-----------------------------------------------------------------------------
  39.  
  40. #define ps2m_dataline_up()    { DDRD&=~(1<<PD7); PORTD|=(1<<PD7); }
  41. #define ps2m_dataline_down()  { PORTD&=~(1<<PD7); DDRD|=(1<<PD7); }
  42. #define ps2m_clockline_up()   { DDRE&=~(1<<PE5); PORTE|=(1<<PE5); }
  43. #define ps2m_clockline_down() { PORTE&=~(1<<PE5); DDRE|=(1<<PE5); }
  44.  
  45. //-----------------------------------------------------------------------------
  46.  
  47. const WIND_DESC wind_t_ps2m_1 PROGMEM = {  3, 2,47,19,0xdf,0x01 };
  48. const WIND_DESC wind_t_ps2m_2 PROGMEM = {  9,10,34, 4,0xaf,0x01 };
  49. const WIND_DESC wind_t_ps2m_3 PROGMEM = { 35,10,13,10,0xdf,0x00 };
  50.  
  51. const u8 ps2msetup1[] PROGMEM = { 0xf3,200,0xf3,100,0xf3,80,0xff };
  52. const u8 ps2msetup2[] PROGMEM = { 0xe8,0x02,0xe6,0xf3,100,0xf4,0xff };
  53.  
  54. //-----------------------------------------------------------------------------
  55.  
  56. u8 ps2m_send_byte(u8 data)
  57. {
  58.  u8 temp;
  59.  temp=0;
  60.  do
  61.  {
  62.   if (!(PINE&(1<<PE5))) temp=0;
  63.  }while (--temp);
  64.  cli();
  65.  ps2m_data=data;
  66.  ps2m_flags=1<<PS2M_BIT_TX;
  67.  ps2m_bit_count=0;
  68.  ps2m_raw_ready=0;
  69.  ps2m_clockline_down();
  70.  sei();
  71.  _delay_loop_2(359);                            // 130 us
  72.  ps2m_dataline_down();
  73.  _delay_loop_1(74);                             // 20 us
  74.  u16 to;
  75.  set_timeout_ms(&to,15);
  76.  ps2m_clockline_up();
  77.  do
  78.  {
  79.   if (check_timeout_ms(&to))  return 0;
  80.  }while (!(ps2m_flags&(1<<PS2M_BIT_ACKBIT)));
  81.  return 1;
  82. }
  83.  
  84. //-----------------------------------------------------------------------------
  85.  
  86. u8 ps2m_receive_byte(u8 *data)
  87. {
  88.  ps2m_raw_ready=0;
  89.  u16 to;
  90.  set_timeout_ms(&to,7);
  91.  do
  92.  {
  93.   if (ps2m_raw_ready)
  94.   {
  95.    *data=ps2m_raw_code;
  96.    ps2m_raw_ready=0;
  97.    return 1;
  98.   }
  99.  }while (!(check_timeout_ms(&to)));
  100.  return 0;
  101. }
  102.  
  103. //-----------------------------------------------------------------------------
  104.  
  105. u8 ps2m_detect_send(u8 data)
  106. {
  107.  print_hexbyte_for_dump(data);
  108.  if (ps2m_send_byte(data))
  109.  {
  110.   u8 response;
  111.   if (ps2m_receive_byte(&response))
  112.   {
  113.    print_hexbyte_for_dump(response);
  114.    if (response==0xfa) return 1;
  115.   }
  116.  }
  117.  return 0;
  118. }
  119.  
  120. //-----------------------------------------------------------------------------
  121.  
  122. u8 ps2m_detect_sendmulti(PGM_U8_P array)
  123. {
  124.  u8 data;
  125.  do
  126.  {
  127.   data=pgm_read_byte(array);
  128.   array++;
  129.   if (data!=0xff)
  130.   {
  131.    if (!(ps2m_detect_send(data))) return 0;
  132.   }
  133.  }while (data!=0xff);
  134.  return 1;
  135. }
  136.  
  137. //-----------------------------------------------------------------------------
  138.  
  139. u8 ps2m_detect_receive(u8 expected)
  140. {
  141.  u8 data;
  142.  if (ps2m_receive_byte(&data))
  143.  {
  144.   print_hexbyte_for_dump(data);
  145.   if (data==expected) return 1;
  146.  }
  147.  return 0;
  148. }
  149.  
  150. //-----------------------------------------------------------------------------
  151.  
  152. u8 t_psm_detect(void)
  153. {
  154.  u8 go2;
  155.  do
  156.  {
  157.   cli();
  158.   ps2m_dataline_up();
  159.   ps2m_clockline_up();
  160.   EICRB=(EICRB&~((1<<ISC51)|(1<<ISC50)))|((1<<ISC51)|(0<<ISC50));
  161.   EIMSK|=(1<<INT5);
  162.   ps2m_flags=0;
  163.   ps2m_bit_count=0;
  164.   ps2m_raw_ready=0;
  165.   sei();
  166.  
  167.   scr_window(&wind_t_ps2m_1);
  168.   scr_set_cursor(4,3);
  169.   uart_crlf();
  170.   print_mlmsg(mlmsg_mouse_detect);
  171.   scr_set_cursor(4,4);
  172.   uart_crlf();
  173.  
  174.   do
  175.   {
  176.    go2=GO_REPEAT;
  177.    ps2m_raw_ready=0;
  178.    u16 to;
  179.    set_timeout_ms(&to,2);
  180.    while (ps2m_raw_ready==0)
  181.    {
  182.     if (check_timeout_ms(&to))
  183.     {
  184.      go2=GO_CONTINUE;
  185.      break;
  186.     }
  187.    }
  188.   }while (go2==GO_REPEAT);
  189.  
  190.   PGM_U8_P *errmlmsg;
  191.   errmlmsg=mlmsg_mouse_fail0;
  192.   go2=GO_ERROR;
  193.   print_hexbyte_for_dump(0xff);
  194.   if (ps2m_send_byte(0xff))
  195.   {
  196.    u8 temp;
  197.    if (ps2m_receive_byte(&temp))
  198.    {
  199.     print_hexbyte_for_dump(temp);
  200.     if (temp==0xfa)
  201.     {
  202.      //ps2m_raw_ready=0;
  203.      errmlmsg=mlmsg_mouse_fail1;
  204.      u16 to;
  205.      set_timeout_ms(&to,1000);
  206.      while (!(check_timeout_ms(&to)))
  207.      {
  208.       if (ps2m_raw_ready)
  209.       {
  210.        go2=GO_CONTINUE;
  211.        break;
  212.       }
  213.      }
  214.      if (go2==GO_CONTINUE)
  215.      {
  216.       go2=GO_ERROR;
  217.       if (ps2m_raw_code==0xaa)
  218.       {
  219.        if (ps2m_detect_receive(0x00))
  220.        {
  221.         scr_set_cursor(4,5);
  222.         uart_crlf();
  223.         print_mlmsg(mlmsg_mouse_setup);
  224.         scr_set_cursor(4,6);
  225.         uart_crlf();
  226.         if (ps2m_detect_sendmulti(ps2msetup1))
  227.         {
  228.          scr_set_cursor(4,7);
  229.          uart_crlf();
  230.          if (ps2m_detect_send(0xf2))
  231.          {
  232.           ps2m_raw_ready=0;
  233.           set_timeout_ms(&to,20);
  234.           while (!(check_timeout_ms(&to)))
  235.           {
  236.            if (ps2m_raw_ready)
  237.            {
  238.             go2=GO_CONTINUE;
  239.             break;
  240.            }
  241.           }
  242.           if (go2==GO_CONTINUE)
  243.           {
  244.            go2=GO_ERROR;
  245.            temp=ps2m_raw_code;
  246.            tpsm_id=temp;
  247.            print_hexbyte_for_dump(temp);
  248.            if ( (temp==0x00) || (temp==0x03) )
  249.            {
  250.             scr_set_cursor(4,8);
  251.             uart_crlf();
  252.             if (ps2m_detect_sendmulti(ps2msetup2))
  253.             {
  254.              scr_set_cursor(4,9);
  255.              uart_crlf();
  256.              go2=GO_CONTINUE;
  257.             }
  258.            }
  259.           }
  260.          }
  261.         }
  262.        }
  263.       }
  264.      }
  265.     }
  266.    }
  267.   }
  268.  
  269.   if (go2!=GO_CONTINUE)
  270.   {
  271.    scr_window(&wind_t_ps2m_2);
  272.    scr_set_cursor(10,11);
  273.    uart_crlf();
  274.    print_mlmsg(errmlmsg);
  275.    scr_set_cursor(10,12);
  276.    print_mlmsg(mlmsg_mouse_restart);
  277.    do
  278.    {
  279.     u16 key;
  280.     key=waitkey();
  281.     if ((u8)(key>>8)==KEY_ENTER)
  282.      go2=GO_RESTART;
  283.     else if ( (!((u8)key&(1<<PS2K_BIT_EXTKEY))) && ((u8)(key>>8)==KEY_ESC) )
  284.      go2=GO_EXIT;
  285.    }while (go2==GO_CONTINUE);
  286.   }
  287.  
  288.  }while ( (go2!=GO_CONTINUE) && (go2!=GO_EXIT) );
  289.  
  290.  return go2;
  291. }
  292.  
  293. //-----------------------------------------------------------------------------
  294.  
  295. void Test_PS2Mouse(void)
  296. {
  297.  flags1&=0b11111011;
  298.  flags1|=0b00000010;
  299.  print_mlmsg(mlmsg_mouse_test);
  300.  flags1|=0b00000100;
  301.  
  302.  if (t_psm_detect()!=GO_EXIT)
  303.  {
  304.   print_mlmsg(mlmsg_mouse_letsgo);
  305.   uart_crlf();
  306.   flags1&=0b11111100;
  307.   int6vect=0b00000010;
  308.   fpga_reg(INT_CONTROL,int6vect);
  309.   scr_window(&wind_t_ps2m_3);
  310.   if (tpsm_id)
  311.    scr_print_msg(msg_tpsm_1);
  312.   else
  313.    scr_print_msg(msg_tpsm_1+10);
  314.   u16 tpsm_x;
  315.   u8 tpsm_y, tpsm_z, tpsm_btn;
  316.   u8 tpsm_byte1, tpsm_byte2, tpsm_byte3, tpsm_byte4;
  317.   tpsm_x=150;
  318.   tpsm_y=120;
  319.   tpsm_z=0;
  320.   tpsm_btn=0;
  321.   ps2m_raw_ready=0;
  322.  
  323.   u8 go2;
  324.   do
  325.   {
  326.    if (tpsm_id)
  327.    {
  328.     scr_set_cursor(45,15);
  329.     print_hexhalf(tpsm_z);
  330.    }
  331.    scr_set_cursor(41,17);
  332.    print_dec16(tpsm_x);
  333.    scr_set_cursor(41,18);
  334.    print_dec16(tpsm_y);
  335.  
  336.    u8 temp;
  337.    temp=11;
  338.    do
  339.    {
  340.     scr_set_cursor(36,temp);
  341.     u8 attr;
  342.     if (tpsm_btn&0x01) attr=0xae; else attr=0xdf;
  343.     scr_fill_attr(attr,3);
  344.     scr_fill_attr(0xdf,1);
  345.     if (tpsm_btn&0x04) attr=0xae; else attr=0xdf;
  346.     scr_fill_attr(attr,3);
  347.     scr_fill_attr(0xdf,1);
  348.     if (tpsm_btn&0x02) attr=0xae; else attr=0xdf;
  349.     scr_fill_attr(attr,3);
  350.    }while (++temp<14);
  351.  
  352.    do
  353.    {
  354.     go2=GO_REPEAT;
  355.     if (newframe)
  356.     {
  357.      newframe=0;
  358.      u16 w;
  359.      w=tpsm_x+98;
  360.      fpga_reg(SCR_MOUSE_TEMP,(u8)(w>>8));
  361.      fpga_reg(SCR_MOUSE_X,(u8)w);
  362.      w=tpsm_y+43;
  363.      fpga_reg(SCR_MOUSE_TEMP,(u8)(w>>8));
  364.      fpga_reg(SCR_MOUSE_Y,(u8)w);
  365.     }
  366.  
  367.     if (ps2m_raw_ready)
  368.     {
  369.      ps2m_raw_ready=0;
  370.      temp=ps2m_raw_code;
  371.      if (temp&0b00001000)
  372.      {
  373.       tpsm_byte1=temp;
  374.       if (ps2m_receive_byte(&tpsm_byte2))
  375.       {
  376.        if (ps2m_receive_byte(&tpsm_byte3))
  377.        {
  378.         if (tpsm_id) temp=ps2m_receive_byte(&tpsm_byte4);
  379.         if (temp)
  380.         {
  381.          tpsm_btn=tpsm_byte1&0x07;
  382.  
  383.          if (tpsm_byte1&0b00010000)
  384.          {
  385.           u16 w;
  386.           w=0xff00|tpsm_byte2;
  387.           tpsm_x+=w;
  388.           if (tpsm_x>317) tpsm_x=0;
  389.          }
  390.          else
  391.          {
  392.           tpsm_x+=tpsm_byte2;
  393.           if (tpsm_x>317) tpsm_x=317;
  394.          }
  395.  
  396.          if (tpsm_byte1&0b00100000)
  397.          {
  398.           u16 w;
  399.           w=(u16)tpsm_y-(0xff00|tpsm_byte3);
  400.           if (w>249) tpsm_y=249; else tpsm_y=(u8)w;
  401.          }
  402.          else
  403.          {
  404.           u16 w;
  405.           w=(u16)tpsm_y-tpsm_byte3;
  406.           if (w>249) tpsm_y=0; else tpsm_y=(u8)w;
  407.          }
  408.  
  409.          if (tpsm_id)  tpsm_z=(tpsm_z+tpsm_byte4)&0x0f;
  410.  
  411.          scr_set_cursor(4,10);
  412.          scr_set_attr(0xdf);
  413.          flags1|=0b00000010;
  414.          print_hexbyte(tpsm_byte1);
  415.          put_char(0x20);
  416.          print_hexbyte(tpsm_byte2);
  417.          put_char(0x20);
  418.          print_hexbyte(tpsm_byte3);
  419.          put_char(0x20);
  420.          if (tpsm_id)
  421.          {
  422.           print_hexbyte(tpsm_byte4);
  423.           put_char(0x20);
  424.          }
  425.          put_char(0x20);
  426.          flags1&=0b11111100;
  427.          go2=GO_REDRAW;
  428.         }
  429.        }
  430.       }
  431.      }
  432.     }
  433.  
  434.     u16 key;
  435.     if (inkey(&key))
  436.     {
  437.      if ( (!((u8)key&(1<<PS2K_BIT_EXTKEY))) && ((u8)(key>>8)==KEY_ESC) )
  438.       go2=GO_EXIT;
  439.     }
  440.  
  441.    }while (go2==GO_REPEAT);
  442.  
  443.   }while (go2!=GO_EXIT);
  444.  
  445.  }
  446.  
  447.  int6vect=0b00000000;
  448.  fpga_reg(INT_CONTROL,int6vect);
  449.  fpga_reg(SCR_MOUSE_TEMP,0);
  450.  fpga_reg(SCR_MOUSE_X,0);
  451.  fpga_reg(SCR_MOUSE_Y,0);
  452.  cli();
  453.  ps2m_dataline_up();
  454.  ps2m_clockline_up();
  455.  EIMSK&=~(1<<INT5);
  456.  sei();
  457.  flags1|=0b00000010;
  458. }
  459.  
  460. //-----------------------------------------------------------------------------
  461.