Welcome 微信登录

首页 / 操作系统 / Linux / Linux joystick 游戏手柄编程 （获取输入数据）

啥也不说了，先上代码：
由于linux中的list.h不能直接用，所以单独提取了出来使用：//listop.h   
  1. /*it is from linux list */  
  2. #ifndef LISTOP_H   
  3. #define LISTOP_H   
  4.   
  5. struct list_head {  
  6.     struct list_head *next, *prev;  
  7. };  
  8.   
  9. typedef struct list_head list_t;  
  10.   
  11. #define LIST_HEAD_INIT（name） { &（name）, &（name） }   
  12.   
  13. #define LIST_HEAD（name）    
  14.     struct list_head name = LIST_HEAD_INIT（name）  
  15.   
  16. #define INIT_LIST_HEAD（ptr） do {    
  17.     （ptr）->next = （ptr）; （ptr）->prev = （ptr）;   
  18. } while （0）  
  19.   
  20. /** 
  21.  * list_add - add a new entry 
  22.  * @new: new entry to be added 
  23.  * @head: list head to add it after 
  24.  * 
  25.  * Insert a new entry after the specified head. 
  26.  * This is good for implementing stacks. 
  27.  */  
  28. void list_add（struct list_head *new, struct list_head *head）;  
  29.   
  30. /** 
  31.  * list_add_tail - add a new entry 
  32.  * @new: new entry to be added 
  33.  * @head: list head to add it before 
  34.  * 
  35.  * Insert a new entry before the specified head. 
  36.  * This is useful for implementing queues. 
  37.  */  
  38. void list_add_tail（struct list_head *new, struct list_head *head）;  
  39.   
  40.   
  41. /** 
  42.  * list_del - deletes entry from list. 
  43.  * @entry: the element to delete from the list. 
  44.  * Note: list_empty on entry does not return true after this, the entry is in an undefined state. 
  45.  */  
  46. void list_del（struct list_head *entry）;  
  47.   
  48. /** 
  49.  * list_del_init - deletes entry from list and reinitialize it. 
  50.  * @entry: the element to delete from the list. 
  51.  */  
  52. void list_del_init（struct list_head *entry）;  
  53.   
  54.   
  55. /** 
  56.  * list_move - delete from one list and add as another"s head 
  57.  * @list: the entry to move 
  58.  * @head: the head that will precede our entry 
  59.  */  
  60. void list_move（struct list_head *list, struct list_head *head）;  
  61.   
  62.   
  63. /** 
  64.  * list_move_tail - delete from one list and add as another"s tail 
  65.  * @list: the entry to move 
  66.  * @head: the head that will follow our entry 
  67.  */  
  68. void list_move_tail（struct list_head *list,  
  69.                   struct list_head *head）;  
  70.   
  71. /** 
  72.  * list_splice - join two lists 
  73.  * @list: the new list to add. 
  74.  * @head: the place to add it in the first list. 
  75.  */  
  76. void list_splice（struct list_head *list, struct list_head *head）;  
  77.   
  78. /** 
  79.  * list_empty - tests whether a list is empty 
  80.  * @head: the list to test. 
  81.  */  
  82. static int list_empty（struct list_head *head）  
  83. {  
  84.     return head->next == head;  
  85. }  
  86.   
  87. /** 
  88.  * list_dequeue - dequeue the head of the list if there are more than one entry 
  89.  * @list: the list to dequeue 
  90.  */  
  91. struct list_head * list_dequeue（ struct list_head *list ）;  
  92.   
  93. /** 
  94.  * list_entry - get the struct for this entry 
  95.  * @ptr:    the &struct list_head pointer. 
  96.  * @type:   the type of the struct this is embedded in. 
  97.  * @member: the name of the list_struct within the struct. 
  98.  */  
  99. #define list_entry（ptr, type, member）    
  100.     （（type *）（（char *）（ptr）-（unsigned long）（&（（type *）0）->member）））  
  101.   
  102. /** 
  103.  * list_for_each    -   iterate over a list 
  104.  * @pos:    the &struct list_head to use as a loop counter. 
  105.  * @head:   the head for your list. 
  106.  */  
  107. #define list_for_each（pos, head）    
  108.     for （pos = （head）->next; pos ！= （head）;   
  109.             pos = pos->next）  
  110.               
  111. /** 
  112.  * list_for_each_safe   -   iterate over a list safe against removal of list entry 
  113.  * @pos:    the &struct list_head to use as a loop counter. 
  114.  * @n:      another &struct list_head to use as temporary storage 
  115.  * @head:   the head for your list. 
  116.  */  
  117. #define list_for_each_safe（pos, n, head）    
  118.     for （pos = （head）->next, n = pos->next; pos ！= （head）;   
  119.         pos = n, n = pos->next）  
  120.   
  121. /** 
  122.  * list_for_each_prev   -   iterate over a list in reverse order 
  123.  * @pos:    the &struct list_head to use as a loop counter. 
  124.  * @head:   the head for your list. 
  125.  */  
  126. #define list_for_each_prev（pos, head）    
  127.     for （pos = （head）->prev; pos ！= （head）;   
  128.             pos = pos->prev）  
  129.               
  130. /** 
  131.  * list_for_each_entry  -   iterate over list of given type 
  132.  * @pos:    the type * to use as a loop counter. 
  133.  * @head:   the head for your list. 
  134.  * @member: the name of the list_struct within the struct. 
  135.  */  
  136. #define list_for_each_entry（pos, head, member）                 
  137.     for （pos = list_entry（（head）->next, typeof（*pos）, member）;     
  138.          &pos->member ！= （head）;       
  139.          pos = list_entry（pos->member.next, typeof（*pos）, member））  
  140.   
  141. #endif  
