3717|1

1万

帖子

25

TA的资源

裸片初长成(高级)

楼主
 

STM32F --- 用USB [复制链接]

        上位机用VC++编程,STM32F用USB与其对接,如果上位机应用程序想读STM32F的内部寄存器或存储器, ------ 不用虚拟串口,
        这样的程序怎么做呢?(包括VC++及STM32F)


-----用STM32CubeMX时不知道选择哪个:


上位机用VC++时,更是没有方向
此帖出自stm32/stm8论坛

最新回复

我用libusb就很好做(不过我的代码和官方例程无关),完整的测试代码,你参考下 #include <stdio.h> #include <stdint.h> #include <stdlib.h> #include <string.h> #include <stdarg.h> #include <time.h> #include "libusb.h" #define VL1602ED_VID        0xB58A #define VL1602ED_PID        0xC200 #define VLLOGIC_REQUESET_REG_RW                                0x00 struct ctrl_regs_t {         // read only area         uint32_t version;         uint32_t board_in_channels_mask;         uint32_t board_out_channels_mask;         uint32_t status_mask;         // read write area         uint32_t command; #define VLLOGIC_CMD_NOP                                                0 #define VLLOGIC_CMD_START                                        0x10000000 #define VLLOGIC_CMD_STOP                                        0x10000001         uint32_t mode; #define VLLOGIC_MODE_NOP                                        0 #define VLLOGIC_MODE_IN                                                (0x1 << 0) #define VLLOGIC_MODE_OUT                                        (0x1 << 1)         // channel parameter         uint32_t sum_l32;         uint32_t sum_h32;         uint32_t rate;         /*         bit                        function         [0, 15]         digital channels enable mask         [16, 17]        analog channels enable mask         */         uint32_t channels_in_enable_mask;         /*         bit                        function         [0, 15]         low level trigger enable mask         [16, 32]        high level trigger enable mask         */         uint32_t digital_channels_level_trigger_mask;         /*         bit                        function         [0, 15]         falling edge trigger enable mask         [16, 32]        rising edge trigger enable mask         */         uint32_t digital_channels_edge_trigger_mask;         /*         bit                        function         [0, 15]         digital channels enable mask         [16, 17]        analog channels enable mask         */         uint32_t channels_out_enable_mask; }; uint8_t buf_20k[20 * 1024 * 1024]; static int vl1602ed_vllogic_test(libusb_device_handle *handle) {         int r;         struct ctrl_regs_t regs;         // control test         r = libusb_control_transfer(handle, LIBUSB_ENDPOINT_IN | LIBUSB_REQUEST_TYPE_CLASS | LIBUSB_RECIPIENT_INTERFACE,                 VLLOGIC_REQUESET_REG_RW, 0, 0, (uint8_t *)&regs, sizeof(struct ctrl_regs_t), 100);         if (r != sizeof(struct ctrl_regs_t))         {                 printf("Get Regs Fail\n");                 return;         }                         regs.rate = 240000000;         libusb_control_transfer(handle, LIBUSB_ENDPOINT_OUT | LIBUSB_REQUEST_TYPE_CLASS | LIBUSB_RECIPIENT_INTERFACE,                 VLLOGIC_REQUESET_REG_RW, 0, 0, (uint8_t *)&regs, sizeof(struct ctrl_regs_t), 100);         memset(&regs, 0, sizeof(struct ctrl_regs_t));         r = libusb_control_transfer(handle, LIBUSB_ENDPOINT_IN | LIBUSB_REQUEST_TYPE_CLASS | LIBUSB_RECIPIENT_INTERFACE,                 VLLOGIC_REQUESET_REG_RW, 0, 0, (uint8_t *)&regs, sizeof(struct ctrl_regs_t), 100);         if (r != sizeof(struct ctrl_regs_t))         {                 printf("Get Regs Fail\n");                 return;         }         //while (1)         {                 int transfer_len = 0, sum = 0;                 clock_t start, end;                 start = clock();                 printf("\n20k Block Test \n");                 printf("Start Clock %d\n", start);                 while (sum < 100 * 1024 * 1024)                 {                         r = libusb_bulk_transfer(handle, 0x80 | 0x1, buf_20k, 20 * 1024, &transfer_len, 1000);                         if (r == LIBUSB_ERROR_PIPE) {                                 libusb_clear_halt(handle, 1);                                 printf("Get 20k buffer Fail\n");                                 break;                         }                         else if (transfer_len == 20 * 1024)                         {                                 sum += transfer_len;                         }                         else                         {                                 printf("Get buffer %d\n", transfer_len);                                 break;                         }                 }                 end = clock();                 printf("End Clock %d\n", end);                 float speed = 100000.0 / (end - start);                 printf("Speed %f MB/S\n", speed);         }         {                 int transfer_len = 0, sum = 0;                 clock_t start, end;                 start = clock();                 printf("\n1MB Block Test \n");                 printf("Start Clock %d\n", start);                 while (sum < 100 * 1024 * 1024)                 {                         r = libusb_bulk_transfer(handle, 0x80 | 0x1, buf_20k, 1024 * 1024, &transfer_len, 1000);                         if (r == LIBUSB_ERROR_PIPE) {                                 libusb_clear_halt(handle, 1);                                 printf("Get 20k buffer Fail\n");                                 break;                         }                         else if (transfer_len == 1024 * 1024)                         {                                 sum += transfer_len;                         }                         else                         {                                 printf("Get buffer %d\n", transfer_len);                                 break;                         }                 }                 end = clock();                 printf("End Clock %d\n", end);                 float speed = 100000.0 / (end - start);                 printf("Speed %f MB/S\n", speed);         }         {                 int transfer_len = 0, sum = 0;                 clock_t start, end;                 start = clock();                 printf("\n10MB Block Test \n");                 printf("Start Clock %d\n", start);                 while (sum < 100 * 1024 * 1024)                 {                         r = libusb_bulk_transfer(handle, 0x80 | 0x1, buf_20k, 10 * 1024 * 1024, &transfer_len, 1000);                         if (r == LIBUSB_ERROR_PIPE) {                                 libusb_clear_halt(handle, 1);                                 printf("Get 20k buffer Fail\n");                                 break;                         }                         else if (transfer_len == 10 * 1024 * 1024)                         {                                 sum += transfer_len;                         }                         else                         {                                 printf("Get buffer %d\n", transfer_len);                                 break;                         }                 }                 end = clock();                 printf("End Clock %d\n", end);                 float speed = 100000.0 / (end - start);                 printf("Speed %f MB/S\n", speed);         }         {                 int transfer_len = 0, sum = 0;                 clock_t start, end;                 start = clock();                 printf("\n20MB Block Test \n");                 printf("Start Clock %d\n", start);                 while (sum < 100 * 1024 * 1024)                 {                         r = libusb_bulk_transfer(handle, 0x80 | 0x1, buf_20k, 20 * 1024 * 1024, &transfer_len, 1000);                         if (r == LIBUSB_ERROR_PIPE) {                                 libusb_clear_halt(handle, 1);                                 printf("Get 20k buffer Fail\n");                                 break;                         }                         else if (transfer_len == 20 * 1024 * 1024)                         {                                 sum += transfer_len;                         }                         else                         {                                 printf("Get buffer %d\n", transfer_len);                                 break;                         }                 }                 end = clock();                 printf("End Clock %d\n", end);                 float speed = 100000.0 / (end - start);                 printf("Speed %f MB/S\n", speed);         } } static int vl1602ed_test(void) {         int r;         libusb_device_handle *handle;         libusb_device *dev;         printf("Opening device %04X:%04X...\n", VL1602ED_VID, VL1602ED_PID);         handle = libusb_open_device_with_vid_pid(NULL, VL1602ED_VID, VL1602ED_PID);         if (handle == NULL)         {                 printf("  Open Failed.\n");                 return -1;         }         else                 printf("  Find Device.\n");         dev = libusb_get_device(handle);         libusb_set_auto_detach_kernel_driver(handle, 1);         printf("Claim Interface 0\n");         r = libusb_claim_interface(handle, 0);         if (r != LIBUSB_SUCCESS)         {                 printf("   Failed.\n");         }         else         {                 r = libusb_claim_interface(handle, 1);                 if (r == LIBUSB_SUCCESS)                 {                         printf("   Success.\n");                         vl1602ed_vllogic_test(handle);                 }         }         //printf("Claim Interface 1\n");         //r = libusb_claim_interface(handle, 0);         //if (r != LIBUSB_SUCCESS)         //{         //        printf("   Failed.\n");         //}         printf("Closing device...\n");         libusb_close(handle); } int main(int argc, char** argv) {         int j, r;         const struct libusb_version* version;         version = libusb_get_version();         printf("Using libusb v%d.%d.%d.%d\n\n", version->major, version->minor, version->micro, version->nano);         r = libusb_init(NULL);         if (r < 0)                 return r;         vl1602ed_test();         libusb_exit(NULL);         return 0; } 复制代码   详情 回复 发表于 2017-3-31 15:58
点赞 关注
 

