lixian
/
doubao_chat
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
doubao_chat/apps/scan_box/usb_hid_pos.c

642 lines
15 KiB
C
Raw Permalink Blame History

#include "app_config.h"
#include "typedef.h"
#include "usb_stack.h"
#include "device/hid.h"
#include "system/includes.h"
//#include "generic/jiffies.h"
#if USB_HID_POS_ENABLE
#define HID_POS_STA_BM_NORMAL 0x00
#define HID_POS_STA_BM_POWER_ON_RESET_SCANNER 0x01
#define HID_POS_STA_BM_PREVENT_READ_OF_BARCODES 0x02
#define HID_POS_STA_BM_INITIATE_BARCODE_READ 0x04
enum {
HID_POS_MSG_BEEP_GOOD = 0x10,
HID_POS_MSG_BEEP_ERROR,
HID_POS_MSG_TRIG_START,
HID_POS_MSG_TRIG_STOP,
HID_POS_MSG_RECV_AT_CMD,
};
struct hid_pos_msg {
u8 *buf;
u32 len;
u32 in_pos;
u32 out_pos;
spinlock_t spinlock;
};
struct hid_pos_handle {
/* void *usb_slave; */
usb_dev usb_id;
int state;
struct hid_pos_msg msg;
u8 at_cmd[62];
int timer;
spinlock_t spinlock;
u8 trigger_sta;
u8 trigger_last_sta;
u8 trigger_on_filter;
u8 trigger_off_filter;
u8 send_trig;
};
static struct hid_pos_handle *__this;
int hid_pos_send_report(usb_dev usb_id, u32 symbology, u32 vendor_code, const u8 *buf, u32 len, u8 force);
static const char Hidpos_report_descr[] = {
0x05, 0x8c,
0x09, 0x02,
0xa1, 0x01,
0x09, 0x12,
0xa1, 0x02,
0x85, 0x02,
0x15, 0x00,
0x26, 0xff, 0x00,
0x75, 0x08,
0x95, 0x01,
0x05, 0x01,
0x09, 0x3b,
0x81, 0x02,
0x95, 0x03,
0x05, 0x8c,
0x09, 0xfb,
0x09, 0xfc,
0x09, 0xfd,
0x81, 0x02,
0x95, 0x38,
0x09, 0xfe,
0x82, 0x02, 0x01,
0x06, 0x66, 0xff,
0x95, 0x02,
0x09, 0x04,
0x09, 0x00,
0x81, 0x02,
0x05, 0x8c,
0x25, 0x01,
0x75, 0x01,
0x95, 0x08,
0x09, 0xff,
0x81, 0x02,
0xc0,
0x09, 0x14,
0xa1, 0x02,
0x85, 0x04,
0x15, 0x00,
0x25, 0x01,
0x75, 0x01,
0x95, 0x08,
0x09, 0x5e,
0x09, 0x5f,
0x09, 0x60,
0x09, 0x00,
0x09, 0x00,
0x09, 0x85,
0x09, 0x86,
//0x09, 0x00,
0x91, 0x86,
0xc0,
#if 0
0x09, 0x16,
0xa1, 0x02,
0x85, 0x06,
0x09, 0xA9,
0xa1, 0x02,
0x75, 0x02,
0x95, 0x01,
0x15, 0x01,
0x25, 0x03,
0x19, 0xAA,
0x29, 0xAC,
0x91, 0x00,
0xc0,
0x09, 0xA9,
0xa1, 0x02,
0x75, 0x02,
0x95, 0x01,
0x15, 0x01,
0x25, 0x03,
0x19, 0xAD,
0x29, 0xAF,
0x91, 0x00,
0xc0,
0x15, 0x00,
0x25, 0x01,
0x75, 0x01,
0x95, 12,
0x09, 0x91,
0x09, 0x92,
0x09, 0x93,
0x09, 0x94,
0x09, 0x95,
0x09, 0x96,
0x09, 0x9b,
0x09, 0x9d,
0x09, 0xa1,
0x09, 0xa2,
0x91, 0x02,
0xc0,
0x09, 0x18,
0xa1, 0x02,
0x85, 0x07,
0x15, 0x00,
0x25, 0x01,
0x75, 0x01,
0x95, 0x01,
0x09, 0xc7,
0x91, 0x02,
0x0a, 0x0a, 0x01,
0xa1, 0x02,
0x75, 0x02,
0x15, 0x01,
0x25, 0x02,
0x95, 0x01,
0x1a, 0x0b, 0x01,
0x2a, 0x0c, 0x01,
0x91, 0x00,
0xc0,
0x09, 0xf0,
0xa1, 0x02,
0x15, 0x00,
0x25, 0x01,
0x75, 0x01,
0x95, 0x01,
0x19, 0xf1,
0x29, 0xf2,
0x91, 0x00,
0xc0,
0x09, 0xD6,
0xa1, 0x02,
0x15, 0x01,
0x25, 0x09,
0x75, 0x04,
0x95, 0x01,
0x19, 0xd7,
0x29, 0xdf,
0x91, 0x00,
0xc0,
0x15, 0x00,
0x25, 48,
0x75, 0x08,
0x95, 0x02,
0x0a, 0x06, 0x01,
0x0a, 0x07, 0x01,
0x91, 0x02,
0x75, 0x01,
0x95, 0x08,
0x09, 0xc9,
0x09, 0xd4,
0x91, 0x02,
0xc0,
0x09, 0x19,
0xa1, 0x02,
0x85, 0x08,
0x15, 0x00,
0x25, 0x01,
0x75, 0x01,
0x95, 0x01,
0x09, 0xca,
0x91, 0x02,
0x0a, 0x0a, 0x01,
0xa1, 0x02,
0x75, 0x02,
0x15, 0x01,
0x25, 0x02,
0x95, 0x01,
0x1a, 0x0b, 0x01,
0x2a, 0x0c, 0x01,
0x91, 0x00,
0xc0,
0x09, 0xf0,
0xa1, 0x02,
0x15, 0x00,
0x25, 0x01,
0x75, 0x01,
0x95, 0x01,
0x19, 0xf1,
0x29, 0xf2,
0x91, 0x00,
0xc0,
0x09, 0xD6,
0xa1, 0x02,
0x15, 0x01,
0x25, 0x03,
0x75, 0x04,
0x95, 0x01,
0x19, 0xd7,
0x29, 0xd9,
0x91, 0x00,
0xc0,
0x15, 2,
0x25, 80,
0x75, 0x08,
0x95, 0x02,
0x0a, 0x06, 0x01,
0x0a, 0x07, 0x01,
0x91, 0x02,
0xc0,
#endif
0x06, 0x66, 0xff,
0x75, 0x08,
0x26, 0xff, 0x00,
0x09, 0x03,
0xa1, 0x02,
0x85, 0xfe,
0x95, 0x01,
0x09, 0x03,
0xb2, 0x82, 0x01,
0xc0,
0x09, 0x01,
0xa1, 0x02,
0x85, 0xfd,
0x95, 0x01,
0x09, 0x21,
0x91, 0x02,
0x95, 0x3e,
0x09, 0x22,
0x92, 0x82, 0x01,
0xc0,
0xc0
};
u8 *hid_pos_get_report_desc()
{
return (u8 *)Hidpos_report_descr;
}
u32 hid_pos_get_report_desc_size()
{
return sizeof(Hidpos_report_descr);
}
static int hid_pos_msg_init(struct hid_pos_msg *msg, u8 *buf, u32 len)
{
if (!msg || !buf || !len) {
return -EINVAL;
}
msg->buf = buf;
msg->len = len;
msg->in_pos = 0;
msg->out_pos = 0;
spin_lock_init(&msg->spinlock);
return 0;
}
static int hid_pos_msg_put(struct hid_pos_msg *msg, u8 value)
{
if (!msg) {
return -EINVAL;
}
spin_lock(&msg->spinlock);
if ((msg->in_pos + msg->len - msg->out_pos) % msg->len == msg->len - 1) {
//msg full
spin_unlock(&msg->spinlock);
return -ENOMEM;
}
msg->buf[msg->in_pos] = value;
msg->in_pos = (msg->in_pos + 1) % msg->len;
spin_unlock(&msg->spinlock);
return 0;
}
static int hid_pos_msg_get(struct hid_pos_msg *msg, u8 *value)
{
if (!msg || !value) {
return -EINVAL;
}
spin_lock(&msg->spinlock);
if ((msg->in_pos + msg->len - msg->out_pos) % msg->len == 0) {
//msg empty
spin_unlock(&msg->spinlock);
return -ENOMEM;
}
*value = msg->buf[msg->out_pos];
msg->out_pos = (msg->out_pos + 1) % msg->len;
spin_unlock(&msg->spinlock);
return 0;
}
static u32 hid_pos_msg_query_size(struct hid_pos_msg *msg)
{
u32 len;
if (!msg) {
return 0;
}
spin_lock(&msg->spinlock);
len = (msg->in_pos + msg->len - msg->out_pos) % msg->len;
spin_unlock(&msg->spinlock);
return len;
}
static int get_trigger_state()
{
//获取触发按键状态
#if 0
static int init = 0;
if (!init) {
gpio_set_pull_up(IO_PORTX_XX);
init = 1;
}
return gpio_direction_input(IO_PORTX_XX);
#else
return 0;
#endif
}
static const char *const hid_pos_at_cmd[] = {
"\x16\x07\r", //BEEP
"\x16M\rP_INFO.", //GET INFO
"\x16M\rTERMID?.", //TERMID
};
static void hid_pos_msg_handle(void *arg)
{
int err;
struct hid_pos_handle *hdl = arg;
u8 msg_val;
u32 idx;
const char *at_cmd_ack;
if (get_trigger_state()) {
hdl->trigger_on_filter++;
hdl->trigger_off_filter = 0;
} else {
hdl->trigger_on_filter = 0;
hdl->trigger_off_filter++;
}
if (hdl->trigger_on_filter >= 2) {
hdl->trigger_sta = 1;
} else if (hdl->trigger_off_filter >= 2) {
hdl->trigger_sta = 0;
}
if (hdl->trigger_sta != hdl->trigger_last_sta) {
if (!(hdl->state & HID_POS_STA_BM_INITIATE_BARCODE_READ)) {
if (hdl->trigger_sta) {
msg_val = HID_POS_MSG_TRIG_START;
} else {
msg_val = HID_POS_MSG_TRIG_STOP;
}
err = hid_pos_msg_put(&hdl->msg, msg_val);
if (err < 0) {
printf("hid pos put msg fail, %d, line %d\n", err, __LINE__);
}
}
}
hdl->trigger_last_sta = hdl->trigger_sta;
if (0 == hid_pos_msg_get(&hdl->msg, &msg_val)) {
switch (msg_val) {
case HID_POS_MSG_BEEP_GOOD:
printf("beep good\n");
/* tick(2); */
break;
case HID_POS_MSG_BEEP_ERROR:
printf("beep error\n");
/* tick(3); */
break;
case HID_POS_MSG_TRIG_START:
printf("trig start\n");
//add codes of LED turning on
hdl->send_trig = 1;
break;
case HID_POS_MSG_TRIG_STOP:
printf("trig stop\n");
//add codes of LED turning off
hdl->send_trig = 0;
break;
case HID_POS_MSG_RECV_AT_CMD:
printf("recv at-cmd\n");
spin_lock(&hdl->spinlock);
for (idx = 0; idx < ARRAY_SIZE(hid_pos_at_cmd); idx++) {
if (memcmp(hdl->at_cmd, hid_pos_at_cmd[idx], strlen(hid_pos_at_cmd[idx])) == 0) {
break;
}
}
spin_unlock(&hdl->spinlock);
printf("idx %d\n", idx);
if (idx < ARRAY_SIZE(hid_pos_at_cmd)) {
switch (idx) {
case 0:
/* tick(2); */
break;
case 1:
at_cmd_ack = "INFO: JL_HID_POS\r\nVERSION: 1.0.0\r\n\x06.";
hid_pos_send_report(hdl->usb_id, 0x365a5d, 0x36, (const u8 *)at_cmd_ack, strlen(at_cmd_ack), 1);
break;
case 2:
at_cmd_ack = "TERMID131\x06.";
hid_pos_send_report(hdl->usb_id, 0x365a5d, 0x36, (const u8 *)at_cmd_ack, strlen(at_cmd_ack), 1);
break;
}
}
break;
}
}
}
int hid_pos_receive(u8 *buf, u32 len)
{
int err = 0;
u8 msg_val;
printf("%s() buf size %d\n", __func__, len);
put_buf(buf, len);
//report id
switch (buf[0]) {
case 4:
puts("trigger report\n");
if (__this) {
if (buf[1] & 0x40) { //Sound Good Read Beep
msg_val = HID_POS_MSG_BEEP_GOOD;
err = hid_pos_msg_put(&__this->msg, msg_val);
if (err < 0) {
printf("hid pos put msg fail, %d, line %d\n", err, __LINE__);
}
}
if (buf[1] & 0x20) { //Sound Error Beep
msg_val = HID_POS_MSG_BEEP_ERROR;
err = hid_pos_msg_put(&__this->msg, msg_val);
if (err < 0) {
printf("hid pos put msg fail, %d, line %d\n", err, __LINE__);
}
}
if (buf[1] & 0x02) { //Prevent Read of Barcodes
__this->state |= HID_POS_STA_BM_PREVENT_READ_OF_BARCODES;
} else {
__this->state &= ~HID_POS_STA_BM_PREVENT_READ_OF_BARCODES;
}
if (buf[1] & 0x04) { //Initiate Barcode Read
if (!(__this->state & HID_POS_STA_BM_INITIATE_BARCODE_READ)) {
__this->state |= HID_POS_STA_BM_INITIATE_BARCODE_READ;
msg_val = HID_POS_MSG_TRIG_START;
err = hid_pos_msg_put(&__this->msg, msg_val);
if (err < 0) {
printf("hid pos put msg fail, %d, line %d\n", err, __LINE__);
}
}
} else {
if ((__this->state & HID_POS_STA_BM_INITIATE_BARCODE_READ)) {
__this->state &= ~HID_POS_STA_BM_INITIATE_BARCODE_READ;
msg_val = HID_POS_MSG_TRIG_STOP;
err = hid_pos_msg_put(&__this->msg, msg_val);
if (err < 0) {
printf("hid pos put msg fail, %d, line %d\n", err, __LINE__);
}
}
}
}
break;
case 254:
puts("Vendor-Defined 3\n");
break;
case 253:
puts("Vendor-Defined 1\n");
//receive at_cmd from pc
spin_lock(&__this->spinlock);
memcpy(__this->at_cmd, &buf[2], buf[1]);
spin_unlock(&__this->spinlock);
msg_val = HID_POS_MSG_RECV_AT_CMD;
err = hid_pos_msg_put(&__this->msg, msg_val);
if (err < 0) {
printf("hid pos put msg fail, %d, line %d\n", err, __LINE__);
}
break;
default:
printf("unsupported report id %d\n", buf[0]);
}
return 0;
}
int hid_pos_open(usb_dev usb_id)
{
struct hid_pos_handle *hdl;
u8 *ptr = NULL;
int err;
hdl = (struct hid_pos_handle *)malloc(sizeof(*hdl));
if (!hdl) {
return -ENOMEM;
}
memset(hdl, 0, sizeof(*hdl));
hdl->usb_id = usb_id;
ptr = (u8 *)malloc(10);
if (!ptr) {
goto __err_exit;
}
hid_pos_msg_init(&hdl->msg, ptr, 10);
spin_lock_init(&hdl->spinlock);
hdl->timer = sys_timer_add(hdl, hid_pos_msg_handle, 50);
hdl->state = HID_POS_STA_BM_NORMAL;
__this = hdl;
return 0;
__err_exit:
if (hdl->timer) {
sys_timer_del(hdl->timer);
}
if (ptr) {
free(ptr);
}
free(hdl);
return -EFAULT;
}
void hid_pos_close(usb_dev usb_id)
{
struct hid_pos_handle *hdl;
int err;
if (__this == NULL) {
return;
}
hdl = __this;
if (hdl->timer) {
sys_timer_del(hdl->timer);
}
free(hdl->msg.buf);
free(hdl);
__this = NULL;
}
int hid_pos_send_report(usb_dev usb_id, u32 symbology, u32 vendor_code, const u8 *buf, u32 len, u8 force)
{
struct hid_pos_handle *hdl;
u32 offset = 0;
u32 fit_len;
u8 decoded_data[64] = {0};
int err = 0;
if (__this == NULL) {
return -EFAULT;
}
hdl = __this;
if (((hdl->state & HID_POS_STA_BM_PREVENT_READ_OF_BARCODES) == 0) &&
(hdl->send_trig || force)) {
decoded_data[0] = 2; //report id: 2
//decoded_data[2] = 0x5d; //Symbology Identifier1
//decoded_data[3] = 0x43; //Symbology Identifier2
//decoded_data[4] = 0x30; //Symbology Identifier3
//decoded_data[61] = 0x6a;
decoded_data[2] = symbology & 0xff;
decoded_data[3] = (symbology >> 8) & 0xff;
decoded_data[4] = (symbology >> 16) & 0xff;
decoded_data[61] = vendor_code & 0xff;
decoded_data[62] = (vendor_code >> 8) & 0xff;
while (offset < len) {
fit_len = len - offset > 56 ? 56 : len - offset;
memset(&decoded_data[5], 0, 56);
memcpy(&decoded_data[5], buf + offset, fit_len);
if (fit_len < 56) {
decoded_data[1] = fit_len;
decoded_data[63] &= ~BIT(0);
} else {
decoded_data[1] = 56;
decoded_data[63] |= BIT(0); //Decode Data Continued
}
hid_send_buf_async(hdl->usb_id, decoded_data, 64);
//hid_tx_data(hdl->usb_id, decode_data, 64);
offset += fit_len;
}
if (!force) {
hdl->send_trig = 0;
}
err = hid_pos_msg_put(&hdl->msg, HID_POS_MSG_TRIG_STOP);
if (err < 0) {
printf("hid pos put msg fail, %d, line %d\n", err, __LINE__);
}
}
if (offset < len) {
err = -EFAULT;
}
return err;
}
int hid_pos_send(u8 *data, u32 len, u8 force)
{
if (data[len - 1] == '\n') {
data[len - 1] = '\r';
}
return hid_pos_send_report(__this->usb_id, 0x30435d, 0x6a, data, len, force);
}
#endif
Reference in New Issue View Git Blame Copy Permalink