// listop.c  
  1. #include "listop.h"   
  2.   
  3.   
  4. static  void __check_head（struct list_head* head）  
  5. {  
  6.     if （（head->next == 0） && （head->prev == 0）） {  
  7.         INIT_LIST_HEAD（head）;  
  8.     }  
  9. }  
  10.   
  11. /* 
  12.  * Insert a new entry between two known consecutive entries. 
  13.  * 
  14.  * This is only for internal list manipulation where we know 
  15.  * the prev/next entries already！ 
  16.  */  
  17. static  void __list_add（struct list_head* new,  
  18.                         struct list_head* prev,  
  19.                         struct list_head* next）  
  20. {  
  21.   
  22.     next->prev = new;  
  23.     new->next = next;  
  24.     new->prev = prev;  
  25.     prev->next = new;  
  26.   
  27. }  
  28.   
  29.   
  30. /* 
  31.  * Delete a list entry by making the prev/next entries 
  32.  * point to each other. 
  33.  * 
  34.  * This is only for internal list manipulation where we know 
  35.  * the prev/next entries already！ 
  36.  */  
  37. static  void __list_del（struct list_head* prev,  
  38.                         struct list_head* next）  
  39. {  
  40.   
  41.     next->prev = prev;  
  42.     prev->next = next;  
  43. }  
  44.   
  45.   
  46.   
  47. /** 
  48.  * list_add - add a new entry 
  49.  * @new: new entry to be added 
  50.  * @head: list head to add it after 
  51.  * 
  52.  * Insert a new entry after the specified head. 
  53.  * This is good for implementing stacks. 
  54.  */  
  55. void list_add（struct list_head* new, struct list_head* head）  
  56. {  
  57.     __check_head（head）;  
  58.     __list_add（new, head, head->next）;  
  59. }  
  60.   
  61. /** 
  62.  * list_add_tail - add a new entry 
  63.  * @new: new entry to be added 
  64.  * @head: list head to add it before 
  65.  * 
  66.  * Insert a new entry before the specified head. 
  67.  * This is useful for implementing queues. 
  68.  */  
  69. void list_add_tail（struct list_head* new, struct list_head* head）  
  70. {  
  71.     __check_head（head）;  
  72.     __list_add（new, head->prev, head）;  
  73. }  
  74.   
  75.   
  76. /** 
  77.  * list_del - deletes entry from list. 
  78.  * @entry: the element to delete from the list. 
  79.  * Note: list_empty on entry does not return true after this, the entry is in an undefined state. 
  80.  */  
  81. void list_del（struct list_head* entry）  
  82. {  
  83.     __list_del（entry->prev, entry->next）;  
  84. }  
  85.   
  86. /** 
  87.  * list_del_init - deletes entry from list and reinitialize it. 
  88.  * @entry: the element to delete from the list. 
  89.  */  
  90. void list_del_init（struct list_head* entry）  
  91. {  
  92.     __list_del（entry->prev, entry->next）;  
  93.     INIT_LIST_HEAD（entry）;  
  94. }  
  95.   
  96. /** 
  97.  * list_move - delete from one list and add as another"s head 
  98.  * @list: the entry to move 
  99.  * @head: the head that will precede our entry 
  100.  */  
  101. void list_move（struct list_head* list, struct list_head* head）  
  102. {  
  103.     __check_head（head）;  
  104.     __list_del（list->prev, list->next）;  
  105.     list_add（list, head）;  
  106. }  
  107.   
  108. /** 
  109.  * list_move_tail - delete from one list and add as another"s tail 
  110.  * @list: the entry to move 
  111.  * @head: the head that will follow our entry 
  112.  */  
  113. void list_move_tail（struct list_head* list,  
  114.                     struct list_head* head）  
  115. {  
  116.     __check_head（head）;  
  117.     __list_del（list->prev, list->next）;  
  118.     list_add_tail（list, head）;  
  119. }  
  120.   
  121.   
  122. /** 
  123.  * list_splice - join two lists 
  124.  * @list: the new list to add. 
  125.  * @head: the place to add it in the first list. 
  126.  */  
  127. void list_splice（struct list_head* list, struct list_head* head）  
  128. {  
  129.     struct list_head* first = list;  
  130.     struct list_head* last  = list->prev;  
  131.     struct list_head* at    = head->next;  
  132.   
  133.     first->prev = head;  
  134.     head->next  = first;  
  135.   
  136.     last->next = at;  
  137.     at->prev   = last;  
  138. }  
  139.   
  140. struct list_head* list_dequeue（ struct list_head* list ） {  
  141.     struct list_head* next, *prev, *result = （（void*）0）;  
  142.   
  143.     prev = list;  
  144.     next = prev->next;  
  145.   
  146.     if （ next ！= prev ） {  
  147.         result = next;  
  148.         next = next->next;  
  149.         next->prev = prev;  
  150.         prev->next = next;  
  151.         result->prev = result->next = result;  
  152.     }  
  153.   
  154.     return result;  
  155. }  
