Subversion Repositories pentevo

Rev

Rev 601 | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

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