回复
举报

750

帖子

3

TA的资源

版主

沙发
 
我用libusb就很好做(不过我的代码和官方例程无关),完整的测试代码,你参考下

  1. #include <stdio.h>
  2. #include <stdint.h>
  3. #include <stdlib.h>
  4. #include <string.h>
  5. #include <stdarg.h>

  6. #include <time.h>

  7. #include "libusb.h"


  8. #define VL1602ED_VID        0xB58A
  9. #define VL1602ED_PID        0xC200

  10. #define VLLOGIC_REQUESET_REG_RW                                0x00


  11. struct ctrl_regs_t
  12. {
  13.         // read only area
  14.         uint32_t version;

  15.         uint32_t board_in_channels_mask;
  16.         uint32_t board_out_channels_mask;

  17.         uint32_t status_mask;

  18.         // read write area
  19.         uint32_t command;
  20. #define VLLOGIC_CMD_NOP                                                0
  21. #define VLLOGIC_CMD_START                                        0x10000000
  22. #define VLLOGIC_CMD_STOP                                        0x10000001

  23.         uint32_t mode;
  24. #define VLLOGIC_MODE_NOP                                        0
  25. #define VLLOGIC_MODE_IN                                                (0x1 << 0)
  26. #define VLLOGIC_MODE_OUT                                        (0x1 << 1)

  27.         // channel parameter
  28.         uint32_t sum_l32;
  29.         uint32_t sum_h32;
  30.         uint32_t rate;

  31.         /*
  32.         bit                        function
  33.         [0, 15]         digital channels enable mask
  34.         [16, 17]        analog channels enable mask
  35.         */
  36.         uint32_t channels_in_enable_mask;

  37.         /*
  38.         bit                        function
  39.         [0, 15]         low level trigger enable mask
  40.         [16, 32]        high level trigger enable mask
  41.         */
  42.         uint32_t digital_channels_level_trigger_mask;

  43.         /*
  44.         bit                        function
  45.         [0, 15]         falling edge trigger enable mask
  46.         [16, 32]        rising edge trigger enable mask
  47.         */
  48.         uint32_t digital_channels_edge_trigger_mask;

  49.         /*
  50.         bit                        function
  51.         [0, 15]         digital channels enable mask
  52.         [16, 17]        analog channels enable mask
  53.         */
  54.         uint32_t channels_out_enable_mask;
  55. };

  56. uint8_t buf_20k[20 * 1024 * 1024];

  57. static int vl1602ed_vllogic_test(libusb_device_handle *handle)
  58. {
  59.         int r;
  60.         struct ctrl_regs_t regs;

  61.         // control test
  62.         r = libusb_control_transfer(handle, LIBUSB_ENDPOINT_IN | LIBUSB_REQUEST_TYPE_CLASS | LIBUSB_RECIPIENT_INTERFACE,
  63.                 VLLOGIC_REQUESET_REG_RW, 0, 0, (uint8_t *)&regs, sizeof(struct ctrl_regs_t), 100);
  64.         if (r != sizeof(struct ctrl_regs_t))
  65.         {
  66.                 printf("Get Regs Fail\n");
  67.                 return;
  68.         }
  69.                
  70.         regs.rate = 240000000;

  71.         libusb_control_transfer(handle, LIBUSB_ENDPOINT_OUT | LIBUSB_REQUEST_TYPE_CLASS | LIBUSB_RECIPIENT_INTERFACE,
  72.                 VLLOGIC_REQUESET_REG_RW, 0, 0, (uint8_t *)&regs, sizeof(struct ctrl_regs_t), 100);
  73.         memset(&regs, 0, sizeof(struct ctrl_regs_t));

  74.         r = libusb_control_transfer(handle, LIBUSB_ENDPOINT_IN | LIBUSB_REQUEST_TYPE_CLASS | LIBUSB_RECIPIENT_INTERFACE,
  75.                 VLLOGIC_REQUESET_REG_RW, 0, 0, (uint8_t *)&regs, sizeof(struct ctrl_regs_t), 100);
  76.         if (r != sizeof(struct ctrl_regs_t))
  77.         {
  78.                 printf("Get Regs Fail\n");
  79.                 return;
  80.         }


  81.         //while (1)
  82.         {
  83.                 int transfer_len = 0, sum = 0;
  84.                 clock_t start, end;

  85.                 start = clock();
  86.                 printf("\n20k Block Test \n");
  87.                 printf("Start Clock %d\n", start);
  88.                 while (sum < 100 * 1024 * 1024)
  89.                 {
  90.                         r = libusb_bulk_transfer(handle, 0x80 | 0x1, buf_20k, 20 * 1024, &transfer_len, 1000);
  91.                         if (r == LIBUSB_ERROR_PIPE) {
  92.                                 libusb_clear_halt(handle, 1);
  93.                                 printf("Get 20k buffer Fail\n");
  94.                                 break;
  95.                         }
  96.                         else if (transfer_len == 20 * 1024)
  97.                         {
  98.                                 sum += transfer_len;
  99.                         }
  100.                         else
  101.                         {
  102.                                 printf("Get buffer %d\n", transfer_len);
  103.                                 break;
  104.                         }
  105.                 }
  106.                 end = clock();
  107.                 printf("End Clock %d\n", end);
  108.                 float speed = 100000.0 / (end - start);
  109.                 printf("Speed %f MB/S\n", speed);
  110.         }
  111.         {
  112.                 int transfer_len = 0, sum = 0;
  113.                 clock_t start, end;

  114.                 start = clock();
  115.                 printf("\n1MB Block Test \n");
  116.                 printf("Start Clock %d\n", start);
  117.                 while (sum < 100 * 1024 * 1024)
  118.                 {
  119.                         r = libusb_bulk_transfer(handle, 0x80 | 0x1, buf_20k, 1024 * 1024, &transfer_len, 1000);
  120.                         if (r == LIBUSB_ERROR_PIPE) {
  121.                                 libusb_clear_halt(handle, 1);
  122.                                 printf("Get 20k buffer Fail\n");
  123.                                 break;
  124.                         }
  125.                         else if (transfer_len == 1024 * 1024)
  126.                         {
  127.                                 sum += transfer_len;
  128.                         }
  129.                         else
  130.                         {
  131.                                 printf("Get buffer %d\n", transfer_len);
  132.                                 break;
  133.                         }
  134.                 }
  135.                 end = clock();
  136.                 printf("End Clock %d\n", end);
  137.                 float speed = 100000.0 / (end - start);
  138.                 printf("Speed %f MB/S\n", speed);
  139.         }
  140.         {
  141.                 int transfer_len = 0, sum = 0;
  142.                 clock_t start, end;

  143.                 start = clock();
  144.                 printf("\n10MB Block Test \n");
  145.                 printf("Start Clock %d\n", start);
  146.                 while (sum < 100 * 1024 * 1024)
  147.                 {
  148.                         r = libusb_bulk_transfer(handle, 0x80 | 0x1, buf_20k, 10 * 1024 * 1024, &transfer_len, 1000);
  149.                         if (r == LIBUSB_ERROR_PIPE) {
  150.                                 libusb_clear_halt(handle, 1);
  151.                                 printf("Get 20k buffer Fail\n");
  152.                                 break;
  153.                         }
  154.                         else if (transfer_len == 10 * 1024 * 1024)
  155.                         {
  156.                                 sum += transfer_len;
  157.                         }
  158.                         else
  159.                         {
  160.                                 printf("Get buffer %d\n", transfer_len);
  161.                                 break;
  162.                         }
  163.                 }
  164.                 end = clock();
  165.                 printf("End Clock %d\n", end);
  166.                 float speed = 100000.0 / (end - start);
  167.                 printf("Speed %f MB/S\n", speed);
  168.         }
  169.         {
  170.                 int transfer_len = 0, sum = 0;
  171.                 clock_t start, end;

  172.                 start = clock();
  173.                 printf("\n20MB Block Test \n");
  174.                 printf("Start Clock %d\n", start);
  175.                 while (sum < 100 * 1024 * 1024)
  176.                 {
  177.                         r = libusb_bulk_transfer(handle, 0x80 | 0x1, buf_20k, 20 * 1024 * 1024, &transfer_len, 1000);
  178.                         if (r == LIBUSB_ERROR_PIPE) {
  179.                                 libusb_clear_halt(handle, 1);
  180.                                 printf("Get 20k buffer Fail\n");
  181.                                 break;
  182.                         }
  183.                         else if (transfer_len == 20 * 1024 * 1024)
  184.                         {
  185.                                 sum += transfer_len;
  186.                         }
  187.                         else
  188.                         {
  189.                                 printf("Get buffer %d\n", transfer_len);
  190.                                 break;
  191.                         }
  192.                 }
  193.                 end = clock();
  194.                 printf("End Clock %d\n", end);
  195.                 float speed = 100000.0 / (end - start);
  196.                 printf("Speed %f MB/S\n", speed);
  197.         }
  198. }

  199. static int vl1602ed_test(void)
  200. {
  201.         int r;
  202.         libusb_device_handle *handle;
  203.         libusb_device *dev;

  204.         printf("Opening device %04X:%04X...\n", VL1602ED_VID, VL1602ED_PID);
  205.         handle = libusb_open_device_with_vid_pid(NULL, VL1602ED_VID, VL1602ED_PID);
  206.         if (handle == NULL)
  207.         {
  208.                 printf("  Open Failed.\n");
  209.                 return -1;
  210.         }
  211.         else
  212.                 printf("  Find Device.\n");

  213.         dev = libusb_get_device(handle);

  214.         libusb_set_auto_detach_kernel_driver(handle, 1);
  215.         printf("Claim Interface 0\n");
  216.         r = libusb_claim_interface(handle, 0);
  217.         if (r != LIBUSB_SUCCESS)
  218.         {
  219.                 printf("   Failed.\n");
  220.         }
  221.         else
  222.         {
  223.                 r = libusb_claim_interface(handle, 1);

  224.                 if (r == LIBUSB_SUCCESS)
  225.                 {
  226.                         printf("   Success.\n");
  227.                         vl1602ed_vllogic_test(handle);
  228.                 }
  229.         }
  230.         //printf("Claim Interface 1\n");
  231.         //r = libusb_claim_interface(handle, 0);
  232.         //if (r != LIBUSB_SUCCESS)
  233.         //{
  234.         //        printf("   Failed.\n");
  235.         //}

  236.         printf("Closing device...\n");
  237.         libusb_close(handle);
  238. }

  239. int main(int argc, char** argv)
  240. {
  241.         int j, r;
  242.         const struct libusb_version* version;

  243.         version = libusb_get_version();
  244.         printf("Using libusb v%d.%d.%d.%d\n\n", version->major, version->minor, version->micro, version->nano);
  245.         r = libusb_init(NULL);
  246.         if (r < 0)
  247.                 return r;

  248.         vl1602ed_test();

  249.         libusb_exit(NULL);

  250.         return 0;
  251. }