主要的文件在这里：
//my_joystick.c
  1. #include <stdio.h>   
  2. #include <sys/types.h>   
  3. #include <sys/time.h>   
  4. #include <sys/stat.h>   
  5. #include <fcntl.h>   
  6. #include <unistd.h>   
  7. #include <errno.h>   
  8. #include <stdlib.h>   
  9. #include <string.h>   
  10. #include <linux/joystick.h>   
  11. //#include <linux/list.h> /*郁闷，不能直接使用linux自带的list链表，需要单独提取出来，见前面的code*/   
  12. #include "listop.h"   
  13.   
  14. #if 1   
  15. #define LOG_DBG（fmt, ...）  fprintf（stdout, fmt, ##__VA_ARGS__）   
  16. #else   
  17. #define LOG_DBG（fmt, ...）   
  18. #endif   
  19.   
  20. #define LOG_ERR（fmt, ...）  fprintf（stderr, fmt, ##__VA_ARGS__）   
  21.   
  22.   
  23. typedef struct _joy_stick_ctx {  
  24.     struct list_head list;  
  25.     int i4_js_fd;  
  26.     unsigned int i4_op_block;  
  27. } JOYSTICK_CTX_T;  
  28.   
  29. LIST_HEAD（_t_js_ctx_head）;  
  30. /*==>  struct list_head _t_js_ctx_head = {&_t_js_ctx_head, &_t_js_ctx_head};*/  
  31.   
  32. int joystick_open（char* cp_js_dev_name, int i4_block）  
  33. {  
  34.     int i4_open_flags = O_RDONLY;  
  35.     JOYSTICK_CTX_T*  pt_joystick_ctx = NULL;  
  36.   
  37.     if （！cp_js_dev_name） {  
  38.         LOG_ERR（"[%s] js device name is NULL ", __func__）;  
  39.         return -1;  
  40.     }  
  41.   
  42.     pt_joystick_ctx = （JOYSTICK_CTX_T*）calloc（sizeof（JOYSTICK_CTX_T）, 1）;  
  43.     if （！pt_joystick_ctx） {  
  44.         LOG_ERR（"[%s] no memory！！ ", __func__）;  
  45.         return -1;  
  46.     }  
  47.   
  48.     pt_joystick_ctx->i4_op_block = i4_block ？ 1 : 0;  
  49.   
  50.     if （pt_joystick_ctx->i4_op_block == 0） {  
  51.         i4_open_flags |= O_NONBLOCK;  
  52.     }  
  53.   
  54.     pt_joystick_ctx->i4_js_fd = open（cp_js_dev_name, i4_open_flags）;  
  55.     if （pt_joystick_ctx->i4_js_fd < 0） {  
  56.         LOG_ERR（"[%s] open device %s error ", __func__, cp_js_dev_name）;  
  57.         free（pt_joystick_ctx）;  
  58.         return -1;  
  59.     }  
  60.   
  61.     list_add_tail（&pt_joystick_ctx->list, &_t_js_ctx_head）;  
  62.   
  63.     return pt_joystick_ctx->i4_js_fd;  
  64. }  
  65.   
  66. int joystick_close（int i4_fd）  
  67. {  
  68.     struct list_head* pt_entry;  
  69.     struct list_head* pt_next;  
  70.     JOYSTICK_CTX_T* pt_node;  
  71.   
  72.     if （list_empty（&_t_js_ctx_head）） {  
  73.         LOG_ERR（"[%s] device not opened ", __func__）;  
  74.         return -1;  
  75.     }  
  76.   
  77.     list_for_each_safe（pt_entry, pt_next, &_t_js_ctx_head） {  
  78.         pt_node = list_entry（pt_entry, JOYSTICK_CTX_T, list）;  
  79.         if （pt_node->i4_js_fd == i4_fd） {  
  80.             list_del_init（&pt_node->list）;  
  81.             free（pt_node）;  
  82.             return close（i4_fd）;  
  83.         }  
  84.     }  
  85.   
  86.     LOG_ERR（"[%s] i4_fd=%d invalid ", __func__, i4_fd）;  
  87.     return -1;  
  88. }  
  89.   
  90. int joystick_read_one_event（int i4_fd, struct js_event* tp_jse）  
  91. {  
  92.     int i4_rd_bytes;  
  93.   
  94.     /*do not check i4_fd again*/  
  95.   
  96.     i4_rd_bytes = read（i4_fd, tp_jse, sizeof（struct js_event））;  
  97.   
  98.     if （i4_rd_bytes == -1） {  
  99.         if （errno == EAGAIN） { /*when no block, it is not error*/  
  100.             return 0;  
  101.         }  
  102.         else {  
  103.             return -1;  
  104.         }  
  105.     }  
  106.   
  107.     return i4_rd_bytes;  
  108. }  
  109.   
  110. int joystick_read_ready（int i4_fd）  
  111. {  
  112.     int i4_block = 2;  
  113.     struct list_head* pt_entry;  
  114.     JOYSTICK_CTX_T* pt_node;  
  115.   
  116.     if （list_empty（&_t_js_ctx_head）） {  
  117.         LOG_ERR（"[%s] device not opened ", __func__）;  
  118.         return -1;  
  119.     }  
  120.   
  121.     list_for_each（pt_entry, &_t_js_ctx_head） {  
  122.         pt_node = list_entry（pt_entry, JOYSTICK_CTX_T, list）;  
  123.         if （pt_node->i4_js_fd == i4_fd） {  
  124.             i4_block = pt_node->i4_op_block;  
  125.             break;  
  126.         }  
  127.     }  
  128.   
  129.     if （i4_block == 2） {  
  130.         LOG_ERR（"[%s] i4_fd=%d invalid ", __func__, i4_fd）;  
  131.         return 0;  
  132.     }  
  133.     else if （i4_block == 1） {  
  134.         fd_set readfd;  
  135.         int i4_ret = 0;  
  136.         struct timeval timeout = {0, 0};  
  137.         FD_ZERO（&readfd）;  
  138.         FD_SET（i4_fd, &readfd）;  
  139.   
  140.         i4_ret = select（i4_fd + 1, &readfd, NULL, NULL, &timeout）;  
  141.   
  142.         if （i4_ret > 0 && FD_ISSET（i4_fd, &readfd）） {  
  143.             return 1;  
  144.         }  
  145.         else {  
  146.             return 0;  
  147.         }  
  148.   
  149.     }  
  150.   
  151.     return 1; /*noblock read, aways ready*/  
  152. }  
  153.   
  154.   
  155. void debug_list（void）  
  156. {  
  157.     if （！ list_empty（&_t_js_ctx_head）） {  
  158.         struct list_head* pt_entry;  
  159.         JOYSTICK_CTX_T* pt_node;  
  160.   
  161.         list_for_each（pt_entry, &_t_js_ctx_head） {  
  162.             pt_node = list_entry（pt_entry, JOYSTICK_CTX_T, list）;  
  163.             LOG_DBG（"fd:%d--block:%d ", pt_node->i4_js_fd, pt_node->i4_op_block）;  
  164.         }  
  165.     }  
  166.     else {  
  167.         LOG_DBG（"-----------> EMPTY NOW "）;  
  168.     }  
  169. }  
  170.   
  171. #if 1   
  172. typedef struct _axes_t {  
  173.     int x;  
  174.     int y;  
  175. } AXES_T;  
  176.   
  177. int main（int argc, char* argv[]）  
  178. {  
  179.     int fd, rc;  
  180.     int op_times = 0;  
  181.     char number_of_axes = 0;  
  182.     char number_of_btns = 0;  
  183.     char js_name_str[128];  
  184.     unsigned int buttons_state = 0;  
  185.     AXES_T* tp_axes = NULL;  
  186.     int i, print_init_stat = 0;  
  187.   
  188.     struct js_event jse;  
  189.   
  190.     fd = joystick_open（"/dev/input/js0", 1）;  
  191.     if （fd < 0） {  
  192.         LOG_ERR（"open failed. "）;  
  193.         exit（1）;  
  194.     }  
  195.   
  196.     rc = ioctl（fd, JSIOCGAXES, &number_of_axes）;  
  197.     if （rc ！= -1） {  
  198.         LOG_DBG（"number_of_axes:%d ", number_of_axes）;  
  199.         if （number_of_axes > 0） {  
  200.             tp_axes = （AXES_T*）calloc（sizeof（AXES_T）, 1）;  
  201.         }  
  202.     }  
  203.   
  204.     rc = ioctl（fd, JSIOCGBUTTONS, &number_of_btns）;  
  205.     if （rc ！= -1） {  
  206.         LOG_DBG（"number_of_btns:%d ", number_of_btns）;  
  207.     }  
  208.   
  209.     if （ioctl（fd, JSIOCGNAME（sizeof（js_name_str））, js_name_str） < 0） {  
  210.         LOG_DBG（js_name_str, "Unknown", sizeof（js_name_str））;  
  211.     }  
  212.   
  213.     LOG_DBG（"joystick Name: %s ", js_name_str）;  
  214.   
  215.     for （;;） {  
  216.         if （joystick_read_ready（fd）） {  
  217.             rc = joystick_read_one_event（fd, &jse）;  
  218.             if （rc > 0） {  
  219.                 if （（jse.type & JS_EVENT_INIT） == JS_EVENT_INIT） {  
  220.                     if （（jse.type & ~JS_EVENT_INIT） == JS_EVENT_BUTTON） {  
  221.                         if （jse.value） {  
  222.                             buttons_state |= （1 << jse.number）;  
  223.                         }  
  224.                         else {  
  225.                             buttons_state &= ~（1 << jse.number）;  
  226.                         }  
  227.                     }  
  228.                     else if （（jse.type & ~JS_EVENT_INIT） == JS_EVENT_AXIS） {  
  229.                         if （tp_axes） {  
  230.                             if （（jse.number & 1） == 0） {  
  231.                                 tp_axes[jse.number / 2].x = jse.value;  
  232.                             }  
  233.                             else {  
  234.                                 tp_axes[jse.number / 2].y = jse.value;  
  235.                             }  
  236.                         }  
  237.   
  238.                     }  
  239.                 }  
  240.                 else {  
  241.                     op_times++;  
  242.                     if （print_init_stat == 0） {  
  243.                         for （i = 0; i < number_of_btns; i++） {  
  244.                             LOG_DBG（"joystick init state: button %d is %s. ", i, （（buttons_state & （1 << i）） == （1 << i）） ？ "DOWN" : "UP"）;  
  245.                         }  
  246.   
  247.                         if （tp_axes）  
  248.                             for （i = 0; i < number_of_axes; i++） {  
  249.                                 LOG_DBG（"joystick init state: axes %d is x=%d  y=%d. ", i, tp_axes[i].x, tp_axes[i].y）;  
  250.                             }  
  251.                         print_init_stat = 1;  
  252.                     }  
  253.   
  254.                     if （jse.type  == JS_EVENT_BUTTON） {  
  255.                         if （jse.value） {  
  256.                             buttons_state |= （1 << jse.number）;  
  257.                         }  
  258.                         else {  
  259.                             buttons_state &= ~（1 << jse.number）;  
  260.                         }  
  261.   
  262.                         LOG_DBG（"joystick state: button %d is %s. ", jse.number, （（buttons_state & （1 << jse.number）） == （1 << jse.number）） ？ "DOWN" : "UP"）;  
  263.                     }  
  264.                     else if （jse.type == JS_EVENT_AXIS） {  
  265.                         if （tp_axes） {  
  266.                     &n
版权所有©石家庄振强科技有限公司2024 冀ICP备08103738号-5 网站地图