复制代码

此帖出自stm32/stm8论坛

赞赏

1

查看全部赞赏

 
个人签名

要666

 

回复
您需要登录后才可以回帖 登录 | 注册

随便看看
查找数据手册?

EEWorld Datasheet 技术支持

相关文章 更多>>
关闭
站长推荐上一条 1/10 下一条
Microchip 直播|利用motorBench开发套件高效开发电机磁场定向控制方案 报名中!
直播主题:利用motorBench开发套件高效开发电机磁场定向控制方案
直播时间:2025年3月25日(星期二)上午10:30-11:30
快来报名!

查看 »

 
EEWorld订阅号

 
EEWorld服务号

 
汽车开发圈

About Us 关于我们 客户服务 联系方式 器件索引 网站地图 最新更新 手机版

站点相关: 国产芯 安防电子 汽车电子 手机便携 工业控制 家用电子 医疗电子 测试测量 网络通信 物联网

北京市海淀区中关村大街18号B座15层1530室 电话:(010)82350740 邮编:100190

电子工程世界版权所有 京B2-20211791 京ICP备10001474号-1 电信业务审批[2006]字第258号函 京公网安备 11010802033920号 Copyright © 2005-2025 EEWORLD.com.cn, Inc. All rights reserved
快速回复 返回顶部 返回列表